Updated package-management code.

Use mini-unzip code to extract, since we don't need all the features of libArchive, and the deployment issues become simpler.

CMakeLists.txt

@@ -225,8 +225,7 @@ else()
 endif(SYSTEM_EXPAT)
 
 if (ENABLE_PACKAGE)
-    message(STATUS "package management: ENABLED: libArchive is needed")
+    message(STATUS "package management: ENABLED")
-    find_package(LibArchive REQUIRED)
 else()
     message(STATUS "package management: DISABLED")
 endif(ENABLE_PACKAGE)

CMakeModules/FindLibArchive.cmake

@@ -1,77 +0,0 @@
-# - Find libarchive library and headers
-# The module defines the following variables:
-#
-#  LibArchive_FOUND        - true if libarchive was found
-#  LibArchive_INCLUDE_DIRS - include search path
-#  LibArchive_LIBRARIES    - libraries to link
-#  LibArchive_VERSION      - libarchive 3-component version number
-
-#=============================================================================
-# Copyright 2010 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-find_path(LibArchive_INCLUDE_DIR
-  NAMES archive.h
-  PATHS
-  ${CMAKE_INSTALL_PREFIX}
-  ${ADDITIONAL_LIBRARY_PATHS}
-  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\LibArchive;InstallPath]/include"
-  )
-
-# NO_DEFAULT_PATH is important on Mac - the libarchive in /usr/lib
-# is too old, and there's no matching headers :(
-find_library(LibArchive_LIBRARY
-if(APPLE)
-      NO_DEFAULT_PATH
-endif(APPLE)
-  NAMES archive libarchive
-  PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
-  PATHS
-  ${CMAKE_INSTALL_PREFIX}
-  ${ADDITIONAL_LIBRARY_PATHS}
-  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\LibArchive;InstallPath]/lib"
-  )
-
-mark_as_advanced(LibArchive_INCLUDE_DIR LibArchive_LIBRARY)
-
-# Extract the version number from the header.
-if(LibArchive_INCLUDE_DIR AND EXISTS "${LibArchive_INCLUDE_DIR}/archive.h")
-  # The version string appears in one of two known formats in the header:
-  #  #define ARCHIVE_LIBRARY_VERSION "libarchive 2.4.12"
-  #  #define ARCHIVE_VERSION_STRING "libarchive 2.8.4"
-  # Match either format.
-  set(_LibArchive_VERSION_REGEX "^#define[ \t]+ARCHIVE[_A-Z]+VERSION[_A-Z]*[ \t]+\"libarchive +([0-9]+)\\.([0-9]+)\\.([0-9]+)[^\"]*\".*$")
-  file(STRINGS "${LibArchive_INCLUDE_DIR}/archive.h" _LibArchive_VERSION_STRING LIMIT_COUNT 1 REGEX "${_LibArchive_VERSION_REGEX}")
-  if(_LibArchive_VERSION_STRING)
-    string(REGEX REPLACE "${_LibArchive_VERSION_REGEX}" "\\1.\\2.\\3" LibArchive_VERSION "${_LibArchive_VERSION_STRING}")
-  endif()
-  unset(_LibArchive_VERSION_REGEX)
-  unset(_LibArchive_VERSION_STRING)
-endif()
-
-# Handle the QUIETLY and REQUIRED arguments and set LIBARCHIVE_FOUND
-# to TRUE if all listed variables are TRUE.
-# (Use ${CMAKE_ROOT}/Modules instead of ${CMAKE_CURRENT_LIST_DIR} because CMake
-#  itself includes this FindLibArchive when built with an older CMake that does
-#  not provide it.  The older CMake also does not have CMAKE_CURRENT_LIST_DIR.)
-include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)
-find_package_handle_standard_args(LibArchive
-                                  REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR
-                                  VERSION_VAR LibArchive_VERSION
-  )
-set(LibArchive_FOUND ${LIBARCHIVE_FOUND})
-unset(LIBARCHIVE_FOUND)
-
-if(LibArchive_FOUND)
-  set(LibArchive_INCLUDE_DIRS ${LibArchive_INCLUDE_DIR})
-  set(LibArchive_LIBRARIES    ${LibArchive_LIBRARY})
-endif()

simgear/package/CMakeLists.txt

@@ -14,7 +14,10 @@ set(SOURCES
     Package.cxx
     Install.cxx
     Root.cxx
-    md5.c
+# internal helpers
+    md5.c md5.h
+    ioapi.c ioapi_mem.c ioapi.h
+    unzip.h unzip.c
     )
 
 simgear_component(package package "${SOURCES}" "${HEADERS}")
@@ -24,7 +27,6 @@ if (SIMGEAR_SHARED)
 else()
     set(APP_LIBS
         SimGearCore
-        ${LibArchive_LIBRARIES}
         ${CMAKE_THREAD_LIBS_INIT}
         ${WINSOCK_LIBRARY}
         ${ZLIB_LIBRARY}

simgear/package/Install.cxx

@@ -5,10 +5,7 @@
 #include <boost/foreach.hpp>
 #include <fstream>
 
-// libarchive support
+#include <simgear/package/unzip.h>
-#include <archive.h>
-#include <archive_entry.h>
-
 #include <simgear/package/md5.h>
 
 #include <simgear/structure/exception.hxx>
@@ -19,6 +16,10 @@
 #include <simgear/io/HTTPClient.hxx>
 #include <simgear/misc/sg_dir.hxx>
 
+extern "C" {
+    void fill_memory_filefunc (zlib_filefunc_def*);
+}
+
 namespace simgear {
     
 namespace pkg {
@@ -63,7 +64,6 @@ protected:
     {
         m_buffer += std::string(s, n);
         MD5Update(&m_md5, (unsigned char*) s, n);
-        std::cout << "got " << m_buffer.size() << " bytes" << std::endl;
     }
     
     virtual void responseComplete()
@@ -73,8 +73,7 @@ protected:
             doFailure();
             return;
         }
-        std::cout << "content lenth:" << responseLength() << std::endl;
+
-        std::cout << m_buffer.size() << " total received" << std::endl;
         MD5Final(&m_md5);
     // convert final sum to hex
         const char hexChar[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
@@ -94,43 +93,125 @@ protected:
         } else {
             std::cout << "MD5 checksum is ok" << std::endl;
         }
-                
-        struct archive* a = archive_read_new();
-        archive_read_support_filter_all(a);
-        archive_read_support_format_all(a);
-        int result = archive_read_open_memory(a, (void*) m_buffer.data(), m_buffer.size());
         
-        if (result != ARCHIVE_OK) {
+        if (!extractUnzip()) {
+            SG_LOG(SG_GENERAL, SG_WARN, "zip extraction failed");
             doFailure();
             return;
         }
-        
-        struct archive_entry* entry;
-        while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
-            SGPath finalPath(m_extractPath);
-            finalPath.append(archive_entry_pathname(entry));
-         //   std::cout << "writing:" << finalPath << std::endl;
-            archive_entry_set_pathname(entry, finalPath.c_str());            
-            archive_read_extract(a, entry, 0);
-        }
-        
-        archive_read_free(a);
                   
         if (m_owner->path().exists()) {
-            std::cout << "removing existing path" << std::endl;
+            //std::cout << "removing existing path" << std::endl;
             Dir destDir(m_owner->path());
             destDir.remove(true /* recursive */);
         }
         
-        std::cout << "renaming to " << m_owner->path() << std::endl;
         m_extractPath.append(m_owner->package()->id());
-        m_extractPath.rename(m_owner->path());
+        m_extractPath.rename(m_owner->path());        
-        
         m_owner->m_revision = m_owner->package()->revision();
         m_owner->writeRevisionFile();
     }
     
 private:
+
+    void extractCurrentFile(unzFile zip, char* buffer, size_t bufferSize)
+    {
+        unz_file_info fileInfo;
+        unzGetCurrentFileInfo(zip, &fileInfo, 
+            buffer, bufferSize, 
+            NULL, NULL,  /* extra field */
+            NULL, NULL /* comment field */);
+            
+        std::string name(buffer);
+    // no absolute paths, no 'up' traversals
+    // we could also look for suspicious file extensions here (forbid .dll, .exe, .so)
+        if ((name[0] == '/') || (name.find("../") != std::string::npos) || (name.find("..\\") != std::string::npos)) {
+            throw sg_format_exception("Bad zip path", name);
+        }
+        
+        if (fileInfo.uncompressed_size == 0) {
+            // assume it's a directory for now
+            // since we create parent directories when extracting
+            // a path, we're done here
+            return;
+        }
+        
+        int result = unzOpenCurrentFile(zip);
+        if (result != UNZ_OK) {
+            throw sg_io_exception("opening current zip file failed", sg_location(name));
+        }
+            
+        std::ofstream outFile;
+        bool eof = false;
+        SGPath path(m_extractPath);
+        path.append(name);
+                        
+    // create enclosing directory heirarchy as required
+        Dir parentDir(path.dir());
+        if (!parentDir.exists()) {
+            bool ok = parentDir.create(0755);
+            if (!ok) {
+                throw sg_io_exception("failed to create directory heirarchy for extraction", path.c_str());
+            }
+        }
+            
+        outFile.open(path.c_str(), std::ios::binary | std::ios::trunc | std::ios::out);
+        if (outFile.fail()) {
+            throw sg_io_exception("failed to open output file for writing", path.c_str());
+        }
+            
+        while (!eof) {
+            int bytes = unzReadCurrentFile(zip, buffer, bufferSize);
+            if (bytes < 0) {
+                throw sg_io_exception("unzip failure reading curent archive", sg_location(name));
+            } else if (bytes == 0) {
+                eof = true;
+            } else {
+                outFile.write(buffer, bytes);
+            }
+        }
+            
+        outFile.close();
+        unzCloseCurrentFile(zip);
+    }
+    
+    bool extractUnzip()
+    {
+        bool result = true;
+        zlib_filefunc_def memoryAccessFuncs;
+        fill_memory_filefunc(&memoryAccessFuncs);
+           
+        char bufferName[128];
+        snprintf(bufferName, 128, "%p+%lx", m_buffer.data(), m_buffer.size());
+        unzFile zip = unzOpen2(bufferName, &memoryAccessFuncs);
+        
+        const size_t BUFFER_SIZE = 32 * 1024;
+        void* buf = malloc(BUFFER_SIZE);
+        
+        try {
+            int result = unzGoToFirstFile(zip);
+            if (result != UNZ_OK) {
+                throw sg_exception("failed to go to first file in archive");
+            }
+            
+            while (true) {
+                extractCurrentFile(zip, (char*) buf, BUFFER_SIZE);
+                result = unzGoToNextFile(zip);
+                if (result == UNZ_END_OF_LIST_OF_FILE) {
+                    break;
+                } else if (result != UNZ_OK) {
+                    throw sg_io_exception("failed to go to next file in the archive");
+                }
+            }
+        } catch (sg_exception& e) {
+            result = false;
+        }
+        
+        free(buf);
+        unzClose(zip);
+        return result;
+    }
+        
     void doFailure()
     {
         Dir dir(m_extractPath);

simgear/package/ioapi.c

@@ -0,0 +1,178 @@
+/* ioapi.c -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 Gilles Vollant
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+
+
+
+/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+
+#ifndef SEEK_CUR
+#define SEEK_CUR    1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END    2
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET    0
+#endif
+
+voidpf ZCALLBACK fopen_file_func OF((
+   voidpf opaque,
+   const char* filename,
+   int mode));
+
+uLong ZCALLBACK fread_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   void* buf,
+   uLong size));
+
+uLong ZCALLBACK fwrite_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   const void* buf,
+   uLong size));
+
+long ZCALLBACK ftell_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+long ZCALLBACK fseek_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   uLong offset,
+   int origin));
+
+int ZCALLBACK fclose_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+int ZCALLBACK ferror_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+
+voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
+   voidpf opaque;
+   const char* filename;
+   int mode;
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+
+uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   void* buf;
+   uLong size;
+{
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+
+uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   const void* buf;
+   uLong size;
+{
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK ftell_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
+   voidpf opaque;
+   voidpf stream;
+   uLong offset;
+   int origin;
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    if (fseek((FILE *)stream, offset, fseek_origin) != 0)
+        ret = -1;
+    return ret;
+}
+
+int ZCALLBACK fclose_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+int ZCALLBACK ferror_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}

simgear/package/ioapi.h

@@ -0,0 +1,75 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 Gilles Vollant
+*/
+
+#ifndef _ZLIBIOAPI_H
+#define _ZLIBIOAPI_H
+
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ      (1)
+#define ZLIB_FILEFUNC_MODE_WRITE     (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE   (8)
+
+
+#ifndef ZCALLBACK
+
+#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+#define ZCALLBACK CALLBACK
+#else
+#define ZCALLBACK
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
+typedef uLong  (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong  (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef long   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
+typedef long   (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+typedef int    (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
+typedef int    (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef struct zlib_filefunc_def_s
+{
+    open_file_func      zopen_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell_file_func      ztell_file;
+    seek_file_func      zseek_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc_def;
+
+
+
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+
+#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
+#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
+#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
+#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
+#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

simgear/package/ioapi_mem.c

@@ -0,0 +1,221 @@
+/* ioapi_mem.c -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   This version of ioapi is designed to access memory rather than files.
+   We do use a region of memory to put data in to and take it out of. We do
+   not have auto-extending buffers and do not inform anyone else that the
+   data has been written. It is really intended for accessing a zip archive
+   embedded in an application such that I can write an installer with no
+   external files. Creation of archives has not been attempted, although
+   parts of the framework are present.
+
+   Based on Unzip ioapi.c version 0.22, May 19th, 2003
+
+   Copyright (C) 1998-2003 Gilles Vollant
+             (C) 2003 Justin Fletcher
+
+   This file is under the same license as the Unzip tool it is distributed
+   with.
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+
+
+
+voidpf ZCALLBACK fopen_mem_func OF((
+   voidpf opaque,
+   const char* filename,
+   int mode));
+
+uLong ZCALLBACK fread_mem_func OF((
+   voidpf opaque,
+   voidpf stream,
+   void* buf,
+   uLong size));
+
+uLong ZCALLBACK fwrite_mem_func OF((
+   voidpf opaque,
+   voidpf stream,
+   const void* buf,
+   uLong size));
+
+long ZCALLBACK ftell_mem_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+long ZCALLBACK fseek_mem_func OF((
+   voidpf opaque,
+   voidpf stream,
+   uLong offset,
+   int origin));
+
+int ZCALLBACK fclose_mem_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+int ZCALLBACK ferror_mem_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+
+typedef struct ourmemory_s {
+  char *base; /* Base of the region of memory we're using */
+  uLong size; /* Size of the region of memory we're using */
+  uLong limit; /* Furthest we've written */
+  uLong cur_offset; /* Current offset in the area */
+} ourmemory_t;
+
+voidpf ZCALLBACK fopen_mem_func (opaque, filename, mode)
+   voidpf opaque;
+   const char* filename;
+   int mode;
+{
+    ourmemory_t *mem = malloc(sizeof(*mem));
+    if (mem==NULL)
+      return NULL; /* Can't allocate space, so failed */
+
+    memset(mem, 0, sizeof(ourmemory_t));
+
+    /* Filenames are specified in the form :
+     *    <hex base of zip file>+<hex size of zip file>
+     * This may not work where memory addresses are longer than the
+     * size of an int and therefore may need addressing for 64bit
+     * architectures
+     */
+    if (sscanf(filename,"%p+%x",&mem->base,&mem->size)!=2)
+      return NULL;
+
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+      mem->limit=0; /* When writing we start with 0 bytes written */
+    else
+      mem->limit=mem->size;
+
+    mem->cur_offset = 0;
+
+    return mem;
+}
+
+
+uLong ZCALLBACK fread_mem_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   void* buf;
+   uLong size;
+{
+    ourmemory_t *mem = (ourmemory_t *)stream;
+
+    if (size > mem->size - mem->cur_offset)
+      size = mem->size - mem->cur_offset;
+
+    memcpy(buf, mem->base + mem->cur_offset, size);
+    mem->cur_offset+=size;
+
+    return size;
+}
+
+
+uLong ZCALLBACK fwrite_mem_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   const void* buf;
+   uLong size;
+{
+    ourmemory_t *mem = (ourmemory_t *)stream;
+
+    if (size > mem->size - mem->cur_offset)
+      size = mem->size - mem->cur_offset;
+
+    memcpy(mem->base + mem->cur_offset, buf, size);
+    mem->cur_offset+=size;
+    if (mem->cur_offset > mem->limit)
+      mem->limit = mem->cur_offset;
+
+    return size;
+}
+
+long ZCALLBACK ftell_mem_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    ourmemory_t *mem = (ourmemory_t *)stream;
+
+    return mem->cur_offset;
+}
+
+long ZCALLBACK fseek_mem_func (opaque, stream, offset, origin)
+   voidpf opaque;
+   voidpf stream;
+   uLong offset;
+   int origin;
+{
+    ourmemory_t *mem = (ourmemory_t *)stream;
+    uLong new_pos;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        new_pos = mem->cur_offset + offset;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        new_pos = mem->limit + offset;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        new_pos = offset;
+        break;
+    default: return -1;
+    }
+
+    if (new_pos > mem->size)
+      return 1; /* Failed to seek that far */
+
+    if (new_pos > mem->limit)
+      memset(mem->base + mem->limit, 0, new_pos - mem->limit);
+
+    mem->cur_offset = new_pos;
+    return 0;
+}
+
+int ZCALLBACK fclose_mem_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    ourmemory_t *mem = (ourmemory_t *)stream;
+
+    /* Note that once we've written to the buffer we don't tell anyone
+       about it here. Probably the opaque handle could be used to inform
+       some other component of how much data was written.
+
+       This, and other aspects of writing through this interface, has
+       not been tested.
+     */
+
+    free (mem);
+    return 0;
+}
+
+int ZCALLBACK ferror_mem_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    ourmemory_t *mem = (ourmemory_t *)stream;
+    /* We never return errors */
+    return 0;
+}
+
+void fill_memory_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_mem_func;
+    pzlib_filefunc_def->zread_file = fread_mem_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_mem_func;
+    pzlib_filefunc_def->ztell_file = ftell_mem_func;
+    pzlib_filefunc_def->zseek_file = fseek_mem_func;
+    pzlib_filefunc_def->zclose_file = fclose_mem_func;
+    pzlib_filefunc_def->zerror_file = ferror_mem_func;
+    pzlib_filefunc_def->opaque = NULL;
+}

simgear/package/pkgutil.cxx

@@ -46,7 +46,7 @@ int main(int argc, char** argv)
         cout << "Will install:" << pkg->id() << " from " << catalog->id() <<
                 "(" << catalog->description() << ")" << endl;
         pkg->install();
-    } else if (!strcmp(argv[1], "uninstall")) {
+    } else if (!strcmp(argv[1], "uninstall") || !strcmp(argv[1], "remove")) {
         pkg::Package* pkg = root->getPackageById(argv[2]);
         if (!pkg) {
             cerr << "unknown package:" << argv[2] << endl;
@@ -76,6 +76,9 @@ int main(int argc, char** argv)
         BOOST_FOREACH(pkg::Package* p, updates) {
             cout << "\t" << p->id() << " " << p->getLocalisedProp("name") << endl;
         }
+    } else {
+        cerr << "unknown command:" << argv[1] << endl;
+        return EXIT_FAILURE;
     }
     
     while (http->hasActiveRequests()) {

simgear/package/unzip.h

@@ -0,0 +1,360 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+   Version 1.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 Gilles Vollant
+
+   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
+     WinZip, InfoZip tools and compatible.
+
+   Multi volume ZipFile (span) are not supported.
+   Encryption compatible with pkzip 2.04g only supported
+   Old compressions used by old PKZip 1.x are not supported
+
+
+   I WAIT FEEDBACK at mail info@winimage.com
+   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+
+*/
+
+/* for more info about .ZIP format, see
+      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
+      http://www.info-zip.org/pub/infozip/doc/
+   PkWare has also a specification at :
+      ftp://ftp.pkware.com/probdesc.zip
+*/
+
+#ifndef _unz_H
+#define _unz_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__;
+typedef unzFile__ *unzFile;
+#else
+typedef voidp unzFile;
+#endif
+
+
+#define UNZ_OK                          (0)
+#define UNZ_END_OF_LIST_OF_FILE         (-100)
+#define UNZ_ERRNO                       (Z_ERRNO)
+#define UNZ_EOF                         (0)
+#define UNZ_PARAMERROR                  (-102)
+#define UNZ_BADZIPFILE                  (-103)
+#define UNZ_INTERNALERROR               (-104)
+#define UNZ_CRCERROR                    (-105)
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+typedef struct unz_global_info_s
+{
+    uLong number_entry;         /* total number of entries in
+                       the central dir on this disk */
+    uLong size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info;
+
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info_s
+{
+    uLong version;              /* version made by                 2 bytes */
+    uLong version_needed;       /* version needed to extract       2 bytes */
+    uLong flag;                 /* general purpose bit flag        2 bytes */
+    uLong compression_method;   /* compression method              2 bytes */
+    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+    uLong crc;                  /* crc-32                          4 bytes */
+    uLong compressed_size;      /* compressed size                 4 bytes */
+    uLong uncompressed_size;    /* uncompressed size               4 bytes */
+    uLong size_filename;        /* filename length                 2 bytes */
+    uLong size_file_extra;      /* extra field length              2 bytes */
+    uLong size_file_comment;    /* file comment length             2 bytes */
+
+    uLong disk_num_start;       /* disk number start               2 bytes */
+    uLong internal_fa;          /* internal file attributes        2 bytes */
+    uLong external_fa;          /* external file attributes        4 bytes */
+
+    tm_unz tmu_date;
+} unz_file_info;
+
+extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
+                                                 const char* fileName2,
+                                                 int iCaseSensitivity));
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+    (like 1 on Unix, 2 on Windows)
+*/
+
+
+extern unzFile ZEXPORT unzOpen OF((const char *path));
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+     "zlib/zlib113.zip".
+     If the zipfile cannot be opened (file don't exist or in not valid), the
+       return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+       of this unzip package.
+*/
+
+extern unzFile ZEXPORT unzOpen2 OF((const char *path,
+                                    zlib_filefunc_def* pzlib_filefunc_def));
+/*
+   Open a Zip file, like unzOpen, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+extern int ZEXPORT unzClose OF((unzFile file));
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+
+extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+                                        unz_global_info *pglobal_info));
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+
+extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+                                           char *szComment,
+                                           uLong uSizeBuf));
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+extern int ZEXPORT unzLocateFile OF((unzFile file,
+                     const char *szFileName,
+                     int iCaseSensitivity));
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+/* ****************************************** */
+/* Ryan supplied functions */
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_pos_s
+{
+    uLong pos_in_zip_directory;   /* offset in zip file directory */
+    uLong num_of_file;            /* # of file */
+} unz_file_pos;
+
+extern int ZEXPORT unzGetFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+/* ****************************************** */
+
+extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+                         unz_file_info *pfile_info,
+                         char *szFileName,
+                         uLong fileNameBufferSize,
+                         void *extraField,
+                         uLong extraFieldBufferSize,
+                         char *szComment,
+                         uLong commentBufferSize));
+/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+        the current file
+  if szFileName!=NULL, the filemane string will be copied in szFileName
+            (fileNameBufferSize is the size of the buffer)
+  if extraField!=NULL, the extra field information will be copied in extraField
+            (extraFieldBufferSize is the size of the buffer).
+            This is the Central-header version of the extra field
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+            (commentBufferSize is the size of the buffer)
+*/
+
+/***************************************************************************/
+/* for reading the content of the current zipfile, you can open it, read data
+   from it, and close it (you can close it before reading all the file)
+   */
+
+extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
+                                                  const char* password));
+/*
+  Open for reading data the current file in the zipfile.
+  password is a crypting password
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw,
+                                           const char* password));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+
+extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
+                      voidp buf,
+                      unsigned len));
+/*
+  Read bytes from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern z_off_t ZEXPORT unztell OF((unzFile file));
+/*
+  Give the current position in uncompressed data
+*/
+
+extern int ZEXPORT unzeof OF((unzFile file));
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+
+extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+                                             voidp buf,
+                                             unsigned len));
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+
+/***************************************************************************/
+
+/* Get the current file offset */
+extern uLong ZEXPORT unzGetOffset (unzFile file);
+
+/* Set the current file offset */
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _unz_H */