new version: 2020.1.3

See:
https://sourceforge.net/p/flightgear/codetickets/2241/

Note did not adjust bug in knob-animation ignoring repeatable flag
(always marked repeatable) since this might break some aircraft.

CMakeLists.txt

@@ -10,12 +10,6 @@ if(COMMAND cmake_policy)
    if(POLICY CMP0067)
        cmake_policy(SET CMP0067 NEW)
    endif()
-    
-  # OpenGL VND policy : use the old definition for now, until we can audit this
-  if(POLICY CMP0072)
-        cmake_policy(SET CMP0072 OLD)
-  endif()
-
    if(POLICY CMP0093)
        cmake_policy(SET CMP0093 NEW)
    endif()
@@ -49,7 +43,7 @@ set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 
 # read 'version' file into a variable (stripping any newlines or spaces)
-file(READ simgear-version versionFile)
+file(READ version versionFile)
 string(STRIP ${versionFile} SIMGEAR_VERSION)
 
 project(SimGear VERSION ${SIMGEAR_VERSION} LANGUAGES C CXX)
@@ -278,15 +272,7 @@ else()
     endif()
 endif(SIMGEAR_HEADLESS)
 
-if(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
-    # As of 2020-08-01, OpenBSD's system zlib is slightly old, but it's usable
-    # with a workaround in simgear/io/iostreams/gzfstream.cxx.
-    find_package(ZLIB 1.2.3 REQUIRED)
-else()
-    find_package(ZLIB 1.2.4 REQUIRED)
-endif()
-
-find_package(LibLZMA REQUIRED)
+find_package(ZLIB 1.2.4 REQUIRED)
 find_package(CURL REQUIRED)
 
 if (SYSTEM_EXPAT)
@@ -431,8 +417,16 @@ if(CMAKE_COMPILER_IS_GNUCXX)
       message(WARNING "GCC 4.4 will be required soon, please upgrade")
     endif()
 
-    if (X86 OR X86_64)
-        set(SIMD_COMPILER_FLAGS "-msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
+    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+      set(CMAKE_C_FLAGS
+        "${CMAKE_C_FLAGS} -O0 -fno-omit-frame-pointer -fno-inline")
+      set(CMAKE_CXX_FLAGS
+        "${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 -ftree-vectorize -ftree-slp-vectorize")
+        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
+      endif()
     endif()
 
     # certain GCC versions don't provide the atomic builds, and hence
@@ -441,10 +435,6 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     check_cxx_source_compiles(
        "int main() { unsigned mValue; return __sync_add_and_fetch(&mValue, 1); }"
         GCC_ATOMIC_BUILTINS_FOUND)
-
-      # override CMake default RelWithDebInfo flags.
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO  "-O3 -g -DNDEBUG")
 endif(CMAKE_COMPILER_IS_GNUCXX)
 
 if (CLANG)
@@ -459,7 +449,16 @@ if (CLANG)
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG")
     set(CMAKE_C_FLAGS_RELWITHDEBINFO  "-O3 -g -DNDEBUG")
 
-    set(SIMD_COMPILER_FLAGS "-msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
+    if (ENABLE_SIMD)
+      if (X86 OR X86_64)
+        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")
+
+        # propogate to the RelWithDebInfo flags
+        set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELEASE} -g -DNDEBUG")
+        set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELEASE} -g -DNDEBUG")
+      endif()
+    endif()
 endif()
 
 if (ENABLE_OPENMP)
@@ -491,8 +490,14 @@ if(WIN32)
 
     if(MSVC)
         set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /MP")
-        if (X86)
-          set(SIMD_COMPILER_FLAGS "/arch:SSE /arch:SSE2")
+        if(ENABLE_SIMD)
+          if (X86)
+            SET(CMAKE_C_FLAGS_RELEASE "/O2 /arch:SSE /arch:SSE2")
+            SET(CMAKE_CXX_FLAGS_RELEASE "/O2 /arch:SSE /arch:SSE2")
+          else()
+            SET(CMAKE_C_FLAGS_RELEASE "/O2")
+            SET(CMAKE_CXX_FLAGS_RELEASE "/O2")
+          endif()
         endif()
 
         if (NOT OSG_FSTREAM_EXPORT_FIXED)
@@ -516,20 +521,6 @@ if(WIN32)
     set( RT_LIBRARY "winmm" )
 endif(WIN32)
 
-# append the SIMD flags if requested
-if (ENABLE_SIMD)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SIMD_COMPILER_FLAGS}")
-
-  # set for multi-configuration generators
-  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${SIMD_COMPILER_FLAGS}")
-
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${SIMD_COMPILER_FLAGS}")
-endif()
-
-
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")

CMakeModules/FindLibLZMA.cmake

@@ -1,124 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindLibLZMA
------------
-
-Find LZMA compression algorithm headers and library.
-
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``LibLZMA::LibLZMA``, if
-liblzma has been found.
-
-Result variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``LIBLZMA_FOUND``
-  True if liblzma headers and library were found.
-``LIBLZMA_INCLUDE_DIRS``
-  Directory where liblzma headers are located.
-``LIBLZMA_LIBRARIES``
-  Lzma libraries to link against.
-``LIBLZMA_HAS_AUTO_DECODER``
-  True if lzma_auto_decoder() is found (required).
-``LIBLZMA_HAS_EASY_ENCODER``
-  True if lzma_easy_encoder() is found (required).
-``LIBLZMA_HAS_LZMA_PRESET``
-  True if lzma_lzma_preset() is found (required).
-``LIBLZMA_VERSION_MAJOR``
-  The major version of lzma
-``LIBLZMA_VERSION_MINOR``
-  The minor version of lzma
-``LIBLZMA_VERSION_PATCH``
-  The patch version of lzma
-``LIBLZMA_VERSION_STRING``
-  version number as a string (ex: "5.0.3")
-#]=======================================================================]
-
-find_path(LIBLZMA_INCLUDE_DIR lzma.h )
-if(NOT LIBLZMA_LIBRARY)
-  find_library(LIBLZMA_LIBRARY_RELEASE NAMES lzma liblzma NAMES_PER_DIR PATH_SUFFIXES lib)
-  find_library(LIBLZMA_LIBRARY_DEBUG NAMES lzmad liblzmad NAMES_PER_DIR PATH_SUFFIXES lib)
-  include(SelectLibraryConfigurations)
-  select_library_configurations(LIBLZMA)
-else()
-  file(TO_CMAKE_PATH "${LIBLZMA_LIBRARY}" LIBLZMA_LIBRARY)
-endif()
-
-if(LIBLZMA_INCLUDE_DIR AND EXISTS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h")
-    file(STRINGS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h" LIBLZMA_HEADER_CONTENTS REGEX "#define LZMA_VERSION_[A-Z]+ [0-9]+")
-
-    string(REGEX REPLACE ".*#define LZMA_VERSION_MAJOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MAJOR "${LIBLZMA_HEADER_CONTENTS}")
-    string(REGEX REPLACE ".*#define LZMA_VERSION_MINOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MINOR "${LIBLZMA_HEADER_CONTENTS}")
-    string(REGEX REPLACE ".*#define LZMA_VERSION_PATCH ([0-9]+).*" "\\1" LIBLZMA_VERSION_PATCH "${LIBLZMA_HEADER_CONTENTS}")
-
-    set(LIBLZMA_VERSION_STRING "${LIBLZMA_VERSION_MAJOR}.${LIBLZMA_VERSION_MINOR}.${LIBLZMA_VERSION_PATCH}")
-    unset(LIBLZMA_HEADER_CONTENTS)
-endif()
-
-# We're using new code known now as XZ, even library still been called LZMA
-# it can be found in http://tukaani.org/xz/
-# Avoid using old codebase
-if (LIBLZMA_LIBRARY)
-  include(CheckLibraryExists)
-  set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
-  set(CMAKE_REQUIRED_QUIET ${LibLZMA_FIND_QUIETLY})
-  if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY})
-  elseif(LIBLZMA_LIBRARY_RELEASE)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_RELEASE})
-  elseif(LIBLZMA_LIBRARY_DEBUG)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_DEBUG})
-  endif()
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_auto_decoder "" LIBLZMA_HAS_AUTO_DECODER)
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_easy_encoder "" LIBLZMA_HAS_EASY_ENCODER)
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_lzma_preset "" LIBLZMA_HAS_LZMA_PRESET)
-  unset(LIBLZMA_LIBRARY_check)
-  set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})
-endif ()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LibLZMA  REQUIRED_VARS  LIBLZMA_LIBRARY
-                                                          LIBLZMA_INCLUDE_DIR
-                                                          LIBLZMA_HAS_AUTO_DECODER
-                                                          LIBLZMA_HAS_EASY_ENCODER
-                                                          LIBLZMA_HAS_LZMA_PRESET
-                                           VERSION_VAR    LIBLZMA_VERSION_STRING
-                                 )
-mark_as_advanced( LIBLZMA_INCLUDE_DIR LIBLZMA_LIBRARY )
-
-if (LIBLZMA_FOUND)
-    set(LIBLZMA_LIBRARIES ${LIBLZMA_LIBRARY})
-    set(LIBLZMA_INCLUDE_DIRS ${LIBLZMA_INCLUDE_DIR})
-    if(NOT TARGET LibLZMA::LibLZMA)
-        add_library(LibLZMA::LibLZMA UNKNOWN IMPORTED)
-        set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                              INTERFACE_INCLUDE_DIRECTORIES ${LIBLZMA_INCLUDE_DIR}
-                              IMPORTED_LINK_INTERFACE_LANGUAGES C)
-
-        if(LIBLZMA_LIBRARY_RELEASE)
-            set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY
-                IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION_RELEASE "${LIBLZMA_LIBRARY_RELEASE}")
-        endif()
-
-        if(LIBLZMA_LIBRARY_DEBUG)
-            set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY
-                IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION_DEBUG "${LIBLZMA_LIBRARY_DEBUG}")
-        endif()
-
-        if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION "${LIBLZMA_LIBRARY}")
-        endif()
-    endif()
-endif ()

SimGearConfig.cmake.in

@@ -1,7 +1,6 @@
 include(CMakeFindDependencyMacro)
 
 find_dependency(ZLIB)
-find_dependency(LibLZMA)
 find_dependency(Threads)
 
 # OSG

simgear-version

@@ -1 +0,0 @@
-2020.3.13

simgear/CMakeLists.txt

@@ -167,10 +167,7 @@ target_link_libraries(SimGearCore PRIVATE
     ${CMAKE_THREAD_LIBS_INIT}
     ${COCOA_LIBRARY}
     ${CURL_LIBRARIES}
-    ${WINSOCK_LIBRARY}
-    ${SHLWAPI_LIBRARY}
-    LibLZMA::LibLZMA
-)
+    ${WINSOCK_LIBRARY})
 
 if(SYSTEM_EXPAT)
     target_link_libraries(SimGearCore PRIVATE ${EXPAT_LIBRARIES})

simgear/canvas/Canvas.cxx

@@ -691,10 +691,6 @@ namespace canvas
       {
         _sampling_dirty = true;
       }
-      else if( name == "anisotropy" )
-      {
-        _texture.setMaxAnisotropy( node->getFloatValue() );
-      }
       else if( name == "additive-blend" )
       {
         _texture.useAdditiveBlend( node->getBoolValue() );

simgear/canvas/ODGauge.cxx

@@ -202,12 +202,6 @@ namespace canvas
     updateSampling();
   }
 
-  //----------------------------------------------------------------------------
-  void ODGauge::setMaxAnisotropy(float anis)
-  {
-    texture->setMaxAnisotropy(anis);
-  }
-
   //----------------------------------------------------------------------------
   void ODGauge::setRender(bool render)
   {
@@ -298,8 +292,8 @@ namespace canvas
   {
     if( camera.valid() && Canvas::getSystemAdapter() )
       Canvas::getSystemAdapter()->removeCamera(camera.get());
-    camera = nullptr;
-    texture = nullptr;
+    camera.release();
+    texture.release();
 
     _flags &= ~AVAILABLE;
   }

simgear/canvas/ODGauge.hxx

@@ -109,8 +109,6 @@ namespace canvas
                         int coverage_samples = 0,
                         int color_samples = 0 );
 
-      void setMaxAnisotropy(float anis);
-
       /**
        * Enable/Disable updating the texture (If disabled the contents of the
        * texture remains with the outcome of the last rendering pass)

simgear/canvas/elements/CanvasImage.cxx

@@ -850,7 +850,7 @@ namespace canvas
 void fillRow(GLubyte* row, GLuint pixel, GLuint width, GLuint pixelBytes)
 {
   GLubyte* dst = row;
-  for (GLuint x = 0; x < width; ++x) {
+  for (int x = 0; x < width; ++x) {
     memcpy(dst, &pixel, pixelBytes);
     dst += pixelBytes;
   }

simgear/canvas/layout/BoxLayout.cxx

@@ -73,7 +73,7 @@ namespace canvas
                               int stretch,
                               uint8_t alignment )
   {
-    ItemData item_data = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    ItemData item_data = {0};
     item_data.layout_item = item;
     item_data.stretch = std::max(0, stretch);
 

simgear/constants.h

@@ -218,9 +218,6 @@ const float SG_RADIANS_TO_DEGREES = 180.0f / SG_PI;
 #define SG_OBJECT_RANGE_ROUGH     9000.0
 #define SG_OBJECT_RANGE_DETAILED  1500.0
 
-/** Minimum expiry time of PagedLOD within the Tile.  Overridden by /sim/rendering/plod-minimum-expiry-time-secs **/
-#define SG_TILE_MIN_EXPIRY 180.0
-
 /** Radius of scenery tiles in m **/
 #define SG_TILE_RADIUS      14000.0
 

simgear/debug/BufferedLogCallback.hxx

@@ -26,7 +26,7 @@
 #include <vector>
 #include <memory> // for std::unique_ptr
 
-#include <simgear/debug/LogCallback.hxx>
+#include <simgear/debug/logstream.hxx>
 
 namespace simgear
 {

simgear/debug/CMakeLists.txt

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

simgear/debug/ErrorReportingCallback.cxx

@@ -1,150 +0,0 @@
-// 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.
-//
-
-#include <simgear_config.h>
-
-#include "ErrorReportingCallback.hxx"
-#include "logstream.hxx"
-
-#include <simgear/misc/sg_path.hxx>
-
-using std::string;
-
-namespace simgear {
-
-static ErrorReportCallback static_callback;
-static ContextCallback static_contextCallback;
-
-
-string_list static_errorNames = {
-    "shader/effect",
-    "loading texture",
-    "XML/animation load",
-    "3D model load",
-    "loading BTG",
-    "sceanrio load",
-    "UI dialog load",
-    "loading Audio/FX",
-    "Nasal/commnad load of XML",
-    "aircraft-systems",
-    "loading input/joystick config",
-    "load AI/traffic",
-    "from TerraSync"};
-
-string_list static_errorTypeNames = {
-    "unknown",
-    "not found",
-    "out of memory",
-    "bad header",
-    "bad data",
-    "misconfigured",
-    "disk IO/permissions",
-    "network IO"};
-
-void setErrorReportCallback(ErrorReportCallback cb)
-{
-    static_callback = cb;
-}
-
-
-void reportError(const std::string& msg, const std::string& more)
-{
-    if (!static_callback)
-        return;
-
-    static_callback(msg, more, false);
-}
-
-void reportFatalError(const std::string& msg, const std::string& more)
-{
-    if (!static_callback)
-        return;
-    static_callback(msg, more, true);
-}
-
-static FailureCallback static_failureCallback;
-
-void reportFailure(LoadFailure type, ErrorCode code, const std::string& details, sg_location loc)
-{
-    if (!static_failureCallback) {
-        SG_LOG(SG_GENERAL, SG_WARN, "Error:" << static_errorTypeNames.at(static_cast<int>(type)) << " from " << static_errorNames.at(static_cast<int>(code)) << "::" << details << "\n\t" << loc.asString());
-        return;
-    }
-
-    static_failureCallback(type, code, details, loc);
-}
-
-void reportFailure(LoadFailure type, ErrorCode code, const std::string& details, const SGPath& path)
-{
-    if (!static_failureCallback) {
-        // if no callback is registered, log here instead
-        SG_LOG(SG_GENERAL, SG_WARN, "Error:" << static_errorTypeNames.at(static_cast<int>(type)) << " from " << static_errorNames.at(static_cast<int>(code)) << "::" << details << "\n\t" << path);
-
-        return;
-    }
-
-    static_failureCallback(type, code, details, sg_location{path});
-}
-
-void setFailureCallback(FailureCallback cb)
-{
-    static_failureCallback = cb;
-}
-
-void setErrorContextCallback(ContextCallback cb)
-{
-    static_contextCallback = cb;
-}
-
-ErrorReportContext::ErrorReportContext(const std::string& key, const std::string& value)
-{
-    add(key, value);
-}
-
-void ErrorReportContext::add(const std::string& key, const std::string& value)
-{
-    if (static_contextCallback) {
-        _keys.push_back(key);
-        static_contextCallback(key, value);
-    }
-}
-
-ErrorReportContext::ErrorReportContext(const ContextMap& context)
-{
-    addFromMap(context);
-}
-
-void ErrorReportContext::addFromMap(const ContextMap& context)
-{
-    if (static_contextCallback) {
-        for (const auto& p : context) {
-            _keys.push_back(p.first);
-            static_contextCallback(p.first, p.second);
-        }
-    }
-}
-
-
-ErrorReportContext::~ErrorReportContext()
-{
-    if (static_contextCallback) {
-        // pop all our keys
-        for (const auto& k : _keys) {
-            static_contextCallback(k, "POP");
-        }
-    }
-}
-
-} // namespace simgear

simgear/debug/ErrorReportingCallback.hxx

@@ -1,128 +0,0 @@
-// 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.
-//
-
-#pragma once
-
-#include <functional>
-#include <map>
-#include <string>
-#include <vector>
-
-#include <simgear/structure/exception.hxx>
-
-//forward decls
-class SGPath;
-
-namespace simgear {
-
-void reportError(const std::string& msg, const std::string& more = {});
-
-void reportFatalError(const std::string& msg, const std::string& more = {});
-
-using ErrorReportCallback = std::function<void(const std::string& msg, const std::string& more, bool isFatal)>;
-
-void setErrorReportCallback(ErrorReportCallback cb);
-
-/** kinds of failures we can report. This is *how* (or why) something failed. Extend
-  as necessary but update the correponsdings string translations if you do. More detail isn't
- necessariyl useful here: better to provide that in the 'details' string
- */
-enum class LoadFailure {
-    Unknown,
-    NotFound,
-    OutOfMemory,
-    BadHeader,
-    BadData,
-    Misconfigured,
-    IOError, // disk full, permissions error, etc
-    NetworkError
-};
-
-/**
- @brief enum of the operations which can fail. This should be extended as necessary: it maps to
- translated error messages for the user. This describes what failed, the enum above gives why/how. The
- combination of what+why should be something at the user level: use details for debug-level information.
- */
-enum class ErrorCode {
-    LoadEffectsShaders,
-    LoadingTexture,
-    XMLModelLoad,
-    ThreeDModelLoad, // AC3D, OBJ, etc
-    BTGLoad,
-    ScenarioLoad,
-    GUIDialog,
-    AudioFX,
-    XMLLoadCommand,
-    AircraftSystems, // autopilot, hydrualics, instruments
-    InputDeviceConfig,
-    AITrafficSchedule,
-    TerraSync
-};
-/**
- @brief Define an error-reporting context value, for the duration of this
- object's lifetime. The context value will be active for any errors occuring on the same thread, while
- this object exists.
- */
-class ErrorReportContext
-{
-public:
-    ErrorReportContext(const std::string& key, const std::string& value);
-
-    using ContextMap = std::map<std::string, std::string>;
-
-    /**
-    Allow establishing multiple context values in a single operation
-     */
-    ErrorReportContext(const ContextMap& context = {});
-
-    void add(const std::string& key, const std::string& value);
-
-    /**
-     @brief allowed delayed add of values
-     */
-    void addFromMap(const ContextMap& context);
-
-    ~ErrorReportContext();
-
-private:
-    std::vector<std::string> _keys;
-};
-
-/**
- * @brief Report failure to load a resource, so they can be collated for reporting
- * to the user.
- * 
- * @param type - the reason for the failure, if it can be determined
- * @param msg - an informational message about what caused the failure
- * @param path - path on disk to the resource. In some cases this may be a relative path;
- *  especially in the case of a resource not found, we cannot report a file path.
- */
-
-void reportFailure(LoadFailure type, ErrorCode code, const std::string& detailedMessage = {}, sg_location loc = {});
-
-/**
-  overload taking a path as the location
- */
-void reportFailure(LoadFailure type, ErrorCode code, const std::string& detailedMessage, const SGPath& p);
-
-using FailureCallback = std::function<void(LoadFailure type, ErrorCode code, const std::string& details, const sg_location& location)>;
-
-void setFailureCallback(FailureCallback cb);
-
-using ContextCallback = std::function<void(const std::string& key, const std::string& value)>;
-
-void setErrorContextCallback(ContextCallback cb);
-
-} // namespace simgear

simgear/debug/LogCallback.cxx

@@ -1,116 +0,0 @@
-// 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.
-//
-
-#include <simgear_config.h>
-
-#include "LogCallback.hxx"
-
-using namespace simgear;
-
-LogCallback::LogCallback(sgDebugClass c, sgDebugPriority p) : m_class(c),
-                                                              m_priority(p)
-{
-}
-
-void LogCallback::operator()(sgDebugClass c, sgDebugPriority p,
-                             const char* file, int line, const std::string& aMessage)
-{
-    // override me
-}
-
-bool LogCallback::doProcessEntry(const LogEntry& e)
-{
-    return false;
-}
-
-void LogCallback::processEntry(const LogEntry& e)
-{
-    if (doProcessEntry(e))
-        return; // derived class used the new API
-
-    // call the old API
-    (*this)(e.debugClass, e.debugPriority, e.file, e.line, e.message);
-}
-
-
-bool LogCallback::shouldLog(sgDebugClass c, sgDebugPriority p) const
-{
-    if ((c & m_class) != 0 && p >= m_priority)
-        return true;
-    if (c == SG_OSG) // always have OSG logging as it OSG logging is configured separately.
-        return true;
-    return false;
-}
-
-void LogCallback::setLogLevels(sgDebugClass c, sgDebugPriority p)
-{
-    m_priority = p;
-    m_class = c;
-}
-const char* LogCallback::debugPriorityToString(sgDebugPriority p)
-{
-    switch (p) {
-    case SG_DEV_ALERT:
-    case SG_ALERT:
-        return "ALRT";
-    case SG_BULK: return "BULK";
-    case SG_DEBUG: return "DBUG";
-    case SG_MANDATORY_INFO:
-    case SG_INFO:
-        return "INFO";
-    case SG_POPUP: return "POPU";
-    case SG_DEV_WARN:
-    case SG_WARN:
-        return "WARN";
-
-    default: return "UNKN";
-    }
-}
-
-const char* LogCallback::debugClassToString(sgDebugClass c)
-{
-    switch (c) {
-    case SG_NONE: return "none";
-    case SG_TERRAIN: return "terrain";
-    case SG_ASTRO: return "astro";
-    case SG_FLIGHT: return "flight";
-    case SG_INPUT: return "input";
-    case SG_GL: return "opengl";
-    case SG_VIEW: return "view";
-    case SG_COCKPIT: return "cockpit";
-    case SG_GENERAL: return "general";
-    case SG_MATH: return "math";
-    case SG_EVENT: return "event";
-    case SG_AIRCRAFT: return "aircraft";
-    case SG_AUTOPILOT: return "autopilot";
-    case SG_IO: return "io";
-    case SG_CLIPPER: return "clipper";
-    case SG_NETWORK: return "network";
-    case SG_ATC: return "atc";
-    case SG_NASAL: return "nasal";
-    case SG_INSTR: return "instruments";
-    case SG_SYSTEMS: return "systems";
-    case SG_AI: return "ai";
-    case SG_ENVIRONMENT: return "environment";
-    case SG_SOUND: return "sound";
-    case SG_NAVAID: return "navaid";
-    case SG_GUI: return "gui";
-    case SG_TERRASYNC: return "terrasync";
-    case SG_PARTICLES: return "particles";
-    case SG_HEADLESS: return "headless";
-    case SG_OSG: return "OSG";
-    default: return "unknown";
-    }
-}

simgear/debug/LogCallback.hxx

@@ -1,56 +0,0 @@
-// 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.
-//
-
-#pragma once
-
-#include <string>
-
-#include "LogEntry.hxx"
-#include "debug_types.h"
-
-namespace simgear {
-
-class LogCallback
-{
-public:
-    virtual ~LogCallback() = default;
-
-    // newer API: return true if you handled the message, otherwise
-    // the old API will be called
-    virtual bool doProcessEntry(const LogEntry& e);
-
-    // old API, kept for compatability
-    virtual void operator()(sgDebugClass c, sgDebugPriority p,
-                            const char* file, int line, const std::string& aMessage);
-
-    void setLogLevels(sgDebugClass c, sgDebugPriority p);
-
-    void processEntry(const LogEntry& e);
-
-protected:
-    LogCallback(sgDebugClass c, sgDebugPriority p);
-
-    bool shouldLog(sgDebugClass c, sgDebugPriority p) const;
-
-    static const char* debugClassToString(sgDebugClass c);
-    static const char* debugPriorityToString(sgDebugPriority p);
-
-private:
-    sgDebugClass m_class;
-    sgDebugPriority m_priority;
-};
-
-
-} // namespace simgear

simgear/debug/LogEntry.cxx

@@ -1,45 +0,0 @@
-
-// 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.
-//
-
-#include <simgear_config.h>
-
-#include "LogEntry.hxx"
-
-#include <cstring> // for strdup
-
-namespace simgear {
-
-LogEntry::~LogEntry()
-{
-    if (freeFilename) {
-        free(const_cast<char*>(file));
-    }
-}
-
-LogEntry::LogEntry(const LogEntry& c) : debugClass(c.debugClass),
-                                        debugPriority(c.debugPriority),
-                                        originalPriority(c.originalPriority),
-                                        file(c.file),
-                                        line(c.line),
-                                        message(c.message),
-                                        freeFilename(c.freeFilename)
-{
-    if (c.freeFilename) {
-        file = strdup(c.file);
-    }
-}
-
-} // namespace simgear

simgear/debug/LogEntry.hxx

@@ -1,54 +0,0 @@
-// 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.
-//
-
-#pragma once
-
-#include <string>
-
-#include "debug_types.h"
-
-namespace simgear {
-/**
- * storage of a single log entry. This is used to pass log entries from
- * the various threads to the logging thread, and also to store the startup
- * entries
- */
-class LogEntry
-{
-public:
-    LogEntry(sgDebugClass c, sgDebugPriority p,
-             sgDebugPriority op,
-             const char* f, int l, const std::string& msg) : debugClass(c), debugPriority(p), originalPriority(op),
-                                                             file(f), line(l),
-                                                             message(msg)
-    {
-    }
-
-    LogEntry(const LogEntry& c);
-    LogEntry& operator=(const LogEntry& c) = delete;
-
-    ~LogEntry();
-
-    const sgDebugClass debugClass;
-    const sgDebugPriority debugPriority;
-    const sgDebugPriority originalPriority;
-    const char* file;
-    const int line;
-    const std::string message;
-
-    bool freeFilename = false; ///< if true, we own, and therefore need to free, the memory pointed to by 'file'
-};
-
-} // namespace simgear

simgear/debug/OsgIoCapture.hxx

@@ -2,7 +2,8 @@
 
 #include <osg/Notify>
 
-#include <simgear/debug/logstream.hxx>
+using namespace osg;
+
 
 /**
 * merge OSG output into our logging system, so it gets recorded to file,

simgear/debug/debug_types.h

@@ -1,5 +1,3 @@
-#pragma once
-
 /** \file debug_types.h
  *  Define the various logging classes and priorities
  */
@@ -54,17 +52,16 @@ typedef enum {
  * appended, or the priority Nasal reports to compiled code will change.
  */
 typedef enum {
-    SG_BULK = 1, // For frequent messages
-    SG_DEBUG,    // Less frequent debug type messages
-    SG_INFO,     // Informatory messages
-    SG_WARN,     // Possible impending problem
-    SG_ALERT,    // Very possible impending problem
-    SG_POPUP,    // Severe enough to alert using a pop-up window
+    SG_BULK = 1,       // For frequent messages
+    SG_DEBUG,          // Less frequent debug type messages
+    SG_INFO,           // Informatory messages
+    SG_WARN,           // Possible impending problem
+    SG_ALERT,          // Very possible impending problem
+    SG_POPUP,          // Severe enough to alert using a pop-up window
     // SG_EXIT,        // Problem (no core)
     // SG_ABORT        // Abandon ship (core)
 
-    SG_DEV_WARN,  // Warning for developers, translated to other priority
-    SG_DEV_ALERT, // Alert for developers, translated
-
-    SG_MANDATORY_INFO // information, but should always be shown
+    SG_DEV_WARN,       // Warning for developers, translated to other priority
+    SG_DEV_ALERT       // Alert for developers, translated
 } sgDebugPriority;
+

simgear/debug/logstream.cxx

@@ -35,7 +35,6 @@
 #include <simgear/threads/SGThread.hxx>
 #include <simgear/threads/SGQueue.hxx>
 
-#include "LogCallback.hxx"
 #include <simgear/io/iostreams/sgstream.hxx>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/misc/strutils.hxx>
@@ -48,9 +47,86 @@
     #include <io.h>
 #endif
 
+
+
 //////////////////////////////////////////////////////////////////////////////
 
+namespace simgear
+{
 
+LogCallback::LogCallback(sgDebugClass c, sgDebugPriority p) :
+	m_class(c),
+	m_priority(p)
+{
+}
+
+bool LogCallback::shouldLog(sgDebugClass c, sgDebugPriority p) const
+{
+
+    if ((c & m_class) != 0 && p >= m_priority)
+        return true;
+    if (c == SG_OSG) // always have OSG logging as it OSG logging is configured separately.
+        return true;
+    return false;
+}
+
+void LogCallback::setLogLevels( sgDebugClass c, sgDebugPriority p )
+{
+	m_priority = p;
+	m_class = c;
+}
+const char* LogCallback::debugPriorityToString(sgDebugPriority p)
+{
+    switch (p) {
+    case SG_ALERT: return "ALRT";
+    case SG_BULK:  return "BULK";
+    case SG_DEBUG: return "DBUG";
+    case SG_INFO:  return "INFO";
+    case SG_POPUP: return "POPU";
+    case SG_WARN:  return "WARN";
+    default: return "UNKN";
+    }
+}
+
+const char* LogCallback::debugClassToString(sgDebugClass c)
+{
+    switch (c) {
+        case SG_NONE:       return "none";
+        case SG_TERRAIN:    return "terrain";
+        case SG_ASTRO:      return "astro";
+        case SG_FLIGHT:     return "flight";
+        case SG_INPUT:      return "input";
+        case SG_GL:         return "opengl";
+        case SG_VIEW:       return "view";
+        case SG_COCKPIT:    return "cockpit";
+        case SG_GENERAL:    return "general";
+        case SG_MATH:       return "math";
+        case SG_EVENT:      return "event";
+        case SG_AIRCRAFT:   return "aircraft";
+        case SG_AUTOPILOT:  return "autopilot";
+        case SG_IO:         return "io";
+        case SG_CLIPPER:    return "clipper";
+        case SG_NETWORK:    return "network";
+        case SG_ATC:        return "atc";
+        case SG_NASAL:      return "nasal";
+        case SG_INSTR:      return "instruments";
+        case SG_SYSTEMS:    return "systems";
+        case SG_AI:         return "ai";
+        case SG_ENVIRONMENT:return "environment";
+        case SG_SOUND:      return "sound";
+        case SG_NAVAID:     return "navaid";
+        case SG_GUI:        return "gui";
+        case SG_TERRASYNC:  return "terrasync";
+        case SG_PARTICLES:  return "particles";
+        case SG_HEADLESS:   return "headless";
+        case SG_OSG:        return "OSG";
+        default:            return "unknown";
+    }
+}
+
+} // of namespace simgear
+
+//////////////////////////////////////////////////////////////////////////////
 
 class FileLogCallback : public simgear::LogCallback
 {
@@ -63,8 +139,8 @@ public:
         logTimer.stamp();
     }
 
-    void operator()(sgDebugClass c, sgDebugPriority p,
-                    const char* file, int line, const std::string& message) override
+    virtual void operator()(sgDebugClass c, sgDebugPriority p,
+        const char* file, int line, const std::string& message)
     {
         if (!shouldLog(c, p)) return;
 
@@ -120,8 +196,8 @@ public:
     }
 #endif
 
-    void operator()(sgDebugClass c, sgDebugPriority p,
-                    const char* file, int line, const std::string& aMessage) override
+    virtual void operator()(sgDebugClass c, sgDebugPriority p,
+        const char* file, int line, const std::string& aMessage)
     {
         if (!shouldLog(c, p)) return;
         //fprintf(stderr, "%s\n", aMessage.c_str());
@@ -150,8 +226,8 @@ public:
     {
     }
 
-    void operator()(sgDebugClass c, sgDebugPriority p,
-                    const char* file, int line, const std::string& aMessage) override
+    virtual void operator()(sgDebugClass c, sgDebugPriority p,
+        const char* file, int line, const std::string& aMessage)
     {
         if (!shouldLog(c, p)) return;
 
@@ -166,6 +242,28 @@ public:
 class logstream::LogStreamPrivate : public SGThread
 {
 private:
+    /**
+     * storage of a single log entry. This is used to pass log entries from
+     * the various threads to the logging thread, and also to store the startup
+     * entries
+     */
+    class LogEntry
+    {
+    public:
+        LogEntry(sgDebugClass c, sgDebugPriority p,
+            const char* f, int l, const std::string& msg) :
+            debugClass(c), debugPriority(p), file(f), line(l),
+                message(msg)
+        {
+        }
+
+        const sgDebugClass debugClass;
+        const sgDebugPriority debugPriority;
+        const char* file;
+        const int line;
+        const std::string message;
+    };
+
     /**
      * RAII object to pause the logging thread if it's running, and restart it.
      * used to safely make configuration changes.
@@ -303,20 +401,13 @@ public:
     ~LogStreamPrivate()
     {
         removeCallbacks();
-
-        // house-keeping, avoid leak warnings if we exit before disabling
-        // startup logging
-        {
-            std::lock_guard<std::mutex> g(m_lock);
-            clearStartupEntriesLocked();
-        }
     }
 
     std::mutex m_lock;
-    SGBlockingQueue<simgear::LogEntry> m_entries;
+    SGBlockingQueue<LogEntry> m_entries;
 
     // log entries posted during startup
-    std::vector<simgear::LogEntry> m_startupEntries;
+    std::vector<LogEntry> m_startupEntries;
     bool m_startupLogging = false;
 
     typedef std::vector<simgear::LogCallback*> CallbackVec;
@@ -339,8 +430,6 @@ public:
     // test suite mode.
     bool m_testMode = false;
 
-    std::vector<std::string> _popupMessages;
-
     void startLog()
     {
         std::lock_guard<std::mutex> g(m_lock);
@@ -358,19 +447,14 @@ public:
         {
             std::lock_guard<std::mutex> g(m_lock);
             m_startupLogging = on;
-            clearStartupEntriesLocked();
+            m_startupEntries.clear();
         }
     }
 
-    void clearStartupEntriesLocked()
-    {
-        m_startupEntries.clear();
-    }
-
-    void run() override
+    virtual void run()
     {
         while (1) {
-            simgear::LogEntry entry(m_entries.pop());
+            LogEntry entry(m_entries.pop());
             // special marker entry detected, terminate the thread since we are
             // making a configuration change or quitting the app
             if ((entry.debugClass == SG_NONE) && entry.file && !strcmp(entry.file, "done")) {
@@ -386,7 +470,8 @@ public:
             }
             // submit to each installed callback in turn
             for (simgear::LogCallback* cb : m_callbacks) {
-                cb->processEntry(entry);
+                (*cb)(entry.debugClass, entry.debugPriority,
+                    entry.file, entry.line, entry.message);
             }
         } // of main thread loop
     }
@@ -401,7 +486,7 @@ public:
 
             // log a special marker value, which will cause the thread to wakeup,
             // and then exit
-            log(SG_NONE, SG_ALERT, "done", -1, "", false);
+            log(SG_NONE, SG_ALERT, "done", -1, "");
         }
         join();
 
@@ -416,8 +501,9 @@ public:
 
         // we clear startup entries not using this, so always safe to run
         // this code, container will simply be empty
-        for (const auto& entry : m_startupEntries) {
-            cb->processEntry(entry);
+        for (auto entry : m_startupEntries) {
+            (*cb)(entry.debugClass, entry.debugPriority,
+               entry.file, entry.line, entry.message);
         }
     }
 
@@ -445,9 +531,9 @@ public:
         PauseThread pause(this);
         m_logPriority = p;
         m_logClass = c;
-        for (auto cb : m_consoleCallbacks) {
-            cb->setLogLevels(c, p);
-        }
+                for (auto cb : m_consoleCallbacks) {
+	        cb->setLogLevels(c, p);
+		}
     }
 
     bool would_log( sgDebugClass c, sgDebugPriority p ) const
@@ -465,17 +551,14 @@ public:
     }
 
     void log( sgDebugClass c, sgDebugPriority p,
-            const char* fileName, int line, const std::string& msg,
-             bool freeFilename)
+            const char* fileName, int line, const std::string& msg)
     {
-        auto tp = translatePriority(p);
+        p = translatePriority(p);
         if (!m_fileLine) {
             /* This prevents output of file:line in StderrLogCallback. */
             line = -line;
         }
-
-        simgear::LogEntry entry(c, tp, p, fileName, line, msg);
-        entry.freeFilename = freeFilename;
+        LogEntry entry(c, p, fileName, line, msg);
         m_entries.push(entry);
     }
 
@@ -506,8 +589,8 @@ logstream::logstream()
 
 logstream::~logstream()
 {
+    popup_msgs.clear();
     d->stop();
-    d.reset();
 }
 
 void
@@ -542,14 +625,7 @@ void
 logstream::log( sgDebugClass c, sgDebugPriority p,
         const char* fileName, int line, const std::string& msg)
 {
-    d->log(c, p, fileName, line, msg, false);
-}
-
-void
-logstream::logCopyingFilename( sgDebugClass c, sgDebugPriority p,
-         const char* fileName, int line, const std::string& msg)
-{
-    d->log(c, p, strdup(fileName), line, msg, true);
+    d->log(c, p, fileName, line, msg);
 }
 
 
@@ -610,18 +686,17 @@ void logstream::hexdump(sgDebugClass c, sgDebugPriority p, const char* fileName,
 void
 logstream::popup( const std::string& msg)
 {
-    std::lock_guard<std::mutex> g(d->m_lock);
-    d->_popupMessages.push_back(msg);
+    popup_msgs.push_back(msg);
 }
 
 std::string
 logstream::get_popup()
 {
-    std::string rv;
-    std::lock_guard<std::mutex> g(d->m_lock);
-    if (!d->_popupMessages.empty()) {
-        rv = d->_popupMessages.front();
-        d->_popupMessages.erase(d->_popupMessages.begin());
+    std::string rv = "";
+    if (!popup_msgs.empty())
+    {
+        rv = popup_msgs.front();
+        popup_msgs.erase(popup_msgs.begin());
     }
     return rv;
 }
@@ -629,8 +704,7 @@ logstream::get_popup()
 bool
 logstream::has_popup()
 {
-    std::lock_guard<std::mutex> g(d->m_lock);
-    return !d->_popupMessages.empty();
+    return (popup_msgs.size() > 0) ? true : false;
 }
 
 bool
@@ -663,16 +737,6 @@ logstream::set_log_classes( sgDebugClass c)
     d->setLogLevels(c, d->m_logPriority);
 }
 
-sgDebugPriority logstream::priorityFromString(const std::string& s)
-{
-    if (s == "bulk") return SG_BULK;
-    if (s == "debug") return SG_DEBUG;
-    if (s == "info") return SG_INFO;
-    if (s == "warn") return SG_WARN;
-    if (s == "alert") return SG_ALERT;
-
-    throw std::invalid_argument("Couldn't parse log prioirty:" + s);
-}
 
 logstream&
 sglog()

simgear/debug/logstream.hxx

@@ -37,8 +37,27 @@ class SGPath;
       
 namespace simgear
 {
+     
+class LogCallback
+{
+public:
+    virtual ~LogCallback() {}
+    virtual void operator()(sgDebugClass c, sgDebugPriority p, 
+        const char* file, int line, const std::string& aMessage) = 0;
+
+	void setLogLevels(sgDebugClass c, sgDebugPriority p);
+protected:
+	LogCallback(sgDebugClass c, sgDebugPriority p);
+
+	bool shouldLog(sgDebugClass c, sgDebugPriority p) const;
+
+    static const char* debugClassToString(sgDebugClass c);
+    static const char* debugPriorityToString(sgDebugPriority p);
+private:
+	sgDebugClass m_class;
+	sgDebugPriority m_priority;
+};
 
-class LogCallback;
 /**
  * Helper force a console on platforms where it might optional, when
  * we need to show a console. This basically means Windows at the
@@ -86,11 +105,6 @@ public:
     
     sgDebugPriority get_log_priority() const;
 
-    /**
-        @brief convert a string value to a log prioirty.
-        throws std::invalid_argument if the string is not valid
-     */
-    static sgDebugPriority priorityFromString(const std::string& s);
     /**
      * set developer mode on/off. In developer mode, SG_DEV_WARN messags
      * are treated as warnings. In normal (non-developer) mode they are
@@ -110,14 +124,6 @@ public:
     void log( sgDebugClass c, sgDebugPriority p,
             const char* fileName, int line, const std::string& msg);
 
-    // overload of above, which can transfer ownership of the file-name.
-    // this is unecesary overhead when logging from C++, since __FILE__ points
-    // to constant data, but it's needed when the filename is Nasal data (for
-    // example) since during shutdown the filename is freed by Nasal GC
-    // asynchronously with the logging thread.
-    void logCopyingFilename( sgDebugClass c, sgDebugPriority p,
-             const char* fileName, int line, const std::string& msg);
-    
     /**
     * output formatted hex dump of memory block
     */
@@ -179,6 +185,8 @@ private:
     // constructor
     logstream();
 
+    std::vector<std::string> popup_msgs;
+
     class LogStreamPrivate;
 
     std::unique_ptr<LogStreamPrivate> d;

simgear/emesary/Transmitter.hxx

@@ -45,6 +45,14 @@ namespace simgear
             std::atomic<int> receiveDepth;
             std::atomic<int> sentMessageCount;
 
+            void UnlockList()
+            {
+                _lock.unlock();
+            }
+            void LockList()
+            {
+                _lock.lock();
+            }
         public:
             Transmitter() : receiveDepth(0), sentMessageCount(0)
             {
@@ -61,17 +69,20 @@ namespace simgear
             // most recently registered recipients should process the messages/events first.
             virtual void Register(IReceiver& r)
             {
-                std::lock_guard<std::mutex> scopeLock(_lock);
+                LockList();
                 recipient_list.push_back(&r);
                 r.OnRegisteredAtTransmitter(this);
                 if (std::find(deleted_recipients.begin(), deleted_recipients.end(), &r) != deleted_recipients.end())
                     deleted_recipients.remove(&r);
+
+                UnlockList();
             }
 
             //  Removes an object from receving message from this transmitter
             virtual void DeRegister(IReceiver& R)
             {
-                std::lock_guard<std::mutex> scopeLock(_lock);
+                LockList();
+                //printf("Remove %x\n", &R);
                 if (recipient_list.size())
                 {
                     if (std::find(recipient_list.begin(), recipient_list.end(), &R) != recipient_list.end())
@@ -82,6 +93,7 @@ namespace simgear
                             deleted_recipients.push_back(&R);
                     }
                 }
+                UnlockList();
             }
 
             // Notify all registered recipients. Stop when receipt status of abort or finished are received.
@@ -95,68 +107,69 @@ namespace simgear
                 ReceiptStatus return_status = ReceiptStatusNotProcessed;
 
                 sentMessageCount++;
-
-                std::vector<IReceiver*> temp;
+                try
                 {
-                    std::lock_guard<std::mutex> scopeLock(_lock);
+                    LockList();
                     if (receiveDepth == 0)
                         deleted_recipients.clear();
                     receiveDepth++;
-
+                    std::vector<IReceiver*> temp(recipient_list.size());
                     int idx = 0;
                     for (RecipientList::iterator i = recipient_list.begin(); i != recipient_list.end(); i++)
                     {
-                        temp.push_back(*i);
+                        temp[idx++] = *i;
                     }
-                }
-                int tempSize = temp.size();
-                for (int index = 0; index < tempSize; index++)
-                {
-                    IReceiver* R = temp[index];
+                    UnlockList();
+                    int tempSize = temp.size();
+                    for (int index = 0; index < tempSize; index++)
                     {
-                        std::lock_guard<std::mutex> scopeLock(_lock);
+                        IReceiver* R = temp[index];
+                        LockList();
                         if (deleted_recipients.size())
                         {
                             if (std::find(deleted_recipients.begin(), deleted_recipients.end(), R) != deleted_recipients.end())
                             {
+                                UnlockList();
                                 continue;
                             }
                         }
-                    }
-                    if (R)
-                    {
-                        ReceiptStatus rstat = R->Receive(M);
-                        switch (rstat)
+                        UnlockList();
+                        if (R)
                         {
-                        case ReceiptStatusFail:
-                            return_status = ReceiptStatusFail;
-                            break;
+                            ReceiptStatus rstat = R->Receive(M);
+                            switch (rstat)
+                            {
+                            case ReceiptStatusFail:
+                                return_status = ReceiptStatusFail;
+                                break;
+                            case ReceiptStatusPending:
+                                return_status = ReceiptStatusPending;
+                                break;
+                            case ReceiptStatusPendingFinished:
+                                return rstat;
 
-                        case ReceiptStatusPending:
-                            return_status = ReceiptStatusPending;
-                            break;
+                            case ReceiptStatusNotProcessed:
+                                break;
+                            case ReceiptStatusOK:
+                                if (return_status == ReceiptStatusNotProcessed)
+                                    return_status = rstat;
+                                break;
 
-                        case ReceiptStatusPendingFinished:
-                            return rstat;
+                            case ReceiptStatusAbort:
+                                return ReceiptStatusAbort;
 
-                        case ReceiptStatusNotProcessed:
-                            break;
-
-                        case ReceiptStatusOK:
-                            if (return_status == ReceiptStatusNotProcessed)
-                                return_status = rstat;
-                            break;
-
-                        case ReceiptStatusAbort:
-                            return ReceiptStatusAbort;
-
-                        case ReceiptStatusFinished:
-                            return ReceiptStatusOK;
+                            case ReceiptStatusFinished:
+                                return ReceiptStatusOK;
+                            }
                         }
+
                     }
-
                 }
-
+                catch (...)
+                {
+                    throw;
+                    // return_status = ReceiptStatusAbort;
+                }
                 receiveDepth--;
                 return return_status;
             }
@@ -164,8 +177,9 @@ namespace simgear
             // number of currently registered recipients
             virtual int Count()
             {
-                std::lock_guard<std::mutex> scopeLock(_lock);
+                LockList();
                 return recipient_list.size();
+                UnlockList();
             }
 
             // number of sent messages.

simgear/environment/metar.cxx

@@ -46,7 +46,6 @@
 #include <sstream>
 
 #include <simgear/debug/logstream.hxx>
-#include <simgear/math/sg_random.h>
 #include <simgear/structure/exception.hxx>
 
 #include "metar.hxx"
@@ -632,41 +631,30 @@ bool SGMetar::scanWind()
 	int dir;
 	if (!strncmp(m, "VRB", 3))
 		m += 3, dir = -1;
-	else if (!strncmp(m, "///", 3))	// direction not measurable
-		m += 3, dir = -1;
 	else if (!scanNumber(&m, &dir, 3))
 		return false;
 
 	int i;
-	if (!strncmp(m, "//", 2))	// speed not measurable
-		m += 2, i = -1;
-	else if (!scanNumber(&m, &i, 2, 3))
+	if (!scanNumber(&m, &i, 2, 3))
 		return false;
 	double speed = i;
 
 	double gust = NaN;
 	if (*m == 'G') {
 		m++;
-		if (!strncmp(m, "//", 2))	// speed not measurable
-			m += 2, i = -1;
-		else if (!scanNumber(&m, &i, 2, 3))
+		if (!scanNumber(&m, &i, 2, 3))
 			return false;
-
-		if (i != -1)
-			gust = i;
+		gust = i;
 	}
-
 	double factor;
 	if (!strncmp(m, "KT", 2))
 		m += 2, factor = SG_KT_TO_MPS;
-	else if (!strncmp(m, "KMH", 3))		// invalid Km/h
+	else if (!strncmp(m, "KMH", 3))
 		m += 3, factor = SG_KMH_TO_MPS;
-	else if (!strncmp(m, "KPH", 3))		// invalid Km/h
+	else if (!strncmp(m, "KPH", 3))		// ??
 		m += 3, factor = SG_KMH_TO_MPS;
 	else if (!strncmp(m, "MPS", 3))
 		m += 3, factor = 1.0;
-	else if (!strncmp(m, " ", 1))		// default to Knots
-		factor = SG_KT_TO_MPS;
 	else
 		return false;
 	if (!scanBoundary(&m))
@@ -686,28 +674,18 @@ bool SGMetar::scanVariability()
 {
 	char *m = _m;
 	int from, to;
-
-	if (!strncmp(m, "///", 3))	// direction not measurable
-		m += 3, from = -1;
-	else if (!scanNumber(&m, &from, 3))
+	if (!scanNumber(&m, &from, 3))
 		return false;
-
 	if (*m++ != 'V')
 		return false;
-
-	if (!strncmp(m, "///", 3))	// direction not measurable
-		m += 3, to = -1;
-	else if (!scanNumber(&m, &to, 3))
+	if (!scanNumber(&m, &to, 3))
 		return false;
-
 	if (!scanBoundary(&m))
 		return false;
-
 	_m = m;
 	_wind_range_from = from;
 	_wind_range_to = to;
 	_grpcount++;
-
 	return true;
 }
 
@@ -974,8 +952,6 @@ bool SGMetar::scanWeather()
 		weather += string(a->text) + " ";
 		if (!strcmp(a->id, "RA"))
 			_rain = w.intensity;
-		else if (!strcmp(a->id, "DZ"))
-			_rain = LIGHT;
 		else if (!strcmp(a->id, "HA"))
 			_hail = w.intensity;
 		else if (!strcmp(a->id, "SN"))
@@ -1069,12 +1045,9 @@ bool SGMetar::scanSkyCondition()
 		return false;
 	m += i;
 
-	if (!strncmp(m, "///", 3))	{ // vis not measurable (e.g. because of heavy snowing)
+	if (!strncmp(m, "///", 3))	// vis not measurable (e.g. because of heavy snowing)
 		m += 3, i = -1;
-		sg_srandom_time();
-		// randomize the base height to avoid the black sky issue
-		i = 50 + static_cast<int>(sg_random() * 250.0);		// range [5,000, 30,000]
-	} else if (scanBoundary(&m)) {
+	else if (scanBoundary(&m)) {
 		_m = m;
 		return true;				// ignore single OVC/BKN/...
 	} else if (!scanNumber(&m, &i, 3))

simgear/environment/test_metar.cxx

@@ -76,38 +76,12 @@ void test_sensor_failure_cloud()
     SG_CHECK_EQUAL_EP2(m1.getPressure_hPa(), 1025, TEST_EPSILON);
 }
 
-void test_sensor_failure_wind()
-{
-    SGMetar m1("2020/10/23 16:55 LIVD 231655Z /////KT 9999 OVC025 10/08 Q1020 RMK OVC VIS MIN 9999 BLU");
-    SG_CHECK_EQUAL(m1.getWindDir(), -1);
-    SG_CHECK_EQUAL_EP2(m1.getWindSpeed_kt(), -1, TEST_EPSILON);
-
-    SGMetar m2("2020/10/21 16:55 LIVD 211655Z /////KT CAVOK 07/03 Q1023 RMK SKC VIS MIN 9999 BLU");
-    SG_CHECK_EQUAL(m2.getWindDir(), -1);
-    SG_CHECK_EQUAL_EP2(m2.getWindSpeed_kt(), -1, TEST_EPSILON);
-
-    SGMetar m3("2020/11/17 16:00 CYAZ 171600Z 14040G//KT 10SM -RA OVC012 12/11 A2895 RMK NS8 VIA CYXY SLP806 DENSITY ALT 900FT");
-    SG_CHECK_EQUAL(m3.getWindDir(), 140);
-    SG_CHECK_EQUAL_EP2(m3.getWindSpeed_kt(), 40, TEST_EPSILON);
-    SG_CHECK_EQUAL_EP2(m3.getGustSpeed_kt(), SGMetarNaN, TEST_EPSILON);
-}
-
-void test_wind_unit_not_specified()
-{
-    SGMetar m1("2020/10/23 11:58 KLSV 231158Z 05010G14 10SM CLR 16/M04 A2992 RMK SLPNO WND DATA ESTMD ALSTG/SLP ESTMD 10320 20124 5//// $");
-    SG_CHECK_EQUAL(m1.getWindDir(), 50);
-    SG_CHECK_EQUAL_EP2(m1.getWindSpeed_kt(), 10.0, TEST_EPSILON);
-    SG_CHECK_EQUAL_EP2(m1.getGustSpeed_kt(), 14.0, TEST_EPSILON);
-}
-
 int main(int argc, char* argv[])
 {
     try {
         test_basic();
         test_sensor_failure_weather();
         test_sensor_failure_cloud();
-        test_sensor_failure_wind();
-        test_wind_unit_not_specified();
     } catch (sg_exception& e) {
         cerr << "got exception:" << e.getMessage() << endl;
         return -1;

simgear/io/ArchiveExtractor_private.hxx

@@ -1,90 +0,0 @@
-// Copyright (C) 2021  James Turner - <james@flightgear.org>
-//
-// 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.
-//
-
-
-#pragma once
-
-#include "untar.hxx"
-
-namespace simgear {
-
-class ArchiveExtractorPrivate
-{
-public:
-    ArchiveExtractorPrivate(ArchiveExtractor* o) : outer(o)
-    {
-        assert(outer);
-    }
-
-    virtual ~ArchiveExtractorPrivate() = default;
-
-    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;
-    }
-};
-
-} // namespace simgear

simgear/io/CMakeLists.txt

@@ -35,12 +35,10 @@ set(SOURCES
     sg_socket.cxx
     sg_socket_udp.cxx
     HTTPClient.cxx
-    HTTPTestApi_private.hxx
     HTTPFileRequest.cxx
     HTTPMemoryRequest.cxx
     HTTPRequest.cxx
     HTTPRepository.cxx
-    HTTPRepository_private.hxx
     untar.cxx
     )
 
@@ -83,7 +81,6 @@ add_test(binobj ${EXECUTABLE_OUTPUT_PATH}/test_binobj)
 
 add_executable(test_repository test_repository.cxx)
 target_link_libraries(test_repository ${TEST_LIBS})
-target_compile_definitions(test_repository PUBLIC BUILDING_TESTSUITE)
 add_test(http_repository ${EXECUTABLE_OUTPUT_PATH}/test_repository)
 
 add_executable(test_untar test_untar.cxx)

simgear/io/DNSClient.cxx

@@ -61,10 +61,6 @@ public:
 
     struct dns_ctx * ctx;
     static size_t instanceCounter;
-
-    using RequestVec = std::vector<Request_ptr>;
-
-    RequestVec _activeRequests;
 };
 
 size_t Client::ClientPrivate::instanceCounter = 0;
@@ -82,11 +78,6 @@ Request::~Request()
 {
 }
 
-void Request::cancel()
-{
-    _cancelled = true;
-}
-
 bool Request::isTimeout() const
 {
     return (time(NULL) - _start) > _timeout_secs;
@@ -123,20 +114,18 @@ static void dnscbSRV(struct dns_ctx *ctx, struct dns_rr_srv *result, void *data)
 {
     SRVRequest * r = static_cast<SRVRequest*>(data);
     if (result) {
-        if (!r->isCancelled()) {
-            r->cname = result->dnssrv_cname;
-            r->qname = result->dnssrv_qname;
-            r->ttl = result->dnssrv_ttl;
-            for (int i = 0; i < result->dnssrv_nrr; i++) {
-                SRVRequest::SRV_ptr srv(new SRVRequest::SRV);
-                r->entries.push_back(srv);
-                srv->priority = result->dnssrv_srv[i].priority;
-                srv->weight = result->dnssrv_srv[i].weight;
-                srv->port = result->dnssrv_srv[i].port;
-                srv->target = result->dnssrv_srv[i].name;
-            }
-            std::sort(r->entries.begin(), r->entries.end(), sortSRV);
+        r->cname = result->dnssrv_cname;
+        r->qname = result->dnssrv_qname;
+        r->ttl = result->dnssrv_ttl;
+        for (int i = 0; i < result->dnssrv_nrr; i++) {
+            SRVRequest::SRV_ptr srv(new SRVRequest::SRV);
+            r->entries.push_back(srv);
+            srv->priority = result->dnssrv_srv[i].priority;
+            srv->weight = result->dnssrv_srv[i].weight;
+            srv->port = result->dnssrv_srv[i].port;
+            srv->target = result->dnssrv_srv[i].name;
         }
+        std::sort( r->entries.begin(), r->entries.end(), sortSRV );
         free(result);
     }
     r->setComplete();
@@ -145,16 +134,11 @@ static void dnscbSRV(struct dns_ctx *ctx, struct dns_rr_srv *result, void *data)
 void SRVRequest::submit( Client * client )
 {
     // if service is defined, pass service and protocol
-    auto q = dns_submit_srv(client->d->ctx, getDn().c_str(), _service.empty() ? NULL : _service.c_str(),
-                            _service.empty() ? NULL : _protocol.c_str(),
-                            0, dnscbSRV, this);
-
-    if (!q) {
+    if (!dns_submit_srv(client->d->ctx, getDn().c_str(), _service.empty() ? NULL : _service.c_str(), _service.empty() ? NULL : _protocol.c_str(), 0, dnscbSRV, this )) {
         SG_LOG(SG_IO, SG_ALERT, "Can't submit dns request for " << getDn());
         return;
     }
     _start = time(NULL);
-    _query = q;
 }
 
 TXTRequest::TXTRequest( const std::string & dn ) :
@@ -167,24 +151,17 @@ static void dnscbTXT(struct dns_ctx *ctx, struct dns_rr_txt *result, void *data)
 {
     TXTRequest * r = static_cast<TXTRequest*>(data);
     if (result) {
-        if (!r->isCancelled()) {
-            r->cname = result->dnstxt_cname;
-            r->qname = result->dnstxt_qname;
-            r->ttl = result->dnstxt_ttl;
-            for (int i = 0; i < result->dnstxt_nrr; i++) {
-                //TODO: interprete the .len field of dnstxt_txt?
-                auto rawTxt = reinterpret_cast<char*>(result->dnstxt_txt[i].txt);
-                if (!rawTxt) {
-                    continue;
-                }
-
-                const string txt{rawTxt};
-                r->entries.push_back(txt);
-                string_list tokens = simgear::strutils::split(txt, "=", 1);
-                if (tokens.size() == 2) {
-                    r->attributes[tokens[0]] = tokens[1];
-                }
-            }
+        r->cname = result->dnstxt_cname;
+        r->qname = result->dnstxt_qname;
+        r->ttl = result->dnstxt_ttl;
+        for (int i = 0; i < result->dnstxt_nrr; i++) {
+          //TODO: interprete the .len field of dnstxt_txt?
+          string txt = string((char*)result->dnstxt_txt[i].txt);
+          r->entries.push_back( txt );
+          string_list tokens = simgear::strutils::split( txt, "=", 1 );
+          if( tokens.size() == 2 ) {
+            r->attributes[tokens[0]] = tokens[1];
+          }
         }
         free(result);
     }
@@ -194,13 +171,11 @@ static void dnscbTXT(struct dns_ctx *ctx, struct dns_rr_txt *result, void *data)
 void TXTRequest::submit( Client * client )
 {
     // protocol and service an already encoded in DN so pass in NULL for both
-    auto q = dns_submit_txt(client->d->ctx, getDn().c_str(), DNS_C_IN, 0, dnscbTXT, this);
-    if (!q) {
+    if (!dns_submit_txt(client->d->ctx, getDn().c_str(), DNS_C_IN, 0, dnscbTXT, this )) {
         SG_LOG(SG_IO, SG_ALERT, "Can't submit dns request for " << getDn());
         return;
     }
     _start = time(NULL);
-    _query = q;
 }
 
 
@@ -215,29 +190,27 @@ static void dnscbNAPTR(struct dns_ctx *ctx, struct dns_rr_naptr *result, void *d
 {
     NAPTRRequest * r = static_cast<NAPTRRequest*>(data);
     if (result) {
-        if (!r->isCancelled()) {
-            r->cname = result->dnsnaptr_cname;
-            r->qname = result->dnsnaptr_qname;
-            r->ttl = result->dnsnaptr_ttl;
-            for (int i = 0; i < result->dnsnaptr_nrr; i++) {
-                if (!r->qservice.empty() && r->qservice != result->dnsnaptr_naptr[i].service)
-                    continue;
+        r->cname = result->dnsnaptr_cname;
+        r->qname = result->dnsnaptr_qname;
+        r->ttl = result->dnsnaptr_ttl;
+        for (int i = 0; i < result->dnsnaptr_nrr; i++) {
+            if( !r->qservice.empty() && r->qservice != result->dnsnaptr_naptr[i].service )
+                continue;
 
-                //TODO: case ignore and result flags may have more than one flag
-                if (!r->qflags.empty() && r->qflags != result->dnsnaptr_naptr[i].flags)
-                    continue;
+            //TODO: case ignore and result flags may have more than one flag
+            if( !r->qflags.empty() && r->qflags != result->dnsnaptr_naptr[i].flags )
+                continue;
 
-                NAPTRRequest::NAPTR_ptr naptr(new NAPTRRequest::NAPTR);
-                r->entries.push_back(naptr);
-                naptr->order = result->dnsnaptr_naptr[i].order;
-                naptr->preference = result->dnsnaptr_naptr[i].preference;
-                naptr->flags = result->dnsnaptr_naptr[i].flags;
-                naptr->service = result->dnsnaptr_naptr[i].service;
-                naptr->regexp = result->dnsnaptr_naptr[i].regexp;
-                naptr->replacement = result->dnsnaptr_naptr[i].replacement;
-            }
-            std::sort(r->entries.begin(), r->entries.end(), sortNAPTR);
+            NAPTRRequest::NAPTR_ptr naptr(new NAPTRRequest::NAPTR);
+            r->entries.push_back(naptr);
+            naptr->order = result->dnsnaptr_naptr[i].order;
+            naptr->preference = result->dnsnaptr_naptr[i].preference;
+            naptr->flags = result->dnsnaptr_naptr[i].flags;
+            naptr->service = result->dnsnaptr_naptr[i].service;
+            naptr->regexp = result->dnsnaptr_naptr[i].regexp;
+            naptr->replacement = result->dnsnaptr_naptr[i].replacement;
         }
+        std::sort( r->entries.begin(), r->entries.end(), sortNAPTR );
         free(result);
     }
     r->setComplete();
@@ -245,13 +218,11 @@ static void dnscbNAPTR(struct dns_ctx *ctx, struct dns_rr_naptr *result, void *d
 
 void NAPTRRequest::submit( Client * client )
 {
-    auto q = dns_submit_naptr(client->d->ctx, getDn().c_str(), 0, dnscbNAPTR, this);
-    if (!q) {
+    if (!dns_submit_naptr(client->d->ctx, getDn().c_str(), 0, dnscbNAPTR, this )) {
         SG_LOG(SG_IO, SG_ALERT, "Can't submit dns request for " << getDn());
         return;
     }
     _start = time(NULL);
-    _query = q;
 }
 
 
@@ -266,7 +237,6 @@ Client::Client() :
 
 void Client::makeRequest(const Request_ptr& r)
 {
-    d->_activeRequests.push_back(r);
     r->submit(this);
 }
 
@@ -277,19 +247,6 @@ void Client::update(int waitTimeout)
         return;
 
     dns_ioevent(d->ctx, now);
-
-    // drop our owning ref to completed requests,
-    // and cancel any which timed out
-    auto it = std::remove_if(d->_activeRequests.begin(), d->_activeRequests.end(),
-                             [this](const Request_ptr& r) {
-                                 if (r->isTimeout()) {
-                                     dns_cancel(d->ctx, reinterpret_cast<struct dns_query*>(r->_query));
-                                     return true;
-                                 }
-
-                                 return r->isComplete();
-                             });
-    d->_activeRequests.erase(it, d->_activeRequests.end());
 }
 
 } // of namespace DNS

simgear/io/DNSClient.hxx

@@ -40,38 +40,28 @@ namespace DNS
 {
 
 class Client;
-
-using UDNSQueryPtr = void*;
-
 class Request : public SGReferenced
 {
 public:
     Request( const std::string & dn );
     virtual ~Request();
-    const std::string& getDn() const { return _dn; }
+    std::string getDn() const { return _dn; }
     int getType() const { return _type; }
     bool isComplete() const { return _complete; }
     bool isTimeout() const;
     void setComplete( bool b = true ) { _complete = b; }
-    bool isCancelled() const { return _cancelled; }
 
     virtual void submit( Client * client) = 0;
 
-    void cancel();
-
     std::string cname;
     std::string qname;
     unsigned ttl;
 protected:
-    friend class Client;
-
-    UDNSQueryPtr _query = nullptr;
     std::string _dn;
     int _type;
     bool _complete;
     time_t _timeout_secs;
     time_t _start;
-    bool _cancelled = false;
 };
 typedef SGSharedPtr<Request> Request_ptr;
 
@@ -79,7 +69,7 @@ class NAPTRRequest : public Request
 {
 public:
     NAPTRRequest( const std::string & dn );
-    void submit(Client* client) override;
+    virtual void submit( Client * client );
 
     struct NAPTR : SGReferenced {
         int order;
@@ -102,7 +92,7 @@ class SRVRequest : public Request
 public:
     SRVRequest( const std::string & dn );
     SRVRequest( const std::string & dn, const string & service, const string & protocol );
-    void submit(Client* client) override;
+    virtual void submit( Client * client );
 
     struct SRV : SGReferenced {
       int priority;
@@ -122,7 +112,7 @@ class TXTRequest : public Request
 {
 public:
     TXTRequest( const std::string & dn );
-    void submit(Client* client) override;
+    virtual void submit( Client * client );
 
     typedef std::vector<string> TXT_list;
     typedef std::map<std::string,std::string> TXT_Attribute_map;

simgear/io/HTTPClient.cxx

@@ -37,6 +37,7 @@
 
 #include <simgear/simgear_config.h>
 
+#include <curl/multi.h>
 
 #include <simgear/io/sg_netChat.hxx>
 
@@ -46,9 +47,6 @@
 #include <simgear/timing/timestamp.hxx>
 #include <simgear/structure/exception.hxx>
 
-#include "HTTPClient_private.hxx"
-#include "HTTPTestApi_private.hxx"
-
 #if defined( HAVE_VERSION_H ) && HAVE_VERSION_H
 #include "version.h"
 #else
@@ -66,23 +64,62 @@ namespace HTTP
 extern const int DEFAULT_HTTP_PORT = 80;
 const char* CONTENT_TYPE_URL_ENCODED = "application/x-www-form-urlencoded";
 
-void Client::ClientPrivate::createCurlMulti() {
-  curlMulti = curl_multi_init();
-  // see https://curl.haxx.se/libcurl/c/CURLMOPT_PIPELINING.html
-  // we request HTTP 1.1 pipelining
-  curl_multi_setopt(curlMulti, CURLMOPT_PIPELINING, 1 /* aka CURLPIPE_HTTP1 */);
-#if (LIBCURL_VERSION_MINOR >= 30)
-  curl_multi_setopt(curlMulti, CURLMOPT_MAX_TOTAL_CONNECTIONS,
-                    (long)maxConnections);
-  curl_multi_setopt(curlMulti, CURLMOPT_MAX_PIPELINE_LENGTH,
-                    (long)maxPipelineDepth);
-  curl_multi_setopt(curlMulti, CURLMOPT_MAX_HOST_CONNECTIONS,
-                    (long)maxHostConnections);
-#endif
-}
+class Connection;
+typedef std::multimap<std::string, Connection*> ConnectionDict;
+typedef std::list<Request_ptr> RequestList;
 
-Client::Client()
+class Client::ClientPrivate
 {
+public:
+    CURLM* curlMulti;
+
+    void createCurlMulti()
+    {
+        curlMulti = curl_multi_init();
+        // see https://curl.haxx.se/libcurl/c/CURLMOPT_PIPELINING.html
+        // we request HTTP 1.1 pipelining
+        curl_multi_setopt(curlMulti, CURLMOPT_PIPELINING, 1 /* aka CURLPIPE_HTTP1 */);
+#if (LIBCURL_VERSION_MINOR >= 30)
+        curl_multi_setopt(curlMulti, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long) maxConnections);
+        curl_multi_setopt(curlMulti, CURLMOPT_MAX_PIPELINE_LENGTH,
+                          (long) maxPipelineDepth);
+        curl_multi_setopt(curlMulti, CURLMOPT_MAX_HOST_CONNECTIONS,
+                          (long) maxHostConnections);
+#endif
+    }
+
+    typedef std::map<Request_ptr, CURL*> RequestCurlMap;
+    RequestCurlMap requests;
+
+    std::string userAgent;
+    std::string proxy;
+    int proxyPort;
+    std::string proxyAuth;
+    unsigned int maxConnections;
+    unsigned int maxHostConnections;
+    unsigned int maxPipelineDepth;
+
+    RequestList pendingRequests;
+
+    SGTimeStamp timeTransferSample;
+    unsigned int bytesTransferred;
+    unsigned int lastTransferRate;
+    uint64_t totalBytesDownloaded;
+};
+
+Client::Client() :
+    d(new ClientPrivate)
+{
+    d->proxyPort = 0;
+    d->maxConnections = 4;
+    d->maxHostConnections = 4;
+    d->bytesTransferred = 0;
+    d->lastTransferRate = 0;
+    d->timeTransferSample.stamp();
+    d->totalBytesDownloaded = 0;
+    d->maxPipelineDepth = 5;
+    setUserAgent("SimGear-" SG_STRINGIZE(SIMGEAR_VERSION));
+
     static bool didInitCurlGlobal = false;
     static std::mutex initMutex;
 
@@ -92,7 +129,7 @@ Client::Client()
       didInitCurlGlobal = true;
     }
 
-    reset();
+    d->createCurlMulti();
 }
 
 Client::~Client()
@@ -124,27 +161,6 @@ void Client::setMaxPipelineDepth(unsigned int depth)
 #endif
 }
 
-void Client::reset()
-{
-    if (d.get()) {
-        curl_multi_cleanup(d->curlMulti);
-    }
-
-    d.reset(new ClientPrivate);
-
-    d->proxyPort = 0;
-    d->maxConnections = 4;
-    d->maxHostConnections = 4;
-    d->bytesTransferred = 0;
-    d->lastTransferRate = 0;
-    d->timeTransferSample.stamp();
-    d->totalBytesDownloaded = 0;
-    d->maxPipelineDepth = 5;
-    setUserAgent("SimGear-" SG_STRINGIZE(SIMGEAR_VERSION));
-    d->tlsCertificatePath = SGPath::fromEnv("SIMGEAR_TLS_CERT_PATH");
-    d->createCurlMulti();
-}
-
 void Client::update(int waitTimeout)
 {
     if (d->requests.empty()) {
@@ -155,22 +171,32 @@ void Client::update(int waitTimeout)
     }
 
     int remainingActive, messagesInQueue;
-    int numFds;
-    CURLMcode mc = curl_multi_wait(d->curlMulti, NULL, 0, waitTimeout, &numFds);
-    if (mc != CURLM_OK) {
-        SG_LOG(SG_IO, SG_WARN, "curl_multi_wait failed:" << curl_multi_strerror(mc));
-        return;
+#if defined(SG_MAC)
+    // Mac 10.8 libCurl lacks this, let's keep compat for now
+    fd_set curlReadFDs, curlWriteFDs, curlErrorFDs;
+    int maxFD;
+    curl_multi_fdset(d->curlMulti,
+                     &curlReadFDs,
+                     &curlWriteFDs,
+                     &curlErrorFDs,
+                     &maxFD);
+
+    struct timeval timeout;
+    long t;
+
+    curl_multi_timeout(d->curlMulti, &t);
+    if ((t < 0) || (t > waitTimeout)) {
+        t = waitTimeout;
     }
 
-    mc = curl_multi_perform(d->curlMulti, &remainingActive);
-    if (mc == CURLM_CALL_MULTI_PERFORM) {
-        // we could loop here, but don't want to get blocked
-        // also this shouldn't  ocurr in any modern libCurl
-        curl_multi_perform(d->curlMulti, &remainingActive);
-    } else if (mc != CURLM_OK) {
-        SG_LOG(SG_IO, SG_WARN, "curl_multi_perform failed:" << curl_multi_strerror(mc));
-        return;
-    }
+    timeout.tv_sec = t / 1000;
+    timeout.tv_usec = (t % 1000) * 1000;
+    ::select(maxFD, &curlReadFDs, &curlWriteFDs, &curlErrorFDs, &timeout);
+#else
+    int numFds;
+    curl_multi_wait(d->curlMulti, NULL, 0, waitTimeout, &numFds);
+#endif
+    curl_multi_perform(d->curlMulti, &remainingActive);
 
     CURLMsg* msg;
     while ((msg = curl_multi_info_read(d->curlMulti, &messagesInQueue))) {
@@ -195,23 +221,12 @@ void Client::update(int waitTimeout)
           assert(it->second == e);
           d->requests.erase(it);
 
-          bool doProcess = true;
-          if (d->testsuiteResponseDoneCallback) {
-            doProcess =
-                !d->testsuiteResponseDoneCallback(msg->data.result, req);
-          }
-
-          if (doProcess) {
-            if (msg->data.result == 0) {
-              req->responseComplete();
-            } else {
-              SG_LOG(SG_IO, SG_WARN,
-                     "CURL Result:" << msg->data.result << " "
-                                    << curl_easy_strerror(msg->data.result));
-              req->setFailure(msg->data.result,
-                              curl_easy_strerror(msg->data.result));
-            }
-          }
+        if (msg->data.result == 0) {
+          req->responseComplete();
+        } else {
+          SG_LOG(SG_IO, SG_WARN, "CURL Result:" << msg->data.result << " " << curl_easy_strerror(msg->data.result));
+          req->setFailure(msg->data.result, curl_easy_strerror(msg->data.result));
+        }
 
         curl_multi_remove_handle(d->curlMulti, e);
         curl_easy_cleanup(e);
@@ -270,11 +285,6 @@ void Client::makeRequest(const Request_ptr& r)
 
     curl_easy_setopt(curlRequest, CURLOPT_FOLLOWLOCATION, 1);
 
-    if (!d->tlsCertificatePath.isNull()) {
-        const auto utf8 = d->tlsCertificatePath.utf8Str();
-        curl_easy_setopt(curlRequest, CURLOPT_CAINFO, utf8.c_str());
-    }
-
     if (!d->proxy.empty()) {
       curl_easy_setopt(curlRequest, CURLOPT_PROXY, d->proxy.c_str());
       curl_easy_setopt(curlRequest, CURLOPT_PROXYPORT, d->proxyPort);
@@ -542,17 +552,6 @@ void Client::clearAllConnections()
     d->createCurlMulti();
 }
 
-/////////////////////////////////////////////////////////////////////
-
-void TestApi::setResponseDoneCallback(Client *cl, ResponseDoneCallback cb) {
-  cl->d->testsuiteResponseDoneCallback = cb;
-}
-
-void TestApi::markRequestAsFailed(Request_ptr req, int curlCode,
-                                  const std::string &message) {
-  req->setFailure(curlCode, message);
-}
-
 } // of namespace HTTP
 
 } // of namespace simgear

simgear/io/HTTPClient.hxx

@@ -24,8 +24,7 @@
 #ifndef SG_HTTP_CLIENT_HXX
 #define SG_HTTP_CLIENT_HXX
 
-#include <functional>
-#include <memory>   // for std::unique_ptr
+#include <memory> // for std::unique_ptr
 #include <stdint.h> // for uint_64t
 
 #include <simgear/io/HTTPFileRequest.hxx>
@@ -48,8 +47,6 @@ public:
 
     void update(int waitTimeout = 0);
 
-    void reset();
-
     void makeRequest(const Request_ptr& r);
 
     void cancelRequest(const Request_ptr& r, std::string reason = std::string());
@@ -126,7 +123,6 @@ private:
 
     friend class Connection;
     friend class Request;
-    friend class TestApi;
 
     class ClientPrivate;
     std::unique_ptr<ClientPrivate> d;

simgear/io/HTTPClient_private.hxx

@@ -1,68 +0,0 @@
-// 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 Library General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
-
-#pragma once
-
-#include <list>
-#include <map>
-
-#include "HTTPClient.hxx"
-#include "HTTPRequest.hxx"
-
-#include <simgear/timing/timestamp.hxx>
-
-#include <curl/multi.h>
-
-namespace simgear {
-namespace HTTP {
-
-typedef std::list<Request_ptr> RequestList;
-
-using ResponseDoneCallback =
-    std::function<bool(int curlResult, Request_ptr req)>;
-
-class Client::ClientPrivate {
-public:
-  CURLM *curlMulti;
-
-  void createCurlMulti();
-
-  typedef std::map<Request_ptr, CURL *> RequestCurlMap;
-  RequestCurlMap requests;
-
-  std::string userAgent;
-  std::string proxy;
-  int proxyPort;
-  std::string proxyAuth;
-  unsigned int maxConnections;
-  unsigned int maxHostConnections;
-  unsigned int maxPipelineDepth;
-
-  RequestList pendingRequests;
-
-  SGTimeStamp timeTransferSample;
-  unsigned int bytesTransferred;
-  unsigned int lastTransferRate;
-  uint64_t totalBytesDownloaded;
-
-  SGPath tlsCertificatePath;
-
-  // only used by unit-tests / test-api, but
-  // only costs us a pointe here to declare it.
-  ResponseDoneCallback testsuiteResponseDoneCallback;
-};
-
-} // namespace HTTP
-
-} // namespace simgear

simgear/io/HTTPRepository.hxx

@@ -20,7 +20,6 @@
 #ifndef SG_IO_HTTP_REPOSITORY_HXX
 #define SG_IO_HTTP_REPOSITORY_HXX
 
-#include <functional>
 #include <memory>
 
 #include <simgear/misc/sg_path.hxx>
@@ -33,85 +32,49 @@ class HTTPRepoPrivate;
 class HTTPRepository
 {
 public:
-  enum ResultCode {
-    REPO_NO_ERROR = 0,
-    REPO_ERROR_NOT_FOUND,
-    REPO_ERROR_SOCKET,
-    SVN_ERROR_XML,
-    SVN_ERROR_TXDELTA,
-    REPO_ERROR_IO,
-    REPO_ERROR_CHECKSUM,
-    REPO_ERROR_FILE_NOT_FOUND,
-    REPO_ERROR_HTTP,
-    REPO_ERROR_CANCELLED,
-    REPO_PARTIAL_UPDATE ///< repository is working, but file-level failures
-                        ///< occurred
-  };
-
-  HTTPRepository(const SGPath &root, HTTP::Client *cl);
-  virtual ~HTTPRepository();
-
-  virtual SGPath fsBase() const;
-
-  virtual void setBaseUrl(const std::string &url);
-  virtual std::string baseUrl() const;
-
-  virtual HTTP::Client *http() const;
-
-  virtual void update();
-
-  virtual bool isDoingSync() const;
-
-  /**
-        @brief call this periodically to progress non-network tasks
-     */
-  void process();
-
-  virtual ResultCode failure() const;
-
-  virtual size_t bytesToDownload() const;
-
-  virtual size_t bytesDownloaded() const;
-
-  virtual size_t bytesToExtract() const;
-
-  /**
-   * optionally provide the location of an installer copy of this
-   * repository. When a file is missing it will be copied from this tree.
-   */
-  void setInstalledCopyPath(const SGPath &copyPath);
-
-  static std::string resultCodeAsString(ResultCode code);
-
-  enum class SyncAction { Add, Update, Delete, UpToDate };
-
-  enum EntryType { FileType, DirectoryType, TarballType };
-
-  struct SyncItem {
-    const std::string directory; // relative path in the repository
-    const EntryType type;
-    const std::string filename;
-    const SyncAction action;
-    const SGPath pathOnDisk; // path the entry does / will have
-  };
-
-    using SyncPredicate = std::function<bool(const SyncItem &item)>;
-
-    void setFilter(SyncPredicate sp);
-
-    struct Failure {
-      SGPath path;
-      ResultCode error;
+    enum ResultCode {
+        REPO_NO_ERROR = 0,
+        REPO_ERROR_NOT_FOUND,
+        REPO_ERROR_SOCKET,
+        SVN_ERROR_XML,
+        SVN_ERROR_TXDELTA,
+        REPO_ERROR_IO,
+        REPO_ERROR_CHECKSUM,
+        REPO_ERROR_FILE_NOT_FOUND,
+        REPO_ERROR_HTTP,
+        REPO_ERROR_CANCELLED,
+        REPO_PARTIAL_UPDATE
     };
 
-    using FailureVec = std::vector<Failure>;
+    HTTPRepository(const SGPath& root, HTTP::Client* cl);
+    virtual ~HTTPRepository();
+
+    virtual SGPath fsBase() const;
+
+    virtual void setBaseUrl(const std::string& url);
+    virtual std::string baseUrl() const;
+
+    virtual HTTP::Client* http() const;
+
+    virtual void update();
+
+    virtual bool isDoingSync() const;
+
+    virtual ResultCode failure() const;
+
+    virtual size_t bytesToDownload() const;
+
+    virtual size_t bytesDownloaded() const;
 
     /**
-     * @brief return file-level failures
+     * optionally provide the location of an installer copy of this
+     * repository. When a file is missing it will be copied from this tree.
      */
-    FailureVec failures() const;
+    void setInstalledCopyPath(const SGPath& copyPath);
+    
+    static std::string resultCodeAsString(ResultCode code);
 
-  private:
+private:
     bool isBare() const;
 
     std::unique_ptr<HTTPRepoPrivate> _d;

simgear/io/HTTPRepository_private.hxx

@@ -1,127 +0,0 @@
-// HTTPRepository.cxx -- plain HTTP TerraSync remote client
-//
-// Copyright (C) 20126  James Turner <zakalawe@mac.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program 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
-// 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.
-
-#pragma once
-
-#include <deque>
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-#include <simgear/io/HTTPClient.hxx>
-#include <simgear/misc/sg_path.hxx>
-
-#include "HTTPRepository.hxx"
-
-namespace simgear {
-
-class HTTPDirectory;
-using HTTPDirectory_ptr = std::unique_ptr<HTTPDirectory>;
-
-class HTTPRepoGetRequest : public HTTP::Request {
-public:
-  HTTPRepoGetRequest(HTTPDirectory *d, const std::string &u)
-      : HTTP::Request(u), _directory(d) {}
-
-  virtual void cancel();
-
-  size_t contentSize() const { return _contentSize; }
-
-  void setContentSize(size_t sz) { _contentSize = sz; }
-
-protected:
-  HTTPDirectory *_directory;
-  size_t _contentSize = 0;
-};
-
-using RepoRequestPtr = SGSharedPtr<HTTPRepoGetRequest>;
-
-class HTTPRepoPrivate {
-public:
-
-
-  HTTPRepository::FailureVec failures;
-  int maxPermittedFailures = 16;
-
-  HTTPRepoPrivate(HTTPRepository* parent)
-      : p(parent)
-  {
-  }
-
-  ~HTTPRepoPrivate();
-
-  HTTPRepository *p; // link back to outer
-  HTTP::Client* http = nullptr;
-  std::string baseUrl;
-  SGPath basePath;
-  bool isUpdating = false;
-  HTTPRepository::ResultCode status = HTTPRepository::REPO_NO_ERROR;
-  HTTPDirectory_ptr rootDir;
-  size_t totalDownloaded = 0;
-  size_t bytesToExtract = 0;
-  size_t bytesExtracted = 0;
-  HTTPRepository::SyncPredicate syncPredicate;
-
-  HTTP::Request_ptr updateFile(HTTPDirectory *dir, const std::string &name,
-                               size_t sz);
-  HTTP::Request_ptr updateDir(HTTPDirectory *dir, const std::string &hash,
-                              size_t sz);
-
-  void failedToGetRootIndex(HTTPRepository::ResultCode st);
-  void failedToUpdateChild(const SGPath &relativePath,
-                           HTTPRepository::ResultCode fileStatus);
-
-  void updatedChildSuccessfully(const SGPath &relativePath);
-
-  void checkForComplete();
-
-  typedef std::vector<RepoRequestPtr> RequestVector;
-  RequestVector queuedRequests, activeRequests;
-
-  void makeRequest(RepoRequestPtr req);
-
-  enum class RequestFinish { Done, Retry };
-
-  void finishedRequest(const RepoRequestPtr &req, RequestFinish retryRequest);
-
-  HTTPDirectory *getOrCreateDirectory(const std::string &path);
-  bool deleteDirectory(const std::string &relPath, const SGPath &absPath);
-
-
-  typedef std::vector<HTTPDirectory_ptr> DirectoryVector;
-  DirectoryVector directories;
-
-  void scheduleUpdateOfChildren(HTTPDirectory *dir);
-
-  SGPath installedCopyPath;
-
-  int countDirtyHashCaches() const;
-  void flushHashCaches();
-
-  enum ProcessResult { ProcessContinue, ProcessDone, ProcessFailed };
-
-  using RepoProcessTask = std::function<ProcessResult(HTTPRepoPrivate *repo)>;
-
-  void addTask(RepoProcessTask task);
-
-  std::deque<RepoProcessTask> pendingTasks;
-};
-
-} // namespace simgear

simgear/io/HTTPRequest.cxx

@@ -56,15 +56,6 @@ Request::~Request()
 
 }
 
-void Request::prepareForRetry() {
-  setReadyState(UNSENT);
-  _willClose = false;
-  _connectionCloseHeader = false;
-  _responseStatus = 0;
-  _responseLength = 0;
-  _receivedBodyBytes = 0;
-}
-
 //------------------------------------------------------------------------------
 Request* Request::done(const Callback& cb)
 {
@@ -202,16 +193,13 @@ void Request::onDone()
 //------------------------------------------------------------------------------
 void Request::onFail()
 {
-  // log if we FAIELD< but not if we CANCELLED
-  if (_ready_state == FAILED) {
-    SG_LOG
-    (
-      SG_IO,
-      SG_INFO,
-      "request failed:" << url() << " : "
-                        << responseCode() << "/" << responseReason()
-    );
-  }
+  SG_LOG
+  (
+    SG_IO,
+    SG_INFO,
+    "request failed:" << url() << " : "
+                      << responseCode() << "/" << responseReason()
+  );
 }
 
 //------------------------------------------------------------------------------
@@ -356,17 +344,12 @@ void Request::setSuccess(int code)
 //------------------------------------------------------------------------------
 void Request::setFailure(int code, const std::string& reason)
 {
-  // we use -1 for cancellation, don't be noisy in that case
-  if (code >= 0) { 
     SG_LOG(SG_IO, SG_WARN, "HTTP request: set failure:" << code << " reason " << reason);
-  }
-
   _responseStatus = code;
   _responseReason = reason;
 
-  if( !isComplete() ) {
-    setReadyState(code < 0 ? CANCELLED : FAILED);
-  }
+  if( !isComplete() )
+    setReadyState(FAILED);
 }
 
 //------------------------------------------------------------------------------
@@ -390,12 +373,6 @@ void Request::setReadyState(ReadyState state)
 
     _cb_fail(this);
   }
-  else if (state == CANCELLED )
-  {
-    onFail(); // do this for compatability
-    onAlways();
-    _cb_fail(this);
-  }
   else
     return;
 
@@ -425,7 +402,7 @@ bool Request::serverSupportsPipelining() const
 //------------------------------------------------------------------------------
 bool Request::isComplete() const
 {
-  return _ready_state == DONE || _ready_state == FAILED || _ready_state == CANCELLED;
+  return _ready_state == DONE || _ready_state == FAILED;
 }
 
 //------------------------------------------------------------------------------

simgear/io/HTTPRequest.hxx

@@ -54,8 +54,7 @@ public:
       HEADERS_RECEIVED,
       LOADING,
       DONE,
-      FAILED,
-      CANCELLED
+      FAILED
     };
 
     virtual ~Request();
@@ -208,9 +207,7 @@ public:
      */
     bool serverSupportsPipelining() const;
 
-    virtual void prepareForRetry();
-
-  protected:
+protected:
     Request(const std::string& url, const std::string method = "GET");
 
     virtual void requestStart();
@@ -224,14 +221,12 @@ public:
     virtual void onFail();
     virtual void onAlways();
 
+    void setFailure(int code, const std::string& reason);
     void setSuccess(int code);
-    void setFailure(int code, const std::string &reason);
-
-  private:
+private:
     friend class Client;
     friend class Connection;
     friend class ContentDecoder;
-    friend class TestApi;
 
     Request(const Request&); // = delete;
     Request& operator=(const Request&); // = delete;

simgear/io/HTTPTestApi_private.hxx

@@ -1,45 +0,0 @@
-// 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 Library General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
-
-#pragma once
-
-#include <functional>
-
-#include "HTTPRequest.hxx"
-
-namespace simgear {
-namespace HTTP {
-
-class Client;
-
-using ResponseDoneCallback =
-    std::function<bool(int curlResult, Request_ptr req)>;
-
-/**
- * @brief this API is for unit-testing HTTP code.
- * Don't use it for anything else. It's for unit-testing.
- */
-class TestApi {
-public:
-  // alow test suite to manipulate requests to simulate network errors;
-  // without this, it's hard to provoke certain failures in a loop-back
-  // network sitation.
-  static void setResponseDoneCallback(Client *cl, ResponseDoneCallback cb);
-
-  static void markRequestAsFailed(Request_ptr req, int curlCode,
-                                  const std::string &message);
-};
-
-} // namespace HTTP
-} // namespace simgear

simgear/io/iostreams/gzfstream.cxx

@@ -185,9 +185,6 @@ gzfilebuf::setcompressionstrategy( int comp_strategy )
 
 z_off_t
 gzfilebuf::approxOffset() {
-    #ifdef __OpenBSD__
-    z_off_t res = 0;
-    #else
     z_off_t res = gzoffset(file);
 
     if (res == -1) {
@@ -204,7 +201,7 @@ gzfilebuf::approxOffset() {
         SG_LOG( SG_GENERAL, SG_ALERT, errMsg );
         throw sg_io_exception(errMsg);
     }
-    #endif
+
     return res;
 }
 

simgear/io/lowlevel.cxx

@@ -23,43 +23,28 @@
 // $Id$
 
 
-#include <simgear_config.h>
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
 
 #include <string.h>		// for memcpy()
-#include <errno.h>
 
-#include <simgear/structure/exception.hxx>
-#include <simgear/misc/strutils.hxx>
-#include <simgear/misc/sg_path.hxx>
+#include "lowlevel.hxx" 
 
-#include "lowlevel.hxx"
 
-thread_local SGPath thread_gzPath;
+static int  read_error = false ;
+static int write_error = false ;
 
-void setThreadLocalSimgearReadPath(const SGPath& path)
-{
-    thread_gzPath = path;
-}
+void sgClearReadError() { read_error = false; }
+void sgClearWriteError() { write_error = false; }
+int sgReadError() { return  read_error ; }
+int sgWriteError() { return write_error ; }
 
-static std::string gzErrorMessage(gzFile fd)
-{
-    int errNum = 0;
-    const char *gzMsg = gzerror(fd, &errNum);
-
-    if (errNum == Z_ERRNO) {
-        return simgear::strutils::error_string(errno);
-    } else if (gzMsg) {
-        return {gzMsg};
-    }
-
-    return {"GZError: no string code for code:" + std::to_string(errNum)};
-}
 
 void sgReadChar ( gzFile fd, char *var )
 {
     if ( gzread ( fd, var, sizeof(char) ) != sizeof(char) ) {
-        throw sg_io_exception("sgReadChar: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
 }
 
@@ -67,7 +52,7 @@ void sgReadChar ( gzFile fd, char *var )
 void sgWriteChar ( gzFile fd, const char var )
 {
     if ( gzwrite ( fd, (void *)(&var), sizeof(char) ) != sizeof(char) ) {
-        throw sg_io_exception("sgWriteChar: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -76,8 +61,7 @@ void sgReadFloat ( gzFile fd, float *var )
 {
     union { float v; uint32_t u; } buf;
     if ( gzread ( fd, &buf.u, sizeof(float) ) != sizeof(float) ) {
-        throw sg_io_exception("sgReadFloat: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( &buf.u );
@@ -94,7 +78,7 @@ void sgWriteFloat ( gzFile fd, const float var )
         sgEndianSwap( &buf.u );
     }
     if ( gzwrite ( fd, (void *)(&buf.u), sizeof(float) ) != sizeof(float) ) {
-        throw sg_io_exception("sgWriteFloat: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -103,8 +87,7 @@ void sgReadDouble ( gzFile fd, double *var )
 {
     union { double v; uint64_t u; } buf;
     if ( gzread ( fd, &buf.u, sizeof(double) ) != sizeof(double) ) {
-        throw sg_io_exception("sgReadDouble: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( &buf.u );
@@ -121,7 +104,7 @@ void sgWriteDouble ( gzFile fd, const double var )
         sgEndianSwap( &buf.u );
     }
     if ( gzwrite ( fd, (void *)(&buf.u), sizeof(double) ) != sizeof(double) ) {
-        throw sg_io_exception("sgWriteDouble: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -129,8 +112,7 @@ void sgWriteDouble ( gzFile fd, const double var )
 void sgReadUInt ( gzFile fd, unsigned int *var )
 {
     if ( gzread ( fd, var, sizeof(unsigned int) ) != sizeof(unsigned int) ) {
-        throw sg_io_exception("sgReadUInt: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( (uint32_t *)var);
@@ -146,7 +128,7 @@ void sgWriteUInt ( gzFile fd, const unsigned int var )
     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
 	 != sizeof(unsigned int) )
     {
-        throw sg_io_exception("sgWriteUInt: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -154,8 +136,7 @@ void sgWriteUInt ( gzFile fd, const unsigned int var )
 void sgReadInt ( gzFile fd, int *var )
 {
     if ( gzread ( fd, var, sizeof(int) ) != sizeof(int) ) {
-        throw sg_io_exception("sgReadInt: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( (uint32_t *)var);
@@ -169,7 +150,7 @@ void sgWriteInt ( gzFile fd, const int var )
         sgEndianSwap( (uint32_t *)&var);
     }
     if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) != sizeof(int) ) {
-        throw sg_io_exception("sgWriteInt: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -177,8 +158,7 @@ void sgWriteInt ( gzFile fd, const int var )
 void sgReadLong ( gzFile fd, int32_t *var )
 {
     if ( gzread ( fd, var, sizeof(int32_t) ) != sizeof(int32_t) ) {
-        throw sg_io_exception("sgReadLong: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( (uint32_t *)var);
@@ -194,7 +174,7 @@ void sgWriteLong ( gzFile fd, const int32_t var )
     if ( gzwrite ( fd, (void *)(&var), sizeof(int32_t) )
          != sizeof(int32_t) )
     {
-        throw sg_io_exception("sgWriteLong: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -202,8 +182,7 @@ void sgWriteLong ( gzFile fd, const int32_t var )
 void sgReadLongLong ( gzFile fd, int64_t *var )
 {
     if ( gzread ( fd, var, sizeof(int64_t) ) != sizeof(int64_t) ) {
-        throw sg_io_exception("sgReadLongLong: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( (uint64_t *)var);
@@ -219,7 +198,7 @@ void sgWriteLongLong ( gzFile fd, const int64_t var )
     if ( gzwrite ( fd, (void *)(&var), sizeof(int64_t) )
          != sizeof(int64_t) )
     {
-        throw sg_io_exception("sgWriteLongLong: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -227,8 +206,7 @@ void sgWriteLongLong ( gzFile fd, const int64_t var )
 void sgReadUShort ( gzFile fd, unsigned short *var )
 {
     if ( gzread ( fd, var, sizeof(unsigned short) ) != sizeof(unsigned short) ){
-        throw sg_io_exception("sgReadUShort: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( (uint16_t *)var);
@@ -244,7 +222,7 @@ void sgWriteUShort ( gzFile fd, const unsigned short var )
     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
 	 != sizeof(unsigned short) )
     {
-        throw sg_io_exception("sgWriteUShort: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -252,8 +230,7 @@ void sgWriteUShort ( gzFile fd, const unsigned short var )
 void sgReadShort ( gzFile fd, short *var )
 {
     if ( gzread ( fd, var, sizeof(short) ) != sizeof(short) ) {
-        throw sg_io_exception("sgReadShort: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         sgEndianSwap( (uint16_t *)var);
@@ -267,7 +244,7 @@ void sgWriteShort ( gzFile fd, const short var )
         sgEndianSwap( (uint16_t *)&var);
     }
     if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) != sizeof(short) ) {
-        throw sg_io_exception("sgWriteShort: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -275,8 +252,7 @@ void sgWriteShort ( gzFile fd, const short var )
 void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
 {
     if ( gzread ( fd, var, sizeof(float) * n ) != (int)(sizeof(float) * n) ) {
-        throw sg_io_exception("sgReadFloat array: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
@@ -300,15 +276,14 @@ void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
     if ( gzwrite ( fd, (void *)var, sizeof(float) * n )
 	 != (int)(sizeof(float) * n) )
     {
-        throw sg_io_exception("sgWriteFloat array: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
 void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
 {
     if ( gzread ( fd, var, sizeof(double) * n ) != (int)(sizeof(double) * n) ) {
-        throw sg_io_exception("sgReadDouble array: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
@@ -332,7 +307,7 @@ void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
     if ( gzwrite ( fd, (void *)var, sizeof(double) * n )
 	 != (int)(sizeof(double) * n) )
     {
-        throw sg_io_exception("sgWriteDouble array: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -340,8 +315,7 @@ void sgReadBytes ( gzFile fd, const unsigned int n, void *var )
 {
     if ( n == 0) return;
     if ( gzread ( fd, var, n ) != (int)n ) {
-        throw sg_io_exception("sgReadBytes: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
 }
 
@@ -349,7 +323,7 @@ void sgWriteBytes ( gzFile fd, const unsigned int n, const void *var )
 {
     if ( n == 0) return;
     if ( gzwrite ( fd, (void *)var, n ) != (int)n ) {
-        throw sg_io_exception("sgWriteBytes: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -359,8 +333,7 @@ void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
     if ( gzread ( fd, var, sizeof(unsigned short) * n )
 	 != (int)(sizeof(unsigned short) * n) )
     {
-        throw sg_io_exception("sgReadUShort array: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
@@ -384,7 +357,7 @@ void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var
     if ( gzwrite ( fd, (void *)var, sizeof(unsigned short) * n )
 	 != (int)(sizeof(unsigned short) * n) )
     {
-        throw sg_io_exception("sgWriteUShort array: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -395,8 +368,7 @@ void sgReadShort ( gzFile fd, const unsigned int n, short *var )
     if ( gzread ( fd, var, sizeof(short) * n )
 	 != (int)(sizeof(short) * n) )
     {
-        throw sg_io_exception("sgReadShort array: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
@@ -420,7 +392,7 @@ void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
     if ( gzwrite ( fd, (void *)var, sizeof(short) * n )
 	 != (int)(sizeof(short) * n) )
     {
-        throw sg_io_exception("sgWriteShort array: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -430,8 +402,7 @@ void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
     if ( gzread ( fd, var, sizeof(unsigned int) * n )
 	 != (int)(sizeof(unsigned int) * n) )
     {
-        throw sg_io_exception("sgReadUInt array: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
@@ -455,7 +426,7 @@ void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
     if ( gzwrite ( fd, (void *)var, sizeof(unsigned int) * n )
 	 != (int)(sizeof(unsigned int) * n) )
     {
-        throw sg_io_exception("sgWriteUInt array: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 
@@ -466,8 +437,7 @@ void sgReadInt ( gzFile fd, const unsigned int n, int *var )
     if ( gzread ( fd, var, sizeof(int) * n )
 	 != (int)(sizeof(int) * n) )
     {
-        throw sg_io_exception("sgReadInt array: GZRead failed:" + gzErrorMessage(fd),
-                              sg_location{thread_gzPath}, nullptr, false);
+        read_error = true ;
     }
     if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
@@ -491,7 +461,7 @@ void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
     if ( gzwrite ( fd, (void *)var, sizeof(int) * n )
 	 != (int)(sizeof(int) * n) )
     {
-        throw sg_io_exception("sgWriteInt array: gzwrite failed:" + gzErrorMessage(fd), {} /* origin */, false);
+        write_error = true ;
     }
 }
 

simgear/io/lowlevel.hxx

@@ -35,9 +35,6 @@
 
 #include <simgear/math/SGMath.hxx>
 
-// forward decls
-class SGPath;
-
 // Note that output is written in little endian form (and converted as
 // necessary for big endian machines)
 
@@ -124,10 +121,9 @@ inline void sgWriteGeod ( gzFile fd, const SGGeod& var ) {
     sgWriteDouble( fd, var.getElevationM() );
 }
 
-/**
-    @ error aid: allow calling code to specify which file path we're reading from, so that erros we
- throw from sgReadXXXX can have a valid location set.
- */
-void setThreadLocalSimgearReadPath(const SGPath& path);
+void sgClearReadError();
+void sgClearWriteError();
+int sgReadError();
+int sgWriteError();
 
 #endif // _SG_LOWLEVEL_HXX

simgear/io/sg_binobj.cxx

@@ -41,10 +41,8 @@
 #include <bitset>
 
 #include <simgear/bucket/newbucket.hxx>
-#include <simgear/debug/ErrorReportingCallback.hxx>
-#include <simgear/math/SGGeometry.hxx>
 #include <simgear/misc/sg_path.hxx>
-#include <simgear/misc/strutils.hxx>
+#include <simgear/math/SGGeometry.hxx>
 #include <simgear/structure/exception.hxx>
 
 #include "lowlevel.hxx"
@@ -455,6 +453,10 @@ void SGBinObject::read_object( gzFile fp,
         }
     }
 
+    if ( sgReadError() ) {
+        throw sg_exception("Error reading object properties");
+    }
+
     size_t indexCount = std::bitset<32>((int)idx_mask).count();
     if (indexCount == 0) {
         throw sg_exception("object index mask has no bits set");
@@ -462,10 +464,18 @@ void SGBinObject::read_object( gzFile fp,
 
     for ( j = 0; j < nelements; ++j ) {
         sgReadUInt( fp, &nbytes );
+        if ( sgReadError() ) {
+            throw sg_exception("Error reading element size");
+        }
+
         buf.resize( nbytes );
         char *ptr = buf.get_ptr();
         sgReadBytes( fp, nbytes, ptr );
 
+        if ( sgReadError() ) {
+            throw sg_exception("Error reading element bytes");
+        }
+
         int_list vs;
         int_list ns;
         int_list cs;
@@ -492,311 +502,306 @@ void SGBinObject::read_object( gzFile fp,
 
 
 // read a binary file and populate the provided structures.
-bool SGBinObject::read_bin( const SGPath& file )
-{
-    gzFile fp = NULL;
-    
-    try {
-        SGVec3d p;
-        int i, k;
-        size_t j;
-        unsigned int nbytes;
-        sgSimpleBuffer buf( 32768 );  // 32 Kb
+bool SGBinObject::read_bin( const SGPath& file ) {
+    SGVec3d p;
+    int i, k;
+    size_t j;
+    unsigned int nbytes;
+    sgSimpleBuffer buf( 32768 );  // 32 Kb
 
-        simgear::ErrorReportContext ec("btg", file.utf8Str());
+    // zero out structures
+    gbs_center = SGVec3d(0, 0, 0);
+    gbs_radius = 0.0;
 
-        // zero out structures
-        gbs_center = SGVec3d(0, 0, 0);
-        gbs_radius = 0.0;
+    wgs84_nodes.clear();
+    normals.clear();
+    texcoords.clear();
 
-        wgs84_nodes.clear();
-        normals.clear();
-        texcoords.clear();
+    pts_v.clear();
+    pts_n.clear();
+    pts_c.clear();
+    pts_tcs.clear();
+    pts_vas.clear();
+    pt_materials.clear();
 
-        pts_v.clear();
-        pts_n.clear();
-        pts_c.clear();
-        pts_tcs.clear();
-        pts_vas.clear();
-        pt_materials.clear();
+    tris_v.clear();
+    tris_n.clear();
+    tris_c.clear();
+    tris_tcs.clear();
+    tris_vas.clear();
+    tri_materials.clear();
 
-        tris_v.clear();
-        tris_n.clear();
-        tris_c.clear();
-        tris_tcs.clear();
-        tris_vas.clear();
-        tri_materials.clear();
+    strips_v.clear();
+    strips_n.clear();
+    strips_c.clear();
+    strips_tcs.clear();
+    strips_vas.clear();
+    strip_materials.clear();
 
-        strips_v.clear();
-        strips_n.clear();
-        strips_c.clear();
-        strips_tcs.clear();
-        strips_vas.clear();
-        strip_materials.clear();
+    fans_v.clear();
+    fans_n.clear();
+    fans_c.clear();
+    fans_tcs.clear();
+    fans_vas.clear();
+    fan_materials.clear();
 
-        fans_v.clear();
-        fans_n.clear();
-        fans_c.clear();
-        fans_tcs.clear();
-        fans_vas.clear();
-        fan_materials.clear();
+    gzFile fp = gzFileFromSGPath(file, "rb");
+    if ( fp == NULL ) {
+        SGPath withGZ = file;
+        withGZ.concat(".gz");
+        fp = gzFileFromSGPath(withGZ, "rb");
+        if (fp == nullptr) {
+            SG_LOG( SG_EVENT, SG_ALERT,
+               "ERROR: opening " << file << " or " << withGZ << " for reading!");
 
-        gzFile fp = gzFileFromSGPath(file, "rb");
-        if ( fp == NULL ) {
-            SGPath withGZ = file;
-            withGZ.concat(".gz");
-            fp = gzFileFromSGPath(withGZ, "rb");
-            if (fp == nullptr) {
-                throw sg_io_exception("Error opening for reading (and .gz)", sg_location(file), {}, false);
-            }
+            throw sg_io_exception("Error opening for reading (and .gz)", sg_location(file));
         }
-        
-        setThreadLocalSimgearReadPath(file);
+    }
 
-        // read headers
-        unsigned int header;
-        sgReadUInt( fp, &header );
+    sgClearReadError();
 
+    // read headers
+    unsigned int header;
+    sgReadUInt( fp, &header );
+    if ( ((header & 0xFF000000) >> 24) == 'S' &&
+         ((header & 0x00FF0000) >> 16) == 'G' ) {
 
-        if ( ((header & 0xFF000000) >> 24) == 'S' &&
-             ((header & 0x00FF0000) >> 16) == 'G' ) {
+        // read file version
+        version = (header & 0x0000FFFF);
+    } else {
+        // close the file before we return
+        gzclose(fp);
+        throw sg_io_exception("Bad BTG magic/version", sg_location(file));
+    }
 
-            // read file version
-            version = (header & 0x0000FFFF);
-        } else {
-            throw sg_io_exception("Bad BTG magic/version", sg_location(file), {}, false);
-        }
+    // read creation time
+    unsigned int foo_calendar_time;
+    sgReadUInt( fp, &foo_calendar_time );
 
-        // read creation time
-        unsigned int foo_calendar_time;
-        sgReadUInt( fp, &foo_calendar_time );
+#if 0
+    time_t calendar_time = foo_calendar_time;
+    // The following code has a global effect on the host application
+    // and can screws up the time elsewhere.  It should be avoided
+    // unless you need this for debugging in which case you should
+    // disable it again once the debugging task is finished.
+    struct tm *local_tm;
+    local_tm = localtime( &calendar_time );
+    char time_str[256];
+    strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
+    SG_LOG( SG_EVENT, SG_DEBUG, "File created on " << time_str);
+#endif
 
-    #if 0
-        time_t calendar_time = foo_calendar_time;
-        // The following code has a global effect on the host application
-        // and can screws up the time elsewhere.  It should be avoided
-        // unless you need this for debugging in which case you should
-        // disable it again once the debugging task is finished.
-        struct tm *local_tm;
-        local_tm = localtime( &calendar_time );
-        char time_str[256];
-        strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
-        SG_LOG( SG_EVENT, SG_DEBUG, "File created on " << time_str);
-    #endif
+    // read number of top level objects
+    int nobjects;
+    if ( version >= 10) { // version 10 extends everything to be 32-bit
+        sgReadInt( fp, &nobjects );
+    } else if ( version >= 7 ) {
+        uint16_t v;
+        sgReadUShort( fp, &v );
+        nobjects = v;
+    } else {
+        int16_t v;
+        sgReadShort( fp, &v );
+        nobjects = v;
+    }
 
-        // read number of top level objects
-        int nobjects;
-        if ( version >= 10) { // version 10 extends everything to be 32-bit
-            sgReadInt( fp, &nobjects );
+    SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin Total objects to read = " << nobjects);
+
+    if ( sgReadError() ) {
+        throw sg_io_exception("Error reading BTG file header", sg_location(file));
+    }
+
+    // read in objects
+    for ( i = 0; i < nobjects; ++i ) {
+        // read object header
+        char obj_type;
+        uint32_t nproperties, nelements;
+        sgReadChar( fp, &obj_type );
+        if ( version >= 10 ) {
+            sgReadUInt( fp, &nproperties );
+            sgReadUInt( fp, &nelements );
         } else if ( version >= 7 ) {
             uint16_t v;
             sgReadUShort( fp, &v );
-            nobjects = v;
+            nproperties = v;
+            sgReadUShort( fp, &v );
+            nelements = v;
         } else {
             int16_t v;
             sgReadShort( fp, &v );
-            nobjects = v;
+            nproperties = v;
+            sgReadShort( fp, &v );
+            nelements = v;
         }
 
-        SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin Total objects to read = " << nobjects);
+        SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin object " << i <<
+                " = " << (int)obj_type << " props = " << nproperties <<
+                " elements = " << nelements);
 
+        if ( obj_type == SG_BOUNDING_SPHERE ) {
+            // read bounding sphere properties
+            read_properties( fp, nproperties );
 
-        // read in objects
-        for ( i = 0; i < nobjects; ++i ) {
-            // read object header
-            char obj_type;
-            uint32_t nproperties, nelements;
-            sgReadChar( fp, &obj_type );
-            if ( version >= 10 ) {
-                sgReadUInt( fp, &nproperties );
-                sgReadUInt( fp, &nelements );
-            } else if ( version >= 7 ) {
-                uint16_t v;
-                sgReadUShort( fp, &v );
-                nproperties = v;
-                sgReadUShort( fp, &v );
-                nelements = v;
-            } else {
-                int16_t v;
-                sgReadShort( fp, &v );
-                nproperties = v;
-                sgReadShort( fp, &v );
-                nelements = v;
+            // read bounding sphere elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                gbs_center = buf.readVec3d();
+                gbs_radius = buf.readFloat();
             }
+        } else if ( obj_type == SG_VERTEX_LIST ) {
+            // read vertex list properties
+            read_properties( fp, nproperties );
 
-            SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin object " << i <<
-                    " = " << (int)obj_type << " props = " << nproperties <<
-                    " elements = " << nelements);
-
-            if ( obj_type == SG_BOUNDING_SPHERE ) {
-                // read bounding sphere properties
-                read_properties( fp, nproperties );
-
-                // read bounding sphere elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                    gbs_center = buf.readVec3d();
-                    gbs_radius = buf.readFloat();
+            // read vertex list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(float) * 3);
+                wgs84_nodes.reserve( count );
+                for ( k = 0; k < count; ++k ) {
+                    SGVec3f v = buf.readVec3f();
+                    // extend from float to double, hmmm
+                    wgs84_nodes.push_back( SGVec3d(v[0], v[1], v[2]) );
                 }
-            } else if ( obj_type == SG_VERTEX_LIST ) {
-                // read vertex list properties
-                read_properties( fp, nproperties );
+            }
+        } else if ( obj_type == SG_COLOR_LIST ) {
+            // read color list properties
+            read_properties( fp, nproperties );
 
-                // read vertex list elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                    int count = nbytes / (sizeof(float) * 3);
-                    wgs84_nodes.reserve( count );
-                    for ( k = 0; k < count; ++k ) {
-                        SGVec3f v = buf.readVec3f();
-                        // extend from float to double, hmmm
-                        wgs84_nodes.push_back( SGVec3d(v[0], v[1], v[2]) );
-                    }
+            // read color list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(float) * 4);
+                colors.reserve(count);
+                for ( k = 0; k < count; ++k ) {
+                    colors.push_back( buf.readVec4f() );
                 }
-            } else if ( obj_type == SG_COLOR_LIST ) {
-                // read color list properties
-                read_properties( fp, nproperties );
+            }
+        } else if ( obj_type == SG_NORMAL_LIST ) {
+            // read normal list properties
+            read_properties( fp, nproperties );
 
-                // read color list elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                    int count = nbytes / (sizeof(float) * 4);
-                    colors.reserve(count);
-                    for ( k = 0; k < count; ++k ) {
-                        colors.push_back( buf.readVec4f() );
-                    }
+            // read normal list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                unsigned char *ptr = (unsigned char *)(buf.get_ptr());
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / 3;
+                normals.reserve( count );
+
+                for ( k = 0; k < count; ++k ) {
+                    SGVec3f normal( (ptr[0]) / 127.5 - 1.0,
+                                    (ptr[1]) / 127.5 - 1.0,
+                                    (ptr[2]) / 127.5 - 1.0);
+                    normals.push_back(normalize(normal));
+                    ptr += 3;
                 }
-            } else if ( obj_type == SG_NORMAL_LIST ) {
-                // read normal list properties
-                read_properties( fp, nproperties );
+            }
+        } else if ( obj_type == SG_TEXCOORD_LIST ) {
+            // read texcoord list properties
+            read_properties( fp, nproperties );
 
-                // read normal list elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    unsigned char *ptr = (unsigned char *)(buf.get_ptr());
-                    sgReadBytes( fp, nbytes, ptr );
-                    int count = nbytes / 3;
-                    normals.reserve( count );
-
-                    for ( k = 0; k < count; ++k ) {
-                        SGVec3f normal( (ptr[0]) / 127.5 - 1.0,
-                                        (ptr[1]) / 127.5 - 1.0,
-                                        (ptr[2]) / 127.5 - 1.0);
-                        normals.push_back(normalize(normal));
-                        ptr += 3;
-                    }
+            // read texcoord list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(float) * 2);
+                texcoords.reserve(count);
+                for ( k = 0; k < count; ++k ) {
+                    texcoords.push_back( buf.readVec2f() );
                 }
-            } else if ( obj_type == SG_TEXCOORD_LIST ) {
-                // read texcoord list properties
-                read_properties( fp, nproperties );
+            }
+        } else if ( obj_type == SG_VA_FLOAT_LIST ) {
+            // read vertex attribute (float) properties
+            read_properties( fp, nproperties );
 
-                // read texcoord list elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                    int count = nbytes / (sizeof(float) * 2);
-                    texcoords.reserve(count);
-                    for ( k = 0; k < count; ++k ) {
-                        texcoords.push_back( buf.readVec2f() );
-                    }
+            // read vertex attribute list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(float));
+                va_flt.reserve(count);
+                for ( k = 0; k < count; ++k ) {
+                    va_flt.push_back( buf.readFloat() );
                 }
-            } else if ( obj_type == SG_VA_FLOAT_LIST ) {
-                // read vertex attribute (float) properties
-                read_properties( fp, nproperties );
+            }
+        } else if ( obj_type == SG_VA_INTEGER_LIST ) {
+            // read vertex attribute (integer) properties
+            read_properties( fp, nproperties );
 
-                // read vertex attribute list elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                    int count = nbytes / (sizeof(float));
-                    va_flt.reserve(count);
-                    for ( k = 0; k < count; ++k ) {
-                        va_flt.push_back( buf.readFloat() );
-                    }
+            // read vertex attribute list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(unsigned int));
+                va_int.reserve(count);
+                for ( k = 0; k < count; ++k ) {
+                    va_int.push_back( buf.readInt() );
                 }
-            } else if ( obj_type == SG_VA_INTEGER_LIST ) {
-                // read vertex attribute (integer) properties
-                read_properties( fp, nproperties );
+            }
+        } else if ( obj_type == SG_POINTS ) {
+            // read point elements
+            read_object( fp, SG_POINTS, nproperties, nelements,
+                         pts_v, pts_n, pts_c, pts_tcs,
+                         pts_vas, pt_materials );
+        } else if ( obj_type == SG_TRIANGLE_FACES ) {
+            // read triangle face properties
+            read_object( fp, SG_TRIANGLE_FACES, nproperties, nelements,
+                         tris_v, tris_n, tris_c, tris_tcs,
+                         tris_vas, tri_materials );
+        } else if ( obj_type == SG_TRIANGLE_STRIPS ) {
+            // read triangle strip properties
+            read_object( fp, SG_TRIANGLE_STRIPS, nproperties, nelements,
+                         strips_v, strips_n, strips_c, strips_tcs,
+                         strips_vas, strip_materials );
+        } else if ( obj_type == SG_TRIANGLE_FANS ) {
+            // read triangle fan properties
+            read_object( fp, SG_TRIANGLE_FANS, nproperties, nelements,
+                         fans_v, fans_n, fans_c, fans_tcs,
+                         fans_vas, fan_materials );
+        } else {
+            // unknown object type, just skip
+            read_properties( fp, nproperties );
 
-                // read vertex attribute list elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    buf.resize( nbytes );
-                    buf.reset();
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                    int count = nbytes / (sizeof(unsigned int));
-                    va_int.reserve(count);
-                    for ( k = 0; k < count; ++k ) {
-                        va_int.push_back( buf.readInt() );
-                    }
-                }
-            } else if ( obj_type == SG_POINTS ) {
-                // read point elements
-                read_object( fp, SG_POINTS, nproperties, nelements,
-                             pts_v, pts_n, pts_c, pts_tcs,
-                             pts_vas, pt_materials );
-            } else if ( obj_type == SG_TRIANGLE_FACES ) {
-                // read triangle face properties
-                read_object( fp, SG_TRIANGLE_FACES, nproperties, nelements,
-                             tris_v, tris_n, tris_c, tris_tcs,
-                             tris_vas, tri_materials );
-            } else if ( obj_type == SG_TRIANGLE_STRIPS ) {
-                // read triangle strip properties
-                read_object( fp, SG_TRIANGLE_STRIPS, nproperties, nelements,
-                             strips_v, strips_n, strips_c, strips_tcs,
-                             strips_vas, strip_materials );
-            } else if ( obj_type == SG_TRIANGLE_FANS ) {
-                // read triangle fan properties
-                read_object( fp, SG_TRIANGLE_FANS, nproperties, nelements,
-                             fans_v, fans_n, fans_c, fans_tcs,
-                             fans_vas, fan_materials );
-            } else {
-                // unknown object type, just skip
-                read_properties( fp, nproperties );
-
-                // read elements
-                for ( j = 0; j < nelements; ++j ) {
-                    sgReadUInt( fp, &nbytes );
-                    // cout << "element size = " << nbytes << endl;
-                    if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
-                    char *ptr = buf.get_ptr();
-                    sgReadBytes( fp, nbytes, ptr );
-                }
+            // read elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                // cout << "element size = " << nbytes << endl;
+                if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
             }
         }
 
-        gzclose(fp);
-        fp = NULL;
-    } catch (std::exception&) {
-        if (fp) {
-            // close the file
-            gzclose(fp);
+        if ( sgReadError() ) {
+            throw sg_io_exception("Error while reading object", sg_location(file, i));
         }
-        
-        throw; // re-throw
     }
 
+    // close the file
+    gzclose(fp);
 
     return true;
 }
@@ -970,112 +975,112 @@ bool SGBinObject::write_bin_file(const SGPath& file)
         return false;
     }
 
-    try {
-        SG_LOG(SG_IO, SG_DEBUG, "points size = " << pts_v.size()
-             << "  pt_materials = " << pt_materials.size() );
-        SG_LOG(SG_IO, SG_DEBUG, "triangles size = " << tris_v.size()
-             << "  tri_materials = " << tri_materials.size() );
-        SG_LOG(SG_IO, SG_DEBUG, "strips size = " << strips_v.size()
-             << "  strip_materials = " << strip_materials.size() );
-        SG_LOG(SG_IO, SG_DEBUG, "fans size = " << fans_v.size()
-             << "  fan_materials = " << fan_materials.size() );
+    sgClearWriteError();
 
-        SG_LOG(SG_IO, SG_DEBUG, "nodes = " << wgs84_nodes.size() );
-        SG_LOG(SG_IO, SG_DEBUG, "colors = " << colors.size() );
-        SG_LOG(SG_IO, SG_DEBUG, "normals = " << normals.size() );
-        SG_LOG(SG_IO, SG_DEBUG, "tex coords = " << texcoords.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "points size = " << pts_v.size()
+         << "  pt_materials = " << pt_materials.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "triangles size = " << tris_v.size()
+         << "  tri_materials = " << tri_materials.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "strips size = " << strips_v.size()
+         << "  strip_materials = " << strip_materials.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "fans size = " << fans_v.size()
+         << "  fan_materials = " << fan_materials.size() );
 
-        version = 10;
-        bool shortMaterialsRanges =
-            (max_object_size(pt_materials) < VERSION_7_MATERIAL_LIMIT) &&
-            (max_object_size(fan_materials) < VERSION_7_MATERIAL_LIMIT) &&
-            (max_object_size(strip_materials) < VERSION_7_MATERIAL_LIMIT) &&
-            (max_object_size(tri_materials) < VERSION_7_MATERIAL_LIMIT);
+    SG_LOG(SG_IO, SG_DEBUG, "nodes = " << wgs84_nodes.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "colors = " << colors.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "normals = " << normals.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "tex coords = " << texcoords.size() );
 
-        if ((wgs84_nodes.size() < 0xffff) &&
-            (normals.size() < 0xffff) &&
-            (texcoords.size() < 0xffff) &&
-            shortMaterialsRanges) {
-            version = 7; // use smaller indices if possible
-        }
+    version = 10;
+    bool shortMaterialsRanges =
+        (max_object_size(pt_materials) < VERSION_7_MATERIAL_LIMIT) &&
+        (max_object_size(fan_materials) < VERSION_7_MATERIAL_LIMIT) &&
+        (max_object_size(strip_materials) < VERSION_7_MATERIAL_LIMIT) &&
+        (max_object_size(tri_materials) < VERSION_7_MATERIAL_LIMIT);
 
-        // write header magic
+    if ((wgs84_nodes.size() < 0xffff) &&
+        (normals.size() < 0xffff) &&
+        (texcoords.size() < 0xffff) &&
+        shortMaterialsRanges) {
+        version = 7; // use smaller indices if possible
+    }
 
-        /** Magic Number for our file format */
-        #define SG_FILE_MAGIC_NUMBER  ( ('S'<<24) + ('G'<<16) + version )
+    // write header magic
 
-        sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
-        time_t calendar_time = time(NULL);
-        sgWriteLong( fp, (int32_t)calendar_time );
+    /** Magic Number for our file format */
+    #define SG_FILE_MAGIC_NUMBER  ( ('S'<<24) + ('G'<<16) + version )
 
-        // calculate and write number of top level objects
-        int nobjects = 5; // gbs, vertices, colors, normals, texcoords
-        nobjects += count_objects(pt_materials);
-        nobjects += count_objects(tri_materials);
-        nobjects += count_objects(strip_materials);
-        nobjects += count_objects(fan_materials);
+    sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
+    time_t calendar_time = time(NULL);
+    sgWriteLong( fp, (int32_t)calendar_time );
 
-        SG_LOG(SG_IO, SG_DEBUG, "total top level objects = " << nobjects);
+    // calculate and write number of top level objects
+    int nobjects = 5; // gbs, vertices, colors, normals, texcoords
+    nobjects += count_objects(pt_materials);
+    nobjects += count_objects(tri_materials);
+    nobjects += count_objects(strip_materials);
+    nobjects += count_objects(fan_materials);
 
-        if (version == 7) {
-            sgWriteUShort( fp, (uint16_t) nobjects );
-        } else {
-            sgWriteInt( fp, nobjects );
-        }
+    SG_LOG(SG_IO, SG_DEBUG, "total top level objects = " << nobjects);
 
-        // write bounding sphere
-        write_header( fp, SG_BOUNDING_SPHERE, 0, 1);
-        sgWriteUInt( fp, sizeof(double) * 3 + sizeof(float) ); // nbytes
-        sgWritedVec3( fp, gbs_center );
-        sgWriteFloat( fp, gbs_radius );
+    if (version == 7) {
+        sgWriteUShort( fp, (uint16_t) nobjects );
+    } else {
+        sgWriteInt( fp, nobjects );
+    }
 
-        // dump vertex list
-        write_header( fp, SG_VERTEX_LIST, 0, 1);
-        sgWriteUInt( fp, wgs84_nodes.size() * sizeof(float) * 3 ); // nbytes
-        for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
-            sgWriteVec3( fp, toVec3f(wgs84_nodes[i] - gbs_center));
-        }
+    // write bounding sphere
+    write_header( fp, SG_BOUNDING_SPHERE, 0, 1);
+    sgWriteUInt( fp, sizeof(double) * 3 + sizeof(float) ); // nbytes
+    sgWritedVec3( fp, gbs_center );
+    sgWriteFloat( fp, gbs_radius );
 
-        // dump vertex color list
-        write_header( fp, SG_COLOR_LIST, 0, 1);
-        sgWriteUInt( fp, colors.size() * sizeof(float) * 4 ); // nbytes
-        for ( i = 0; i < (int)colors.size(); ++i ) {
-          sgWriteVec4( fp, colors[i]);
-        }
+    // dump vertex list
+    write_header( fp, SG_VERTEX_LIST, 0, 1);
+    sgWriteUInt( fp, wgs84_nodes.size() * sizeof(float) * 3 ); // nbytes
+    for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
+        sgWriteVec3( fp, toVec3f(wgs84_nodes[i] - gbs_center));
+    }
 
-        // dump vertex normal list
-        write_header( fp, SG_NORMAL_LIST, 0, 1);
-        sgWriteUInt( fp, normals.size() * 3 );              // nbytes
-        char normal[3];
-        for ( i = 0; i < (int)normals.size(); ++i ) {
-            SGVec3f p = normals[i];
-            normal[0] = (unsigned char)((p.x() + 1.0) * 127.5);
-            normal[1] = (unsigned char)((p.y() + 1.0) * 127.5);
-            normal[2] = (unsigned char)((p.z() + 1.0) * 127.5);
-            sgWriteBytes( fp, 3, normal );
-        }
+    // dump vertex color list
+    write_header( fp, SG_COLOR_LIST, 0, 1);
+    sgWriteUInt( fp, colors.size() * sizeof(float) * 4 ); // nbytes
+    for ( i = 0; i < (int)colors.size(); ++i ) {
+      sgWriteVec4( fp, colors[i]);
+    }
 
-        // dump texture coordinates
-        write_header( fp, SG_TEXCOORD_LIST, 0, 1);
-        sgWriteUInt( fp, texcoords.size() * sizeof(float) * 2 ); // nbytes
-        for ( i = 0; i < (int)texcoords.size(); ++i ) {
-          sgWriteVec2( fp, texcoords[i]);
-        }
+    // dump vertex normal list
+    write_header( fp, SG_NORMAL_LIST, 0, 1);
+    sgWriteUInt( fp, normals.size() * 3 );              // nbytes
+    char normal[3];
+    for ( i = 0; i < (int)normals.size(); ++i ) {
+        SGVec3f p = normals[i];
+        normal[0] = (unsigned char)((p.x() + 1.0) * 127.5);
+        normal[1] = (unsigned char)((p.y() + 1.0) * 127.5);
+        normal[2] = (unsigned char)((p.z() + 1.0) * 127.5);
+        sgWriteBytes( fp, 3, normal );
+    }
 
-        write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tcs, pts_vas, pt_materials);
-        write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tcs, tris_vas, tri_materials);
-        write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tcs, strips_vas, strip_materials);
-        write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tcs, fans_vas, fan_materials);
+    // dump texture coordinates
+    write_header( fp, SG_TEXCOORD_LIST, 0, 1);
+    sgWriteUInt( fp, texcoords.size() * sizeof(float) * 2 ); // nbytes
+    for ( i = 0; i < (int)texcoords.size(); ++i ) {
+      sgWriteVec2( fp, texcoords[i]);
+    }
 
-        // close the file
-        gzclose(fp);
-        fp = NULL;
-    } catch (std::exception&) {
-        if (fp) {
-            gzclose(fp);
-        }
+    write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tcs, pts_vas, pt_materials);
+    write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tcs, tris_vas, tri_materials);
+    write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tcs, strips_vas, strip_materials);
+    write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tcs, fans_vas, fan_materials);
+
+    // close the file
+    gzclose(fp);
+
+    if ( sgWriteError() ) {
+        cout << "Error while writing file " << file << endl;
         return false;
     }
+
     return true;
 }
 

simgear/io/sg_file.cxx

@@ -71,31 +71,21 @@ SGFile::~SGFile() {
 std::string SGFile::computeHash()
 {
     if (!file_name.exists())
-        return {};
-        
+        return std::string();
     simgear::sha1nfo info;
     sha1_init(&info);
-    
-    // unique_ptr with custom deleter for exception safety
-    const int bufSize = 1024 * 1024;
-    std::unique_ptr<char, std::function<void(char*)>> buf{static_cast<char*>(malloc(bufSize)), 
-        [](char* p) { free(p); }};
-
-    if (!buf) {
-        throw sg_exception("Malloc of SHA buffer failed", {}, file_name);
-    }
-
+    char* buf = static_cast<char*>(malloc(1024 * 1024));
     size_t readLen;
     SGBinaryFile f(file_name);
     if (!f.open(SG_IO_IN)) {
-        SG_LOG(SG_IO, SG_ALERT, "SGFile::computeHash: Failed to open " << file_name);
-        return {};
+        throw sg_io_exception("Couldn't open file for compute hash", file_name);
     }
-    while ((readLen = f.read(buf.get(), bufSize)) > 0) {
-        sha1_write(&info, buf.get(), readLen);
+    while ((readLen = f.read(buf, 1024 * 1024)) > 0) {
+        sha1_write(&info, buf, readLen);
     }
 
     f.close();
+    free(buf);
     std::string hashBytes((char*)sha1_result(&info), HASH_LENGTH);
     return simgear::strutils::encodeHex(hashBytes);
 }

simgear/io/test_repository.cxx

@@ -1,18 +1,16 @@
 #include <cassert>
 #include <cstdlib>
-#include <errno.h>
-#include <fcntl.h>
-#include <functional>
 #include <iostream>
 #include <map>
 #include <sstream>
+#include <errno.h>
+#include <fcntl.h>
 
 #include <simgear/simgear_config.h>
 
-#include "HTTPClient.hxx"
-#include "HTTPRepository.hxx"
-#include "HTTPTestApi_private.hxx"
 #include "test_HTTP.hxx"
+#include "HTTPRepository.hxx"
+#include "HTTPClient.hxx"
 
 #include <simgear/misc/strutils.hxx>
 #include <simgear/misc/sg_hash.hxx>
@@ -27,14 +25,8 @@
 
 using namespace simgear;
 
-using TestApi = simgear::HTTP::TestApi;
-
 std::string dataForFile(const std::string& parentName, const std::string& name, int revision)
 {
-    if (name == "zeroByteFile") {
-        return {};
-    }
-
     std::ostringstream os;
     // random content but which definitely depends on our tree location
     // and revision.
@@ -53,9 +45,6 @@ std::string hashForData(const std::string& d)
     return strutils::encodeHex(sha1_result(&info), HASH_LENGTH);
 }
 
-class TestRepoEntry;
-using AccessCallback = std::function<void(TestRepoEntry &entry)>;
-
 class TestRepoEntry
 {
 public:
@@ -81,8 +70,7 @@ public:
     int requestCount;
     bool getWillFail;
     bool returnCorruptData;
-
-    AccessCallback accessCallback;
+    std::unique_ptr<SGCallback> accessCallback;
 
     void clearRequestCounts();
 
@@ -282,8 +270,8 @@ public:
                 return;
             }
 
-            if (entry->accessCallback) {
-              entry->accessCallback(*entry);
+            if (entry->accessCallback.get()) {
+                (*entry->accessCallback)();
             }
 
             if (entry->getWillFail) {
@@ -294,29 +282,20 @@ public:
             entry->requestCount++;
 
             std::string content;
-            bool closeSocket = false;
-            size_t contentSize = 0;
-
             if (entry->returnCorruptData) {
                 content = dataForFile("!$£$!" + entry->parent->name,
                                       "corrupt_" + entry->name,
                                       entry->revision);
-                contentSize = content.size();
             } else {
-              content = entry->data();
-              contentSize = content.size();
+                content = entry->data();
             }
 
             std::stringstream d;
             d << "HTTP/1.1 " << 200 << " " << reasonForCode(200) << "\r\n";
-            d << "Content-Length:" << contentSize << "\r\n";
+            d << "Content-Length:" << content.size() << "\r\n";
             d << "\r\n"; // final CRLF to terminate the headers
             d << content;
             push(d.str().c_str());
-
-            if (closeSocket) {
-              closeWhenDone();
-            }
         } else {
             sendErrorResponse(404, false, "");
         }
@@ -413,7 +392,6 @@ void waitForUpdateComplete(HTTP::Client* cl, HTTPRepository* repo)
         cl->update();
         testServer.poll();
 
-        repo->process();
         if (!repo->isDoingSync()) {
             return;
         }
@@ -423,16 +401,6 @@ void waitForUpdateComplete(HTTP::Client* cl, HTTPRepository* repo)
     std::cerr << "timed out" << std::endl;
 }
 
-void runForTime(HTTP::Client *cl, HTTPRepository *repo, int msec = 15) {
-  SGTimeStamp start(SGTimeStamp::now());
-  while (start.elapsedMSec() < msec) {
-    cl->update();
-    testServer.poll();
-    repo->process();
-    SGTimeStamp::sleepForMSec(1);
-  }
-}
-
 void testBasicClone(HTTP::Client* cl)
 {
     std::unique_ptr<HTTPRepository> repo;
@@ -450,7 +418,6 @@ void testBasicClone(HTTP::Client* cl)
     verifyFileState(p, "fileA");
     verifyFileState(p, "dirA/subdirA/fileAAA");
     verifyFileState(p, "dirC/subdirA/subsubA/fileCAAA");
-    verifyFileState(p, "dirA/subdirA/zeroByteFile");
 
     global_repo->findEntry("fileA")->revision++;
     global_repo->findEntry("dirB/subdirA/fileBAA")->revision++;
@@ -651,19 +618,9 @@ void testAbandonCorruptFiles(HTTP::Client* cl)
     repo->setBaseUrl("http://localhost:2000/repo");
     repo->update();
     waitForUpdateComplete(cl, repo.get());
-    if (repo->failure() != HTTPRepository::REPO_PARTIAL_UPDATE) {
-      std::cerr << "Got failure state:" << repo->failure() << std::endl;
-      throw sg_exception("Bad result from corrupt files test");
-    }
-
-    auto failedFiles = repo->failures();
-    if (failedFiles.size() != 1) {
-      throw sg_exception("Bad result from corrupt files test");
-    }
-
-    if (failedFiles.front().path.utf8Str() != "dirB/subdirG/fileBGA") {
-      throw sg_exception("Bad path from corrupt files test:" +
-                         failedFiles.front().path.utf8Str());
+    if (repo->failure() != HTTPRepository::REPO_ERROR_CHECKSUM) {
+        std::cerr << "Got failure state:" << repo->failure() << std::endl;
+        throw sg_exception("Bad result from corrupt files test");
     }
 
     repo.reset();
@@ -700,21 +657,15 @@ void testServerModifyDuringSync(HTTP::Client* cl)
     repo.reset(new HTTPRepository(p, cl));
     repo->setBaseUrl("http://localhost:2000/repo");
 
-    global_repo->findEntry("dirA/fileAA")->accessCallback =
-        [](const TestRepoEntry &r) {
-          std::cout << "Modifying sub-tree" << std::endl;
-          global_repo->findEntry("dirB/subdirA/fileBAC")->revision++;
-          global_repo->defineFile("dirB/subdirZ/fileBZA");
-          global_repo->findEntry("dirB/subdirB/fileBBB")->revision++;
-        };
+    global_repo->findEntry("dirA/fileAA")->accessCallback.reset(make_callback(&modifyBTree));
 
     repo->update();
     waitForUpdateComplete(cl, repo.get());
 
-    global_repo->findEntry("dirA/fileAA")->accessCallback = AccessCallback{};
+    global_repo->findEntry("dirA/fileAA")->accessCallback.reset();
 
-    if (repo->failure() != HTTPRepository::REPO_PARTIAL_UPDATE) {
-      throw sg_exception("Bad result from modify during sync test");
+    if (repo->failure() != HTTPRepository::REPO_ERROR_CHECKSUM) {
+        throw sg_exception("Bad result from modify during sync test");
     }
 
     std::cout << "Passed test modify server during sync" << std::endl;
@@ -804,124 +755,6 @@ void testCopyInstalledChildren(HTTP::Client* cl)
     std::cout << "passed Copy installed children" << std::endl;
 }
 
-void testRetryAfterSocketFailure(HTTP::Client *cl) {
-  global_repo->clearRequestCounts();
-  global_repo->clearFailFlags();
-
-  std::unique_ptr<HTTPRepository> repo;
-  SGPath p(simgear::Dir::current().path());
-  p.append("http_repo_retry_after_socket_fail");
-  simgear::Dir pd(p);
-  if (pd.exists()) {
-    pd.removeChildren();
-  }
-
-  repo.reset(new HTTPRepository(p, cl));
-  repo->setBaseUrl("http://localhost:2000/repo");
-
-  int aaFailsRemaining = 2;
-  int subdirBAFailsRemaining = 2;
-  TestApi::setResponseDoneCallback(
-      cl, [&aaFailsRemaining, &subdirBAFailsRemaining](int curlResult,
-                                                       HTTP::Request_ptr req) {
-        if (req->url() == "http://localhost:2000/repo/dirA/fileAA") {
-          if (aaFailsRemaining == 0)
-            return false;
-
-          --aaFailsRemaining;
-          TestApi::markRequestAsFailed(req, 56, "Simulated socket failure");
-          return true;
-        } else if (req->url() ==
-                   "http://localhost:2000/repo/dirB/subdirA/.dirindex") {
-          if (subdirBAFailsRemaining == 0)
-            return false;
-
-          --subdirBAFailsRemaining;
-          TestApi::markRequestAsFailed(req, 56, "Simulated socket failure");
-          return true;
-        } else {
-          return false;
-        }
-      });
-
-  repo->update();
-  waitForUpdateComplete(cl, repo.get());
-
-  if (repo->failure() != HTTPRepository::REPO_NO_ERROR) {
-    throw sg_exception("Bad result from retry socket failure test");
-  }
-
-  verifyFileState(p, "dirA/fileAA");
-  verifyFileState(p, "dirB/subdirA/fileBAA");
-  verifyFileState(p, "dirB/subdirA/fileBAC");
-
-  verifyRequestCount("dirA/fileAA", 3);
-  verifyRequestCount("dirB/subdirA", 3);
-  verifyRequestCount("dirB/subdirA/fileBAC", 1);
-}
-
-void testPersistentSocketFailure(HTTP::Client *cl) {
-  global_repo->clearRequestCounts();
-  global_repo->clearFailFlags();
-
-  std::unique_ptr<HTTPRepository> repo;
-  SGPath p(simgear::Dir::current().path());
-  p.append("http_repo_persistent_socket_fail");
-  simgear::Dir pd(p);
-  if (pd.exists()) {
-    pd.removeChildren();
-  }
-
-  repo.reset(new HTTPRepository(p, cl));
-  repo->setBaseUrl("http://localhost:2000/repo");
-
-  TestApi::setResponseDoneCallback(
-      cl, [](int curlResult, HTTP::Request_ptr req) {
-        const auto url = req->url();
-        if (url.find("http://localhost:2000/repo/dirB") == 0) {
-          TestApi::markRequestAsFailed(req, 56, "Simulated socket failure");
-          return true;
-        }
-
-        return false;
-      });
-
-  repo->update();
-  waitForUpdateComplete(cl, repo.get());
-
-  if (repo->failure() != HTTPRepository::REPO_PARTIAL_UPDATE) {
-    throw sg_exception("Bad result from retry socket failure test");
-  }
-
-  verifyFileState(p, "dirA/fileAA");
-  verifyRequestCount("dirA/fileAA", 1);
-
-  verifyRequestCount("dirD/fileDA", 1);
-  verifyRequestCount("dirD/subdirDA/fileDAA", 1);
-  verifyRequestCount("dirD/subdirDB/fileDBA", 1);
-}
-
-void testHashOnEmptyFile()
-{
-    std::unique_ptr<HTTPRepository> repo;
-    SGPath p(simgear::Dir::current().path());
-    p.append("sgfile_compute_hash");
-    simgear::Dir pd(p);
-    if (pd.exists()) {
-        pd.removeChildren();
-    } else {
-        pd.create(0700);
-    }
-
-    SGPath fPath = p / "test_empty_file";
-    
-    SGFile file(fPath);
-    file.open(SG_IO_OUT);
-    file.close();
-
-    const auto hash = file.computeHash();
-}
-
 int main(int argc, char* argv[])
 {
   sglog().setLogLevels( SG_ALL, SG_INFO );
@@ -937,8 +770,6 @@ int main(int argc, char* argv[])
     global_repo->defineFile("dirA/fileAC");
     global_repo->defineFile("dirA/subdirA/fileAAA");
     global_repo->defineFile("dirA/subdirA/fileAAB");
-    global_repo->defineFile("dirA/subdirA/zeroByteFile");
-
     global_repo->defineFile("dirB/subdirA/fileBAA");
     global_repo->defineFile("dirB/subdirA/fileBAB");
     global_repo->defineFile("dirB/subdirA/fileBAC");
@@ -969,10 +800,6 @@ int main(int argc, char* argv[])
     cl.clearAllConnections();
 
     testCopyInstalledChildren(&cl);
-    testRetryAfterSocketFailure(&cl);
-    testPersistentSocketFailure(&cl);
-
-    testHashOnEmptyFile();
 
     std::cout << "all tests passed ok" << std::endl;
     return 0;

simgear/io/test_untar.cxx

@@ -32,7 +32,7 @@ void testTarGz()
     uint8_t* buf = (uint8_t*) alloca(8192);
     size_t bufSize = f.read((char*) buf, 8192);
 
-    SG_VERIFY(ArchiveExtractor::determineType(buf, bufSize) == ArchiveExtractor::GZData);
+    SG_VERIFY(ArchiveExtractor::determineType(buf, bufSize) == ArchiveExtractor::TarData);
 
     f.close();
 }
@@ -174,34 +174,6 @@ void testPAXAttributes()
 
 }
 
-void testExtractXZ()
-{
-    SGPath p = SGPath(SRC_DIR);
-    p.append("test.tar.xz");
-
-    SGBinaryFile f(p);
-    f.open(SG_IO_IN);
-
-    SGPath extractDir = simgear::Dir::current().path() / "test_extract_xz";
-    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());
-}
-
 int main(int ac, char ** av)
 {
     testTarGz();
@@ -209,8 +181,7 @@ int main(int ac, char ** av)
     testFilterTar();
 	testExtractStreamed();
 	testExtractZip();
-    testExtractXZ();
-
+   
     // disabled to avoiding checking in large PAX archive
     // testPAXAttributes();
     

simgear/io/untar.cxx

@@ -31,18 +31,87 @@
 #include <simgear/sg_inlines.h>
 #include <simgear/io/sg_file.hxx>
 #include <simgear/misc/sg_dir.hxx>
-#include <simgear/misc/strutils.hxx>
-
 #include <simgear/io/iostreams/sgstream.hxx>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/package/unzip.h>
 #include <simgear/structure/exception.hxx>
 
-#include "ArchiveExtractor_private.hxx"
-
 namespace simgear
 {
 
+	class ArchiveExtractorPrivate
+	{
+	public:
+		ArchiveExtractorPrivate(ArchiveExtractor* o) :
+			outer(o)
+		{
+			assert(outer);
+		}
+
+        virtual ~ArchiveExtractorPrivate() = default;
+        
+		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;
+
+/* tar Header Block, from POSIX 1003.1-1990.  */
 
 typedef struct
 {
@@ -82,410 +151,317 @@ typedef struct
 #define FIFOTYPE '6'            /* FIFO special */
 #define CONTTYPE '7'            /* reserved */
 
-    const char PAX_GLOBAL_HEADER = 'g';
-    const char PAX_FILE_ATTRIBUTES = 'x';
+	const char PAX_GLOBAL_HEADER = 'g';
+	const char PAX_FILE_ATTRIBUTES = 'x';
 
 
-    ///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    const int ZLIB_DECOMPRESS_BUFFER_SIZE = 32 * 1024;
-    const int ZLIB_INFLATE_WINDOW_BITS = MAX_WBITS;
-    const int ZLIB_DECODE_GZIP_HEADER = 16;
-
-    /* tar Header Block, from POSIX 1003.1-1990.  */
-
-
-    class TarExtractorPrivate : public ArchiveExtractorPrivate
-    {
-    public:
-        union {
-            UstarHeaderBlock header;
-            uint8_t headerBytes[TAR_HEADER_BLOCK_SIZE];
-        };
-
-        size_t bytesRemaining;
-        std::unique_ptr<SGFile> currentFile;
-        size_t currentFileSize;
-
-        uint8_t* headerPtr;
-        bool skipCurrentEntry = false;
-        std::string paxAttributes;
-        std::string paxPathName;
-
-        TarExtractorPrivate(ArchiveExtractor* o) : ArchiveExtractorPrivate(o)
-        {
-            setState(TarExtractorPrivate::READING_HEADER);
-        }
-
-        ~TarExtractorPrivate() = default;
-
-        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) {
-                return;
-            }
-
-            if (state == READING_FILE) {
-                if (currentFile) {
-                    currentFile->close();
-                    currentFile.reset();
-                }
-                readPaddingIfRequired();
-            } else if (state == READING_HEADER) {
-                processHeader();
-            } else if (state == PRE_END_OF_ARCHVE) {
-                if (headerIsAllZeros()) {
-                    setState(END_OF_ARCHIVE);
-                } 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);
-            }
-        }
-
-        void setState(State newState)
-        {
-            if ((newState == READING_HEADER) || (newState == PRE_END_OF_ARCHVE)) {
-                bytesRemaining = TAR_HEADER_BLOCK_SIZE;
-                headerPtr = headerBytes;
-            }
-
-            state = newState;
-        }
-
-        void extractBytes(const uint8_t* bytes, size_t count) override
-        {
-            // uncompressed, just pass through directly
-            processBytes((const char*)bytes, count);
-        }
-
-        void flush() override
-        {
-            // no-op for tar files, we process everything greedily
-        }
-
-        void processHeader()
-        {
-            if (headerIsAllZeros()) {
-                if (state == PRE_END_OF_ARCHVE) {
-                    setState(END_OF_ARCHIVE);
-                } else {
-                    setState(PRE_END_OF_ARCHVE);
-                }
-                return;
-            }
-
-            if (strncmp(header.magic, TMAGIC, TMAGLEN) != 0) {
-                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, "unsafe tar path, skipping::" << tarPath);
-                skipCurrentEntry = true;
-            }
-
-            auto result = filterPath(tarPath);
-            if (result == ArchiveExtractor::Stop) {
-                setState(FILTER_STOPPED);
-                return;
-            } else if (result == ArchiveExtractor::Skipped) {
-                skipCurrentEntry = true;
-            }
-
-            SGPath p = extractRootPath() / tarPath;
-            if (header.typeflag == DIRTYPE) {
-                if (!skipCurrentEntry) {
-                    Dir dir(p);
-                    dir.create(0755);
-                }
-                setState(READING_HEADER);
-            } else if ((header.typeflag == REGTYPE) || (header.typeflag == AREGTYPE)) {
-                currentFileSize = ::strtol(header.size, NULL, 8);
-                bytesRemaining = currentFileSize;
-                if (!skipCurrentEntry) {
-                    currentFile.reset(new SGBinaryFile(p));
-                    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;
-            }
-        }
-
-        void processBytes(const char* bytes, size_t count)
-        {
-            if ((state >= ERROR_STATE) || (state == END_OF_ARCHIVE)) {
-                return;
-            }
-
-            size_t curBytes = std::min(bytesRemaining, count);
-            if (state == READING_FILE) {
-                if (currentFile) {
-                    currentFile->write(bytes, curBytes);
-                }
-                bytesRemaining -= curBytes;
-            } else if ((state == READING_HEADER) || (state == PRE_END_OF_ARCHVE) || (state == END_OF_ARCHIVE)) {
-                memcpy(headerPtr, bytes, curBytes);
-                bytesRemaining -= curBytes;
-                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();
-            if (count > curBytes) {
-                // recurse with unprocessed bytes
-                processBytes(bytes + curBytes, count - curBytes);
-            }
-        }
-
-        bool headerIsAllZeros() const
-        {
-            char* headerAsChar = (char*)&header;
-            for (size_t i = 0; i < offsetof(UstarHeaderBlock, magic); ++i) {
-                if (*headerAsChar++ != 0) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        // https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.3.0/com.ibm.zos.v2r3.bpxa500/paxex.htm#paxex
-        void parsePAXAttributes(bool areGlobal)
-        {
-            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;
-            }
-        }
-
-        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;
-            }
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-
-class GZTarExtractor : public TarExtractorPrivate
+class TarExtractorPrivate : public ArchiveExtractorPrivate
 {
 public:
-    GZTarExtractor(ArchiveExtractor* outer) : TarExtractorPrivate(outer)
-    {
-        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;
-    }
+    
+    union {
+        UstarHeaderBlock header;
+        uint8_t headerBytes[TAR_HEADER_BLOCK_SIZE];
+    };
 
-    ~GZTarExtractor()
-    {
-        if (haveInitedZLib) {
-            inflateEnd(&zlibStream);
-        }
-        free(zlibOutput);
-    }
-
-    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 {
-                // set error state
-                state = TarExtractorPrivate::BAD_DATA;
-                return;
-            }
-
-            haveInitedZLib = true;
-            setState(TarExtractorPrivate::READING_HEADER);
-        } // of init on first-bytes case
-
-        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));
-    }
-
-private:
+    size_t bytesRemaining;
+    std::unique_ptr<SGFile> currentFile;
+    size_t currentFileSize;
     z_stream zlibStream;
     uint8_t* zlibOutput;
     bool haveInitedZLib = false;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-#if 1 || defined(HAVE_XZ)
-
-#include <lzma.h>
-
-class XZTarExtractor : public TarExtractorPrivate
-{
-public:
-    XZTarExtractor(ArchiveExtractor* outer) : TarExtractorPrivate(outer)
+    bool uncompressedData = false; // set if reading a plain .tar (not tar.gz)
+    uint8_t* headerPtr;
+    bool skipCurrentEntry = false;
+    std::string paxAttributes;
+    std::string paxPathName;
+    
+    TarExtractorPrivate(ArchiveExtractor* o) :
+		ArchiveExtractorPrivate(o)
     {
-        _xzStream = LZMA_STREAM_INIT;
-        _outputBuffer = (uint8_t*)malloc(ZLIB_DECOMPRESS_BUFFER_SIZE);
+		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()
+    {
+        free(zlibOutput);
+    }
 
-        auto ret = lzma_stream_decoder(&_xzStream, UINT64_MAX, LZMA_TELL_ANY_CHECK);
-        if (ret != LZMA_OK) {
-            setState(BAD_ARCHIVE);
+    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) {
             return;
         }
-    }
 
-    ~XZTarExtractor()
-    {
-        free(_outputBuffer);
-    }
-
-    void extractBytes(const uint8_t* bytes, size_t count) override
-    {
-        lzma_action action = LZMA_RUN;
-        _xzStream.next_in = bytes;
-        _xzStream.avail_in = count;
-
-        size_t writtenSize;
-        do {
-            _xzStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
-            _xzStream.next_out = _outputBuffer;
-
-            const auto ret = lzma_code(&_xzStream, action);
-
-            writtenSize = ZLIB_DECOMPRESS_BUFFER_SIZE - _xzStream.avail_out;
-            if (writtenSize > 0) {
-                processBytes((const char*)_outputBuffer, writtenSize);
+        if (state == READING_FILE) {
+            if (currentFile) {
+                currentFile->close();
+                currentFile.reset();
             }
-
-            if (ret == LZMA_GET_CHECK) {
-                //
-            } else if (ret == LZMA_STREAM_END) {
+            readPaddingIfRequired();
+        } else if (state == READING_HEADER) {
+            processHeader();
+        } else if (state == PRE_END_OF_ARCHVE) {
+            if (headerIsAllZeros()) {
                 setState(END_OF_ARCHIVE);
-                break;
-            } else if (ret != LZMA_OK) {
-                setState(BAD_ARCHIVE);
-                break;
+            } else {
+                // what does the spec say here?
             }
-        } while ((_xzStream.avail_in > 0) || (writtenSize > 0));
-    }
-
-    void flush() override
-    {
-        const auto ret = lzma_code(&_xzStream, LZMA_FINISH);
-        if (ret != LZMA_STREAM_END) {
-            setState(BAD_ARCHIVE);
+        } 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);
         }
     }
 
-private:
-    lzma_stream _xzStream;
-    uint8_t* _outputBuffer = nullptr;
-};
+    void setState(State newState)
+    {
+        if ((newState == READING_HEADER) || (newState == PRE_END_OF_ARCHVE)) {
+            bytesRemaining = TAR_HEADER_BLOCK_SIZE;
+            headerPtr = headerBytes;
+        }
 
-#endif
+        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()) {
+            if (state == PRE_END_OF_ARCHVE) {
+                setState(END_OF_ARCHIVE);
+            } else {
+                setState(PRE_END_OF_ARCHVE);
+            }
+            return;
+        }
+
+        if (strncmp(header.magic, TMAGIC, TMAGLEN) != 0) {
+            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, "unsafe tar path, skipping::" << tarPath);
+            skipCurrentEntry = true;
+        }
+
+        auto result = filterPath(tarPath);
+        if (result == ArchiveExtractor::Stop) {
+            setState(FILTER_STOPPED);
+            return;
+        } else if (result == ArchiveExtractor::Skipped) {
+            skipCurrentEntry = true;
+        }
+        
+        SGPath p = extractRootPath() / tarPath;
+        if (header.typeflag == DIRTYPE) {
+            if (!skipCurrentEntry) {
+                Dir dir(p);
+                dir.create(0755);
+            }
+            setState(READING_HEADER);
+        } else if ((header.typeflag == REGTYPE) || (header.typeflag == AREGTYPE)) {
+            currentFileSize = ::strtol(header.size, NULL, 8);
+            bytesRemaining = currentFileSize;
+            if (!skipCurrentEntry) {
+                currentFile.reset(new SGBinaryFile(p));
+                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;
+        }
+    }
+
+    void processBytes(const char* bytes, size_t count)
+    {
+        if ((state >= ERROR_STATE) || (state == END_OF_ARCHIVE)) {
+            return;
+        }
+
+        size_t curBytes = std::min(bytesRemaining, count);
+        if (state == READING_FILE) {
+            if (currentFile) {
+                currentFile->write(bytes, curBytes);
+            }
+            bytesRemaining -= curBytes;
+        } else if ((state == READING_HEADER) || (state == PRE_END_OF_ARCHVE) || (state == END_OF_ARCHIVE)) {
+            memcpy(headerPtr, bytes, curBytes);
+            bytesRemaining -= curBytes;
+            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();
+        if (count > curBytes) {
+            // recurse with unprocessed bytes
+            processBytes(bytes + curBytes, count - curBytes);
+        }
+    }
+
+    bool headerIsAllZeros() const
+    {
+        char* headerAsChar = (char*) &header;
+        for (size_t i=0; i < offsetof(UstarHeaderBlock, magic); ++i) {
+            if (*headerAsChar++ != 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    // https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.3.0/com.ibm.zos.v2r3.bpxa500/paxex.htm#paxex
+    void parsePAXAttributes(bool areGlobal)
+    {
+        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;
+        }
+    }
+    
+    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;
+        }
+    }
+};
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -533,34 +509,32 @@ public:
 		const size_t BUFFER_SIZE = 1024 * 1024;
 		void* buf = malloc(BUFFER_SIZE);
 
-        int result = unzGoToFirstFile(zip);
-        if (result != UNZ_OK) {
-            SG_LOG(SG_IO, SG_ALERT, outer->rootPath() << "failed to go to first file in archive:" << result);
+		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);
-            return;
         }
-
-        while (true) {
-            extractCurrentFile(zip, (char*)buf, BUFFER_SIZE);
-            if (state == FILTER_STOPPED) {
-                state = END_OF_ARCHIVE;
-                break;
-            }
-
-            result = unzGoToNextFile(zip);
-            if (result == UNZ_END_OF_LIST_OF_FILE) {
-                state = END_OF_ARCHIVE;
-                break;
-            } else if (result != UNZ_OK) {
-                SG_LOG(SG_IO, SG_ALERT, outer->rootPath() << "failed to go to next file in archive:" << result);
-                state = BAD_ARCHIVE;
-                break;
-            }
-        }
-
-
+        
         free(buf);
         unzClose(zip);
     }
@@ -618,7 +592,7 @@ public:
 
 		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:" + strutils::error_string(errno), path);
+			throw sg_io_exception("failed to open output file for writing", path);
 		}
 
 		while (!eof) {
@@ -659,19 +633,17 @@ void ArchiveExtractor::extractBytes(const uint8_t* bytes, size_t count)
 
 		if (r == TarData) {
 			d.reset(new TarExtractorPrivate(this));
-        } else if (r == GZData) {
-            d.reset(new GZTarExtractor(this));
-        } else if (r == XZData) {
-            d.reset(new XZTarExtractor(this));
-        } else if (r == ZipData) {
-            d.reset(new ZipExtractorPrivate(this));
-        } else {
-            SG_LOG(SG_IO, SG_WARN, "Invalid archive type");
+		}
+		else if (r == ZipData) {
+			d.reset(new ZipExtractorPrivate(this));
+		}
+		else {
+			SG_LOG(SG_IO, SG_WARN, "Invalid archive type");
 			_invalidDataType = true;
 			return;
-        }
+		}
 
-        // if hit here, we created the extractor. Feed the prefbuffer
+		// if hit here, we created the extractor. Feed the prefbuffer
 		// bytes through it
 		d->extractBytes((uint8_t*) _prebuffer.data(), _prebuffer.size());
 		_prebuffer.clear();
@@ -723,18 +695,9 @@ ArchiveExtractor::DetermineResult ArchiveExtractor::determineType(const uint8_t*
 		return ZipData;
 	}
 
-    if (count < 6) {
-        return InsufficientData;
-    }
-
-    const uint8_t XZ_HEADER[6] = {0xFD, '7', 'z', 'X', 'Z', 0x00};
-    if (memcmp(bytes, XZ_HEADER, 6) == 0) {
-        return XZData;
-    }
-
-    auto r = isTarData(bytes, count);
-    if ((r == TarData) || (r == InsufficientData) || (r == GZData))
-        return r;
+	auto r = isTarData(bytes, count);
+	if ((r == TarData) || (r == InsufficientData))
+		return r;
 
 	return Invalid;
 }
@@ -747,8 +710,6 @@ ArchiveExtractor::DetermineResult ArchiveExtractor::isTarData(const uint8_t* byt
     }
 
     UstarHeaderBlock* header = 0;
-    DetermineResult result = InsufficientData;
-
     if ((bytes[0] == 0x1f) && (bytes[1] == 0x8b)) {
         // GZIP identification bytes
         z_stream z;
@@ -766,11 +727,11 @@ ArchiveExtractor::DetermineResult ArchiveExtractor::isTarData(const uint8_t* byt
             return Invalid;
         }
 
-        int zResult = inflate(&z, Z_SYNC_FLUSH);
-        if ((zResult == Z_OK) || (zResult == Z_STREAM_END)) {
+        int result = inflate(&z, Z_SYNC_FLUSH);
+        if ((result == Z_OK) || (result == Z_STREAM_END)) {
             // all good
         } else {
-            SG_LOG(SG_IO, SG_WARN, "isTarData: Zlib inflate failed:" << zResult);
+            SG_LOG(SG_IO, SG_WARN, "isTarData: Zlib inflate failed:" << result);
             inflateEnd(&z);
             return Invalid; // not tar data
         }
@@ -783,7 +744,6 @@ ArchiveExtractor::DetermineResult ArchiveExtractor::isTarData(const uint8_t* byt
 
         header = reinterpret_cast<UstarHeaderBlock*>(zlibOutput);
         inflateEnd(&z);
-        result = GZData;
     } else {
         // uncompressed tar
         if (count < TAR_HEADER_BLOCK_SIZE) {
@@ -791,14 +751,13 @@ ArchiveExtractor::DetermineResult ArchiveExtractor::isTarData(const uint8_t* byt
         }
 
         header = (UstarHeaderBlock*) bytes;
-        result = TarData;
     }
 
     if (strncmp(header->magic, TMAGIC, TMAGLEN) != 0) {
         return Invalid;
     }
 
-    return result;
+    return TarData;
 }
 
 void ArchiveExtractor::extractLocalFile(const SGPath& archiveFile)

simgear/io/untar.hxx

@@ -36,16 +36,15 @@ public:
 	ArchiveExtractor(const SGPath& rootPath);
 	virtual ~ArchiveExtractor();
 
-    enum DetermineResult {
-        Invalid,
-        InsufficientData,
-        TarData,
-        ZipData,
-        GZData, // Gzipped-tar
-        XZData  // XZ (aka LZMA) tar
-    };
+	enum DetermineResult
+	{
+		Invalid,
+		InsufficientData,
+		TarData,
+		ZipData
+	};
 
-    static DetermineResult determineType(const uint8_t* bytes, size_t count);
+	static DetermineResult determineType(const uint8_t* bytes, size_t count);
 
 	/**
 	 * @brief API to extract a local zip or tar.gz 
@@ -71,11 +70,6 @@ public:
 		Stop
 	};
 
-    SGPath rootPath() const
-    {
-        return _rootPath;
-    }
-
 protected:
 
 

simgear/math/SGGeod.hxx

@@ -29,13 +29,6 @@ public:
   /// Default constructor, initializes the instance to lat = lon = elev = 0
   SGGeod(void);
 
-  /**
-    return an SGGeod for which isValid() returns false.
-    This is necessaerby becuase for historical reasons, ther defaulrt constructor above initialsies to zero,zero,zero
-    which *is*
-   */
-  static SGGeod invalid();
-
   /// Factory from angular values in radians and elevation is 0
   static SGGeod fromRad(double lon, double lat);
   /// Factory from angular values in degrees and elevation is 0

simgear/math/SGGeodesy.cxx

@@ -537,13 +537,6 @@ SGGeodesy::advanceRadM(const SGGeoc& geoc, double course, double distance,
   }
 }
 
-SGGeoc SGGeodesy::advanceDegM(const SGGeoc &geoc, double course,
-                              double distance) {
-  SGGeoc result;
-  advanceRadM(geoc, course * SG_DEGREES_TO_RADIANS, distance, result);
-  return result;
-}
-
 double
 SGGeodesy::courseRad(const SGGeoc& from, const SGGeoc& to)
 {
@@ -663,8 +656,3 @@ SGGeodesy::radialIntersection(const SGGeod& a, double aRadial,
   result = SGGeod::fromGeoc(r);
   return true;
 }
-
-SGGeod SGGeod::invalid()
-{
-    return SGGeod::fromDeg(-999.9, -999.0);
-}

simgear/math/SGGeodesy.hxx

@@ -65,9 +65,6 @@ public:
   // Geocentric course/distance computation
   static void advanceRadM(const SGGeoc& geoc, double course, double distance,
                           SGGeoc& result);
-
-  static SGGeoc advanceDegM(const SGGeoc &geoc, double course, double distance);
-
   static double courseRad(const SGGeoc& from, const SGGeoc& to);
   static double distanceRad(const SGGeoc& from, const SGGeoc& to);
   static double distanceM(const SGGeoc& from, const SGGeoc& to);

simgear/misc/ResourceManager.cxx

@@ -49,11 +49,6 @@ ResourceManager* ResourceManager::instance()
     return static_manager;
 }    
 
-bool ResourceManager::haveInstance()
-{
-    return static_manager != nullptr;
-}
-
 ResourceManager::~ResourceManager()
 {
     assert(this == static_manager);
@@ -61,15 +56,6 @@ ResourceManager::~ResourceManager()
     std::for_each(_providers.begin(), _providers.end(), 
         [](ResourceProvider* p) { delete p; });
 }
-
-void ResourceManager::reset()
-{
-    if (static_manager) {
-        delete static_manager;
-        static_manager = nullptr;
-    }
-}
-
 /**
  * trivial provider using a fixed base path
  */
@@ -121,8 +107,6 @@ void ResourceManager::removeProvider(ResourceProvider* aProvider)
         SG_LOG(SG_GENERAL, SG_DEV_ALERT, "unknown provider doing remove");
         return;
     }
-
-    _providers.erase(it);
 }
 
 SGPath ResourceManager::findPath(const std::string& aResource, SGPath aContext)

simgear/misc/ResourceManager.hxx

@@ -45,12 +45,8 @@ public:
       PRIORITY_HIGH = 1000
     } Priority;
 
-    static ResourceManager* instance();
-
-    static bool haveInstance();
-
-    static void reset();
-
+    static ResourceManager* instance();    
+    
     /**
      * add a simple fixed resource location, to resolve against
      */

simgear/misc/sg_path.cxx

@@ -44,11 +44,9 @@
 #if defined(SG_WINDOWS)
 #  include <direct.h>
 #  include <sys/utime.h>
-#  include <Shlwapi.h>
 #endif
 
 #include "sg_path.hxx"
-#include <simgear/misc/sg_dir.hxx>
 
 using std::string;
 using simgear::strutils::starts_with;
@@ -196,8 +194,7 @@ SGPath::SGPath(PermissionChecker validator)
     _permission_checker(validator),
     _cached(false),
     _rwCached(false),
-    _cacheEnabled(true),
-    _existsCached(false)
+    _cacheEnabled(true)
 {
 }
 
@@ -208,8 +205,7 @@ SGPath::SGPath( const std::string& p, PermissionChecker validator )
     _permission_checker(validator),
     _cached(false),
     _rwCached(false),
-    _cacheEnabled(true),
-    _existsCached(false)
+    _cacheEnabled(true)
 {
     fix();
 }
@@ -234,8 +230,7 @@ SGPath::SGPath( const SGPath& p,
     _permission_checker(validator),
     _cached(false),
     _rwCached(false),
-    _cacheEnabled(p._cacheEnabled),
-    _existsCached(false)
+    _cacheEnabled(p._cacheEnabled)
 {
     append(r);
     fix();
@@ -515,19 +510,6 @@ void SGPath::checkAccess() const
 
 bool SGPath::exists() const
 {
-#if defined(SG_WINDOWS)
-  // optimisation: _wstat is slow, eg for TerraSync
-  if (!_cached && !_existsCached) {
-      std::wstring w(wstr());
-    if ((path.length() > 1) && (path.back() == '/')) {
-	    w.pop_back();
-    }
-
-    _existsCached = true;
-    _exists = PathFileExistsW(w.c_str());
-    return _exists;
-  }
-#endif
   validate();
   return _exists;
 }
@@ -996,9 +978,8 @@ SGPath SGPath::realpath() const
               // (needed for fgValidatePath security)
     {
         if (path.empty()) {
-            return simgear::Dir::current().path();
+            return SGPath(".").realpath(); // current directory
         }
-
         std::string this_dir = dir();
         if (isAbsolute() && this_dir.empty()) { // top level
             this_dir = "/";

simgear/misc/sg_path.hxx

@@ -356,7 +356,6 @@ private:
     mutable bool _exists : 1;
     mutable bool _isDir : 1;
     mutable bool _isFile : 1;
-    mutable bool _existsCached : 1; ///< only used on Windows
     mutable time_t _modTime;
     mutable size_t _size;
 };

simgear/misc/simgear_optional.hxx

@@ -74,22 +74,6 @@ public:
         return _value;
     }
 
-    const T& value_or(const T& defaultValue) const
-    {
-        if (!_haveValue) {
-            return defaultValue;
-        }
-        return _value;
-    }
-
-    T& value_or(T& defaultValue) const
-    {
-        if (!_haveValue) {
-            return defaultValue;
-        }
-        return _value;
-    }
-
     T& value()
     {
         if (!_haveValue) {

simgear/misc/strutils.cxx

@@ -267,38 +267,6 @@ namespace simgear {
 	    return do_strip( s, BOTHSTRIP );
 	}
 
-    string makeStringSafeForPropertyName(const std::string& str)
-    {
-        // This function replaces all characters in 'str' that are not
-        // alphanumeric or '-'.
-        // TODO: make the function multibyte safe.
-        string res = str;
-
-        int index = 0;
-        for (char& c : res) {
-            if (!std::isalpha(c) && !std::isdigit(c) && c != '-') {
-                switch (c) {
-                case ' ':
-                case '\t':
-                case '\n':
-                case '\r':
-                case '_':
-                case '.':
-                case '/':
-                case '\\':
-                    res[index] = '-';
-                    break;
-                default:
-                    res[index] = '_';
-                    SG_LOG(SG_GENERAL, SG_WARN, "makeStringSafeForPropertyName: Modified '" << str << "' to '" << res << "'");
-                }
-            }
-            index++;
-        }
-
-        return res;
-    }
-
         void
         stripTrailingNewlines_inplace(string& s)
         {

simgear/misc/strutils.hxx

@@ -75,9 +75,7 @@ namespace simgear {
 	std::string rstrip( const std::string& s );
 	std::string strip( const std::string& s );
 
-    std::string makeStringSafeForPropertyName(const std::string& str);
-
-    /**
+	/**
          * Return a new string with any trailing \\r and \\n characters removed.
          * Typically useful to clean a CR-terminated line obtained from
          * std::getline() which, upon reading CRLF (\\r\\n), discards the Line

simgear/misc/strutils_test.cxx

@@ -737,11 +737,6 @@ void testDecodeHex()
     SG_VERIFY(decoded == data1);
 }
 
-void test_makeStringSafeForPropertyName()
-{
-    SG_CHECK_EQUAL(strutils::makeStringSafeForPropertyName(" ABC/01234\t:\\\"_*$"), "-ABC-01234-_-_-__");
-}
-
 int main(int argc, char* argv[])
 {
     test_strip();
@@ -766,7 +761,6 @@ int main(int argc, char* argv[])
     test_formatGeod();
     test_iequals();
     testDecodeHex();
-    test_makeStringSafeForPropertyName();
-
+    
     return EXIT_SUCCESS;
 }

simgear/nasal/code.c

@@ -36,7 +36,7 @@ void naRuntimeError(naContext c, const char* fmt, ...)
 
 void naRethrowError(naContext subc)
 {
-    strncpy(subc->callParent->error, subc->error, sizeof(subc->callParent->error));
+    strncpy(subc->callParent->error, subc->error, sizeof(subc->error));
     subc->callParent->dieArg = subc->dieArg;
     longjmp(subc->callParent->jumpHandle, 1);
 }
@@ -248,7 +248,7 @@ void naFreeContext(naContext c)
     // than I have right now. So instead I'm clearing the stack tops here, so
     // a freed context looks the same as a new one returned by initContext.
 
-    c->fTop = c->opTop = c->markTop = c->ntemps = 0;
+    c->fTop = c->opTop = c->markTop = 0;
 
     c->nextFree = globals->freeContexts;
     globals->freeContexts = c;

simgear/nasal/cppbind/NasalContext.cxx

@@ -21,7 +21,6 @@
 #include "NasalString.hxx"
 
 #include <cassert>
-#include <stdexcept> // for std::runtime_error
 
 namespace nasal
 {

simgear/nasal/cppbind/NasalEmesaryInterface.hxx

@@ -63,7 +63,7 @@ namespace nasal
 
     class NasalMainLoopRecipient : public simgear::Emesary::IReceiver {
     public:
-        NasalMainLoopRecipient() : receiveCount(0), Active(false), CanWait(false) {
+        NasalMainLoopRecipient() : receiveCount(0) {
             simgear::Emesary::GlobalTransmitter::instance()->Register(*this);
         }
         virtual ~NasalMainLoopRecipient() {

simgear/nasal/iolib.c

@@ -7,7 +7,7 @@
 #include "iolib.h"
 
 static void ghostDestroy(void* g);
-naGhostType naIOGhostType = { ghostDestroy, "iofile", NULL, NULL };
+naGhostType naIOGhostType = { ghostDestroy, "iofile" };
 
 static struct naIOGhost* ioghost(naRef r)
 {

simgear/nasal/lib.c

@@ -472,7 +472,7 @@ static naRef f_sprintf(naContext c, naRef me, int argc, naRef* args)
         } else {
             arg = naNumValue(arg);
             if(naIsNil(arg))
-                fout = dosprintf("nil");
+                fout = dosprintf(fstr, "nil");
             else if(t=='d' || t=='i' || t=='c')
                 fout = dosprintf(fstr, (int)naNumValue(arg).num);
             else if(t=='o' || t=='u' || t=='x' || t=='X')

simgear/nasal/misc.c

@@ -100,14 +100,7 @@ naRef naNewHash(struct Context* c)
 
 naRef naNewCode(struct Context* c)
 {
-    naRef r = naNew(c, T_CODE);
-    // naNew can return a previously used naCode. naCodeGen will init
-    // all these members but a GC can occur inside naCodeGen, so we see
-    // partially initalized state here. To avoid this, clear out the values
-    // which mark() cares about.
-    PTR(r).code->srcFile = naNil();
-    PTR(r).code->nConstants = 0;
-    return r;
+    return naNew(c, T_CODE);
 }
 
 naRef naNewCCode(struct Context* c, naCFunction fptr)

simgear/nasal/threadlib.c

@@ -9,10 +9,10 @@
 #include "code.h"
 
 static void lockDestroy(void* lock) { naFreeLock(lock); }
-static naGhostType LockType = { lockDestroy, NULL, NULL, NULL };
+static naGhostType LockType = { lockDestroy };
 
 static void semDestroy(void* sem) { naFreeSem(sem); }
-static naGhostType SemType = { semDestroy, NULL, NULL, NULL };
+static naGhostType SemType = { semDestroy };
 
 typedef struct {
     naContext ctx;

simgear/package/Catalog.cxx

@@ -143,15 +143,9 @@ protected:
         Dir d(m_owner->installRoot());
         SGPath p = d.file("catalog.xml");
         sg_ofstream f(p, std::ios::out | std::ios::trunc);
-        const auto sz = m_buffer.size();
-        f.write(m_buffer.data(), sz);
+        f.write(m_buffer.data(), m_buffer.size());
         f.close();
 
-        if (f.fail()) {
-            m_owner->refreshComplete(Delegate::FAIL_FILESYSTEM);
-            return;
-        }
-
         time(&m_owner->m_retrievedTime);
         m_owner->writeTimestamp();
         m_owner->refreshComplete(Delegate::STATUS_REFRESHED);
@@ -601,17 +595,13 @@ void Catalog::setUserEnabled(bool b)
 
     m_userEnabled = b;
     SGPath disableMarkerFile = installRoot() / "_disabled_";
-
-    if (m_userEnabled == false) {
-        sg_ofstream of(disableMarkerFile, std::ios::trunc | std::ios::out);
-        of << "1" << std::flush; // touch the file
-        of.close();
+    if (m_userEnabled) {
+        sg_ofstream of(disableMarkerFile);
+        of << "1\n"; // touch the file
     } else {
-        if (disableMarkerFile.exists()) {
-            const bool ok = disableMarkerFile.remove();
-            if (!ok) {
-                SG_LOG(SG_IO, SG_WARN, "Failed to remove catalog-disable marker file:" << disableMarkerFile);
-            }
+        bool ok = disableMarkerFile.remove();
+        if (!ok) {
+            SG_LOG(SG_GENERAL, SG_ALERT, "Failed to remove catalog-disable marker file:" << disableMarkerFile);
         }
     }
 
@@ -625,8 +615,6 @@ void Catalog::setUserEnabled(bool b)
 
 void Catalog::processAlternate(SGPropertyNode_ptr alt)
 {
-    m_refreshRequest.reset();
-
     std::string altId;
     const auto idPtr = alt->getStringValue("id");
     if (idPtr) {
@@ -651,81 +639,24 @@ void Catalog::processAlternate(SGPropertyNode_ptr alt)
         return;
     }
 
-    // we have an alternate ID, and it's different from our ID, so let's
+    // we have an alternate ID, and it's differnt from our ID, so let's
     // define a new catalog
     if (!altId.empty()) {
-      // don't auto-re-add Catalogs the user has explicilty rmeoved, that would
-      // suck
-      const auto removedByUser = root()->explicitlyRemovedCatalogs();
-      auto it = std::find(removedByUser.begin(), removedByUser.end(), altId);
-      if (it != removedByUser.end()) {
+        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_WARN,
-             "Adding new catalog:" << altId << " as version alternate for "
-                                   << id());
-      // new catalog being added
-      auto newCat = createFromUrl(root(), altUrl);
-
-      bool didRun = false;
-      newCat->m_migratedFrom = this;
-
-      auto migratePackagesCb = [didRun](Catalog *c) mutable {
-        // removing callbacks is awkward, so use this
-        // flag to only run once. (and hence, we need to be mutable)
-        if (didRun)
-          return;
-
-        if (c->status() == Delegate::STATUS_REFRESHED) {
-          didRun = true;
-
-          string_list existing;
-          for (const auto &pack : c->migratedFrom()->installedPackages()) {
-            existing.push_back(pack->id());
-          }
-
-          const int count = c->markPackagesForInstallation(existing);
-          SG_LOG(
-              SG_GENERAL, SG_INFO,
-              "Marked " << count
-                        << " packages from previous catalog for installation");
-        }
-      };
-
-      newCat->addStatusCallback(migratePackagesCb);
-      // 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);
-    m_refreshRequest = new Downloader(this, altUrl);
-    root()->makeHTTPRequest(m_refreshRequest);
+    Downloader* dl = new Downloader(this, altUrl);
+    root()->makeHTTPRequest(dl);
 }
 
-int Catalog::markPackagesForInstallation(const string_list &packageIds) {
-  int result = 0;
-
-  for (const auto &id : packageIds) {
-    auto ourPkg = getPackageById(id);
-    if (!ourPkg)
-      continue;
-
-    auto existing = ourPkg->existingInstall();
-    if (!existing) {
-      ourPkg->markForInstall();
-      ++result;
-    }
-  } // of outer package ID candidates iteration
-
-  return result;
-}
-
-CatalogRef Catalog::migratedFrom() const { return m_migratedFrom; }
-
 } // of namespace pkg
 
 } // of namespace simgear

simgear/package/Catalog.hxx

@@ -23,7 +23,6 @@
 #include <map>
 
 #include <simgear/misc/sg_path.hxx>
-#include <simgear/misc/strutils.hxx>
 #include <simgear/props/props.hxx>
 
 #include <simgear/structure/SGReferenced.hxx>
@@ -94,7 +93,7 @@ public:
 
     /**
      * retrieve all the packages in the catalog which are installed
-     * and have a pending update
+     * and have a pendig update
      */
     PackageList packagesNeedingUpdate() const;
 
@@ -152,32 +151,7 @@ public:
     
     bool isUserEnabled() const;
     void setUserEnabled(bool b);
-
-    /**
-     * Given a list of package IDs, mark all which exist in this package,
-     * for installation. ANy packahe IDs not present in this catalog,
-     * will be ignored.
-     *
-     * @result The number for packages newly marked for installation.
-     */
-    int markPackagesForInstallation(const string_list &packageIds);
-
-    /**
-     * When a catalog is added due to migration, this will contain the
-     * Catalog which triggered the add. Usually this will be a catalog
-     * corresponding to an earlier version.
-     *
-     * Note it's only valid at the time, the migration actually took place;
-     * when the new catalog is loaded from disk, this value will return
-     * null.
-     *
-     * This is intended to allow Uis to show a 'catalog was migrated'
-     * feedback, when they see a catalog refresh, which has a non-null
-     * value of this method.
-     */
-    CatalogRef migratedFrom() const;
-
-  private:
+private:
     Catalog(Root* aRoot);
 
     class Downloader;
@@ -223,8 +197,6 @@ public:
     PackageWeakMap m_variantDict;
 
     function_list<Callback> m_statusCallbacks;
-
-    CatalogRef m_migratedFrom;
 };
 
 } // of namespace pkg

simgear/package/CatalogTest.cxx

@@ -166,8 +166,7 @@ int parseTest()
 {
     SGPath rootPath = simgear::Dir::current().path();
     rootPath.append("testRoot");
-
-    pkg::RootRef root(new pkg::Root(rootPath, "8.1.2"));
+    pkg::Root* root = new pkg::Root(rootPath, "8.1.12");
     root->setLocale("de");
     pkg::CatalogRef cat = pkg::Catalog::createFromPath(root, SGPath(SRC_DIR "/catalogTest1"));
 
@@ -345,6 +344,7 @@ int parseTest()
     SG_CHECK_EQUAL(urls.size(), 3);
     SG_CHECK_EQUAL(urls.at(1), "http://localhost:2000/mirrorB/b737.tar.gz");
 
+    delete root;
     return EXIT_SUCCESS;
 }
 
@@ -827,10 +827,7 @@ void testVersionMigrateToId(HTTP::Client* cl)
         
         it = std::find(enabledCats.begin(), enabledCats.end(), altCat);
         SG_VERIFY(it != enabledCats.end());
-
-        SG_CHECK_EQUAL(altCat->packagesNeedingUpdate().size(),
-                       1); // should be the 737
-
+        
         // 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");
@@ -843,8 +840,8 @@ void testVersionMigrateToId(HTTP::Client* cl)
         pkg::PackageRef p3 = root->getPackageById("b737-NG");
         SG_CHECK_EQUAL(p2, p3);
     }
-
-    // test that re-init-ing doesn't migrate again
+    
+    // test that re-init-ing doesn't mirgate again
     {
         pkg::RootRef root(new pkg::Root(rootPath, "7.5"));
         root->setHTTPClient(cl);
@@ -953,7 +950,7 @@ int parseInvalidTest()
 {
     SGPath rootPath = simgear::Dir::current().path();
     rootPath.append("testRoot");
-    pkg::RootRef root(new pkg::Root(rootPath, "8.1.12"));
+    pkg::Root* root = new pkg::Root(rootPath, "8.1.12");
     pkg::CatalogRef cat = pkg::Catalog::createFromPath(root, SGPath(SRC_DIR "/catalogTestInvalid"));
     SG_VERIFY(cat.valid());
 
@@ -1187,128 +1184,6 @@ void testMirrorsFailure(HTTP::Client* cl)
     
 }
 
-void testMigrateInstalled(HTTP::Client *cl) {
-  SGPath rootPath(simgear::Dir::current().path());
-  rootPath.append("pkg_migrate_installed");
-  simgear::Dir pd(rootPath);
-  pd.removeChildren();
-
-  pkg::RootRef root(new pkg::Root(rootPath, "8.1.2"));
-  root->setHTTPClient(cl);
-
-  pkg::CatalogRef oldCatalog, newCatalog;
-
-  {
-    oldCatalog = pkg::Catalog::createFromUrl(
-        root.ptr(), "http://localhost:2000/catalogTest1/catalog.xml");
-    waitForUpdateComplete(cl, root);
-
-    pkg::PackageRef p1 =
-        root->getPackageById("org.flightgear.test.catalog1.b747-400");
-    p1->install();
-    auto p2 = root->getPackageById("org.flightgear.test.catalog1.c172p");
-    p2->install();
-    auto p3 = root->getPackageById("org.flightgear.test.catalog1.b737-NG");
-    p3->install();
-    waitForUpdateComplete(cl, root);
-  }
-
-  {
-    newCatalog = pkg::Catalog::createFromUrl(
-        root.ptr(), "http://localhost:2000/catalogTest2/catalog.xml");
-    waitForUpdateComplete(cl, root);
-
-    string_list existing;
-    for (const auto &pack : oldCatalog->installedPackages()) {
-      existing.push_back(pack->id());
-    }
-
-    SG_CHECK_EQUAL(4, existing.size());
-
-    int result = newCatalog->markPackagesForInstallation(existing);
-    SG_CHECK_EQUAL(2, result);
-    SG_CHECK_EQUAL(2, newCatalog->packagesNeedingUpdate().size());
-
-    auto p1 = root->getPackageById("org.flightgear.test.catalog2.b737-NG");
-    auto ins = p1->existingInstall();
-    SG_CHECK_EQUAL(0, ins->revsion());
-  }
-
-  {
-    root->scheduleAllUpdates();
-    waitForUpdateComplete(cl, root);
-
-    SG_CHECK_EQUAL(0, newCatalog->packagesNeedingUpdate().size());
-
-    auto p1 = root->getPackageById("org.flightgear.test.catalog2.b737-NG");
-    auto ins = p1->existingInstall();
-    SG_CHECK_EQUAL(ins->revsion(), p1->revision());
-  }
-}
-
-void testDontMigrateRemoved(HTTP::Client *cl) {
-  global_catalogVersion = 2; // version which has migration info
-  SGPath rootPath(simgear::Dir::current().path());
-  rootPath.append("cat_dont_migrate_id");
-  simgear::Dir pd(rootPath);
-  pd.removeChildren();
-
-  // install and mnaully remove the alt catalog
-
-  {
-    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-alt.xml");
-    waitForUpdateComplete(cl, root);
-
-    root->removeCatalogById("org.flightgear.test.catalog-alt");
-  }
-
-  // install the migration catalog
-  {
-    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());
-  }
-
-  // change version to an alternate one
-  {
-    pkg::RootRef root(new pkg::Root(rootPath, "7.5"));
-
-    auto removed = root->explicitlyRemovedCatalogs();
-    auto j = std::find(removed.begin(), removed.end(),
-                       "org.flightgear.test.catalog-alt");
-    SG_VERIFY(j != removed.end());
-
-    root->setHTTPClient(cl);
-
-    // this would tirgger migration, but we blocked it
-    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());
-
-    // check the new catalog
-    auto altCat = root->getCatalogById("org.flightgear.test.catalog-alt");
-    SG_VERIFY(altCat.get() == nullptr);
-  }
-}
-
 int main(int argc, char* argv[])
 {
     sglog().setLogLevels( SG_ALL, SG_WARN );
@@ -1333,31 +1208,27 @@ int main(int argc, char* argv[])
     testRefreshCatalog(&cl);
 
     testInstallTarPackage(&cl);
-
+    
     testInstallArchiveType(&cl);
-
+    
     testDisableDueToVersion(&cl);
-
+    
     testOfflineMode(&cl);
-
+    
     testVersionMigrate(&cl);
-
+    
     updateInvalidToValid(&cl);
     updateValidToInvalid(&cl);
     updateInvalidToInvalid(&cl);
-
+    
     removeInvalidCatalog(&cl);
-
+    
     testVersionMigrateToId(&cl);
 
     testInstallBadPackage(&cl);
-
+    
     testMirrorsFailure(&cl);
-
-    testMigrateInstalled(&cl);
-
-    testDontMigrateRemoved(&cl);
-
+    
     cerr << "Successfully passed all tests!" << endl;
     return EXIT_SUCCESS;
 }

simgear/package/Package.cxx

@@ -34,7 +34,7 @@ namespace simgear {
 namespace pkg {
 
 Package::Package(const SGPropertyNode* aProps, CatalogRef aCatalog) :
-    m_catalog(aCatalog.get())
+    m_catalog(aCatalog)
 {
     initWithProps(aProps);
 }
@@ -198,11 +198,6 @@ InstallRef Package::install()
 {
     InstallRef ins = existingInstall();
     if (ins) {
-      // if there's updates, treat this as a 'start update' request
-      if (ins->hasUpdate()) {
-        m_catalog->root()->scheduleToUpdate(ins);
-      }
-
         return ins;
     }
 
@@ -215,39 +210,13 @@ InstallRef Package::install()
     return ins;
 }
 
-InstallRef Package::markForInstall() {
-  InstallRef ins = existingInstall();
-  if (ins) {
-    return ins;
-  }
-
-  const auto pd = pathOnDisk();
-
-  Dir dir(pd);
-  if (!dir.create(0700)) {
-    SG_LOG(SG_IO, SG_ALERT,
-           "Package::markForInstall: couldn't create directory at:" << pd);
-    return {};
-  }
-
-  ins = new Install{this, pd};
-  _install_cb(this, ins); // not sure if we should trigger the callback for this
-
-  // repeat for dependencies to be kind
-  for (auto dep : dependencies()) {
-    dep->markForInstall();
-  }
-
-  return ins;
-}
-
 InstallRef Package::existingInstall(const InstallCallback& cb) const
 {
     InstallRef install;
     try {
         install = m_catalog->root()->existingInstallForPackage(const_cast<Package*>(this));
     } catch (std::exception& ) {
-      return {};
+        return InstallRef();
     }
 
   if( cb )
@@ -266,11 +235,6 @@ std::string Package::id() const
     return m_id;
 }
 
-CatalogRef Package::catalog() const
-{
-    return {m_catalog};
-}
-
 std::string Package::qualifiedId() const
 {
     return m_catalog->id() + "." + id();

simgear/package/Package.hxx

@@ -61,13 +61,6 @@ public:
     InstallRef
     existingInstall(const InstallCallback& cb = InstallCallback()) const;
 
-    /**
-     * Mark this package for installation, but don't actually start the
-     * download process. This creates the on-disk placeholder, so
-     * the package will appear an eededing to be updated.
-     */
-    InstallRef markForInstall();
-
     bool isInstalled() const;
 
     /**
@@ -137,7 +130,8 @@ public:
 
     size_t fileSizeBytes() const;
 
-    CatalogRef catalog() const;
+    CatalogRef catalog() const
+        { return m_catalog; }
 
     bool matches(const SGPropertyNode* aFilter) const;
 
@@ -242,7 +236,7 @@ private:
     SGPropertyNode_ptr m_props;
     std::string m_id;
     string_set m_tags;
-    Catalog* m_catalog = nullptr; // non-owning ref, explicitly
+    CatalogRef m_catalog;
     string_list m_variants;
 
     mutable function_list<InstallCallback> _install_cb;

simgear/package/Root.cxx

@@ -133,9 +133,7 @@ public:
 
     void fireRefreshStatus(CatalogRef catalog, Delegate::StatusCode status)
     {
-        // take a copy of delegates since firing this can modify the data
-        const auto currentDelegates = delegates;
-        for (auto d : currentDelegates) {
+        for (auto d : delegates) {
             d->catalogRefreshed(catalog, status);
         }
     }
@@ -285,32 +283,6 @@ public:
         fireDataForThumbnail(url, reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size());
     }
 
-    void writeRemovedCatalogsFile() const {
-      SGPath p = path / "RemovedCatalogs";
-      sg_ofstream stream(p, std::ios::out | std::ios::trunc | std::ios::binary);
-      for (const auto &cid : manuallyRemovedCatalogs) {
-        stream << cid << "\n";
-      }
-      stream.close();
-    }
-
-    void loadRemovedCatalogsFile() {
-      manuallyRemovedCatalogs.clear();
-      SGPath p = path / "RemovedCatalogs";
-      if (!p.exists())
-        return;
-
-      sg_ifstream stream(p, std::ios::in);
-      while (!stream.eof()) {
-        std::string line;
-        std::getline(stream, line);
-        const auto trimmed = strutils::strip(line);
-        if (!trimmed.empty()) {
-          manuallyRemovedCatalogs.push_back(trimmed);
-        }
-      } // of lines iteration
-    }
-
     DelegateVec delegates;
 
     SGPath path;
@@ -340,9 +312,6 @@ public:
 
     typedef std::map<PackageRef, InstallRef> InstallCache;
     InstallCache m_installs;
-
-    /// persistent list of catalogs the user has manually removed
-    string_list manuallyRemovedCatalogs;
 };
 
 
@@ -431,8 +400,6 @@ Root::Root(const SGPath& aPath, const std::string& aVersion) :
         thumbsCacheDir.create(0755);
     }
 
-    d->loadRemovedCatalogsFile();
-
     for (SGPath c : dir.children(Dir::TYPE_DIR | Dir::NO_DOT_OR_DOTDOT)) {
         // note this will set the catalog status, which will insert into
         // disabled catalogs automatically if necesary
@@ -654,13 +621,6 @@ void Root::scheduleToUpdate(InstallRef aInstall)
     }
 }
 
-void Root::scheduleAllUpdates() {
-  auto toBeUpdated = packagesNeedingUpdate(); // make a copy
-  for (const auto &u : toBeUpdated) {
-    scheduleToUpdate(u->existingInstall());
-  }
-}
-
 bool Root::isInstallQueued(InstallRef aInstall) const
 {
     auto it = std::find(d->updateDeque.begin(), d->updateDeque.end(), aInstall);
@@ -724,17 +684,20 @@ void Root::catalogRefreshStatus(CatalogRef aCat, Delegate::StatusCode aReason)
     auto catIt = d->catalogs.find(aCat->id());
     d->fireRefreshStatus(aCat, aReason);
 
-    if (aCat->isUserEnabled() &&
-        (aReason == Delegate::STATUS_REFRESHED) && 
-        (catIt == d->catalogs.end())) 
-    {
+    if (aReason == Delegate::STATUS_IN_PROGRESS) {
+        d->refreshing.insert(aCat);
+    } else {
+        d->refreshing.erase(aCat);
+    }
+
+    if ((aReason == Delegate::STATUS_REFRESHED) && (catIt == d->catalogs.end())) {
         assert(!aCat->id().empty());
         d->catalogs.insert(catIt, CatalogDict::value_type(aCat->id(), aCat));
 
-    // catalog might have been previously disabled, let's remove in that case
+        // catalog might have been previously disabled, let's remove in that case
         auto j = std::find(d->disabledCatalogs.begin(),
-                        d->disabledCatalogs.end(),
-                        aCat);
+                           d->disabledCatalogs.end(),
+                           aCat);
         if (j != d->disabledCatalogs.end()) {
             SG_LOG(SG_GENERAL, SG_INFO, "re-enabling disabled catalog:" << aCat->id());
             d->disabledCatalogs.erase(j);
@@ -742,7 +705,7 @@ void Root::catalogRefreshStatus(CatalogRef aCat, Delegate::StatusCode aReason)
     }
 
     if (!aCat->isEnabled()) {
-        // catalog has errors or was disabled by user, disable it
+        // catalog has errors, disable it
         auto j = std::find(d->disabledCatalogs.begin(),
                            d->disabledCatalogs.end(),
                            aCat);
@@ -757,17 +720,6 @@ void Root::catalogRefreshStatus(CatalogRef aCat, Delegate::StatusCode aReason)
         }
     } // of catalog is disabled
 
-    // remove from refreshing /after/ checking for enable / disabled, since for
-    // new catalogs, the reference in d->refreshing might be our /only/
-    // reference to the catalog. Once the refresh is done (either failed or
-    // succeeded) the Catalog will be in either d->catalogs or
-    // d->disabledCatalogs
-    if (aReason == Delegate::STATUS_IN_PROGRESS) {
-      d->refreshing.insert(aCat);
-    } else {
-      d->refreshing.erase(aCat);
-    }
-
     if (d->refreshing.empty()) {
         d->fireRefreshStatus(CatalogRef(), Delegate::STATUS_REFRESHED);
         d->firePackagesChanged();
@@ -828,9 +780,6 @@ bool Root::removeCatalogById(const std::string& aId)
             << "failed to remove directory");
     }
 
-    d->manuallyRemovedCatalogs.push_back(aId);
-    d->writeRemovedCatalogsFile();
-
     // notify that a catalog is being removed
     d->firePackagesChanged();
 
@@ -902,10 +851,6 @@ void Root::unregisterInstall(InstallRef ins)
     d->fireFinishUninstall(ins->package());
 }
 
-string_list Root::explicitlyRemovedCatalogs() const {
-  return d->manuallyRemovedCatalogs;
-}
-
 } // of namespace pkg
 
 } // of namespace simgear

simgear/package/Root.hxx

@@ -155,22 +155,7 @@ public:
     void requestThumbnailData(const std::string& aUrl);
     
     bool isInstallQueued(InstallRef aInstall) const;
-
-    /**
-     * Mark all 'to be updated' packages for update now
-     */
-    void scheduleAllUpdates();
-
-    /**
-     * @brief list of catalog IDs, the user has explicitly removed via
-     * removeCatalogById(). This is important to allow the user to opt-out
-     * of migrated packages.
-     *
-     * This information is stored in a helper file, in the root directory
-     */
-    string_list explicitlyRemovedCatalogs() const;
-
-  private:
+private:
     friend class Install;
     friend class Catalog;    
     friend class Package;

simgear/package/catalogTest2/catalog.xml

@@ -1,86 +0,0 @@
-<?xml version="1.0"?>
-
-<PropertyList>
-    <id>org.flightgear.test.catalog2</id>
-    <description>Second test catalog</description>
-    <url>http://localhost:2000/catalogTest2/catalog.xml</url>
-    <catalog-version>4</catalog-version>
-
-    <version>8.1.*</version>
-    <version>8.0.0</version>
-    <version>8.2.0</version>
-
-    <package>
-        <id>alpha</id>
-        <name>Alpha package</name>
-        <revision type="int">8</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>b737-NG</id>
-        <name>Boeing 737 NG</name>
-        <dir>b737NG</dir>
-        <description>A popular twin-engined narrow body jet</description>
-        <revision type="int">111</revision>
-        <file-size-bytes type="int">860</file-size-bytes>
-
-        <tag>boeing</tag>
-        <tag>jet</tag>
-        <tag>ifr</tag>
-
-      <!-- not within a localized element -->
-          <de>
-            <description>German description of B737NG XYZ</description>
-          </de>
-          <fr>
-            <description>French description of B737NG</description>
-          </fr>
-
-        <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/mirrorA/b737.tar.gz</url>
-        <url>http://localhost:2000/mirrorB/b737.tar.gz</url>
-        <url>http://localhost:2000/mirrorC/b737.tar.gz</url>
-      </package>
-
-    <package>
-        <id>b747-400</id>
-        <name>Boeing 747-400</name>
-        <dir>b744</dir>
-        <description>A popular four-engined wide-body jet</description>
-        <revision type="int">111</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>4d3f7417d74f811aa20ccc4f35673d20</md5>
-        <!-- this URL will sometimes fail, on purpose -->
-        <url>http://localhost:2000/catalogTest1/b747.tar.gz</url>
-      </package>
-
-</PropertyList>

simgear/props/AtomicChangeListener.cxx

@@ -59,12 +59,6 @@ void AtomicChangeListener::fireChangeListeners()
     listeners.clear();
 }
 
-void AtomicChangeListener::clearPendingChanges()
-{
-    auto& listeners = ListenerListSingleton::instance()->listeners;
-    listeners.clear();
-}
-
 void AtomicChangeListener::valueChangedImplementation()
 {
     if (!_dirty) {

simgear/props/AtomicChangeListener.hxx

@@ -52,17 +52,7 @@ public:
     bool isDirty() { return _dirty; }
     bool isValid() { return _valid; }
     virtual void unregister_property(SGPropertyNode* node) override;
-
     static void fireChangeListeners();
-
-    /**
-     * @brief Ensure we've deleted any pending changes. 
-     * 
-     * This is important in shutdown and reset, to avoid holding
-     * property listeners around after the property tree is destroyed
-     */
-    static void clearPendingChanges();
-
 private:
     virtual void valueChangedImplementation() override;
     virtual void valuesChanged();

simgear/props/condition.cxx

@@ -535,8 +535,7 @@ readComparison( SGPropertyNode *prop_root,
 {
   SGComparisonCondition * condition = new SGComparisonCondition(type, reverse);
   if (node->nChildren() < 2 || node->nChildren() > 3 ) {
-    throw sg_exception("condition: comparison without two or three children",
-                       {}, {}, false);
+    throw sg_exception("condition: comparison without two or three children");
   }
   
   const SGPropertyNode* left = node->getChild(0), 
@@ -552,8 +551,7 @@ readComparison( SGPropertyNode *prop_root,
       SGExpressiond* exp = SGReadDoubleExpression(prop_root, left->getChild(0));
       condition->setLeftDExpression(exp);
     } else {
-      throw sg_exception("Unknown condition comparison left child:" + leftName,
-                         {}, {}, false);
+      throw sg_exception("Unknown condition comparison left child:" + leftName);
     }
   }
     
@@ -567,8 +565,7 @@ readComparison( SGPropertyNode *prop_root,
       SGExpressiond* exp = SGReadDoubleExpression(prop_root, right->getChild(0));
       condition->setRightDExpression(exp);
     } else {
-      throw sg_exception("Unknown condition comparison right child:" + rightName,
-                         {}, {}, false);
+      throw sg_exception("Unknown condition comparison right child:" + rightName);
     }
   }
   
@@ -583,8 +580,7 @@ readComparison( SGPropertyNode *prop_root,
       SGExpressiond* exp = SGReadDoubleExpression(prop_root, n->getChild(0));
       condition->setPrecisionDExpression(exp);
     } else {
-      throw sg_exception("Unknown condition comparison precision child:" + name,
-                         {}, {}, false);
+      throw sg_exception("Unknown condition comparison precision child:" + name );
     }
   }
   

simgear/props/props.cxx

@@ -19,10 +19,6 @@
 #include <sstream>
 #include <iomanip>
 #include <iterator>
-#include <exception> // can't use sg_exception becuase of PROPS_STANDALONE
-#include <mutex>
-#include <thread>
-
 #include <stdio.h>
 #include <string.h>
 
@@ -52,22 +48,6 @@ using std::stringstream;
 
 using namespace simgear;
 
-
-struct SGPropertyNodeListeners
-{
-  /* Protect _num_iterators and _items. We use a recursive mutex to allow
-  nested access to work as normal. */
-  std::recursive_mutex  _rmutex;
-
-  /* This keeps a count of the current number of nested invocations of
-  forEachListener(). If non-zero, other code higher up the stack is iterating
-  _items[] so for example code must not erase items in the vector. */
-  int _num_iterators = 0;
-
-  std::vector<SGPropertyChangeListener *> _items;
-};
-
-
 ////////////////////////////////////////////////////////////////////////
 // Local classes.
 ////////////////////////////////////////////////////////////////////////
@@ -566,15 +546,23 @@ find_node (SGPropertyNode * current,
   }
 }
 #else
-template <typename Range>
-SGPropertyNode *find_node(SGPropertyNode *current, const Range &path,
-                          bool create, int last_index = -1) {
+template<typename Range>
+SGPropertyNode*
+find_node (SGPropertyNode * current,
+           const Range& path,
+           bool create,
+           int last_index = -1)
+{
   using namespace boost;
-  auto itr = make_split_iterator(path, first_finder("/", is_equal()));
+  typedef split_iterator<typename range_result_iterator<Range>::type>
+    PathSplitIterator;
+
+  PathSplitIterator itr
+    = make_split_iterator(path, first_finder("/", is_equal()));
   if (*path.begin() == '/')
     return find_node_aux(current->getRootNode(), itr, create, last_index);
-  else
-    return find_node_aux(current, itr, create, last_index);
+   else
+     return find_node_aux(current, itr, create, last_index);
 }
 #endif
 
@@ -980,7 +968,7 @@ SGPropertyNode::~SGPropertyNode ()
 
   if (_listeners) {
     vector<SGPropertyChangeListener*>::iterator it;
-    for (it = _listeners->_items.begin(); it != _listeners->_items.end(); ++it)
+    for (it = _listeners->begin(); it != _listeners->end(); ++it)
       (*it)->unregister_property(this);
     delete _listeners;
   }
@@ -2404,22 +2392,8 @@ SGPropertyNode::addChangeListener (SGPropertyChangeListener * listener,
                                    bool initial)
 {
   if (_listeners == 0)
-    _listeners = new SGPropertyNodeListeners;
-
-  std::lock_guard<std::recursive_mutex> lock(_listeners->_rmutex);
-  /* If there's a nullptr entry (a listener that was unregistered), we
-  overwrite it. This ensures that listeners that routinely unregister+register
-  themselves don't make _listeners->_items grow unnecessarily. Otherwise simply
-  append. */
-  auto it = std::find(_listeners->_items.begin(), _listeners->_items.end(),
-        (SGPropertyChangeListener*) nullptr
-        );
-  if (it == _listeners->_items.end()) {
-    _listeners->_items.push_back(listener);
-  }
-  else {
-    *it = listener;
-  }
+    _listeners = new vector<SGPropertyChangeListener*>;
+  _listeners->push_back(listener);
   listener->register_property(this);
   if (initial)
     listener->valueChanged(this);
@@ -2430,35 +2404,15 @@ SGPropertyNode::removeChangeListener (SGPropertyChangeListener * listener)
 {
   if (_listeners == 0)
     return;
-  /* We use a std::unique_lock rather than a std::lock_guard because we may
-  need to unlock early. */
-  std::unique_lock<std::recursive_mutex> lock(_listeners->_rmutex);
   vector<SGPropertyChangeListener*>::iterator it =
-    find(_listeners->_items.begin(), _listeners->_items.end(), listener);
-  if (it != _listeners->_items.end()) {
-    assert(_listeners->_num_iterators >= 0);
-    if (_listeners->_num_iterators) {
-      /* _listeners._items is currently being iterated further up the stack in
-      this thread by one or more nested invocations of forEachListener(), so
-      we must be careful to not break these iterators. So we must not delete
-      _listeners. And we must not erase this entry from the vector because that
-      could cause the next listener to be missed out.
-
-      So we simply set this entry to nullptr (nullptr items are skipped by
-      forEachListener()). When all invocations of forEachListener() have
-      finished iterating and it is safe to modify things again, it will clean
-      up any nullptr entries in _listeners->_items. */
-      *it = nullptr;
-      listener->unregister_property(this);
-    }
-    else {
-      _listeners->_items.erase(it);
-      listener->unregister_property(this);
-      if (_listeners->_items.empty()) {
-        lock.unlock();
-        delete _listeners;
-        _listeners = 0;
-      }
+    find(_listeners->begin(), _listeners->end(), listener);
+  if (it != _listeners->end()) {
+    _listeners->erase(it);
+    listener->unregister_property(this);
+    if (_listeners->empty()) {
+      vector<SGPropertyChangeListener*>* tmp = _listeners;
+      _listeners = 0;
+      delete tmp;
     }
   }
 }
@@ -2507,72 +2461,15 @@ SGPropertyNode::fireChildrenRemovedRecursive()
   }
 }
 
-/* Calls <callback> for each item in _listeners. We are careful to skip nullptr
-entries in _listeners->items[], which can be created if listeners are removed
-while we are iterating. */
-static void forEachListener(
-    SGPropertyNode* node,
-    SGPropertyNodeListeners*& _listeners,
-    std::function<void (SGPropertyChangeListener*)> callback
-    )
-{
-  if (!_listeners) return;
-
-  std::lock_guard<std::recursive_mutex> lock(_listeners->_rmutex);
-  assert(_listeners->_num_iterators >= 0);
-  _listeners->_num_iterators += 1;
-
-  /* We need to use an index here when iterating _listeners->_items, not an
-  iterator. This is because a listener may add new listeners, causing the
-  vector to be reallocated, which would invalidate any iterator. */
-  for (size_t i = 0; i < _listeners->_items.size(); ++i) {
-    auto listener = _listeners->_items[i];
-    if (listener) {
-      try {
-        callback(listener);
-      }
-      catch (std::exception& e) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "Ignoring exception from property callback: " << e.what());
-      }
-    }
-  }
-
-  _listeners->_num_iterators -= 1;
-  assert(_listeners->_num_iterators >= 0);
-
-  if (_listeners->_num_iterators == 0) {
-
-    /* Remove any items that have been set to nullptr. */
-    _listeners->_items.erase(
-        std::remove(_listeners->_items.begin(), _listeners->_items.end(), (SGPropertyChangeListener*) nullptr),
-        _listeners->_items.end()
-        );
-    if (_listeners->_items.empty()) {
-      delete _listeners;
-      _listeners = nullptr;
-    }
-  }
-}
-
-int SGPropertyNode::nListeners() const
-{
-  if (!_listeners) return 0;
-  std::lock_guard<std::recursive_mutex> lock(_listeners->_rmutex);
-  int   n = 0;
-  for (auto listener: _listeners->_items) {
-    if (listener)   n += 1;
-  }
-  return n;
-}
-
 void
 SGPropertyNode::fireValueChanged (SGPropertyNode * node)
 {
-  forEachListener(
-      node,
-      _listeners,
-      [&](SGPropertyChangeListener* listener) { listener->valueChanged(node);}
-      );
+  if (_listeners != 0) {
+    for (unsigned int i = 0; i < _listeners->size(); i++) {
+        if ((*_listeners)[i])
+            (*_listeners)[i]->valueChanged(node);
+    }
+  }
   if (_parent != 0)
     _parent->fireValueChanged(node);
 }
@@ -2581,11 +2478,11 @@ void
 SGPropertyNode::fireChildAdded (SGPropertyNode * parent,
 				SGPropertyNode * child)
 {
-  forEachListener(
-      parent,
-      _listeners,
-      [&](SGPropertyChangeListener* listener) { listener->childAdded(parent, child);}
-      );
+  if (_listeners != 0) {
+    for (unsigned int i = 0; i < _listeners->size(); i++) {
+      (*_listeners)[i]->childAdded(parent, child);
+    }
+  }
   if (_parent != 0)
     _parent->fireChildAdded(parent, child);
 }
@@ -2594,11 +2491,11 @@ void
 SGPropertyNode::fireChildRemoved (SGPropertyNode * parent,
 				  SGPropertyNode * child)
 {
-  forEachListener(
-      parent,
-      _listeners,
-      [&](SGPropertyChangeListener* listener) { listener->childRemoved(parent, child);}
-      );
+  if (_listeners != 0) {
+    for (unsigned int i = 0; i < _listeners->size(); i++) {
+      (*_listeners)[i]->childRemoved(parent, child);
+    }
+  }
   if (_parent != 0)
     _parent->fireChildRemoved(parent, child);
 }

simgear/props/props.hxx

@@ -759,9 +759,6 @@ private:
 };
 
 
-struct SGPropertyNodeListeners;
-
-
 /**
  * A node in a property tree.
  */
@@ -1716,7 +1713,7 @@ public:
   /**
    * Get the number of listeners.
    */
-  int nListeners () const;
+  int nListeners () const { return _listeners ? (int)_listeners->size() : 0; }
 
 
   /**
@@ -1850,7 +1847,7 @@ private:
     char * string_val;
   } _local_val;
 
-  SGPropertyNodeListeners*  _listeners;
+  std::vector<SGPropertyChangeListener *> * _listeners;
 
   // Pass name as a pair of iterators
   template<typename Itr>
@@ -2197,12 +2194,11 @@ public:
         _property->addChangeListener(this,initial);
     }
 
-    SGPropertyChangeCallback(const SGPropertyChangeCallback<T>& other)
-        : SGPropertyChangeListener(other),
-        _obj(other._obj), _callback(other._callback), _property(other._property)
-    {
-        _property->addChangeListener(this,false);
-    }
+	SGPropertyChangeCallback(const SGPropertyChangeCallback<T>& other) :
+		_obj(other._obj), _callback(other._callback), _property(other._property)
+	{
+		 _property->addChangeListener(this,false);
+	}
 
     virtual ~SGPropertyChangeCallback()
     {

simgear/props/props_io.cxx

@@ -161,7 +161,7 @@ setFlag( int& mode,
     string message = "Unrecognized flag value '";
     message += flag;
     message += '\'';
-    throw sg_io_exception(message, location, SG_ORIGIN, false);
+    throw sg_io_exception(message, location, SG_ORIGIN);
   }
 }
 
@@ -176,7 +176,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
       string message = "Root element name is ";
       message += name;
       message += "; expected PropertyList";
-      throw sg_io_exception(message, location, SG_ORIGIN, false);
+      throw sg_io_exception(message, location, SG_ORIGIN);
     }
 
     // Check for an include.
@@ -188,7 +188,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
           {
               string message ="Cannot open file ";
               message += attval;
-              throw sg_io_exception(message, location, SG_ORIGIN, false);
+              throw sg_io_exception(message, location, SG_ORIGIN);
           }
           readProperties(path, _root, 0, _extended);
       } catch (sg_io_exception &e) {
@@ -278,7 +278,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
           {
             string message ="Cannot open file ";
             message += val;
-            throw sg_io_exception(message, location, SG_ORIGIN, false);
+            throw sg_io_exception(message, location, SG_ORIGIN);
           }
           readProperties(path, node, 0, _extended);
         }
@@ -353,7 +353,7 @@ PropsVisitor::endElement (const char * name)
       string message = "Unrecognized data type '";
       message += st.type;
       message += '\'';
-      throw sg_io_exception(message, location, SG_ORIGIN, false);
+      throw sg_io_exception(message, location, SG_ORIGIN);
     }
     if( !ret )
       SG_LOG
@@ -701,7 +701,7 @@ writeProperties (const SGPath &path, const SGPropertyNode * start_node,
   if (output.good()) {
     writeProperties(output, start_node, write_all, archive_flag);
   } else {
-    throw sg_io_exception("Cannot open file", sg_location(path.utf8Str()), "", false);
+    throw sg_io_exception("Cannot open file", sg_location(path.utf8Str()));
   }
 }
 
@@ -770,7 +770,7 @@ copyPropertyValue(const SGPropertyNode *in, SGPropertyNode *out)
                 break;
             string message = "Unknown internal SGPropertyNode type";
             message += in->getType();
-            throw sg_error(message, SG_ORIGIN, false);
+            throw sg_error(message, SG_ORIGIN);
     }
     
     return retval;
@@ -854,48 +854,4 @@ copyPropertiesWithAttribute(const SGPropertyNode *in, SGPropertyNode *out,
     return true;
 }
 
-namespace {
-
-// for normal recursion we want to call the predicate *before* creating children
-bool _inner_copyPropertiesIf(const SGPropertyNode *in, SGPropertyNode *out,
-                        PropertyPredicate predicate)
-{
-    bool retval = copyPropertyValue(in, out);
-    if (!retval) {
-        return false;
-    }
-    out->setAttributes( in->getAttributes() );
-    
-    int nChildren = in->nChildren();
-    for (int i = 0; i < nChildren; i++) {
-        const SGPropertyNode* in_child = in->getChild(i);
-        // skip this child
-        if (!predicate(in_child)) {
-          continue;
-        }
-
-        SGPropertyNode* out_child = out->getChild(in_child->getNameString(),
-                                      in_child->getIndex(),
-                                      true);
-        
-        bool ok = copyPropertiesIf(in_child, out_child, predicate);
-        if (!ok) {
-            return false;
-        }
-    } // of children iteration
-    return true;
-}
-
-} // of anonymous namespace
-
-bool copyPropertiesIf(const SGPropertyNode *in, SGPropertyNode *out,
-                        PropertyPredicate predicate)
-{
-  // allow the *entire* copy to be a no-op
-    bool doCopy = predicate(in);
-    if (!doCopy)
-      return true; // doesn't count as failure
-
-   return _inner_copyPropertiesIf(in, out, predicate);
-}
 // end of props_io.cxx

simgear/props/props_io.hxx

@@ -17,7 +17,6 @@
 
 #include <string>
 #include <iosfwd>
-#include <functional>
 
 /**
  * Read properties from an XML input stream.
@@ -68,16 +67,6 @@ bool copyProperties (const SGPropertyNode *in, SGPropertyNode *out);
 bool copyPropertiesWithAttribute(const SGPropertyNode *in, SGPropertyNode *out,
                                  SGPropertyNode::Attribute attr);
 
-using PropertyPredicate = std::function<bool (const SGPropertyNode* in)>;
-
-/**
- * Copy properties, if the predicate returns true for the in node.
- * If a parent node returns false, descendats will <em>not</em> be
- * checked
- */
-bool copyPropertiesIf(const SGPropertyNode *in, SGPropertyNode *out,
-                        PropertyPredicate predicate);
-
 #endif // __PROPS_IO_HXX
 
 // end of props_io.hxx

simgear/props/props_test.cxx

@@ -451,17 +451,13 @@ void defineSamplePropertyTree(SGPropertyNode_ptr root)
 class TestListener : public SGPropertyChangeListener
 {
 public:
-    TestListener(SGPropertyNode* root, bool recursive = false, bool self_unregister = false) :
-        _root(root), _self_unregister(self_unregister) {}
+    TestListener(SGPropertyNode* root, bool recursive = false) :
+        _root(root) {}
 
     virtual void valueChanged(SGPropertyNode* node) override
     {
         std::cout << "saw value changed for:" << node->getPath() << std::endl;
         valueChangeCount[node]++;
-        if (_self_unregister) {
-            std::cout << "valueChanged(): calling removeChangeListener() to self-remove\n";
-            node->removeChangeListener(this);
-        }
     }
 
     int checkValueChangeCount(const std::string& path) const
@@ -537,7 +533,6 @@ public:
         }
 private:
     SGPropertyNode* _root;
-    bool            _self_unregister;
     std::map<SGPropertyNode*, unsigned int> valueChangeCount;
 
     std::vector<ParentChange> adds;
@@ -947,13 +942,6 @@ void testDeleterListener()
         SG_VERIFY(ensureNListeners(tree, 0));
     }
 
-    // Self-unregister. prior to 2019-07-08 this would segv.
-    {
-        std::shared_ptr<TestListener>   l1( new TestListener(tree.get(), true /* recursive */, true /*self_unregister*/));
-        tree->setFloatValue("position/body/sub/self-unregister", 0.1);
-        tree->getNode("position/body/sub/self-unregister")->addChangeListener(l1.get());
-        tree->setFloatValue("position/body/sub/self-unregister", 0.2);
-    }
 }
 
 int main (int ac, char ** av)

simgear/scene/material/Effect.cxx

@@ -67,21 +67,16 @@
 #include <osgDB/ReadFile>
 #include <osgDB/Registry>
 
-#include <simgear/debug/ErrorReportingCallback.hxx>
-#include <simgear/io/iostreams/sgstream.hxx>
-#include <simgear/props/props_io.hxx>
-#include <simgear/props/vectorPropTemplates.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
 #include <simgear/scene/tgdb/userdata.hxx>
 #include <simgear/scene/util/OsgMath.hxx>
-#include <simgear/scene/util/SGProgram.hxx>
-#include <simgear/scene/util/SGReaderWriterOptions.hxx>
 #include <simgear/scene/util/SGSceneFeatures.hxx>
 #include <simgear/scene/util/StateAttributeFactory.hxx>
 #include <simgear/structure/OSGUtils.hxx>
 #include <simgear/structure/SGExpression.hxx>
 #include <simgear/props/props_io.hxx>
 #include <simgear/props/vectorPropTemplates.hxx>
-#include <simgear/debug/ErrorReportingCallback.hxx>
+
 #include <simgear/io/iostreams/sgstream.hxx>
 
 namespace simgear
@@ -108,7 +103,6 @@ bool loadShaderFromUTF8File(osg::Shader* shader, const std::string& fileName)
     if (!inStream.is_open())
         return false;
 
-    shader->setFileName(fileName);
     shader->setShaderSource(inStream.read_all());
     return true;
 }
@@ -227,9 +221,8 @@ Effect::Effect()
 }
 
 Effect::Effect(const Effect& rhs, const CopyOp& copyop)
-    : osg::Object(rhs, copyop), root(rhs.root), parametersProp(rhs.parametersProp), _cache(0),
-      _isRealized(rhs._isRealized),
-      _effectFilePath(rhs._effectFilePath)
+    : osg::Object(rhs,copyop), root(rhs.root), parametersProp(rhs.parametersProp), _cache(0),
+      _isRealized(rhs._isRealized)
 {
     typedef vector<ref_ptr<Technique> > TechniqueList;
     for (TechniqueList::const_iterator itr = rhs.techniques.begin(),
@@ -294,8 +287,6 @@ Effect::~Effect()
 void buildPass(Effect* effect, Technique* tniq, const SGPropertyNode* prop,
                const SGReaderWriterOptions* options)
 {
-    simgear::ErrorReportContext ec("effect-pass", prop->getPath());
-
     Pass* pass = new Pass;
     tniq->passes.push_back(pass);
     for (int i = 0; i < prop->nChildren(); ++i) {
@@ -846,12 +837,10 @@ void reload_shaders()
         string fileName = SGModelLib::findDataFile(sitr->first.first);
         if (!fileName.empty()) {
             loadShaderFromUTF8File(shader, fileName);
-        } else {
-            SG_LOG(SG_INPUT, SG_ALERT, "Could not locate shader: " << fileName);
-            simgear::reportFailure(simgear::LoadFailure::NotFound,
-                                   simgear::ErrorCode::LoadEffectsShaders,
-                                   "Reload: couldn't find shader:" + sitr->first.first);
         }
+        else
+            SG_LOG(SG_INPUT, SG_ALERT, "Could not locate shader: " << fileName);
+
     }
 }
 
@@ -939,16 +928,15 @@ void ShaderProgramBuilder::buildAttribute(Effect* effect, Pass* pass,
         // FIXME orig: const string& shaderName = shaderKey.first;
         string shaderName = shaderKey.first;
         Shader::Type stype = (Shader::Type)shaderKey.second;
-        const bool compositorEnabled = getPropertyRoot()->getBoolValue("/sim/version/compositor-support", false);
-        if (compositorEnabled &&
+        if (getPropertyRoot()->getBoolValue("/sim/version/compositor-support", false) &&
             shaderName.substr(0, shaderName.find("/")) == "Shaders") {
             shaderName = "Compositor/" + shaderName;
         }
         string fileName = SGModelLib::findDataFile(shaderName, options);
         if (fileName.empty())
         {
-            simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::LoadEffectsShaders,
-                                   "Couldn't locate shader:" + shaderName, sg_location{shaderName});
+            SG_LOG(SG_INPUT, SG_ALERT, "Could not locate shader" << shaderName);
+
 
             throw BuilderException(string("couldn't find shader ") +
                 shaderName);
@@ -962,11 +950,7 @@ void ShaderProgramBuilder::buildAttribute(Effect* effect, Pass* pass,
         pass->setAttributeAndModes(program);
         return;
     }
-
-    auto sgprogram = new SGProgram;
-    program = sgprogram;
-    sgprogram->setEffectFilePath(effect->filePath());
-
+    program = new Program;
     for (const auto& skey : resolvedKey.shaders) {
         const string& fileName = skey.first;
         Shader::Type stype = (Shader::Type)skey.second;
@@ -977,30 +961,11 @@ void ShaderProgramBuilder::buildAttribute(Effect* effect, Pass* pass,
             ref_ptr<Shader> shader = new Shader(stype);
 			shader->setName(fileName);
             if (loadShaderFromUTF8File(shader, fileName)) {
-                if (!program->addShader(shader.get())) {
-                    simgear::reportFailure(simgear::LoadFailure::BadData,
-                                           simgear::ErrorCode::LoadEffectsShaders,
-                                           "Program::addShader failed",
-                                           SGPath::fromUtf8(fileName));
-                }
-
+                program->addShader(shader.get());
                 shaderMap.insert(ShaderMap::value_type(skey, shader));
-            } else {
-                simgear::reportFailure(simgear::LoadFailure::BadData,
-                                       simgear::ErrorCode::LoadEffectsShaders,
-                                       "Failed to read shader source code",
-                                       SGPath::fromUtf8(fileName));
             }
         }
     }
-
-    if (sgprogram->getNumShaders() == 0) {
-        simgear::reportFailure(simgear::LoadFailure::BadData,
-                               simgear::ErrorCode::LoadEffectsShaders,
-                               "No shader source code defined for effect",
-                               effect->filePath());
-    }
-
     for (const auto& key : prgKey.attributes) {
         program->addBindAttribLocation(key.first, key.second);
     }
@@ -1361,8 +1326,6 @@ InstallAttributeBuilder<DepthBuilder> installDepth("depth");
 void buildTechnique(Effect* effect, const SGPropertyNode* prop,
                     const SGReaderWriterOptions* options)
 {
-    simgear::ErrorReportContext ec("effect-technique", prop->getPath());
-
     Technique* tniq = new Technique;
     effect->techniques.push_back(tniq);
     tniq->setScheme(prop->getStringValue("scheme"));
@@ -1518,21 +1481,20 @@ void mergeSchemesFallbacks(Effect *effect, const SGReaderWriterOptions *options)
 
 // Walk the techniques property tree, building techniques and
 // passes.
+static std::mutex  realizeTechniques_lock;
 bool Effect::realizeTechniques(const SGReaderWriterOptions* options)
 {
-    simgear::ErrorReportContext ec{"effect", getName()};
-
+    std::lock_guard<std::mutex> g(realizeTechniques_lock);
     if (getPropertyRoot()->getBoolValue("/sim/version/compositor-support", false))
         mergeSchemesFallbacks(this, options);
 
     if (_isRealized)
         return true;
-
     PropertyList tniqList = root->getChildren("technique");
-    for (const auto& tniq : tniqList) {
-        buildTechnique(this, tniq, options);
-    }
-
+    for (PropertyList::iterator itr = tniqList.begin(), e = tniqList.end();
+         itr != e;
+         ++itr)
+        buildTechnique(this, *itr, options);
     _isRealized = true;
     return true;
 }
@@ -1668,15 +1630,3 @@ expression::ExpParserRegistrar propvalueRegistrar("float-property",
                                                  propertyExpressionParser<float>);
 
 }
-
-using namespace simgear;
-
-void Effect::setFilePath(const SGPath& path)
-{
-    _effectFilePath = path;
-}
-
-SGPath Effect::filePath() const
-{
-    return _effectFilePath;
-}

simgear/scene/material/Effect.hxx

@@ -29,11 +29,10 @@
 #include <osg/observer_ptr>
 #include <osgDB/ReaderWriter>
 
-#include <simgear/misc/sg_path.hxx>
 #include <simgear/props/props.hxx>
 #include <simgear/scene/util/UpdateOnceCallback.hxx>
-#include <simgear/structure/Singleton.hxx>
 #include <simgear/threads/SGThread.hxx>
+#include <simgear/structure/Singleton.hxx>
 
 namespace osg
 {
@@ -107,10 +106,6 @@ public:
 
     std::string getName(){return _name;}
     void setName(std::string name){_name = name;}
-
-    void setFilePath(const SGPath& path);
-    SGPath filePath() const;
-
 protected:
     ~Effect();
     // Support for a cache of effects that inherit from this one, so
@@ -147,26 +142,21 @@ protected:
     Cache* _cache;
     friend size_t hash_value(const Key& key);
     friend Effect* makeEffect(SGPropertyNode* prop, bool realizeTechniques,
-                              const SGReaderWriterOptions* options,
-                              const SGPath& path);
+                              const SGReaderWriterOptions* options);
     bool _isRealized;
     std::string _name;
-    SGPath _effectFilePath;
 };
-
 // Automatic support for boost hash function
 size_t hash_value(const Effect::Key&);
 
 
 Effect* makeEffect(const std::string& name,
                    bool realizeTechniques,
-                   const SGReaderWriterOptions* options,
-                   const SGPath& modelPath = SGPath{});
+                   const SGReaderWriterOptions* options);
 
 Effect* makeEffect(SGPropertyNode* prop,
                    bool realizeTechniques,
-                   const SGReaderWriterOptions* options,
-                   const SGPath& path = SGPath{});
+                   const SGReaderWriterOptions* options);
 
 bool makeParametersFromStateSet(SGPropertyNode* paramRoot,
                                 const osg::StateSet* ss);

simgear/scene/material/EffectBuilder.cxx

@@ -75,13 +75,13 @@ BuilderException::BuilderException()
 }
 
 BuilderException::BuilderException(const char* message, const char* origin)
-    : sg_exception(message, origin, {}, false)
+  : sg_exception(message, origin)
 {
 }
 
 BuilderException::BuilderException(const std::string& message,
                                    const std::string& origin)
-    : sg_exception(message, origin, {}, false)
+  : sg_exception(message, origin)
 {
 }
 

simgear/scene/material/TextureBuilder.cxx

@@ -39,13 +39,12 @@
 #include <OpenThreads/Mutex>
 #include <OpenThreads/ScopedLock>
 
-#include <simgear/debug/ErrorReportingCallback.hxx>
-#include <simgear/props/vectorPropTemplates.hxx>
 #include <simgear/scene/util/OsgMath.hxx>
 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
 #include <simgear/scene/util/SGSceneFeatures.hxx>
 #include <simgear/scene/util/StateAttributeFactory.hxx>
 #include <simgear/structure/OSGUtils.hxx>
+#include <simgear/props/vectorPropTemplates.hxx>
 
 namespace simgear
 {
@@ -274,20 +273,11 @@ bool setAttrs(const TexTuple& attrs, Texture* tex,
         options->setLoadOriginHint(SGReaderWriterOptions::LoadOriginHint::ORIGIN_EFFECTS_NORMALIZED);
     else
         options->setLoadOriginHint(SGReaderWriterOptions::LoadOriginHint::ORIGIN_EFFECTS);
-
-    try {
-    #if OSG_VERSION_LESS_THAN(3,4,2)
-        result = osgDB::readImageFile(imageName, options);
-    #else
-        result = osgDB::readRefImageFile(imageName, options);
-    #endif
-    } catch (std::exception& e) {
-        simgear::reportFailure(simgear::LoadFailure::OutOfMemory, simgear::ErrorCode::LoadingTexture,
-                               string{"osgDB::readRefImageFile failed:"} + e.what(),
-                               SGPath::fromUtf8(imageName));
-        return false;
-    }
-
+#if OSG_VERSION_LESS_THAN(3,4,2)
+    result = osgDB::readImageFile(imageName, options);
+#else
+    result = osgDB::readRefImageFile(imageName, options);
+#endif
     options->setLoadOriginHint(origLOH);
     osg::ref_ptr<osg::Image> image;
     if (result.success())
@@ -306,9 +296,6 @@ bool setAttrs(const TexTuple& attrs, Texture* tex,
         tex->setMaxAnisotropy(SGSceneFeatures::instance()->getTextureFilter());
     } else {
         SG_LOG(SG_INPUT, SG_ALERT, "failed to load effect texture file " << imageName);
-        simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::LoadingTexture,
-                               "osgDB::readRefImageFile failed:" + result.message(),
-                               SGPath::fromUtf8(imageName));
         return false;
     }
 
@@ -593,8 +580,8 @@ Texture* CubeMapBuilder::build(Effect* effect, Pass* pass, const SGPropertyNode*
     const SGPropertyNode* texturesProp = getEffectPropertyChild(effect, props, "images");
     const SGPropertyNode* crossProp = getEffectPropertyChild(effect, props, "image");
     if (!texturesProp && !crossProp) {
-        simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::LoadingTexture, "No images defined for cube map");
         throw BuilderException("no images defined for cube map");
+        return NULL; // This is redundant
     }
 
     // Using 6 separate images
@@ -775,9 +762,6 @@ Texture* CubeMapBuilder::build(Effect* effect, Pass* pass, const SGPropertyNode*
             return cubeTexture.release();
 
         } else {
-            simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::LoadingTexture,
-                                   "Could not load cube-map image:" + result.message(),
-                                   sg_location{texname});
             throw BuilderException("Could not load cube cross");
         }
     }
@@ -858,9 +842,6 @@ Texture* Texture3DBuilder::build(Effect* effect, Pass* pass,
         tex->setImage(image3d.get());
     } else {
         SG_LOG(SG_INPUT, SG_ALERT, "failed to load effect texture file " << imageName);
-        simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::LoadingTexture,
-                               "osgDB::readRefImageFile failed:" + result.message(),
-                               SGPath::fromUtf8(imageName));
         return NULL;
     }
 

simgear/scene/material/makeEffect.cxx

@@ -25,11 +25,9 @@
 #include <osgDB/ReadFile>
 #include <osgDB/Registry>
 
-#include <simgear/debug/ErrorReportingCallback.hxx>
 #include <simgear/debug/logstream.hxx>
-#include <simgear/misc/sg_path.hxx>
-#include <simgear/props/props_io.hxx>
 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
+#include <simgear/props/props_io.hxx>
 #include <simgear/scene/util/SGSceneFeatures.hxx>
 #include <simgear/scene/util/SplicingVisitor.hxx>
 #include <simgear/structure/SGExpression.hxx>
@@ -114,8 +112,7 @@ void mergePropertyTrees(SGPropertyNode* resultNode,
 
 Effect* makeEffect(const string& name,
                    bool realizeTechniques,
-                   const SGReaderWriterOptions* options,
-                   const SGPath& modelPath)
+                   const SGReaderWriterOptions* options)
 {
     {
         OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(effectMutex);
@@ -126,22 +123,23 @@ Effect* makeEffect(const string& name,
     }
     string effectFileName(name);
     effectFileName += ".eff";
-    string absFileName = SGModelLib::findDataFile(effectFileName, options, modelPath);
+    string absFileName
+        = SGModelLib::findDataFile(effectFileName, options);
     if (absFileName.empty()) {
-        simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::LoadEffectsShaders, "Couldn't find Effect:" + effectFileName);
-        return nullptr;
+        SG_LOG(SG_INPUT, SG_ALERT, "can't find \"" << effectFileName << "\"");
+        return 0;
     }
     SGPropertyNode_ptr effectProps = new SGPropertyNode();
     try {
         readProperties(absFileName, effectProps.ptr(), 0, true);
     }
     catch (sg_io_exception& e) {
-        simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::LoadEffectsShaders, e.getFormattedMessage(),
-                               e.getLocation());
-        return nullptr;
+        SG_LOG(SG_INPUT, SG_ALERT, "error reading \"" << absFileName << "\": "
+               << e.getFormattedMessage());
+        return 0;
     }
     ref_ptr<Effect> result = makeEffect(effectProps.ptr(), realizeTechniques,
-                                        options, SGPath::fromUtf8(absFileName));
+                                        options);
     if (result.valid()) {
         OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(effectMutex);
         pair<EffectMap::iterator, bool> irslt
@@ -158,8 +156,7 @@ Effect* makeEffect(const string& name,
 
 Effect* makeEffect(SGPropertyNode* prop,
                    bool realizeTechniques,
-                   const SGReaderWriterOptions* options,
-                   const SGPath& filePath)
+                   const SGReaderWriterOptions* options)
 {
     // Give default names to techniques and passes
     vector<SGPropertyNode_ptr> techniques = prop->getChildren("technique");
@@ -197,7 +194,7 @@ Effect* makeEffect(SGPropertyNode* prop,
     Effect* parent = 0;
     if (inheritProp) {
         //prop->removeChild("inherits-from");
-        parent = makeEffect(inheritProp->getStringValue(), false, options, filePath);
+        parent = makeEffect(inheritProp->getStringValue(), false, options);
         if (parent) {
             Effect::Key key;
             key.unmerged = prop;
@@ -220,7 +217,6 @@ Effect* makeEffect(SGPropertyNode* prop,
             if (!effect.valid()) {
                 effect = new Effect;
                 effect->setName(nameProp->getStringValue());
-                effect->setFilePath(filePath.isNull() ? parent->filePath() : filePath);
                 effect->root = new SGPropertyNode;
                 mergePropertyTrees(effect->root, prop, parent->root);
                 effect->parametersProp = effect->root->getChild("parameters");
@@ -238,13 +234,12 @@ Effect* makeEffect(SGPropertyNode* prop,
                 effect->generator = parent->generator;  // Copy the generators
             }
         } else {
-            simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::LoadEffectsShaders,
-                                   string{"couldn't find base effect to inherit from:"} + inheritProp->getStringValue(), filePath);
-            return nullptr;
+            SG_LOG(SG_INPUT, SG_ALERT, "can't find base effect " <<
+                   inheritProp->getStringValue());
+            return 0;
         }
     } else {
         effect = new Effect;
-        effect->setFilePath(filePath);
         effect->setName(nameProp->getStringValue());
         effect->root = prop;
         effect->parametersProp = effect->root->getChild("parameters");
@@ -271,9 +266,9 @@ Effect* makeEffect(SGPropertyNode* prop,
             effect->realizeTechniques(options);
         }
         catch (BuilderException& e) {
-            simgear::reportFailure(simgear::LoadFailure::Misconfigured, simgear::ErrorCode::LoadEffectsShaders,
-                                   "Failed to build technique:" + e.getFormattedMessage(), filePath);
-            return nullptr;
+            SG_LOG(SG_INPUT, SG_ALERT, "Error building technique: "
+                   << e.getFormattedMessage());
+            return 0;
         }
     }
     return effect.release();

simgear/scene/material/mat.cxx

@@ -97,13 +97,11 @@ SGMaterial::SGMaterial( const SGReaderWriterOptions* options,
                         const SGPropertyNode *props,
                         SGPropertyNode *prop_root,
                         AreaList *a,
-                        SGSharedPtr<const SGCondition> c,
-                        const std::string& n)
+						SGSharedPtr<const SGCondition> c)
 {
     init();
     areas = a;
     condition = c;
-    region = n;
     read_properties( options, props, prop_root );
     buildEffectProperties(options);
 }
@@ -112,14 +110,12 @@ SGMaterial::SGMaterial( const osgDB::Options* options,
                         const SGPropertyNode *props,
                         SGPropertyNode *prop_root,
                         AreaList *a,
-                        SGSharedPtr<const SGCondition> c,
-                        const std::string& n)
+                        SGSharedPtr<const SGCondition> c)
 {
     osg::ref_ptr<SGReaderWriterOptions> opt;
     opt = SGReaderWriterOptions::copyOrCreate(options);
     areas = a;
     condition = c;
-    region = n;
     init();
     read_properties(opt.get(), props, prop_root);
     buildEffectProperties(opt.get());

simgear/scene/material/mat.hxx

@@ -97,16 +97,14 @@ public:
              const SGPropertyNode *props,
              SGPropertyNode *prop_root,
              AreaList *a,
-             SGSharedPtr<const SGCondition> c,
-             const std::string& n);
+			 SGSharedPtr<const SGCondition> c);
 
 
   SGMaterial(const simgear::SGReaderWriterOptions*,
              const SGPropertyNode *props,
              SGPropertyNode *prop_root,
              AreaList *a,
-             SGSharedPtr<const SGCondition> c,
-             const std::string& n);
+			 SGSharedPtr<const SGCondition> c);
 
   /**
    * Destructor.
@@ -125,11 +123,6 @@ public:
   simgear::Effect* get_one_effect(int texIndex);
   simgear::Effect* get_effect();
 
-  /**
-   * Get the region Name.
-   */
-  const std::string get_region_name() const { return region; }
-
   /**
    * Get the Effect Name.
    */
@@ -494,9 +487,6 @@ private:
   SGVec4f ambient, diffuse, specular, emission;
   double shininess;
 
-  // region of this material
-  std::string region;
-
   // effect for this material
   std::string effect;
 

simgear/scene/material/matlib.cxx

@@ -83,8 +83,6 @@ bool SGMaterialLib::load( const SGPath &fg_root, const SGPath& mpath,
     options->setObjectCacheHint(osgDB::Options::CACHE_ALL);
     options->setDatabasePath(fg_root.utf8Str());
 
-    std::lock_guard<std::mutex> g(d->mutex);
-
     simgear::PropertyList blocks = materialblocks.getChildren("region");
     simgear::PropertyList::const_iterator block_iter = blocks.begin();
 
@@ -130,13 +128,12 @@ bool SGMaterialLib::load( const SGPath &fg_root, const SGPath& mpath,
 
 		// Now build all the materials for this set of areas and conditions
 
-		const std::string region = node->getStringValue("name");
 		const simgear::PropertyList materials = node->getChildren("material");
 		simgear::PropertyList::const_iterator materials_iter = materials.begin();
 		for (; materials_iter != materials.end(); materials_iter++) {
 			const SGPropertyNode *node = materials_iter->get();
 			SGSharedPtr<SGMaterial> m =
-					new SGMaterial(options.get(), node, prop_root, arealist, condition, region);
+					new SGMaterial(options.get(), node, prop_root, arealist, condition);
 
 			std::vector<SGPropertyNode_ptr>names = node->getChildren("name");
 			for ( unsigned int j = 0; j < names.size(); j++ ) {
@@ -155,20 +152,14 @@ bool SGMaterialLib::load( const SGPath &fg_root, const SGPath& mpath,
 
 // find a material record by material name and tile center
 SGMaterial *SGMaterialLib::find( const string& material, const SGVec2f center ) const
-{
-    std::lock_guard<std::mutex> g(d->mutex);
-    return internalFind(material, center);
-}
-
-SGMaterial* SGMaterialLib::internalFind(const string& material, const SGVec2f center) const
 {
     SGMaterial *result = NULL;
     const_material_map_iterator it = matlib.find( material );
-    if (it != end()) {
+    if ( it != end() ) {            
         // We now have a list of materials that match this
         // name. Find the first one that matches.
-        // We start at the end of the list, as the materials
-        // list is ordered with the smallest regions at the end.
+    	// We start at the end of the list, as the materials
+    	// list is ordered with the smallest regions at the end.
         material_list::const_reverse_iterator iter = it->second.rbegin();
         while (iter != it->second.rend()) {
             result = *iter;
@@ -192,12 +183,11 @@ SGMaterial *SGMaterialLib::find( const string& material, const SGGeod& center )
 SGMaterialCache *SGMaterialLib::generateMatCache(SGVec2f center)
 {
 	SGMaterialCache* newCache = new SGMaterialCache();
-    std::lock_guard<std::mutex> g(d->mutex);
-
     material_map::const_reverse_iterator it = matlib.rbegin();
     for (; it != matlib.rend(); ++it) {
-        newCache->insert(it->first, internalFind(it->first, center));
+        newCache->insert(it->first, find(it->first, center));
     }
+    
     return newCache;
 }
 

simgear/scene/material/matlib.hxx

@@ -81,10 +81,7 @@ private:
     typedef material_map::const_iterator const_material_map_iterator;
 
     material_map matlib;
-
-
-    SGMaterial* internalFind(const std::string& material, const SGVec2f center) const;
-
+    
 public:
 
     // Constructor

simgear/scene/material/matmodel.cxx

@@ -28,7 +28,7 @@
 #include <simgear/compiler.h>
 
 #include <map>
-#include <mutex>
+
 
 #include <osg/AlphaFunc>
 #include <osg/Group>
@@ -103,39 +103,37 @@ SGMatModel::get_model_count( SGPropertyNode *prop_root )
 inline void
 SGMatModel::load_models( SGPropertyNode *prop_root )
 {
-    std::lock_guard<std::mutex> g(_loadMutex);
-
-    // Load model only on demand
-    if (!_models_loaded) {
-        for (unsigned int i = 0; i < _paths.size(); i++) {
-            osg::Node* entity = SGModelLib::loadModel(_paths[i], prop_root);
-            if (entity != 0) {
-                // FIXME: this stuff can be handled
-                // in the XML wrapper as well (at least,
-                // the billboarding should be handled
-                // there).
-
-                if (_heading_type == HEADING_BILLBOARD) {
-                    // if the model is a billboard, it is likely :
-                    // 1. a branch with only leaves,
-                    // 2. a tree or a non rectangular shape faked by transparency
-                    // We add alpha clamp then
-                    osg::StateSet* stateSet = entity->getOrCreateStateSet();
-                    osg::AlphaFunc* alphaFunc =
-                        new osg::AlphaFunc(osg::AlphaFunc::GREATER, 0.01f);
-                    stateSet->setAttributeAndModes(alphaFunc,
-                                                   osg::StateAttribute::OVERRIDE);
-                    stateSet->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
-                }
-
-                _models.push_back(entity);
-
-            } else {
-                SG_LOG(SG_INPUT, SG_ALERT, "Failed to load object " << _paths[i]);
-                // Ensure the vector contains something, otherwise get_random_model below fails
-                _models.push_back(new osg::Node());
-            }
-        }
+				// Load model only on demand
+  if (!_models_loaded) {
+    for (unsigned int i = 0; i < _paths.size(); i++) {
+      osg::Node *entity = SGModelLib::loadModel(_paths[i], prop_root);
+      if (entity != 0) {
+        // FIXME: this stuff can be handled
+        // in the XML wrapper as well (at least,
+        // the billboarding should be handled
+        // there).
+        
+        if (_heading_type == HEADING_BILLBOARD) {
+          // if the model is a billboard, it is likely :
+          // 1. a branch with only leaves,
+          // 2. a tree or a non rectangular shape faked by transparency
+          // We add alpha clamp then
+          osg::StateSet* stateSet = entity->getOrCreateStateSet();
+          osg::AlphaFunc* alphaFunc =
+            new osg::AlphaFunc(osg::AlphaFunc::GREATER, 0.01f);
+          stateSet->setAttributeAndModes(alphaFunc,
+                                         osg::StateAttribute::OVERRIDE);
+          stateSet->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
+        } 
+        
+        _models.push_back(entity);
+        
+      } else {
+        SG_LOG(SG_INPUT, SG_ALERT, "Failed to load object " << _paths[i]);
+        // Ensure the vector contains something, otherwise get_random_model below fails
+        _models.push_back(new osg::Node());
+      }
+    }
   }
   _models_loaded = true;
 }

simgear/scene/material/matmodel.hxx

@@ -149,8 +149,6 @@ private:
     double _spacing_m;
     double _range_m;
     HeadingType _heading_type;
-
-    std::mutex _loadMutex;
 };
 
 

simgear/scene/material/mipmap.cxx

@@ -82,13 +82,13 @@ void _writeColor(GLenum pixelFormat, T* data, float scale, osg::Vec4 value)
     switch(pixelFormat)
     {
         case(GL_DEPTH_COMPONENT):   //intentionally fall through and execute the code for GL_LUMINANCE
-        case(GL_LUMINANCE):         { *data = value.r()*scale; break; }
-        case(GL_ALPHA):             { *data = value.a()*scale; break; }
-        case(GL_LUMINANCE_ALPHA):   { *data++ = value.r()*scale; *data = value.a()*scale; break; }
-        case(GL_RGB):               { *data++ = value.r()*scale; *data++ = value.g()*scale; *data = value.b()*scale; break; }
-        case(GL_RGBA):              { *data++ = value.r()*scale; *data++ = value.g()*scale; *data++ = value.b()*scale; *data = value.a()*scale; break; }
-        case(GL_BGR):               { *data++ = value.b()*scale; *data++ = value.g()*scale; *data = value.r()*scale; break; }
-        case(GL_BGRA):              { *data++ = value.b()*scale; *data++ = value.g()*scale; *data++ = value.r()*scale; *data = value.a()*scale; break; }
+        case(GL_LUMINANCE):         { *data++ = value.r()*scale; break; }
+        case(GL_ALPHA):             { *data++ = value.a()*scale; break; }
+        case(GL_LUMINANCE_ALPHA):   { *data++ = value.r()*scale; *data++ = value.a()*scale; break; }
+        case(GL_RGB):               { *data++ = value.r()*scale; *data++ = value.g()*scale; *data++ = value.b()*scale; break; }
+        case(GL_RGBA):              { *data++ = value.r()*scale; *data++ = value.g()*scale; *data++ = value.b()*scale; *data++ = value.a()*scale; break; }
+        case(GL_BGR):               { *data++ = value.b()*scale; *data++ = value.g()*scale; *data++ = value.r()*scale; break; }
+        case(GL_BGRA):              { *data++ = value.b()*scale; *data++ = value.g()*scale; *data++ = value.r()*scale; *data++ = value.a()*scale; break; }
     }
 }
 
@@ -265,13 +265,7 @@ osg::Image* computeMipmap( osg::Image* image, MipMapTuple attrs )
 {
     bool computeMipmap = false;
     unsigned int nbComponents = osg::Image::computeNumComponents( image->getPixelFormat() );
-    int s = image->s();
-    int t = image->t();
-    if ( (s & (s - 1)) || (t & (t - 1)) ) // power of two test
-    {
-        SG_LOG(SG_IO, SG_DEV_ALERT, "mipmapping: texture size not a power-of-two: " + image->getFileName());
-    }
-    else if ( std::get<0>(attrs) != AUTOMATIC &&
+    if ( std::get<0>(attrs) != AUTOMATIC &&
         ( std::get<1>(attrs) != AUTOMATIC || nbComponents < 2 ) &&
         ( std::get<2>(attrs) != AUTOMATIC || nbComponents < 3 ) &&
         ( std::get<3>(attrs) != AUTOMATIC || nbComponents < 4 ) )
@@ -289,7 +283,9 @@ osg::Image* computeMipmap( osg::Image* image, MipMapTuple attrs )
     if ( computeMipmap )
     {
         osg::ref_ptr<osg::Image> mipmaps = new osg::Image();
-        int r = image->r();
+        int s = image->s(),
+            t = image->t(),
+            r = image->r();
         int nb = osg::Image::computeNumberOfMipmapLevels(s, t, r);
         osg::Image::MipmapDataType mipmapOffsets;
         unsigned int offset = 0;

simgear/scene/model/ModelRegistry.cxx

@@ -56,15 +56,12 @@
 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
 #include <simgear/scene/util/NodeAndDrawableVisitor.hxx>
 
-
-#include <simgear/debug/ErrorReportingCallback.hxx>
-
-#include <simgear/io/sg_file.hxx>
-#include <simgear/misc/lru_cache.hxx>
-#include <simgear/props/condition.hxx>
+#include <simgear/structure/exception.hxx>
 #include <simgear/props/props.hxx>
 #include <simgear/props/props_io.hxx>
-#include <simgear/structure/exception.hxx>
+#include <simgear/props/condition.hxx>
+#include <simgear/io/sg_file.hxx>
+#include <simgear/misc/lru_cache.hxx>
 
 #include "BoundingVolumeBuildVisitor.hxx"
 #include "model.hxx"
@@ -292,11 +289,6 @@ ModelRegistry::readImage(const string& fileName,
 
     const SGReaderWriterOptions* sgoptC = dynamic_cast<const SGReaderWriterOptions*>(opt);
 
-    simgear::ErrorReportContext ec;
-    if (sgoptC && sgoptC->getModelData()) {
-        ec.addFromMap(sgoptC->getModelData()->getErrorContext());
-    }
-
     if (cache_active && (!sgoptC || sgoptC->getLoadOriginHint() != SGReaderWriterOptions::LoadOriginHint::ORIGIN_SPLASH_SCREEN)) {
         if (fileExtension != "dds" && fileExtension != "gz") {
 
@@ -367,8 +359,6 @@ ModelRegistry::readImage(const string& fileName,
                 if (res.validImage()) {
                     osg::ref_ptr<osg::Image> srcImage = res.getImage();
                     int width = srcImage->s();
-                    //int packing = srcImage->getPacking();
-                    //printf("packing %d format %x pixel size %d InternalTextureFormat %x\n", packing, srcImage->getPixelFormat(), srcImage->getPixelSizeInBits(), srcImage->getInternalTextureFormat() );
                     bool transparent = srcImage->isImageTranslucent();
                     bool isNormalMap = false;
                     bool isEffect = false;
@@ -377,11 +367,6 @@ ModelRegistry::readImage(const string& fileName,
                     */
                     bool can_compress = (transparent && compress_transparent) || (!transparent && compress_solid);
 
-                    if (srcImage->getPixelSizeInBits() <= 16) {
-                        SG_LOG(SG_IO, SG_INFO, "Ignoring " + absFileName + " for inclusion into the texture cache because pixel density too low at " << srcImage->getPixelSizeInBits() << " bits per pixek");
-                        can_compress = false;
-                    }
-
                     int height = srcImage->t();
 
                     // use the new file origin to determine any special processing
@@ -401,10 +386,6 @@ ModelRegistry::readImage(const string& fileName,
                         isEffect = true;
 //                        can_compress = false;
                     }
-                    else if (sgoptC && !transparent && sgoptC->getLoadOriginHint() == SGReaderWriterOptions::LoadOriginHint::ORIGIN_CANVAS) {
-                        SG_LOG(SG_IO, SG_INFO, "From Canvas " + absFileName + " will generate mipmap only");
-                        can_compress = false;
-                    }
                     if (can_compress)
                     {
                         std::string pot_message;
@@ -557,13 +538,7 @@ ModelRegistry::readImage(const string& fileName,
         }
     }
 
-    try {
-        res = registry->readImageImplementation(absFileName, opt);
-    } catch (std::bad_alloc&) {
-        simgear::reportFailure(simgear::LoadFailure::OutOfMemory, simgear::ErrorCode::ThreeDModelLoad,
-                               "Out of memory loading texture", sg_location{absFileName});
-        return ReaderWriter::ReadResult::INSUFFICIENT_MEMORY_TO_LOAD;
-    }
+    res = registry->readImageImplementation(absFileName, opt);
 
     if (!res.success()) {
         SG_LOG(SG_IO, SG_DEV_WARN, "Image loading failed:" << res.message());
@@ -728,17 +703,7 @@ ReaderWriter::ReadResult
 ModelRegistry::readNode(const string& fileName,
                         const Options* opt)
 {
-    // propogate error context from the caller
-    simgear::ErrorReportContext ec;
-    auto sgopt = dynamic_cast<const SGReaderWriterOptions*>(opt);
-    if (sgopt) {
-        if (sgopt->getModelData()) {
-            ec.addFromMap(sgopt->getModelData()->getErrorContext());
-        }
-
-        ec.addFromMap(sgopt->getErrorContext());
-    }
-
+    ReaderWriter::ReadResult res;
     CallbackMap::iterator iter
         = nodeCallbackMap.find(getFileExtension(fileName));
     ReaderWriter::ReadResult result;
@@ -747,11 +712,6 @@ ModelRegistry::readNode(const string& fileName,
     else
         result = _defaultCallback->readNode(fileName, opt);
 
-    if (!result.validNode()) {
-        simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::ThreeDModelLoad,
-                               "Failed to load 3D model:" + result.message(), sg_location{fileName});
-    }
-
     return result;
 }
 

simgear/scene/model/SGReaderWriterXML.cxx

@@ -35,13 +35,12 @@
 #include <osgDB/FileNameUtils>
 
 #include <simgear/compiler.h>
-#include <simgear/debug/ErrorReportingCallback.hxx>
-#include <simgear/props/condition.hxx>
+#include <simgear/structure/exception.hxx>
 #include <simgear/props/props.hxx>
 #include <simgear/props/props_io.hxx>
+#include <simgear/props/condition.hxx>
 #include <simgear/scene/util/SGNodeMasks.hxx>
 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
-#include <simgear/structure/exception.hxx>
 
 #include "modellib.hxx"
 #include "SGReaderWriterXML.hxx"
@@ -82,7 +81,6 @@ SGReaderWriterXML::readNode(const std::string& name,
                             const osgDB::Options* options) const
 {
     std::string fileName = osgDB::findDataFile(name, options);
-    simgear::ErrorReportContext ec{"model-xml", fileName};
 
     osg::Node *result=0;
     try {
@@ -264,10 +262,8 @@ sgLoad3DModel_internal(const SGPath& path,
                        SGPropertyNode *overlay)
 {
     if (!path.exists()) {
-        simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::XMLModelLoad,
-                               "Failed to load model XML: not found", path);
-        SG_LOG(SG_IO, SG_DEV_ALERT, "Failed to load file: \"" << path << "\"");
-        return std::make_tuple(0, (osg::Node*)NULL);
+      SG_LOG(SG_IO, SG_DEV_ALERT, "Failed to load file: \"" << path << "\"");
+      return std::make_tuple(0, (osg::Node *) NULL);
     }
 
     osg::ref_ptr<SGReaderWriterOptions> options;
@@ -295,8 +291,6 @@ sgLoad3DModel_internal(const SGPath& path,
        try {
             readProperties(modelpath, props);
         } catch (const sg_exception &t) {
-            simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::XMLModelLoad,
-                                   "Failed to load model XML:" + t.getFormattedMessage(), t.getLocation());
             SG_LOG(SG_IO, SG_DEV_ALERT, "Failed to load xml: "
                    << t.getFormattedMessage());
             throw;
@@ -311,24 +305,18 @@ sgLoad3DModel_internal(const SGPath& path,
         if (props->hasValue("/path")) {
             string modelPathStr = props->getStringValue("/path");
             modelpath = SGModelLib::findDataFile(modelPathStr, NULL, modelDir);
-            if (modelpath.isNull()) {
-                simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::ThreeDModelLoad,
-                                       "Model not found:" + modelPathStr, path);
+            if (modelpath.isNull())
                 throw sg_io_exception("Model file not found: '" + modelPathStr + "'",
-                                      path, {}, false);
-            }
+                        path);
 
             if (props->hasValue("/texture-path")) {
                 string texturePathStr = props->getStringValue("/texture-path");
                 if (!texturePathStr.empty())
                 {
                     texturepath = SGModelLib::findDataFile(texturePathStr, NULL, modelDir);
-                    if (texturepath.isNull()) {
-                        simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::LoadingTexture,
-                                               "Texture file not found:" + texturePathStr, path);
+                    if (texturepath.isNull())
                         throw sg_io_exception("Texture file not found: '" + texturePathStr + "'",
                                 path);
-                    }
                 }
             }
         } else {
@@ -355,13 +343,9 @@ sgLoad3DModel_internal(const SGPath& path,
 #else
         modelResult = osgDB::readRefNodeFile(modelpath.utf8Str(), options.get());
 #endif
-        if (!modelResult.validNode()) {
-            simgear::reportFailure(simgear::LoadFailure::BadData, simgear::ErrorCode::XMLModelLoad,
-                                   "Failed to load 3D model:" + modelResult.message(), modelpath);
+        if (!modelResult.validNode())
             throw sg_io_exception("Failed to load 3D model:" + modelResult.message(),
-                                  modelpath, {}, false);
-        }
-
+                                  modelpath);
         model = copyModel(modelResult.getNode());
         // Add an extra reference to the model stored in the database.
         // That is to avoid expiring the object from the cache even if
@@ -429,9 +413,6 @@ sgLoad3DModel_internal(const SGPath& path,
 
         if (submodelPath.isNull()) {
           SG_LOG(SG_IO, SG_DEV_ALERT, "Failed to load file: \"" << subPathStr << "\"");
-          simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::XMLModelLoad,
-                                 "Couldn't find file for submodel:" + subPathStr,
-                                 SGPath::fromUtf8(subPathStr));
           continue;
         }
 
@@ -444,8 +425,6 @@ sgLoad3DModel_internal(const SGPath& path,
             }
         }
 
-        simgear::ErrorReportContext("submodel", submodelPath.utf8Str());
-
         try {
             int num_anims;
             std::tie(num_anims, submodel) = sgLoad3DModel_internal(submodelPath, options.get(),
@@ -511,8 +490,7 @@ sgLoad3DModel_internal(const SGPath& path,
         }
     }
 
-    auto particlesManager = ParticlesGlobalManager::instance();
-    if (particlesManager->isEnabled()) { //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) {
@@ -525,9 +503,9 @@ sgLoad3DModel_internal(const SGPath& path,
 
                 options2->setDatabasePath(texturepath.utf8Str());
             }
-            group->addChild(particlesManager->appendParticles(particle_nodes[i],
-                                                              prop_root,
-                                                              options2.get()));
+            group->addChild(Particles::appendParticles(particle_nodes[i],
+                                                       prop_root,
+                                                       options2.get()));
         }
     }
 
@@ -559,8 +537,8 @@ sgLoad3DModel_internal(const SGPath& path,
     // Some material animations (eventually all) are actually effects.
     makeEffectAnimations(animation_nodes, effect_nodes);
     {
-        ref_ptr<Node> modelWithEffects = instantiateEffects(group.get(), effect_nodes, options.get(),
-                                                            path.dirPath());
+        ref_ptr<Node> modelWithEffects
+            = instantiateEffects(group.get(), effect_nodes, options.get());
         group = static_cast<Group*>(modelWithEffects.get());
     }
 
@@ -574,22 +552,13 @@ sgLoad3DModel_internal(const SGPath& path,
             } // of object-names in the animation
             continue;
         }
-        
-        try {
-            /*
-             * Setup the model data for the node currently being animated.
-             */
-            modelData.LoadAnimationValuesForElement(animation_nodes[i], i);
+        /*
+         * Setup the model data for the node currently being animated.
+         */
+        modelData.LoadAnimationValuesForElement(animation_nodes[i], i);
 
-            /// OSGFIXME: duh, why not only model?????
-            SGAnimation::animate(modelData);
-        } catch (sg_exception& e) {
-            simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::XMLModelLoad,
-                                   "Couldn't load animation " + animation_nodes[i]->getNameString()
-                                    + ":" + e.getFormattedMessage(),
-                                   modelpath);
-            throw;
-        }
+        /// OSGFIXME: duh, why not only model?????
+        SGAnimation::animate(modelData);
     }
 
     animationcount += animation_nodes.size();

simgear/scene/model/SGText.cxx

@@ -16,27 +16,23 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
-#include <simgear_config.h>
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
 
 #include <cstdio>
 
 #include "SGText.hxx"
 
+#include <simgear/math/SGMath.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/strutils.hxx>
 
 #include <osg/Geode>
 #include <osg/MatrixTransform>
 #include <osgText/Text>
 #include <osgText/Font>
 
-#include <simgear/misc/ResourceManager.hxx>
-#include <simgear/math/SGMath.hxx>
-#include <simgear/misc/sg_path.hxx>
-#include <simgear/misc/strutils.hxx>
-#include <simgear/scene/material/Effect.hxx>
-#include <simgear/scene/material/EffectGeode.hxx>
-#include <simgear/scene/util/SGReaderWriterOptions.hxx>
-#include <simgear/debug/ErrorReportingCallback.hxx>
-
 using std::string;
 
 class SGText::UpdateCallback : public osg::NodeCallback {
@@ -84,7 +80,7 @@ void SGText::UpdateCallback::operator()(osg::Node * node, osg::NodeVisitor *nv )
     // be lazy and set the text only if the property has changed.
     // update() computes the glyph representation which looks 
     // more expensive than a the above string compare.
-    text->setText( buf, osgText::String::ENCODING_UTF8 );
+    text->setText( buf );
     text->update();
   }
   traverse( node, nv );
@@ -99,15 +95,9 @@ osg::Node * SGText::appendText(const SGPropertyNode* configNode,
   osg::Geode * g = new osg::Geode;
   g->addDrawable( text );
 
-  const std::string requestedFont = configNode->getStringValue("font","Helvetica");
-  const SGPath fontPath = simgear::ResourceManager::instance()->findPath("Fonts/" + requestedFont);
-  if ( !fontPath.isNull() ) {
-    text->setFont( fontPath.utf8Str() );
-  } else {
-    simgear::reportFailure(simgear::LoadFailure::NotFound,
-                          simgear::ErrorCode::LoadingTexture,
-                                   "SGText: couldn;t find font:" + requestedFont);
-  }
+  SGPath path("Fonts" );
+  path.append( configNode->getStringValue( "font", "Helvetica" ));
+  text->setFont( path.utf8Str() );
 
   text->setCharacterSize(configNode->getDoubleValue("character-size", 1.0 ), 
                          configNode->getDoubleValue("character-aspect-ratio", 1.0 ));

simgear/scene/model/animation.cxx

@@ -39,11 +39,9 @@
 #include <simgear/bvh/BVHGroup.hxx>
 #include <simgear/bvh/BVHLineGeometry.hxx>
 
-#include <simgear/debug/ErrorReportingCallback.hxx>
 #include <simgear/math/interpolater.hxx>
 #include <simgear/props/condition.hxx>
 #include <simgear/props/props.hxx>
-
 #include <simgear/scene/material/EffectGeode.hxx>
 #include <simgear/scene/material/EffectCullVisitor.hxx>
 #include <simgear/scene/util/DeletionManager.hxx>
@@ -775,16 +773,10 @@ bool SGAnimation::setCenterAndAxisFromObject(osg::Node *rootNode, SGVec3d& cente
                     object_group->setNodeMask(0);
                 }
                 else {
-                    reportFailure(LoadFailure::Misconfigured, ErrorCode::XMLModelLoad,
-                                  "Could not find valid line segment for axis animation:" + axis_object_name,
-                                  SGPath::fromUtf8(_modelData.getPath()));
                     SG_LOG(SG_IO, SG_DEV_ALERT, "Could not find a valid line segment for animation:  " << axis_object_name << " in file: " << _modelData.getPath());
                 }
             }
             else if (can_warn) {
-                reportFailure(LoadFailure::Misconfigured, ErrorCode::XMLModelLoad,
-                              "Could not find object for axis animation:" + axis_object_name,
-                              SGPath::fromUtf8(_modelData.getPath()));
                 SG_LOG(SG_IO, SG_DEV_ALERT, "Could not find at least one of the following objects for axis animation: " << axis_object_name << " in file: " << _modelData.getPath());
             }
         }
@@ -1143,8 +1135,16 @@ void SpinAnimCallback::operator()(osg::Node* node, osg::NodeVisitor* nv)
         double intPart;
         double rot = modf(rotation, &intPart);
         double angle = rot * 2.0 * osg::PI;
-        transform->setAngleRad(angle);
+        const SGVec3d& sgcenter = transform->getCenter();
+        const SGVec3d& sgaxis = transform->getAxis();
+        Matrixd mat = Matrixd::translate(-sgcenter[0], -sgcenter[1], -sgcenter[2])
+            * Matrixd::rotate(angle, sgaxis[0], sgaxis[1], sgaxis[2])
+            * Matrixd::translate(sgcenter[0], sgcenter[1], sgcenter[2])
+            * *cv->getModelViewMatrix();
+        ref_ptr<RefMatrix> refmat = new RefMatrix(mat);
+        cv->pushModelViewMatrix(refmat.get(), transform->getReferenceFrame());
         traverse(transform, nv);
+        cv->popModelViewMatrix();
     } else {
         traverse(transform, nv);
     }

simgear/scene/model/model.cxx

@@ -24,12 +24,11 @@
 #include <simgear/scene/util/SplicingVisitor.hxx>
 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
 
-#include <simgear/debug/ErrorReportingCallback.hxx>
-#include <simgear/props/condition.hxx>
+#include <simgear/structure/exception.hxx>
+#include <simgear/structure/Singleton.hxx>
 #include <simgear/props/props.hxx>
 #include <simgear/props/props_io.hxx>
-#include <simgear/structure/Singleton.hxx>
-#include <simgear/structure/exception.hxx>
+#include <simgear/props/condition.hxx>
 
 #include "model.hxx"
 
@@ -234,7 +233,7 @@ public:
     typedef std::map<string, SGPropertyNode_ptr> EffectMap;
     using SplicingVisitor::apply;
     MakeEffectVisitor(const SGReaderWriterOptions* options = 0)
-        : _options(options), _modelPath(SGPath{})
+        : _options(options)
     {
     }
     virtual void apply(osg::Group& node);
@@ -246,17 +245,10 @@ public:
         _currentEffectParent = effect;
     }
     SGPropertyNode* getDefaultEffect() { return _currentEffectParent; }
-
-    void setModelPath(const SGPath& p)
-    {
-        _modelPath = p;
-    }
-
 protected:
     EffectMap _effectMap;
     SGPropertyNode_ptr _currentEffectParent;
     osg::ref_ptr<const SGReaderWriterOptions> _options;
-    SGPath _modelPath;
 };
 
 void MakeEffectVisitor::apply(osg::Group& node)
@@ -294,7 +286,7 @@ void MakeEffectVisitor::apply(osg::Geode& geode)
     makeParametersFromStateSet(ssRoot, ss);
     SGPropertyNode_ptr effectRoot = new SGPropertyNode;
     effect::mergePropertyTrees(effectRoot, ssRoot, _currentEffectParent);
-    Effect* effect = makeEffect(effectRoot, true, _options.get(), _modelPath);
+    Effect* effect = makeEffect(effectRoot, true, _options.get());
     EffectGeode* eg = dynamic_cast<EffectGeode*>(&geode);
     if (eg) {
         eg->setEffect(effect);
@@ -339,8 +331,7 @@ protected:
 
 ref_ptr<Node> instantiateEffects(osg::Node* modelGroup,
                                  PropertyList& effectProps,
-                                 const SGReaderWriterOptions* options,
-                                 const SGPath& modelPath)
+                                 const SGReaderWriterOptions* options)
 {
     SGPropertyNode_ptr defaultEffectPropRoot;
     MakeEffectVisitor visitor(options);
@@ -365,15 +356,13 @@ ref_ptr<Node> instantiateEffects(osg::Node* modelGroup,
     if (!defaultEffectPropRoot)
         defaultEffectPropRoot = DefaultEffect::instance()->getEffect();
     visitor.setDefaultEffect(defaultEffectPropRoot.ptr());
-    visitor.setModelPath(modelPath);
     modelGroup->accept(visitor);
     osg::NodeList& result = visitor.getResults();
     return ref_ptr<Node>(result[0].get());
 }
 
 ref_ptr<Node> instantiateMaterialEffects(osg::Node* modelGroup,
-                                         const SGReaderWriterOptions* options,
-                                         const SGPath& modelPath)
+                                        const SGReaderWriterOptions* options)
 {
 
     SGPropertyNode_ptr effect;
@@ -391,8 +380,6 @@ ref_ptr<Node> instantiateMaterialEffects(osg::Node* modelGroup,
       } else {
         effect = DefaultEffect::instance()->getEffect();
         SG_LOG( SG_TERRAIN, SG_ALERT, "Unable to get effect for " << options->getMaterialName());
-        simgear::reportFailure(simgear::LoadFailure::NotFound, simgear::ErrorCode::LoadEffectsShaders,
-                               "Unable to get effect for material:" + options->getMaterialName());
       }
     } else {
       effect = DefaultEffect::instance()->getEffect();
@@ -400,7 +387,7 @@ ref_ptr<Node> instantiateMaterialEffects(osg::Node* modelGroup,
 
     effect->addChild("default")->setBoolValue(true);
     effectProps.push_back(effect);
-    return instantiateEffects(modelGroup, effectProps, options, modelPath);
+    return instantiateEffects(modelGroup, effectProps, options);
 }
 
 }