empty docx bugfix

.gitmodules

@@ -4,30 +4,42 @@
 [submodule "cJSON"]
 	path = cJSON
 	url = https://github.com/DaveGamble/cJSON
-[submodule "lib/mupdf"]
-	path = lib/mupdf
-	url = git://git.ghostscript.com/mupdf.git
-[submodule "lib/onion"]
-	path = lib/onion
-	url = https://github.com/davidmoreno/onion
-[submodule "lib/ffmpeg"]
-	path = lib/ffmpeg
-	url = https://git.ffmpeg.org/ffmpeg.git
 [submodule "lmdb"]
 	path = lmdb
 	url = https://github.com/LMDB/lmdb
 [submodule "utf8.h"]
 	path = utf8.h
 	url = https://github.com/sheredom/utf8.h
-[submodule "lib/openjpeg"]
-	path = lib/openjpeg
-	url = https://github.com/uclouvain/openjpeg
-[submodule "lib/harfbuzz"]
-	path = lib/harfbuzz
-	url = https://github.com/harfbuzz/harfbuzz
-[submodule "lib/libmagic"]
-	path = lib/libmagic
-	url = https://github.com/threatstack/libmagic
 [submodule "lib/bzip2-1.0.6"]
 	path = lib/bzip2-1.0.6
 	url = https://github.com/enthought/bzip2-1.0.6
+[submodule "lib/libmagic"]
+	path = lib/libmagic
+	url = https://github.com/threatstack/libmagic
+[submodule "lib/harfbuzz"]
+	path = lib/harfbuzz
+	url = https://github.com/harfbuzz/harfbuzz
+[submodule "lib/openjpeg"]
+	path = lib/openjpeg
+	url = https://github.com/uclouvain/openjpeg
+[submodule "lib/ffmpeg"]
+	path = lib/ffmpeg
+	url = https://git.ffmpeg.org/ffmpeg.git
+[submodule "lib/onion"]
+	path = lib/onion
+	url = https://github.com/davidmoreno/onion
+[submodule "lib/mupdf"]
+	path = lib/mupdf
+	url = git://git.ghostscript.com/mupdf.git
+[submodule "lib/zstd"]
+	path = lib/zstd
+	url = https://github.com/facebook/zstd
+[submodule "lib/lz4"]
+	path = lib/lz4
+	url = https://github.com/lz4/lz4
+[submodule "lib/libarchive"]
+	path = lib/libarchive
+	url = https://github.com/libarchive/libarchive
+[submodule "lib/libxml2"]
+	path = lib/libxml2
+	url = https://github.com/GNOME/libxml2

CMakeLists.txt

@@ -41,7 +41,7 @@ if (WITH_SIST2)
 
             # utf8.h
             utf8.h/utf8.h
-    )
+            src/parsing/arc.c src/parsing/arc.h src/parsing/doc.c src/parsing/doc.h)
 endif ()
 
 if (WITH_SIST2_SCAN)
@@ -74,7 +74,7 @@ if (WITH_SIST2_SCAN)
 
             # utf8.h
             utf8.h/utf8.h
-    )
+            src/parsing/arc.c src/parsing/arc.h src/parsing/doc.c src/parsing/doc.h)
 endif ()
 
 find_package(PkgConfig REQUIRED)
@@ -113,6 +113,8 @@ if (WITH_SIST2)
             ${PROJECT_SOURCE_DIR}/lmdb/libraries/liblmdb/
             ${PROJECT_SOURCE_DIR}/lib/onion/src/
             ${PROJECT_SOURCE_DIR}/lib/mupdf/include/
+            ${PROJECT_SOURCE_DIR}/include/
+            /usr/include/libxml2/
     )
     target_link_directories(
             sist2 PUBLIC
@@ -157,9 +159,16 @@ if (WITH_SIST2)
             m
             bz2
             magic
-            harfbuzz
-            openjp2
+            ${PROJECT_SOURCE_DIR}/lib/libharfbuzz.a
+            ${PROJECT_SOURCE_DIR}/lib/libopenjp2.a
             freetype
+            archive
+
+#            ${PROJECT_SOURCE_DIR}/lib/libxml2.a
+            xml2
+            ${PROJECT_SOURCE_DIR}/lib/libopc/libmce.a
+            ${PROJECT_SOURCE_DIR}/lib/libopc/libopc.a
+            ${PROJECT_SOURCE_DIR}/lib/libopc/libplib.a
     )
 
 endif ()
@@ -189,6 +198,8 @@ if (WITH_SIST2_SCAN)
             ${PROJECT_SOURCE_DIR}/lmdb/libraries/liblmdb/
             ${PROJECT_SOURCE_DIR}/lib/onion/src/
             ${PROJECT_SOURCE_DIR}/lib/mupdf/include/
+            ${PROJECT_SOURCE_DIR}/include/
+            /usr/include/libxml2/
     )
     target_link_directories(
             sist2_scan PUBLIC
@@ -228,6 +239,16 @@ if (WITH_SIST2_SCAN)
             ${PROJECT_SOURCE_DIR}/lib/libharfbuzz.a
             ${PROJECT_SOURCE_DIR}/lib/libopenjp2.a
             freetype
+
+            ${PROJECT_SOURCE_DIR}/lib/libarchive.a
+            ${PROJECT_SOURCE_DIR}/lib/liblz4.a
+            ${PROJECT_SOURCE_DIR}/lib/liblzma.a
+            ${PROJECT_SOURCE_DIR}/lib/libzstd.a
+
+            ${PROJECT_SOURCE_DIR}/lib/libxml2.a
+            ${PROJECT_SOURCE_DIR}/lib/libopc/libmce.a
+            ${PROJECT_SOURCE_DIR}/lib/libopc/libopc.a
+            ${PROJECT_SOURCE_DIR}/lib/libopc/libplib.a
     )
 endif ()
 

Docker/Dockerfile

@@ -2,7 +2,7 @@ FROM ubuntu:19.10
 MAINTAINER simon987 <me@simon987.net>
 
 RUN apt update
-RUN apt install -y libglib2.0-0 libcurl4 libmagic1 libharfbuzz-bin libopenjp2-7
+RUN apt install -y libglib2.0-0 libcurl4 libmagic1 libharfbuzz-bin libopenjp2-7 libarchive13 liblzma5 libzstd1 liblz4-1
 
 ADD sist2 /root/sist2
 

README.md

@@ -15,9 +15,11 @@ sist2 (Simple incremental search tool)
 * Generates thumbnails\*
 * Incremental scanning
 * Automatic tagging from file attributes via [user scripts](scripting/README.md)
+* Recursive scan inside archive files \*\*
 
 
-\* See [format support](#format-support)
+\* See [format support](#format-support)    
+\** See [Archive files](#archive-files)
 
 ## Getting Started
 
@@ -33,8 +35,6 @@ sist2 (Simple incremental search tool)
 
 ## Example usage
 
-![demo](demo.gif)
-
 See help page `sist2 --help` for more details.
 
 **Scan a directory**
@@ -91,9 +91,25 @@ pdf,xps,cbz,fb2,epub | MuPDF | yes | yes, `png` | title |
 `image/*` | ffmpeg | - | yes, `jpeg` | `EXIF:Artist`, `EXIF:ImageDescription` |
 ttf,ttc,cff,woff,fnt,otf | Freetype2 | - | yes, `bmp` | Name & style |
 `text/plain` | *(none)* | yes | no | - |
-docx, xlsx, pptx |  | *planned* | no | *planned* |
+tar, zip, rar, 7z, ar ...  | Libarchive | yes\* | - | no |
+docx, xlsx, pptx | libOPC | yes | no | no |
 
+\* *See [Archive files](#archive-files)*
+ 
+### Archive files
+**sist2** will scan files stored into archive files (zip, tar, 7z...) as if
+they were directly in the file system. Recursive (archives inside archives)
+scan is also supported.
 
+**Limitations**:
+* Parsing media files with formats that require
+*seek* (e.g. `.gif`, `.mp4` w/ fragmented metadata etc.) is not supported.
+* Archive files are scanned sequentially, by a single thread. On systems where
+**sist2** is not I/O bound, scans might be faster when larger archives are split
+ into smaller parts.
+
+To check if a media file can be parsed without *seek*, execute `cat file.mp4 | ffprobe -`
+ 
 
 
 ## Build from source
@@ -108,12 +124,12 @@ binaries.
     apt install git cmake pkg-config libglib2.0-dev\
         libssl-dev uuid-dev libavformat-dev libswscale-dev \
         python3 libmagic-dev libfreetype6-dev libcurl-dev \
-        libbz2-dev yasm libharfbuzz-dev ragel
+        libbz2-dev yasm libharfbuzz-dev ragel libarchive-dev
    ```
     *(FreeBSD)*
     ```bash
    pkg install cmake gcc yasm gmake bash ffmpeg e2fsprogs-uuid\
-        autotools ragel
+        autotools ragel libarchive
    ```
 
 2. Build
@@ -122,4 +138,4 @@ binaries.
     ./scripts/get_static_libs.sh
     cmake .
     make
-    ```
+    ```

include/mce/config.h

@@ -0,0 +1,53 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the 
+ distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+ may be used to endorse or promote products derived from this 
+ software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/**@file config/mce/config.h
+ */
+#ifndef MCE_CONFIG_H
+#define MCE_CONFIG_H
+
+#include <libxml/xmlstring.h>
+#include <stdio.h>
+#include <plib/plib.h>
+#include <assert.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MCE_NAMESPACE_SUBSUMPTION_ENABLED 0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif  
+
+#endif /* MCE_CONFIG_H */

include/mce/helper.h

@@ -0,0 +1,189 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file mce/helper.h
+Helper functions needed by mce/textreader.h and mce/textwriter.h to implement MCE:
+- mceQNameLevelAdd(), mceQNameLevelLookup() and mceQNameLevelCleanup() maintain a set of mceQNameLevel_t tuples.
+- mceQNameLevelPush() and mceQNameLevelPopIfMatch() maintain a stack of mceQNameLevel_t tuples.
+- mceCtxInit(), mceCtxCleanup() and mceCtxUnderstandsNamespace() manage a context which holds all information needed to do MCE proprocessing.
+ */
+#include <mce/config.h>
+
+#ifndef MCE_HELPER_H
+#define MCE_HELPER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+      Tiple (ns, ln, level).
+    */
+    typedef struct MCE_QNAME_LEVEL {
+        xmlChar *ns;
+        xmlChar *ln;
+        puint32_t level;
+        puint32_t flag; // used by mceTextWriter
+    } mceQNameLevel_t;
+
+    /**
+     */
+    typedef enum MCE_SKIP_STATE_ENUM {
+        MCE_SKIP_STATE_IGNORE,
+        MCE_SKIP_STATE_ALTERNATE_CONTENT,
+        MCE_SKIP_STATE_CHOICE_MATCHED
+    } mceSkipState_t;
+
+    /**
+     Represents an intervall of levels which are "skipped" i.e. ignored.
+     */
+    typedef struct MCE_SKIP_ITEM {
+        puint32_t level_start;
+        puint32_t level_end;
+        mceSkipState_t state;
+    } mceSkipItem_t;
+
+    /**
+      Either represents a set of (ns, ln, level) triples.
+    */
+    typedef struct MCE_QNAME_LEVEL_SET {
+        mceQNameLevel_t *list_array;
+        puint32_t list_items;
+        puint32_t max_level;
+    } mceQNameLevelSet_t;
+
+    /**
+     The skip stack.
+     */
+    typedef struct MCE_SKIP_STACK {
+        mceSkipItem_t *stack_array;
+        puint32_t stack_items;
+    } mceSkipStack_t;
+
+
+    typedef enum MCE_ERROR_ENUM {
+        MCE_ERROR_NONE,
+        MCE_ERROR_XML,
+        MCE_ERROR_MUST_UNDERSTAND,
+        MCE_ERROR_VALIDATION,
+        MCE_ERROR_MEMORY
+    } mceError_t;
+
+    /**
+      Holds all information to do MCE preprocessing.
+    */
+    typedef struct MCE_CONTEXT {
+        mceQNameLevelSet_t ignorable_set;
+        mceQNameLevelSet_t understands_set;
+        mceQNameLevelSet_t processcontent_set;
+        mceQNameLevelSet_t suspended_set;
+#if (MCE_NAMESPACE_SUBSUMPTION_ENABLED)
+        mceQNameLevelSet_t subsume_namespace_set;
+        mceQNameLevelSet_t subsume_exclude_set;
+        mceQNameLevelSet_t subsume_prefix_set;
+#endif
+        mceSkipStack_t skip_stack;
+        mceError_t error;
+        pbool_t mce_disabled;        
+        puint32_t suspended_level;
+    } mceCtx_t;
+
+    /**
+      Add a new tiple (ns, ln, level) to the triple set \c qname_level_set.
+      The \c ns_sub string is optional and will not be touched.
+    */
+    pbool_t mceQNameLevelAdd(mceQNameLevelSet_t *qname_level_set, const xmlChar *ns, const xmlChar *ln, puint32_t level);
+
+    /**
+      Lookup a tiple (ns, ln, level) via \c ns and \c ln. If \c ignore_ln is PTRUE then the first tiple matching \c ns will be returned.
+    */
+    mceQNameLevel_t* mceQNameLevelLookup(mceQNameLevelSet_t *qname_level_set, const xmlChar *ns, const xmlChar *ln, pbool_t ignore_ln);
+
+    /**
+      Remove all triples (ns, ln, level) where the level greater or equal to \c level.
+    */
+    pbool_t mceQNameLevelCleanup(mceQNameLevelSet_t *qname_level_set, puint32_t level);
+
+    /**
+      Push a new skip intervall (level_start, level_end, state) on the stack \c skip_stack.
+    */
+    pbool_t mceSkipStackPush(mceSkipStack_t *skip_stack, puint32_t level_start, puint32_t level_end, mceSkipState_t state);
+
+    /**
+      Pop the intervall (ns, ln, level) from the stack \c qname_level_array.
+    */
+    void mceSkipStackPop(mceSkipStack_t *skip_stack);
+
+    /**
+     Returns top item or NULL.
+     */
+    mceSkipItem_t *mceSkipStackTop(mceSkipStack_t *skip_stack);
+
+    /**
+     Returns TRUE, if the \c level is in the top skip intervall.
+     */
+    pbool_t mceSkipStackSkip(mceSkipStack_t *skip_stack, puint32_t level);
+
+    /**
+      Initialize the mceCtx_t \c ctx.
+    */
+    pbool_t mceCtxInit(mceCtx_t *ctx);
+
+    /**
+      Cleanup, i.e. release all resourced from the mceCtx_t \c ctx.
+    */
+    pbool_t mceCtxCleanup(mceCtx_t *ctx);
+
+    /**
+      Register the namespace \ns in \c ctx.
+    */
+    pbool_t mceCtxUnderstandsNamespace(mceCtx_t *ctx, const xmlChar *ns);
+
+    /**
+     Register the namespace \ns in \c ctx.
+     */
+    pbool_t mceCtxSuspendProcessing(mceCtx_t *ctx, const xmlChar *ns, const xmlChar *ln);
+    
+
+
+#if (MCE_NAMESPACE_SUBSUMPTION_ENABLED)
+    /**
+    Subsume namespace \c ns_new with \c ns_old.
+     */
+    pbool_t mceCtxSubsumeNamespace(mceCtx_t *ctx, const xmlChar *prefix_new, const xmlChar *ns_new, const xmlChar *ns_old);
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* MCE_HELPER_H */

include/mce/textreader.h

@@ -0,0 +1,464 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file mce/textreader.h
+ 
+ */
+#ifndef MCE_TEXTREADER_H
+#define MCE_TEXTREADER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+      A handle to an MCE-aware libxml2 xmlTextReader.
+    */
+    typedef struct MCE_TEXTREADER mceTextReader_t;
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#include <mce/config.h>
+#include <opc/opc.h>
+#include <mce/helper.h>
+#include <libxml/xmlwriter.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    struct MCE_TEXTREADER {
+        xmlTextReaderPtr reader;
+        mceCtx_t mceCtx;
+    };
+
+    /**
+      Wrapper around an libxml2 xmlTextReaderRead function.
+      \see http://xmlsoft.org/html/libxml-xmlreader.html#xmlTextReaderRead
+    */
+    int mceTextReaderRead(mceTextReader_t *mceTextReader);
+
+    /**
+      Wrapper around a libxml2 xmlTextReaderNext function.
+      \see http://xmlsoft.org/html/libxml-xmlreader.html#xmlTextReaderNext
+    */
+    int mceTextReaderNext(mceTextReader_t *mceTextReader);
+
+    /** 
+      Creates an mceTextReader from an XmlTextReader. 
+      \code
+      mceTextReader reader;
+      mceTextReaderInit(&reader, xmlNewTextReaderFilename("sample.xml"));
+      // reader is ready to use.
+      mceTextReaderCleanup(&reader);
+      \endcode
+      \see http://xmlsoft.org/html/libxml-xmlreader.html#xmlNewTextReaderFilename
+    */
+    int mceTextReaderInit(mceTextReader_t *mceTextReader, xmlTextReaderPtr reader);
+
+    /**
+      Cleanup MCE reader, i.e. free all resources. Also calls xmlTextReaderClose and xmlFreeTextReader.
+      \see http://xmlsoft.org/html/libxml-xmlreader.html#xmlTextReaderClose
+      \see http://xmlsoft.org/html/libxml-xmlreader.html#xmlFreeTextReader
+    */
+    int mceTextReaderCleanup(mceTextReader_t *mceTextReader);
+
+    /** 
+      Reads all events \c mceTextReader and pipes them to \writer.
+      \code
+      mceTextReader reader;
+      mceTextReaderInit(&reader, xmlNewTextReaderFilename("sample.xml"));
+      mceTextReaderUnderstandsNamespace(&reader, _X("http://myextension"));
+      xmlTextWriterPtr writer=xmlNewTextWriterFilename("out.xml", 0);
+      mceTextReaderDump(&reader, writer, P_FALSE);
+      xmlFreeTextWriter(writer);
+      mceTextReaderCleanup(&reader);
+      \endcode
+      */
+    int mceTextReaderDump(mceTextReader_t *mceTextReader, xmlTextWriter *writer, pbool_t fragment);
+
+    /**
+      Registers an MCE namespace.
+      \see mceTextReaderDump()
+      */
+    int mceTextReaderUnderstandsNamespace(mceTextReader_t *mceTextReader, const xmlChar *ns);
+
+    /**
+     Disable MCE processing.
+     \return Returns old value.
+     */
+    pbool_t mceTextReaderDisableMCE(mceTextReader_t *mceTextReader, pbool_t flag);
+
+
+    /**
+     Signal an error to the MCE processor.
+     */
+    void mceRaiseError(xmlTextReader *reader, mceCtx_t *ctx, mceError_t error, const xmlChar *str, ...);
+
+    /**
+        Internal function which does the MCE postprocessing. E.g. mceTextReaderRead() is implemented as
+        \code
+        mceTextReaderPostprocess(mceTextReader->reader, &mceTextReader->mceCtx, xmlTextReaderRead(mceTextReader->reader))
+        \endcode
+        This function is exposed to make existing libxm2 xmlTextReader MCE aware.
+    */
+    int mceTextReaderPostprocess(xmlTextReader *reader, mceCtx_t *ctx, int ret);
+
+    /**
+     Get the error code.
+     */
+    mceError_t mceTextReaderGetError(mceTextReader_t *mceTextReader);
+
+/**
+ Helper macro to declare a start/end document block in a declarative way:
+ \code
+  mce_start_document(reader) {
+  } mce_end_document(reader);
+  \endcode
+  \hideinitializer
+*/
+#define mce_start_document(_reader_) \
+    if (NULL!=(_reader_)) {            \
+        mceTextReaderRead(_reader_); \
+        if (0)                     
+
+/**
+  \see mce_start_document.
+  \hideinitializer
+*/
+#define mce_end_document(_reader_)   \
+    } /* if (NULL!=reader) */        \
+
+
+/**
+  Container for mce_start_element and mce_start_attribute declarations.
+  \see mce_match_element
+  \see mce_match_attribute
+  \hideinitializer
+  */
+#define mce_start_choice(_reader_)  \
+    if (0)                          
+
+/**
+  \see mce_start_choice
+  \hideinitializer
+  */
+#define mce_end_choice(_reader_) 
+
+
+/**
+  Skips the attributes. 
+  \see mce_match_element.
+  \hideinitializer
+*/
+#define mce_skip_attributes(_reader_) \
+    mce_start_attributes(_reader_) {  \
+    } mce_end_attributes(_reader_);   
+
+
+/**
+  Skips the attributes. 
+  \see mce_match_attribute.
+  \hideinitializer
+*/
+#define mce_skip_children(_reader_) \
+    mce_start_children(_reader_) {  \
+    } mce_end_children(_reader_);   
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_start_children(_reader_)                  \
+if (!xmlTextReaderIsEmptyElement((_reader_)->reader)) { \
+    mceTextReaderRead(_reader_); do {                 \
+        if (0)                                        
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_end_children(_reader_)                                                      \
+        else {                                                                          \
+            if (XML_READER_TYPE_END_ELEMENT!=xmlTextReaderNodeType((_reader_)->reader)) { \
+                mceTextReaderNext(_reader_); /*skip unhandled element */                \
+            }                                                                           \
+        }                                                                               \
+    } while(XML_READER_TYPE_END_ELEMENT!=xmlTextReaderNodeType((_reader_)->reader) &&     \
+            XML_READER_TYPE_NONE!=xmlTextReaderNodeType((_reader_)->reader));             \
+} /* if (!xmlTextReaderIsEmptyElement(reader->reader)) */                               
+
+
+/**
+  Helper macro to match an element. Usefull for calling code in a seperate function:
+
+  \code
+  void handleElement(reader) {
+    mce_start_choice(reader) {
+        mce_start_element(reader, _X("ns"), _X("element")) {
+            
+        } mce_end_element(reader)
+    } mce_end_choice(reader);
+  }
+
+  void parse(reader) {
+    mce_start_document(reader) {
+      mce_start_element(reader, _X("ns"), _X("ln")) {
+        mce_skip_attributes(reader);
+        mce_start_children(reader) {
+           mce_match_element(reader, _X("ns"), _X("element")) {
+             handleElement(reader);
+           }
+        } mce_end_children(reader);
+      } mce_end_element();
+    } mce_end_document(reader);
+  }
+  \endcode
+  \hideinitializer
+*/
+#define mce_match_element(_reader_, ns, ln)                                                       \
+    } else if (XML_READER_TYPE_ELEMENT==xmlTextReaderNodeType((_reader_)->reader)                 \
+            && (NULL==ns || 0==xmlStrcmp(ns, xmlTextReaderConstNamespaceUri((_reader_)->reader))) \
+            && (NULL==ln || 0==xmlStrcmp(ln, xmlTextReaderConstLocalName((_reader_)->reader)))) { 
+
+
+/**
+ Helper macro to declare a element block in a declarative way:
+ \code
+  mce_start_element(reader) {
+    mce_start_attributes(reader) {
+      mce_start_attribute(reader, _X("ns"), _X("lnA")) {
+         // code for handling lnA.
+      } mce_end_attribute(reader);
+      mce_start_attribute(reader, _X("ns"), _X("lnB")) {
+         // code for handling lnB.
+      } mce_end_attribute(reader);
+    } mce_end_attributes(reader);
+    mce_start_children(reader) {
+        mce_start_element(reader, _X("ns"), _X("lnA")) {
+         // code for handling lnA.
+        } mce_end_element(reader);
+        mce_start_element(reader, _X("ns"), _X("lnB")) {
+         // code for handling lnB.
+        } mce_end_element(reader);
+        mce_start_text(reader) {
+         // code for handling text.
+        } mce_end_text(reader);
+    } mce_end_children(reader);
+  } mce_end_element(reader);
+  \endcode
+  \hideinitializer
+*/
+#define mce_start_element(_reader_, ns, ln) \
+    mce_match_element(_reader_, ns, ln)     
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_end_element(_reader_) \
+    mceTextReaderNext(_reader_)   
+
+/**
+  Matches #TEXT without consuming it.
+  \hideinitializer
+*/
+#define mce_match_text(_reader_)                                                                   \
+    } else if (XML_READER_TYPE_TEXT==xmlTextReaderNodeType((_reader_)->reader)                     \
+            || XML_READER_TYPE_SIGNIFICANT_WHITESPACE==xmlTextReaderNodeType((_reader_)->reader)) {
+
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_start_text(_reader_) \
+    mce_match_text(_reader_)      
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_end_text(_reader_) \
+    mceTextReaderNext(_reader_)
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_start_attributes(_reader_)                            \
+    if (1==xmlTextReaderMoveToFirstAttribute((_reader_)->reader)) { \
+        do {                                                      \
+            if (0)                                                
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_end_attributes(_reader_)                                    \
+            else { /* skipped attribute */ }                            \
+        } while(1==xmlTextReaderMoveToNextAttribute((_reader_)->reader)); \
+    xmlTextReaderMoveToElement((_reader_)->reader); }                     
+
+/**
+  Helper macro to match an attribute. Usefull for calling code in a seperate function:
+
+  \code
+  void handleA(reader) {
+    mce_start_choice(reader) {
+        mce_start_attribute(reader, _X("ns"), _X("attr")) {
+
+        } mce_end_attribute(reader);
+    } mce_end_choice(reader);
+  }
+
+  void parse(reader) {
+    mce_start_document(reader) {
+      mce_start_element(reader, _X("ns"), _X("ln")) {
+        mce_start_attributes(reader) {
+           mce_match_attribute(reader, _X("ns"), _X("attr")) {
+             handleA(reader);
+           }
+        } mce_end_attributes(reader);
+        mce_skip_children(reader);
+      } mce_end_element();
+    } mce_end_document(reader);
+  }
+  \endcode
+  \hideinitializer
+*/
+#define mce_match_attribute(_reader_, ns, ln)                                                   \
+    } else if ((NULL==ns || 0==xmlStrcmp(ns, xmlTextReaderConstNamespaceUri((_reader_)->reader))) \
+            && (NULL==ln || 0==xmlStrcmp(ln, xmlTextReaderConstLocalName((_reader_)->reader)))) { 
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_start_attribute(_reader_, ns, ln) \
+    mce_match_attribute(_reader_, ns, ln) 
+
+/**
+  \see mce_start_element.
+  \hideinitializer
+*/
+#define mce_end_attribute(_reader_)
+
+
+/**
+  Error handling for MCE parsers.
+  \code
+   mce_start_element(&reader, NULL, _X("Default")) {
+       const xmlChar *ext=NULL;
+       const xmlChar *type=NULL;
+       mce_start_attributes(&reader) {
+           mce_start_attribute(&reader, NULL, _X("Extension")) {
+               ext=xmlTextReaderConstValue(reader.reader);
+           } mce_end_attribute(&reader);
+           mce_start_attribute(&reader, NULL, _X("ContentType")) {
+               type=xmlTextReaderConstValue(reader.reader);
+           } mce_end_attribute(&reader);
+       } mce_end_attributes(&reader);
+       mce_error_guard_start(&reader) {
+           mce_error(&reader, NULL==ext || ext[0]==0, MCE_ERROR_VALIDATION, "Missing @Extension attribute!");
+           mce_error(&reader, NULL==type || type[0]==0, MCE_ERROR_VALIDATION, "Missing @ContentType attribute!");
+           opcContainerType *ct=insertType(c, type, OPC_TRUE);
+           mce_error(&reader, NULL==ct, MCE_ERROR_MEMORY, NULL);
+           opcContainerExtension *ce=opcContainerInsertExtension(c, ext, OPC_TRUE);
+           mce_error(&reader, NULL==ce, MCE_ERROR_MEMORY, NULL);
+           mce_errorf(&reader, NULL!=ce->type && 0!=xmlStrcmp(ce->type, type), MCE_ERROR_VALIDATION, "Extension \"%s\" is mapped to type \"%s\" as well as \"%s\"", ext, type, ce->type);
+           ce->type=ct->type;
+       } mce_error_guard_end(&reader);
+       mce_skip_children(&reader);
+   } mce_end_element(&reader);
+  \endcode
+  \hideinitializer
+*/
+#define mce_error_guard_start(_reader_) if (MCE_ERROR_NONE==(_reader_)->mceCtx.error) do {
+
+/**
+  \see mce_error_guard_start
+  \hideinitializer
+*/
+#define mce_error_guard_end(_reader_)  } while(0)
+
+/**
+  Signal an error if guard if false.
+  \hideinitializer
+*/
+#define mce_error(_reader_, guard, err, msg) if (guard) { (_reader_)->mceCtx.error=(err); fprintf(stderr, (NULL!=msg?msg:#err));  continue; }
+
+/**
+  Signal an error if guard if false.
+  \hideinitializer
+*/
+#if defined(__GNUC__)
+#define mce_errorf(_reader_, guard, err, msg, ...) if (guard) { mceRaiseError((_reader_)->reader, &(_reader_)->mceCtx, err, _X((NULL!=msg?msg:#err)), ##__VA_ARGS__ );  continue; }
+#else
+#define mce_errorf(_reader_, guard, err, msg, ...) if (guard) { mceRaiseError((_reader_)->reader, &(_reader_)->mceCtx, err, _X((NULL!=msg?msg:#err)), __VA_ARGS__ );  continue; }
+#endif
+
+/**
+  Only issues the error when in "strict mode".
+  \hideinitializer
+*/
+#define mce_error_strict mce_error
+
+/**
+  \see mce_error_strict
+  \hideinitializer
+*/
+#define mce_error_strictf mce_errorf
+
+
+/**
+  Marker for a MCE defintion.
+  \hideinitializer
+*/
+#define mce_def
+
+/**
+  Marker for a MCE reference.
+  \hideinitializer
+*/
+#define mce_ref(r) (r)
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* MCE_TEXTREADER_H */

include/mce/textwriter.h

@@ -0,0 +1,176 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file mce/textwriter.h
+
+*/
+#include <mce/config.h>
+#include <libxml/xmlwriter.h>
+#include <mce/helper.h>
+
+#ifndef MCE_TEXTWRITER_H
+#define MCE_TEXTWRITER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+/**
+  Default flags for an MCE namespace declaration.
+  */
+#define MCE_DEFAULT 0x0
+
+/**
+  Flags MCE namespace declaration "ignorable".
+  */
+#define MCE_IGNORABLE 0x1
+
+/**
+  Flags MCE namespace declaration "must understand".
+  */
+#define MCE_MUSTUNDERSTAND 0x2
+
+    /**
+      The MCE text writer context.
+      */
+    typedef struct MCE_TEXTWRITER_STRUCT mceTextWriter;
+
+    /**
+      Create a new MCE text writer.
+      \see http://xmlsoft.org/html/libxml-xmlIO.html#xmlOutputBufferCreateIO
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlNewTextWriter
+      */
+    mceTextWriter *mceTextWriterCreateIO(xmlOutputWriteCallback iowrite, xmlOutputCloseCallback  ioclose, void *ioctx, xmlCharEncodingHandlerPtr encoder);
+
+    /**
+      Helper which create a new MCE text writer for a FILE handle.
+      */
+    mceTextWriter *mceNewTextWriterFile(FILE *file);
+
+    /**
+      Free all resources for \w.
+      */
+    int mceTextWriterFree(mceTextWriter *w);
+
+    /**
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterStartDocument
+      */
+    int mceTextWriterStartDocument(mceTextWriter *w);
+
+    /**
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterEndDocument
+      */
+    int mceTextWriterEndDocument(mceTextWriter *w);
+
+    /**
+      Start a new XML element. If ns==NULL then there is no namespace and ""==ns means the default namespace.
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterStartElement
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterStartElementNS
+      */
+    int mceTextWriterStartElement(mceTextWriter *w, const xmlChar *ns, const xmlChar *ln);
+
+    /**
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterEndElement
+      */
+    int mceTextWriterEndElement(mceTextWriter *w, const xmlChar *ns, const xmlChar *ln);
+
+    /**
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterWriteString
+      */
+    int mceTextWriterWriteString(mceTextWriter *w, const xmlChar *content);
+
+    /**
+      Register a namespace. Must be called before mceTextWriterStartElement.
+      \see MCE_DEFAULT
+      \see MCE_IGNORABLE
+      \see MCE_MUSTUNDERSTAND
+      */
+    const xmlChar *mceTextWriterRegisterNamespace(mceTextWriter *w, const xmlChar *ns, const xmlChar *prefix, int flags);
+
+    /**
+      Register qname (ns, ln) as a "process content" element wrt. MCE. Must be called before mceTextWriterStartElement.
+      */
+    int mceTextWriterProcessContent(mceTextWriter *w, const xmlChar *ns, const xmlChar *ln);
+
+    /**
+      Writes a formatted attribute.
+      \see http://xmlsoft.org/html/libxml-xmlwriter.html#xmlTextWriterWriteFormatAttribute
+      */
+    int mceTextWriterAttributeF(mceTextWriter *w, const xmlChar *ns, const xmlChar *ln, const char *value, ...);
+
+    /**
+      Starts an MCE alternate content section.
+      */
+    int mceTextWriterStartAlternateContent(mceTextWriter *w);
+
+    /**
+      Ends an MCE alternate content section.
+      */
+    int mceTextWriterEndAlternateContent(mceTextWriter *w);
+
+    /**
+      Start an MCE choice.
+      */
+    int mceTextWriterStartChoice(mceTextWriter *w, const xmlChar *ns);
+
+    /**
+      Ends an MCE choice.
+      */
+    int mceTextWriterEndChoice(mceTextWriter *w);
+
+    /**
+      Start an MCE fallback.
+      */
+    int mceTextWriterStartFallback(mceTextWriter *w);
+
+    /**
+      Ends an MCE fallback.
+      */
+    int mceTextWriterEndFallback(mceTextWriter *w);
+
+
+    /**
+      Returns the underlying xmlTextWriter.
+      */
+    xmlTextWriterPtr mceTextWriterIntern(mceTextWriter *w);
+
+    /**
+      Helper which create a new xmlTextWriterPtr for a FILE handle.
+      */
+    xmlTextWriterPtr xmlNewTextWriterFile(FILE *file);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+
+#endif /* MCE_TEXTWRITER_H */

include/opc/config.h

@@ -0,0 +1,189 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the 
+ distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+ may be used to endorse or promote products derived from this 
+ software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/**@file config/opc/config.h
+ */
+#ifndef OPC_CONFIG_H
+#define OPC_CONFIG_H
+
+#include <libxml/xmlstring.h>
+#include <plib/plib.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif   
+
+
+/**
+  Assert expression e is true. Will be removed entirely in release mode.
+  \hideinitializer
+ */
+#define OPC_ASSERT(e) assert(e)
+
+/**
+  Assert expression e is true. Expression will be executed in release mode too.
+  \hideinitializer
+ */
+#ifdef NDEBUG
+#define OPC_ENSURE(e) (void)(e)
+#else
+#define OPC_ENSURE(e) assert(e)
+#endif
+
+
+/**
+  Constant for boolean true.
+  \hideinitializer
+ */
+#define OPC_TRUE (0==0)
+
+/**
+  Constant for boolean false.
+  \hideinitializer
+ */
+#define OPC_FALSE (0==1)
+
+    /** 
+      Boolean type.
+      \hideinitializer
+      */
+    typedef pbool_t opc_bool_t;
+
+    /** 
+      Type which represents an offset in e.g. a file.
+      \hideinitializer
+      */
+    typedef pofs_t opc_ofs_t;
+
+    /** 
+      8-bit unsigned integer.
+      \hideinitializer
+      */
+    typedef puint8_t opc_uint8_t;
+
+    /** 
+      16-bit unsigned integer.
+      \hideinitializer
+      */
+    typedef puint16_t opc_uint16_t;
+
+    /** 
+      32-bit unsigned integer.
+      \hideinitializer
+      */
+    typedef puint32_t opc_uint32_t;
+
+    /** 
+      64-bit unsigned integer.
+      \hideinitializer
+      */
+    typedef puint64_t opc_uint64_t;
+
+    /** 
+      8-bit signed integer.
+      \hideinitializer
+      */
+    typedef pint8_t opc_int8_t;
+
+    /** 
+      16-bit signed integer.
+      \hideinitializer
+      */
+    typedef pint16_t opc_int16_t;
+
+    /** 
+      32-bit signed integer.
+      \hideinitializer
+      */
+    typedef pint32_t opc_int32_t;
+
+    /** 
+      64-bit signed integer.
+      \hideinitializer
+      */
+    typedef pint64_t opc_int64_t;
+
+/**
+  Default size fo the deflate buffer used by zlib.
+  */
+#define OPC_DEFLATE_BUFFER_SIZE 4096
+
+/**
+  Max system path len.
+  */
+#define OPC_MAX_PATH 512
+
+    /**
+      Error codes for the OPC module.
+      */
+    typedef enum OPC_ERROR_ENUM {
+        OPC_ERROR_NONE,
+        OPC_ERROR_STREAM,
+        OPC_ERROR_SEEK, // can't seek
+        OPC_ERROR_UNSUPPORTED_DATA_DESCRIPTOR,
+        OPC_ERROR_UNSUPPORTED_COMPRESSION,
+        OPC_ERROR_DEFLATE,
+        OPC_ERROR_HEADER,
+        OPC_ERROR_MEMORY,
+        OPC_ERROR_XML, 
+        OPC_ERROR_USER // user triggered an abort
+    } opc_error_t;
+    
+    /**
+      Compression options for OPC streams.
+      */
+    typedef enum OPC_COMPRESSIONOPTION_ENUM {
+        OPC_COMPRESSIONOPTION_NONE,
+        OPC_COMPRESSIONOPTION_NORMAL,
+        OPC_COMPRESSIONOPTION_MAXIMUM,
+        OPC_COMPRESSIONOPTION_FAST,
+        OPC_COMPRESSIONOPTION_SUPERFAST
+    } opcCompressionOption_t;
+
+
+/**
+  Helper for debug logs.
+  \hideinitializer
+  */
+#define opc_logf printf
+
+/**
+  Abstraction for memset(m, 0, s).
+  \hideinitializer
+ */
+#define opc_bzero_mem(m,s) memset(m, 0, s)
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif  
+
+#endif /* OPC_CONFIG_H */

include/opc/container.h

@@ -0,0 +1,300 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/container.h
+
+ The container.h module has the fundamental methods for dealing with ZIP-based OPC container. 
+ 
+ OPC container can be opened in READ-ONLY mode, WRITE-ONLY mode, READ/WRITE mode, TEMPLATE mode and TRANSITION mode. 
+ The most notable mode is the READ/WRITE mode, which gives you concurrent stream-based READ and WRITE access to a 
+ single ZIP-based OPC container. This is achieved without the use of temporary files by taking advantage of the 
+ OPC specific “interleave” mode. \see http://standards.iso.org/ittf/PubliclyAvailableStandards/c051459_ISOIEC_29500-2_2008(E).zip
+ 
+ The TEMPLATE mode allows very fast customized "cloning" of ZIP-based OPC container by using "RAW access" to the ZIP streams. 
+ The TRANSITION mode is a special version of the TEMPLATE mode, which allows transition-based READ/WRITE access to the 
+ ZIP-based OPC container using a temporary file.
+ 
+ */
+#include <opc/config.h>
+#include <opc/file.h>
+
+#ifndef OPC_CONTAINER_H
+#define OPC_CONTAINER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+    /**
+     Handle to an OPC container created by \ref opcContainerOpen.
+     \see opcContainerOpen.
+     */
+    typedef struct OPC_CONTAINER_STRUCT opcContainer;
+    
+    /**
+     Modes for opcContainerOpen();
+     \see opcContainerOpen
+     */
+    typedef enum {
+        /**
+         Opens the OPC container denoted by \a fileName in READ-ONLY mode. The \a destName parameter must be \a NULL.
+         \hideinitializer
+         */
+        OPC_OPEN_READ_ONLY=0, 
+        /**
+         Opens the OPC container denoted by \a fileName in WRITE-ONLY mode. The \a destName parameter must be \a NULL.
+         \hideinitializer
+         */
+        OPC_OPEN_WRITE_ONLY=1,
+        /**
+         Opens the OPC container denoted by \a fileName in READ/WRITE mode. The \a destName parameter must be \a NULL.
+         \hideinitializer
+         */
+        OPC_OPEN_READ_WRITE=2,
+        /**
+         This mode will open the container denoted by \a fileName in READ-ONLY mode and the container denoted by 
+         \a destName in write-only mode. Any modifications will be written to the container denoted by \a destName 
+         and the unmodified streams from \a fileName will be written to \a destName on closing.
+         \warning Currently not implemented.
+         \hideinitializer
+         */
+        OPC_OPEN_TEMPLATE=3,
+        /**
+         Like the OPC_OPEN_TEMPLATE mode, but the \a destName will be renamed to the \a fileName on closing. If \a destName 
+         is \a NULL, then the name of the temporary file will be generated automatically.
+         \warning Currently not implemented.
+         \hideinitializer
+         */
+        OPC_OPEN_TRANSITION=4
+    } opcContainerOpenMode; 
+    
+    /** Modes for opcContainerClose.
+     \see opcContainerClose.
+     */
+    typedef enum {
+        /**
+         Close the OPC container without any further postprocessing.
+         \hideinitializer
+         */
+        OPC_CLOSE_NOW = 0,
+        /**
+         Close the OPC container and trim the file by removing unused fragments like e.g. 
+         deleted parts.
+         \hideinitializer
+         */
+        OPC_CLOSE_TRIM = 1,
+        /**
+         Close the OPC container like in \a OPC_CLOSE_TRIM mode, but additionally remove any 
+         "interleaved" parts by reordering them.
+         \warning Currently not implemented. Same semantic as OPC_CLOSE_TRIM.       
+         \hideinitializer
+         */
+        OPC_CLOSE_DEFRAG = 2
+    } opcContainerCloseMode;
+    
+    /**
+     Opens a ZIP-based OPC container.
+     @param[in] fileName. For more details see \ref opcContainerOpenMode.
+     @param[in] mode. For more details see \ref opcContainerOpenMode.
+     @param[in] userContext. Will not be modified by libopc. Can be used to e.g. store the "this" pointer for C++ bindings.
+     @param[in] destName. For more details see \ref opcContainerOpenMode.
+     @return \a NULL if failed. 
+     \see opcContainerOpenMode
+     \see opcContainerDump
+     */
+    opcContainer* opcContainerOpen(const xmlChar *fileName, 
+                                   opcContainerOpenMode mode, 
+                                   void *userContext, 
+                                   const xmlChar *destName);
+
+    /**
+     Opens a ZIP-based OPC container from memory.
+     @param[in] data. 
+     @param[in] data_len.
+     @param[in] userContext. Will not be modified by libopc. Can be used to e.g. store the "this" pointer for C++ bindings.
+     @param[in] mode. For more details see \ref opcContainerOpenMode.
+     @return \a NULL if failed. 
+     */
+    opcContainer* opcContainerOpenMem(const opc_uint8_t *data, opc_uint32_t data_len,
+                                      opcContainerOpenMode mode, 
+                                      void *userContext);
+
+    /**
+     Opens a ZIP-based OPC container from memory.
+     @param[in] ioread. 
+     @param[in] iowrite. 
+     @param[in] ioclose. 
+     @param[in] ioseek. 
+     @param[in] iotrim. 
+     @param[in] ioflush. 
+     @param[in] iocontext. 
+     @param[in] file_size. 
+     @param[in] userContext. Will not be modified by libopc. Can be used to e.g. store the "this" pointer for C++ bindings.
+     @param[in] mode. For more details see \ref opcContainerOpenMode.
+     @return \a NULL if failed. 
+     */
+    opcContainer* opcContainerOpenIO(opcFileReadCallback *ioread,
+                                     opcFileWriteCallback *iowrite,
+                                     opcFileCloseCallback *ioclose,
+                                     opcFileSeekCallback *ioseek,
+                                     opcFileTrimCallback *iotrim,
+                                     opcFileFlushCallback *ioflush,
+                                     void *iocontext,
+                                     pofs_t file_size,
+                                     opcContainerOpenMode mode, 
+                                     void *userContext);
+    
+    /**
+     Close an OPC container.
+     @param[in] c. \ref opcContainer openered by \ref opcContainerOpen.
+     @param[in] mode. For more information see \ref opcContainerCloseMode.
+     @return Non-zero if successful.
+     \see opcContainerOpen
+     \see opcContainerCloseMode
+     */
+    opc_error_t opcContainerClose(opcContainer *c, opcContainerCloseMode mode);
+    
+    /**
+     Returns the unmodified user context passed to \ref opcContainerOpen.
+     \see opcContainerOpen
+     */
+    void *opcContainerGetUserContext(opcContainer *c);
+    
+    /**
+     List all types, relations and parts of the container \a c to \a out.
+     \par Sample:
+     \include opc_dump.c
+     */
+    opc_error_t opcContainerDump(opcContainer *c, FILE *out);
+    
+    /**
+     Exports the OPC container to "Flat OPC" (http://blogs.msdn.com/b/ericwhite/archive/2008/09/29/the-flat-opc-format.aspx).
+     The flat versions of an OPC file are very important when dealing with e.g XSL(T)-based or Javascript-based transformations.
+     \see opcContainerFlatImport.
+     \todo Implementation needed.
+     */
+    int opcContainerFlatExport(opcContainer *c, const xmlChar *fileName);
+    
+    /**
+     Imports the flat version of an OPC container. 
+     \see opcContainerFlatExport.
+     \todo Implementation needed.
+     */
+    int opcContainerFlatImport(opcContainer *c, const xmlChar *fileName);
+    
+    /**
+     Iterate all types.
+     \code
+     for(xmlChar *type=opcContentTypeFirst(c);
+         NULL!=type;
+         type=opcContentTypeNext(c, type)) {
+        printf("%s\n", type);
+     }
+     \endcode
+    */
+    const xmlChar *opcContentTypeFirst(opcContainer *container);
+    
+    /**
+     \see opcContentTypeNext()
+    */
+    const xmlChar *opcContentTypeNext(opcContainer *container, const xmlChar *type);
+
+    /**
+     Iterate extensions.
+     \code
+     for(const xmlChar *ext=opcExtensionFirst(c);
+         NULL!=ext;
+         ext=opcExtensionNext(ext)) {
+        printf("%s\n", ext);
+     }
+     \endcode
+    */
+    const xmlChar *opcExtensionFirst(opcContainer *container);
+    
+    /**
+     \see opcExtensionFirst()
+     */
+    const xmlChar *opcExtensionNext(opcContainer *container, const xmlChar *ext);
+    
+    /**
+     Get registered type for extension.
+     \see opcExtensionRegister()
+     */
+    const xmlChar *opcExtensionGetType(opcContainer *container, const xmlChar *ext);
+
+    /**
+     Register a mime-type and and extension.
+     \see opcExtensionGetType()
+     */
+    const xmlChar *opcExtensionRegister(opcContainer *container, const xmlChar *ext, const xmlChar *type);
+
+
+    /**
+     Iterator through all relation types of the container:
+     \code
+     for(xmlChar *type=opcRelationTypeFirst(c);
+         NULL!=type;
+         type=opcRelationTypeNext(c, type)) {
+        printf("%s\n", type);
+     }
+     \endcode
+     */
+    const xmlChar *opcRelationTypeFirst(opcContainer *container);
+
+    /**
+     \see opcRelationTypeFirst()
+    */
+    const xmlChar *opcRelationTypeNext(opcContainer *container, const xmlChar *type);
+
+
+    /**
+     Iterator through all relation types of the container:
+     \code
+     for(xmlChar *target=opcExternalTargetFirst(c);
+         NULL!=target;
+         type=opcExternalTargetNext(c, target)) {
+        printf("%s\n", target);
+     }
+     \endcode
+     */
+    const xmlChar *opcExternalTargetFirst(opcContainer *container);
+
+    /**
+     \see opcExternalTargetFirst()
+    */
+    const xmlChar *opcExternalTargetNext(opcContainer *container, const xmlChar *target);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_CONTAINER_H */

include/opc/file.h

@@ -0,0 +1,200 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/file.h
+ The opc module contains the file library functions.
+*/
+#include <opc/config.h>
+
+#ifndef OPC_FILE_H
+#define OPC_FILE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+/**
+  Flag for READ access.
+  \hideinitializer
+*/
+#define OPC_FILE_READ  (1<<0)
+
+/**
+  Flag for WRITE access.
+  \hideinitializer
+*/
+#define OPC_FILE_WRITE (1<<1)
+
+/**
+  Flag indicates that file will be truncated when opened.
+  \hideinitializer
+*/
+#define OPC_FILE_TRUNC  (1<<2)
+
+
+    /** 
+      Abstraction for see modes.
+      */
+    typedef enum OPC_FILESEEKMODE_ENUM {
+        opcFileSeekSet = SEEK_SET,
+        opcFileSeekCur = SEEK_CUR,
+        opcFileSeekEnd = SEEK_END
+    } opcFileSeekMode;
+
+     /**
+      Callback to read a file. E.g. for a FILE * context this can be implemented as
+      \code
+      static int opcFileRead(void *iocontext, char *buffer, int len) {
+          return fread(buffer, sizeof(char), len, (FILE*)iocontext);
+      }
+      \endcode
+      */
+    typedef int opcFileReadCallback(void *iocontext, char *buffer, int len);
+
+     /**
+      Callback to write a file. E.g. for a FILE * context this can be implemented as
+      \code
+      static int opcFileWrite(void *iocontext, const char *buffer, int len) {
+          return fwrite(buffer, sizeof(char), len, (FILE*)iocontext);
+      }
+      \endcode
+      */
+    typedef int opcFileWriteCallback(void *iocontext, const char *buffer, int len);
+
+     /**
+      Callback to close a file. E.g. for a FILE * context this can be implemented as
+      \code
+      static int opcFileClose(void *iocontext) {
+          return fclose((FILE*)iocontext);
+      }
+      \endcode
+      */
+    typedef int opcFileCloseCallback(void *iocontext);
+
+     /**
+      Callback to seek a file. E.g. for a FILE * context this can be implemented as
+      \code
+      static opc_ofs_t opcFileSeek(void *iocontext, opc_ofs_t ofs) {
+          int ret=fseek((FILE*)iocontext, ofs, SEEK_SET);
+          if (ret>=0) {
+              return ftell((FILE*)iocontext);
+          } else {
+              return ret;
+          }
+      }
+      \endcode
+      */
+    typedef opc_ofs_t opcFileSeekCallback(void *iocontext, opc_ofs_t ofs);
+
+     /**
+      Callback to trim a file. E.g. for a FILE * context this can be implemented as
+      \code
+      static int opcFileTrim(void *iocontext, opc_ofs_t new_size) {
+      #ifdef WIN32
+          return _chsize(fileno((FILE*)iocontext), new_size);
+      #else
+          return ftruncate(fileno((FILE*)iocontext), new_size);
+      #endif
+      }
+      \endcode
+      */
+    typedef int opcFileTrimCallback(void *iocontext, opc_ofs_t new_size);
+
+     /**
+      Callback to flush a file. E.g. for a FILE * context this can be implemented as
+      \code
+      static int opcFileFlush(void *iocontext) {
+          return fflush((FILE*)iocontext);
+      }
+      \endcode
+      */
+    typedef int opcFileFlushCallback(void *iocontext);
+
+    /**
+      Represents a state of a file, i.e. file position (buf_pos) and error status (err).
+      */
+    typedef struct OPC_FILERAWSTATE_STRUCT {
+        opc_error_t err;
+        opc_ofs_t   buf_pos; // current pos in file
+    } opcFileRawState;
+
+    /**
+     File IO context.
+     */
+    typedef struct OPC_IO_STRUCT {
+        opcFileReadCallback *_ioread;
+        opcFileWriteCallback *_iowrite;
+        opcFileCloseCallback *_ioclose;
+        opcFileSeekCallback *_ioseek;
+        opcFileTrimCallback *_iotrim;
+        opcFileFlushCallback *_ioflush;
+        void *iocontext;
+        int flags;
+        opcFileRawState state;
+        opc_ofs_t file_size;
+    } opcIO_t;
+
+    /**
+      Initialize an IO context.
+      */
+    opc_error_t opcFileInitIO(opcIO_t *io,
+                              opcFileReadCallback *ioread,
+                              opcFileWriteCallback *iowrite,
+                              opcFileCloseCallback *ioclose,
+                              opcFileSeekCallback *ioseek,
+                              opcFileTrimCallback *iotrim,
+                              opcFileFlushCallback *ioflush,
+                              void *iocontext,
+                              pofs_t file_size,
+                              int flags);
+
+    /**
+      Initialize an IO context for a file.
+      */
+    opc_error_t opcFileInitIOFile(opcIO_t *io, const xmlChar *filename, int flags);
+
+    /**
+      Initialize an IO for memory.
+      \warning Currently supports READ-ONLY file access.
+      */
+    opc_error_t opcFileInitIOMemory(opcIO_t *io, const opc_uint8_t *data, opc_uint32_t data_len, int flags);
+
+    /**
+      Cleanup an IO context, i.e. release all system resources.
+      */
+    opc_error_t opcFileCleanupIO(opcIO_t *io);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_FILE_H */

include/opc/helper.h

@@ -0,0 +1,60 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/helper.h
+  Contains helper functions for the opc module.
+*/
+#include <opc/config.h>
+
+#ifndef OPC_HELPER_H
+#define OPC_HELPER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+
+    /**
+      Constructs a segment name.
+      */
+    opc_uint16_t opcHelperAssembleSegmentName(char *out, opc_uint16_t out_size, const xmlChar *name, opc_uint32_t segment_number, opc_uint32_t next_segment_id, opc_bool_t rels_segment, opc_uint16_t *out_max);
+
+    /**
+      Splits a filename into the segment informations.
+      */
+    opc_error_t opcHelperSplitFilename(opc_uint8_t *filename, opc_uint32_t filename_length, opc_uint32_t *segment_number, opc_bool_t *last_segment, opc_bool_t *rel_segment);
+
+#endif /* OPC_HELPER_H */

include/opc/inputstream.h

@@ -0,0 +1,74 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/inputstream.h
+ 
+ */
+#include <opc/config.h>
+
+#ifndef OPC_INPUTSTREAM_H
+#define OPC_INPUTSTREAM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+    /**
+      Internal type which represents a binary input stream.
+      */
+    typedef struct OPC_CONTAINER_INPUTSTREAM_STRUCT opcContainerInputStream;
+
+    /**
+      Opens the part \c name of the \c container for reading.
+      */
+    opcContainerInputStream* opcContainerOpenInputStream(opcContainer *container, const xmlChar *name);
+
+    /**
+     Reads maximal \c buffer_len bytes from the input \c stream to \c buffer. 
+     \return The number of byes read or "0" in case of an error or end-of-stream.
+     */
+    opc_uint32_t opcContainerReadInputStream(opcContainerInputStream* stream, opc_uint8_t *buffer, opc_uint32_t buffer_len);
+
+    /**
+      Closes the input stream and releases all system resources.
+      */
+    opc_error_t opcContainerCloseInputStream(opcContainerInputStream* stream);
+
+    /**
+      Returns the type of compression used for the stream.
+      */
+    opcCompressionOption_t opcContainerGetInputStreamCompressionOption(opcContainerInputStream* stream);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_INPUTSTREAM_H */

include/opc/opc.h

@@ -0,0 +1,73 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/opc.h
+ The opc module contains the basic library functions.
+*/
+#include <opc/config.h>
+#include <opc/container.h>
+#include <opc/part.h>
+#include <opc/relation.h>
+#include <opc/inputstream.h>
+#include <opc/outputstream.h>
+#include <opc/zip.h>
+#include <opc/xmlreader.h>
+#include <opc/xmlwriter.h>
+#include <opc/properties.h>
+
+#ifndef OPC_OPC_H
+#define OPC_OPC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+    
+    /**
+     * Initialize libopc.
+     * Sample:
+     * \include opc_helloworld.c
+     * @return Non-zero if successful.
+     */
+    opc_error_t opcInitLibrary();
+
+    /**
+     * Free libopc. Clean up all resources.
+     * @return Non-zero if successful.
+     * \see opcInitLibrary.
+     */
+    opc_error_t opcFreeLibrary();
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_OPC_H */

include/opc/outputstream.h

@@ -0,0 +1,71 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/outputstream.h
+ 
+ */
+#include <opc/config.h>
+
+#ifndef OPC_OUTPUTSTREAM_H
+#define OPC_OUTPUTSTREAM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+    /**
+      Internal type which represents a binary output stream.
+      */
+    typedef struct OPC_CONTAINER_OUTPUTSTREAM_STRUCT opcContainerOutputStream;
+
+    /** 
+      Open the part \c name or writing in \c container with compression \c compression_option.
+      \note Make sure the part exists! 
+      \see opcPartCreate.
+      */
+    opcContainerOutputStream* opcContainerCreateOutputStream(opcContainer *container, const xmlChar *name, opcCompressionOption_t compression_option);
+
+    /**
+      Write \c buffer_len bytes from \c buffer to \c stream. 
+      \return Returns the number of bytes written.
+      */
+    opc_uint32_t opcContainerWriteOutputStream(opcContainerOutputStream* stream, const opc_uint8_t *buffer, opc_uint32_t buffer_len);
+
+    /**
+      Close the \c stream and free all associated resources.
+      */
+    opc_error_t opcContainerCloseOutputStream(opcContainerOutputStream* stream);
+        
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_OUTPUTSTREAM_H */

include/opc/part.h

@@ -0,0 +1,118 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/part.h
+ 
+ */
+#include <opc/config.h>
+
+#ifndef OPC_PART_H
+#define OPC_PART_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+    /**
+     Handle to an OPC part created by \ref opcPartOpen.
+     \see opcPartOpen.
+     */
+    typedef xmlChar* opcPart;
+
+/**
+  Represents an invalid (resp. NULL) part.
+  In releations OPC_PART_INVALID also represents the root part.
+  \hideinitializer
+  */
+#define OPC_PART_INVALID NULL
+
+    /**
+     Find a part in a \ container by \c absolutePath and/or \c type.
+     Currently no flags are supported.
+     */
+    opcPart opcPartFind(opcContainer *container, 
+                        const xmlChar *absolutePath, 
+                        const xmlChar *type,
+                        int flags);
+
+    /**
+     Creates a part in a \ container with \c absolutePath and \c type.
+     Currently no flags are supported.
+     */
+    opcPart opcPartCreate(opcContainer *container, 
+                          const xmlChar *absolutePath, 
+                          const xmlChar *type,
+                          int flags);
+
+    /**
+      Returns the type of the container.
+      The string is interned and must not be freed.
+      */
+    const xmlChar *opcPartGetType(opcContainer *c, opcPart part);
+
+    /**
+      Returns the type of the container. 
+      If \c override_only then the return value will be NULL for parts not having an override type.
+      The string is interned and must not be freed.
+      */
+    const xmlChar *opcPartGetTypeEx(opcContainer *c, opcPart part, opc_bool_t override_only);
+
+    /**
+     Deleted that part \c absolutePath in the \c container.
+     */
+    opc_error_t opcPartDelete(opcContainer *container, const xmlChar *absolutePath);
+
+    /**
+      Get the first part.
+      \code
+      for(opcPart part=opcPartGetFirst(c);OPC_PART_INVALID!=part;part=opcPartGetNext(c, part)) {
+        printf("%s; \n", part, opcPartGetType(c, part));
+      }
+      \endcode 
+      */
+    opcPart opcPartGetFirst(opcContainer *container);
+
+    /**
+     Get the next part.
+     \see opcPartGetFirst
+      */
+    opcPart opcPartGetNext(opcContainer *container, opcPart part);
+
+    /**
+      Returns the size in bytes of the \c part.
+      */
+    opc_ofs_t opcPartGetSize(opcContainer *c, opcPart part);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_PART_H */

include/opc/properties.h

@@ -0,0 +1,121 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/properties.h
+ 
+ */
+#include <opc/config.h>
+#include <opc/container.h>
+
+#ifndef OPC_PROPERTIES_H
+#define OPC_PROPERTIES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+    /** 
+      Represents a simple Dublin Core type.
+      */
+    typedef struct OPC_DC_SIMPLE_TYPE {
+        xmlChar *str;
+        xmlChar *lang;
+    } opcDCSimpleType_t;
+
+    /** 
+      Represents the core properties of an OPC container.
+      */
+    typedef struct OPC_PROPERTIES_STRUCT {
+        xmlChar *category;                /* xsd:string     */
+        xmlChar *contentStatus;           /* xsd:string     */
+        xmlChar *created;                 /* dc:date        */
+        opcDCSimpleType_t creator;        /* dc:any         */
+        opcDCSimpleType_t description;    /* dc:any         */
+        opcDCSimpleType_t identifier;     /* dc:any         */
+        opcDCSimpleType_t *keyword_array; /* cp:CT_Keywords */
+        opc_uint32_t keyword_items;
+        opcDCSimpleType_t language;       /* dc:any         */
+        xmlChar *lastModifiedBy;          /* xsd:string     */
+        xmlChar *lastPrinted;             /* xsd:dateTime   */
+        xmlChar *modified;                /* dc:date        */
+        xmlChar *revision;                /* xsd:string     */
+        opcDCSimpleType_t subject;        /* dc:any         */
+        opcDCSimpleType_t title;          /* dc:any         */
+        xmlChar *version;                 /* xsd:string     */
+    } opcProperties_t;
+
+    /**
+      Initialize the core properties \c cp.
+      \see opcCorePropertiesSetString
+      */
+    opc_error_t opcCorePropertiesInit(opcProperties_t *cp);
+
+    /**
+      Cleanup the core properties \c cp, i.e. release all resources.
+      \see opcCorePropertiesSetString
+      */
+    opc_error_t opcCorePropertiesCleanup(opcProperties_t *cp);
+
+    /**
+      Rease the core properties \c cp from the container \c.
+      */
+    opc_error_t opcCorePropertiesRead(opcProperties_t *cp, opcContainer *c);
+
+
+    /**
+      Write/Update the core properties \c cp in the container \c.
+      */
+    opc_error_t opcCorePropertiesWrite(opcProperties_t *cp, opcContainer *c);
+
+    /**
+      Update a string in the core properties the right way.
+      \code
+      opcProperties_t cp;
+      opcCorePropertiesInit(&cp);
+      opcCorePropertiesSetString(&cp.revision, "1");
+      opcCorePropertiesSetStringLang(&cp.creator, "Florian Reuter", NULL);
+      opcCorePropertiesCleanup(&cp);
+      \endcode
+      */
+    opc_error_t opcCorePropertiesSetString(xmlChar **prop, const xmlChar *str);
+
+    /** 
+      Update a core properties the right way.
+      \see opcCorePropertiesSetString
+      */
+    opc_error_t opcCorePropertiesSetStringLang(opcDCSimpleType_t *prop, const xmlChar *str, const xmlChar *lang);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_PROPERTIES_H */

include/opc/relation.h

@@ -0,0 +1,140 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/relation.h
+ 
+ */
+#include <opc/config.h>
+
+#ifndef OPC_RELATION_H
+#define OPC_RELATION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+    /**
+     Indentifier for an OPC relation.
+     */
+    typedef opc_uint32_t opcRelation;
+
+/**
+  Constant which represents an invalid relation.
+*/
+#define OPC_RELATION_INVALID (-1)
+
+    /**
+      Find a relation originating from \c part in \c container with \c relationId and/or \c mimeType.
+      If \c part is OPC_PART_INVALID then part represents the root part.
+      @param[in] relationId The relationId (e.g. "rId1") or NULL.
+      @param[in] mimeType The mimeType or NULL.
+      */
+    opcRelation opcRelationFind(opcContainer *container, opcPart part, const xmlChar *relationId, const xmlChar *mimeType);
+
+    /**
+      Deleted the relation from the container.
+      \see opcRelationFind.
+      */
+    opc_error_t opcRelationDelete(opcContainer *container, opcPart part, const xmlChar *relationId, const xmlChar *mimeType);
+
+    /**
+      Returns the first relation.
+      The following code will dump all relations:
+      \code
+        for(opcPart part=opcPartGetFirst(c);OPC_PART_INVALID!=part;part=opcPartGetNext(c, part)) {
+           for(opcRelation rel=opcRelationFirst(part, c);
+               OPC_PART_INVALID!=rel;
+               rel=opcRelationNext(c, rel)) {
+               opcPart internal_target=opcRelationGetInternalTarget(c, part, rel);
+               const xmlChar *external_target=opcRelationGetExternalTarget(c, part, rel);
+               const xmlChar *target=(NULL!=internal_target?internal_target:external_target);
+               const xmlChar *prefix=NULL;
+               opc_uint32_t counter=-1;
+               const xmlChar *type=NULL;
+               opcRelationGetInformation(c, part, rel, &prefix, &counter, &type);        
+               if (-1==counter) { // no counter after prefix
+                  printf("%s;%s;%s;%s\n", part, prefix, target, type);
+               } else {
+                  printf("%s;%s%i;%s;%s\n", part, prefix, counter, target, type);
+               }
+           }
+        }
+      \endcode
+      */
+    opcRelation opcRelationFirst(opcContainer *container, opcPart part);
+
+    /**
+      \see opcRelationFirst
+      */
+    opcRelation opcRelationNext(opcContainer *container, opcPart part, opcRelation relation);
+    
+    /**
+      Returns the internal target.
+      \note To test for an external target use opcRelationGetExternalTarget.
+      \see opcRelationGetExternalTarget
+      */
+    opcPart opcRelationGetInternalTarget(opcContainer *container, opcPart part, opcRelation relation);
+
+    /**
+      Returns the external target or NULL if it is an internal target.
+      The string is interned. Must not be freed.
+      \see opcRelationGetExternalTarget
+      */
+    const xmlChar *opcRelationGetExternalTarget(opcContainer *container, opcPart part, opcRelation relation);
+
+    /**
+      Returns the relations type.
+      The string is interned. Must not be freed.
+      */
+    const xmlChar *opcRelationGetType(opcContainer *container, opcPart part, opcRelation relation);
+
+    /** 
+      Get information about a relation.
+      \see opcRelationFirst
+      */
+    void opcRelationGetInformation(opcContainer *container, opcPart part, opcRelation relation, const xmlChar **prefix, opc_uint32_t *counter, const xmlChar **type);
+
+    /** 
+      Add a relation to \c container from \c src part to \c dest part with id \c rid and type \c type.
+      */
+    opc_uint32_t opcRelationAdd(opcContainer *container, opcPart src, const xmlChar *rid, opcPart dest, const xmlChar *type);
+
+    /** 
+      Add an external relation to \c container from \c src part to \c target URL with id \c rid and type \c type.
+      */
+    opc_uint32_t opcRelationAddExternal(opcContainer *container, opcPart src, const xmlChar *rid, const xmlChar *target, const xmlChar *type);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+
+#endif /* OPC_RELATION_H */

include/opc/xmlreader.h

@@ -0,0 +1,69 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/xmlreader.h
+ 
+ */
+
+#ifndef OPC_XMLREADER_H
+#define OPC_XMLREADER_H
+
+#include <opc/config.h>
+#include <libxml/xmlreader.h>
+#include <mce/textreader.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+    /** 
+      Open an MCE reader for \c partName. Parameters \c URL, \c encoding and \c options will be passed unmodified to 
+      http://xmlsoft.org/html/libxml-xmlreader.html#xmlReaderForIO and they can we NULL, NULL, 0.
+      \note Make sure the part exists.
+      \see opcPartFind
+      */
+    opc_error_t opcXmlReaderOpen(opcContainer *container, mceTextReader_t *mceTextReader, const xmlChar *partName, const char * URL, const char * encoding, int options);
+
+    /**
+      Returns an libxml DOM document. Parameters \c URL, \c encoding and \c options will be passed unmodified to 
+      http://xmlsoft.org/html/libxml-parser.html#xmlReadIO and they can we NULL, NULL, 0.
+      \note Make sure the part exists.
+      \see opcPartFind
+      */
+    xmlDocPtr opcXmlReaderReadDoc(opcContainer *container, const xmlChar *partName, const char * URL, const char * encoding, int options);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_XMLREADER_H */

include/opc/xmlwriter.h

@@ -0,0 +1,57 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/xmlwriter.h
+ 
+ */
+#include <opc/config.h>
+#include <mce/textwriter.h>
+
+#ifndef OPC_XMLWRITER_H
+#define OPC_XMLWRITER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+    /**
+      Create an MCE text writer for \c part in \c container with compression \c compression_option.
+      \note Make sure the part exists.
+      \see opcPartFind
+      */
+    mceTextWriter *mceTextWriterOpen(opcContainer *c, opcPart part, opcCompressionOption_t compression_option);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_XMLWRITER_H */

include/opc/zip.h

@@ -0,0 +1,255 @@
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+/** @file opc/zip.h
+  The ZIP file backend of an OPC container.
+ */
+#include <opc/config.h>
+#include <opc/file.h>
+#include <opc/container.h>
+
+#ifndef OPC_ZIP_H
+#define OPC_ZIP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif    
+
+    /**
+     Default growth hint of an OPC stream.
+     */
+    #define OPC_DEFAULT_GROWTH_HINT 512
+
+    /**
+     Handle to a ZIP archive.
+     \see internal.h
+     */
+    typedef struct OPC_ZIP_STRUCT opcZip;
+
+    /**
+      Handle to a raw ZIP input stream.
+     \see internal.h
+      */
+    typedef struct OPC_ZIPINPUTSTREAM_STRUCT opcZipInputStream;
+
+    /**
+      Handle to a raw ZIP output stream.
+     \see internal.h
+      */
+    typedef struct OPC_ZIPOUTPUTSTREAM_STRUCT opcZipOutputStream;
+
+    /**
+     Holds all information of a ZIP segment.
+     */
+    typedef struct OPC_ZIP_SEGMENT_INFO_STRUCT {
+        xmlChar name[OPC_MAX_PATH]; 
+        opc_uint32_t name_len;
+        opc_uint32_t segment_number;
+        opc_bool_t   last_segment;
+        opc_bool_t   rels_segment;
+        opc_uint32_t header_size;
+        opc_uint32_t min_header_size;
+        opc_uint32_t trailing_bytes;
+        opc_uint32_t compressed_size;
+        opc_uint32_t uncompressed_size;
+        opc_uint16_t bit_flag;
+        opc_uint32_t data_crc;
+        opc_uint16_t compression_method;
+        opc_ofs_t    stream_ofs;
+        opc_uint16_t growth_hint;
+    } opcZipSegmentInfo_t;
+
+    /**
+      \see opcZipLoader
+      */
+    typedef int opcZipLoaderOpenCallback(void *iocontext);
+    /**
+      \see opcZipLoader
+      */
+    typedef int opcZipLoaderSkipCallback(void *iocontext);
+    /**
+      \see opcZipLoader
+      */
+    typedef int opcZipLoaderReadCallback(void *iocontext, char *buffer, int len);
+    /**
+      \see opcZipLoader
+      */
+    typedef int opcZipLoaderCloseCallback(void *iocontext);
+
+    /**
+      \see opcZipLoader
+      */
+    typedef opc_error_t (opcZipLoaderSegmentCallback_t)(void *iocontext, void *userctx, opcZipSegmentInfo_t *info, opcZipLoaderOpenCallback *open, opcZipLoaderReadCallback *read, opcZipLoaderCloseCallback *close, opcZipLoaderSkipCallback *skip);
+
+    /**
+      Walks every segment in a ZIP archive and calls the \c segmentCallback callback method.
+      The implementer \c segmentCallback method must then eiher use the passed \c open, \c read and \c close methods
+      to read the stream or the passed \c skip methods to skip the stream.
+      This method can be used to e.g. read ZIP file in stream mode.
+      */
+    opc_error_t opcZipLoader(opcIO_t *io, void *userctx, opcZipLoaderSegmentCallback_t *segmentCallback);
+
+    /**
+      \see opcZipClose
+     */
+    typedef opc_error_t (opcZipSegmentReleaseCallback)(opcZip *zip, opc_uint32_t segment_id);
+
+    /** 
+     Closes the ZIP archive \c zip and will call \c releaseCallback for every segment to give the implementer a chance
+     to free user resources.
+     */
+    void opcZipClose(opcZip *zip, opcZipSegmentReleaseCallback* releaseCallback);
+
+    /**
+      Creates an empty ZIP archive with the given \c io.
+      */
+    opcZip *opcZipCreate(opcIO_t *io);
+
+    /**
+      Commits all buffers and writes the ZIP archives local header directories.
+      if \c trim is true then padding bytes will be removed, i.e. the ZIP file size fill be minimalized.
+     */
+    opc_error_t opcZipCommit(opcZip *zip, opc_bool_t trim);
+
+    /**
+      Garbage collection on the passed \c zip archive. This will e.g. make deleted files available as free space.
+      */
+    opc_error_t opcZipGC(opcZip *zip);
+
+    /**
+      Load segment information into \c info.
+      If \c rels_segment is -1 then load the info for part with name \c partName.
+      Otherwise load the segment information for the ".rels." segment of \c partName.
+      \return Returns the segment_id.
+      */
+    opc_uint32_t opcZipLoadSegment(opcZip *zip, const xmlChar *partName, opc_bool_t rels_segment, opcZipSegmentInfo_t *info);
+
+    /**
+      Create a segment with the given parameters.
+      \return Returns the segment_id.
+      */
+    opc_uint32_t opcZipCreateSegment(opcZip *zip, 
+                                     const xmlChar *partName, 
+                                     opc_bool_t relsSegment, 
+                                     opc_uint32_t segment_size, 
+                                     opc_uint32_t growth_hint,
+                                     opc_uint16_t compression_method,
+                                     opc_uint16_t bit_flag);
+
+    /**
+      Creates an input stream for the segment with \c segment_id.
+      \see opcZipLoadSegment
+      \see opcZipCreateSegment
+      */
+    opcZipInputStream *opcZipOpenInputStream(opcZip *zip, opc_uint32_t segment_id);
+
+    /**
+     Free all resources of the input stream.
+     */
+    opc_error_t opcZipCloseInputStream(opcZip *zip, opcZipInputStream *stream);
+
+    /**
+     Read maximal \c buf_len bytes from the input stream into \buf. 
+     \return Returns the number of bytes read.
+     */
+    opc_uint32_t opcZipReadInputStream(opcZip *zip, opcZipInputStream *stream, opc_uint8_t *buf, opc_uint32_t buf_len);
+
+
+    /**
+      Creates an output stream for the segment with \c segment_id.
+      If \c *segment_id is -1 then a new segment will be created. 
+      Otherwise the segment with \c *segment_id will be overwritten.
+     */
+    opcZipOutputStream *opcZipCreateOutputStream(opcZip *zip, 
+                                             opc_uint32_t *segment_id, 
+                                             const xmlChar *partName, 
+                                             opc_bool_t relsSegment, 
+                                             opc_uint32_t segment_size, 
+                                             opc_uint32_t growth_hint,
+                                             opc_uint16_t compression_method,
+                                             opc_uint16_t bit_flag);
+
+    /**
+      Opens an existing ouput stream for reading.
+      The \c *segment_id will be set to -1 and reset on opcZipCloseOutputStream.
+      \see opcZipCloseOutputStream
+     */
+    opcZipOutputStream *opcZipOpenOutputStream(opcZip *zip, opc_uint32_t *segment_id);
+
+    /** 
+      Will close the stream and free all resources. Additionally the new segment id will be stored in \c *segment_id.
+      \see opcZipOpenOutputStream
+      */
+    opc_error_t opcZipCloseOutputStream(opcZip *zip, opcZipOutputStream *stream, opc_uint32_t *segment_id);
+
+    /**
+     Write \c buf_len bytes to \c buf. 
+     \return Returns the number of bytes written.
+     */
+    opc_uint32_t opcZipWriteOutputStream(opcZip *zip, opcZipOutputStream *stream, const opc_uint8_t *buf, opc_uint32_t buf_len);
+
+    /**
+     Returns the first segment id or -1.
+     Use the following code to iterarte through all segments.
+     \code 
+     for(opc_uint32_t segment_id=opcZipGetFirstSegmentId(zip);
+         -1!=segment_id;
+         segment_id=opcZipGetNextSegmentId(zip, segment_id) {
+        ...
+     }
+     \endcode
+     \see opcZipGetNextSegmentId
+     */
+    opc_uint32_t opcZipGetFirstSegmentId(opcZip *zip);
+
+    /**
+     Returns the next segment id or -1.
+     \see opcZipGetFirstSegmentId
+     */
+    opc_uint32_t opcZipGetNextSegmentId(opcZip *zip, opc_uint32_t segment_id);
+
+    /**
+     Returns info about the given segment id.
+     */
+    opc_error_t opcZipGetSegmentInfo(opcZip *zip, opc_uint32_t segment_id, const xmlChar **name, opc_bool_t *rels_segment, opc_uint32_t *crc);
+
+    /**
+     Marks a given segments as deleted.
+     \see opcZipGC
+     */
+    opc_bool_t opcZipSegmentDelete(opcZip *zip, opc_uint32_t *first_segment, opc_uint32_t *last_segment, opcZipSegmentReleaseCallback* releaseCallback);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif    
+        
+#endif /* OPC_ZIP_H */

include/plib/plib.h

@@ -0,0 +1,168 @@
+/* include/plib/plib.h.  Generated from plib.h by configure.  */
+/*
+ Copyright (c) 2010, Florian Reuter
+ All rights reserved.
+ 
+ Redistribution and use in source and binary forms, with or without 
+ modification, are permitted provided that the following conditions 
+ are met:
+ 
+ * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+ * Neither the name of Florian Reuter nor the names of its contributors 
+   may be used to endorse or promote products derived from this 
+   software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+*/
+#ifndef _PLIB_PLIB_H_
+#define _PLIB_PLIB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HAVE_STDINT_H 1
+#define HAVE_STDDEF_H 1
+#define HAVE_STDIO_H 1
+#define HAVE_STRING_H 1
+#define HAVE_LIMITS_H 1
+#define HAVE_STDLIB_H 1
+/* #undef HAVE_IO_H */
+#define HAVE_UNISTD_H 1
+#define HAVE_SYS_TYPES_H 1
+#define IS_CONFIGURED 1
+
+#if !defined(IS_CONFIGURED)
+#if defined(WIN32)
+#define HAVE_STRING_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_LIMITS_H 1
+#define HAVE_STDDEF_H 1
+#define HAVE_STDIO_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_IO_H
+#define snprintf _snprintf
+#else
+#error "configure not executed and we are not on a win32 machine? please run configure or define WIN32 is you are on a WIN32 platform."
+#endif
+#endif
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+typedef size_t pofs_t; // maximum file offset for eg. read write ops
+#else
+#error "system types can not be determined"
+#endif
+
+#ifdef HAVE_STDIO_H
+#include <stdio.h>
+#else
+#error "system io can not be determined"
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+
+typedef int8_t pint8_t;
+typedef uint8_t puint8_t;
+
+typedef int16_t pint16_t;
+typedef uint16_t puint16_t;
+
+typedef int32_t pint32_t;
+typedef uint32_t puint32_t;
+
+typedef int64_t pint64_t;
+typedef uint64_t puint64_t;
+
+typedef int pbool_t;
+
+typedef size_t psize_t;
+
+// INTN_MAX, INTN_MIN, UINTN_MAX
+#else
+#error "system types can not be determined"
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#define PUINT8_MAX UCHAR_MAX 
+#define PINT32_MAX INT_MAX 
+#define PINT32_MIN INT_MIN 
+#define PUINT32_MAX UINT_MAX 
+#define PUINT32_MIN 0 
+#define PUINT16_MAX	USHRT_MAX 
+#define PUINT16_MIN 0 
+#else
+#error "limits can not be determined"
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+/**
+ Converts an ASCII string to a xmlChar string. This only works for ASCII strings.
+ */
+#ifndef _X
+#define _X(s) BAD_CAST(s) 
+#endif
+
+
+/**
+ Converts an xmlChar string to an ASCII string. This only works for ASCII charsets.
+ */
+#ifndef _X2C
+#define _X2C(s) ((char*)(s))
+#endif
+
+
+#define PASSERT(e) assert(e)
+#ifdef NDEBUG
+#define PENSURE(e) (void)(e)
+#else
+#define PENSURE(e) assert(e)
+#endif
+#define PTRUE (0==0)
+#define PFALSE (0==1)
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* _PLIB_PLIB_H_ */

mime.csv

@@ -252,7 +252,7 @@ text/html, acgi|htm|html|htmls|htx|shtml
 text/javascript, js
 text/mcf, mcf
 text/pascal, pas
-text/plain, com|cmd|conf|def|g|idc|list|lst|mar|sdml|text|txt|md|groovy|license|properties|desktop|ini|rst|cmake|ipynb|readme|less|lo|go|yml|d|cs|hpp|srt
+text/plain, com|cmd|conf|def|g|idc|list|lst|mar|sdml|text|txt|md|groovy|license|properties|desktop|ini|rst|cmake|ipynb|readme|less|lo|go|yml|d|cs|hpp|srt|nfo|sfv|m3u
 text/richtext, rt|rtf|rtx
 text/rtf,
 text/scriplet, wsc
@@ -410,4 +410,9 @@ text/PGP,
 audio/x-hx-aac-adts,
 application/x-chrome-extension,
 image/heic, heic
-image/x-gem,
+image/x-gem,
+application/x-lzma, lzma
+application/warc, warc
+application/x-lz4, lz4
+application/x-lzip, lz
+application/x-lzop, lzo

scripts/get_static_libs.sh

@@ -67,5 +67,43 @@ make -j 4
 cd ..
 mv libmagic/src/.libs/libmagic.a .
 
+# libarchive
+cd libarchive/build
+./autogen.sh
+cd ..
+./configure --without-nettle --without-expat --without-xml2 --without-openssl
+make -j 4
+cd ..
+mv libarchive/.libs/libarchive.a .
+
+# lz4
+cd lz4
+make -j 4
+cd ..
+mv lz4/lib/liblz4.a .
+
+# lzma
+wget https://newcontinuum.dl.sourceforge.net/project/lzmautils/xz-5.2.3.tar.gz
+tar -xzf xz-5.2.3.tar.gz
+rm xz-5.2.3.tar.gz
+cd xz-5.2.3
+./autogen.sh
+./configure
+make -j 4
+cd ..
+mv xz-5.2.3/src/liblzma/.libs/liblzma.a .
+
+# zstd
+cd zstd
+make -j 4
+cd ..
+mv zstd/lib/libzstd.a .
+
+# xml2
+cd libxml2
+./autogen.sh --without-zlib --without-lzma
+make
+cd ..
+mv libxml2/.libs/libxml2.a .
 
 cd ..

scripts/mime.py

@@ -34,6 +34,34 @@ font = (
     "font/woff2"
 )
 
+# Archive "formats"
+archive = (
+    "application/x-tar",
+    "application/zip",
+    "application/x-rar",
+    "application/x-arc",
+    "application/x-warc",
+    "application/x-7z-compressed",
+)
+
+# Archive "filters"
+arc_filter = (
+    "application/gzip",
+    "application/x-bzip2",
+    "application/x-xz",
+    "application/x-zstd",
+    "application/x-lzma",
+    "application/x-lz4",
+    "application/x-lzip",
+    "application/x-lzop",
+)
+
+doc = (
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+)
+
 cnt = 1
 
 
@@ -48,6 +76,12 @@ def mime_id(mime):
         mime_id += " | 0x40000000"
     elif mime in font:
         mime_id += " | 0x20000000"
+    elif mime in archive:
+        mime_id += " | 0x10000000"
+    elif mime in arc_filter:
+        mime_id += " | 0x08000000"
+    elif mime in doc:
+        mime_id += " | 0x04000000"
     elif mime == "application/x-empty":
         return "1"
     return mime_id

src/cli.c

@@ -1,12 +1,13 @@
 #include "cli.h"
 
 #define DEFAULT_OUTPUT "index.sist2/"
-#define DEFAULT_CONTENT_SIZE 4096
+#define DEFAULT_CONTENT_SIZE 32768
 #define DEFAULT_QUALITY 5
 #define DEFAULT_SIZE 500
 #define DEFAULT_REWRITE_URL ""
 
 #define DEFAULT_ES_URL "http://localhost:9200"
+#define DEFAULT_BATCH_SIZE 100
 
 #define DEFAULT_BIND_ADDR "localhost"
 #define DEFAULT_PORT "4090"
@@ -20,6 +21,33 @@ scan_args_t *scan_args_create() {
     return args;
 }
 
+void scan_args_destroy(scan_args_t *args) {
+    if (args->name != NULL) {
+        free(args->name);
+    }
+    if (args->path != NULL) {
+        free(args->path);
+    }
+    if (args->output != NULL) {
+        free(args->output);
+    }
+    free(args);
+}
+
+#ifndef SIST_SCAN_ONLY
+
+void index_args_destroy(index_args_t *args) {
+    //todo
+    free(args);
+}
+
+void web_args_destroy(web_args_t *args) {
+    //todo
+    free(args);
+}
+
+#endif
+
 int scan_args_validate(scan_args_t *args, int argc, const char **argv) {
     if (argc < 2) {
         fprintf(stderr, "Required positional argument: PATH.\n");
@@ -51,16 +79,13 @@ int scan_args_validate(scan_args_t *args, int argc, const char **argv) {
 
     if (args->size == 0) {
         args->size = DEFAULT_SIZE;
-    } else if (args->size <= 0) {
-        fprintf(stderr, "Invalid size: %d\n", args->size);
+    } else if (args->size > 0 && args->size < 32) {
+        printf("Invalid size: %d\n", args->content_size);
         return 1;
     }
 
     if (args->content_size == 0) {
         args->content_size = DEFAULT_CONTENT_SIZE;
-    } else if (args->content_size <= 0) {
-        fprintf(stderr, "Invalid content-size: %d\n", args->content_size);
-        return 1;
     }
 
     if (args->threads == 0) {
@@ -96,10 +121,24 @@ int scan_args_validate(scan_args_t *args, int argc, const char **argv) {
     if (args->rewrite_url == NULL) {
         args->rewrite_url = DEFAULT_REWRITE_URL;
     }
+
+    if (args->archive == NULL || strcmp(args->archive, "recurse") == 0) {
+        args->archive_mode = ARC_MODE_RECURSE;
+    } else if (strcmp(args->archive, "list") == 0) {
+        args->archive_mode = ARC_MODE_LIST;
+    } else if (strcmp(args->archive, "shallow") == 0) {
+        args->archive_mode = ARC_MODE_SHALLOW;
+    } else if (strcmp(args->archive, "skip") == 0) {
+        args->archive_mode = ARC_MODE_SKIP;
+    } else {
+        fprintf(stderr, "Archive mode must be one of (skip, list, shallow, recurse), got '%s'", args->archive);
+        return 1;
+    }
     return 0;
 }
 
 #ifndef SIST_SCAN_ONLY
+
 int index_args_validate(index_args_t *args, int argc, const char **argv) {
 
     if (argc < 2) {
@@ -113,6 +152,7 @@ int index_args_validate(index_args_t *args, int argc, const char **argv) {
         return 1;
     } else {
         args->index_path = argv[1];
+        free(index_path);
     }
 
     if (args->es_url == NULL) {
@@ -144,6 +184,11 @@ int index_args_validate(index_args_t *args, int argc, const char **argv) {
         *(args->script + info.st_size) = '\0';
         close(fd);
     }
+
+    if (args->batch_size == 0) {
+        args->batch_size = DEFAULT_BATCH_SIZE;
+    }
+
     return 0;
 }
 
@@ -167,7 +212,7 @@ int web_args_validate(web_args_t *args, int argc, const char **argv) {
     }
 
     if (args->credentials != NULL) {
-        args->b64credentials = onion_base64_encode(args->credentials, (int)strlen(args->credentials));
+        args->b64credentials = onion_base64_encode(args->credentials, (int) strlen(args->credentials));
         //Remove trailing newline
         *(args->b64credentials + strlen(args->b64credentials) - 1) = '\0';
     }
@@ -194,5 +239,6 @@ web_args_t *web_args_create() {
     web_args_t *args = calloc(sizeof(web_args_t), 1);
     return args;
 }
+
 #endif
 

src/cli.h

@@ -14,9 +14,12 @@ typedef struct scan_args {
     char *name;
     int depth;
     char *path;
+    char *archive;
+    archive_mode_t archive_mode;
 } scan_args_t;
 
 scan_args_t *scan_args_create();
+void scan_args_destroy(scan_args_t *args);
 int scan_args_validate(scan_args_t *args, int argc, const char **argv);
 
 #ifndef SIST_SCAN_ONLY
@@ -26,6 +29,7 @@ typedef struct index_args {
     const char *script_path;
     char *script;
     int print;
+    int batch_size;
     int force_reset;
 } index_args_t;
 
@@ -40,7 +44,10 @@ typedef struct web_args {
 } web_args_t;
 
 index_args_t *index_args_create();
+void index_args_destroy(index_args_t *args);
+
 web_args_t *web_args_create();
+void web_args_destroy(web_args_t *args);
 
 int index_args_validate(index_args_t *args, int argc, const char **argv);
 int web_args_validate(web_args_t *args, int argc, const char **argv);

src/ctx.h

@@ -16,6 +16,7 @@ struct {
     int content_size;
     float tn_qscale;
     int depth;
+    archive_mode_t archive_mode;
 
     size_t stat_tn_size;
     size_t stat_index_size;
@@ -30,12 +31,13 @@ struct {
 #ifndef SIST_SCAN_ONLY
 struct {
     char *es_url;
+    int batch_size;
 } IndexCtx;
 
 struct {
     char *es_url;
     int index_count;
-    char* b64credentials;
+    char *b64credentials;
     struct index_t indices[16];
 } WebCtx;
 #endif

src/index/elastic.c

@@ -9,7 +9,6 @@
 
 #include "static_generated.c"
 
-#define BULK_INDEX_SIZE 100
 
 typedef struct es_indexer {
     int queued;
@@ -173,7 +172,7 @@ void elastic_index_line(es_bulk_line_t *line) {
 
     Indexer->queued += 1;
 
-    if (Indexer->queued >= BULK_INDEX_SIZE) {
+    if (Indexer->queued >= IndexCtx.batch_size) {
         elastic_flush();
     }
 }

src/io/serialize.c

@@ -1,7 +1,7 @@
 #include "src/ctx.h"
 #include "serialize.h"
 
-static __thread int IndexFd = -1;
+static __thread int index_fd = -1;
 
 typedef struct {
     unsigned char uuid[16];
@@ -111,6 +111,8 @@ char *get_meta_key_text(enum metakey meta_key) {
             return "title";
         case MetaFontName:
             return "font_name";
+        case MetaParent:
+            return "parent";
         default:
             return NULL;
     }
@@ -119,13 +121,13 @@ char *get_meta_key_text(enum metakey meta_key) {
 
 void write_document(document_t *doc) {
 
-    if (IndexFd == -1) {
+    if (index_fd == -1) {
         char dstfile[PATH_MAX];
         pthread_t self = pthread_self();
         snprintf(dstfile, PATH_MAX, "%s_index_%lu", ScanCtx.index.path, self);
-        IndexFd = open(dstfile, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
+        index_fd = open(dstfile, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
 
-        if (IndexFd == -1) {
+        if (index_fd == -1) {
             perror("open");
         }
     }
@@ -158,13 +160,16 @@ void write_document(document_t *doc) {
     }
     dyn_buffer_write_char(&buf, '\n');
 
-    write(IndexFd, buf.buf, buf.cur);
+    int res = write(index_fd, buf.buf, buf.cur);
+    if (res == -1) {
+        perror("write");
+    }
     ScanCtx.stat_index_size += buf.cur;
     dyn_buffer_destroy(&buf);
 }
 
-void serializer_cleanup() {
-    close(IndexFd);
+void thread_cleanup() {
+    close(index_fd);
 }
 
 void read_index(const char *path, const char index_id[UUID_STR_LEN], index_func func) {
@@ -244,6 +249,7 @@ void read_index(const char *path, const char index_id[UUID_STR_LEN], index_func
                 case MetaAlbumArtist:
                 case MetaGenre:
                 case MetaFontName:
+                case MetaParent:
                 case MetaTitle: {
                     buf.cur = 0;
                     while ((c = getc(file)) != 0) {

src/io/serialize.h

@@ -18,7 +18,7 @@ void incremental_read(GHashTable *table, const char *filepath);
 /**
  * Must be called after write_document
  */
-void serializer_cleanup();
+void thread_cleanup();
 
 void write_index_descriptor(char *path, index_descriptor_t *desc);
 

src/io/walk.c

@@ -1,7 +1,8 @@
 #include "walk.h"
 #include "src/ctx.h"
 
-parse_job_t *create_parse_job(const char *filepath, const struct stat *info, int base) {
+__always_inline
+parse_job_t *create_fs_parse_job(const char *filepath, const struct stat *info, int base) {
     int len = (int) strlen(filepath);
     parse_job_t *job = malloc(sizeof(parse_job_t) + len);
 
@@ -14,14 +15,22 @@ parse_job_t *create_parse_job(const char *filepath, const struct stat *info, int
         job->ext = len;
     }
 
-    memcpy(&(job->info), info, sizeof(struct stat));
+    job->info = *info;
+
+    memset(job->parent, 0, 16);
+
+    job->vfile.filepath = job->filepath;
+    job->vfile.read = fs_read;
+    job->vfile.close = fs_close;
+    job->vfile.fd = -1;
+    job->vfile.is_fs_file = TRUE;
 
     return job;
 }
 
 int handle_entry(const char *filepath, const struct stat *info, int typeflag, struct FTW *ftw) {
     if (ftw->level <= ScanCtx.depth && typeflag == FTW_F && S_ISREG(info->st_mode)) {
-        parse_job_t *job = create_parse_job(filepath, info, ftw->base);
+        parse_job_t *job = create_fs_parse_job(filepath, info, ftw->base);
         tpool_add_work(ScanCtx.pool, parse, job);
     }
 

src/main.c

@@ -10,7 +10,7 @@
 #define EPILOG "Made by simon987 <me@simon987.net>. Released under GPL-3.0"
 
 
-static const char *const Version = "1.1.8";
+static const char *const Version = "1.1.11";
 static const char *const usage[] = {
         "sist2 scan [OPTION]... PATH",
         "sist2 index [OPTION]... INDEX",
@@ -19,10 +19,11 @@ static const char *const usage[] = {
 };
 
 void global_init() {
-    #ifndef SIST_SCAN_ONLY
+#ifndef SIST_SCAN_ONLY
     curl_global_init(CURL_GLOBAL_NOTHING);
-    #endif
+#endif
     av_log_set_level(AV_LOG_QUIET);
+    opcInitLibrary();
 }
 
 void init_dir(const char *dirpath) {
@@ -41,10 +42,22 @@ void init_dir(const char *dirpath) {
 void scan_print_header() {
     printf("sist2 V%s\n", Version);
     printf("---------------------\n");
-    printf("threads\t\t%d\n", ScanCtx.threads);
-    printf("tn_qscale\t%.1f/31.0\n", ScanCtx.tn_qscale);
-    printf("tn_size\t\t%dpx\n", ScanCtx.tn_size);
-    printf("output\t\t%s\n", ScanCtx.index.path);
+    printf("threads\t\t\t%d\n", ScanCtx.threads);
+    printf("tn_qscale\t\t%.1f/31.0\n", ScanCtx.tn_qscale);
+
+    if (ScanCtx.tn_size > 0) {
+        printf("tn_size\t\t\t%dpx\n", ScanCtx.tn_size);
+    } else {
+        printf("tn_size\t\t\tdisabled\n");
+    }
+
+    if (ScanCtx.content_size > 0) {
+        printf("content_size\t\t%d B\n", ScanCtx.content_size);
+    } else {
+        printf("content_size\t\t\tdisabled\n");
+    }
+
+    printf("output\t\t\t%s\n", ScanCtx.index.path);
 }
 
 void sist2_scan(scan_args_t *args) {
@@ -54,6 +67,7 @@ void sist2_scan(scan_args_t *args) {
     ScanCtx.content_size = args->content_size;
     ScanCtx.threads = args->threads;
     ScanCtx.depth = args->depth;
+    ScanCtx.archive_mode = args->archive_mode;
     strncpy(ScanCtx.index.path, args->output, sizeof(ScanCtx.index.path));
     strncpy(ScanCtx.index.desc.name, args->name, sizeof(ScanCtx.index.desc.name));
     strncpy(ScanCtx.index.desc.root, args->path, sizeof(ScanCtx.index.desc.root));
@@ -93,7 +107,7 @@ void sist2_scan(scan_args_t *args) {
         printf("Loaded %d items in to mtime table.", g_hash_table_size(ScanCtx.original_table));
     }
 
-    ScanCtx.pool = tpool_create(args->threads, serializer_cleanup);
+    ScanCtx.pool = tpool_create(args->threads, thread_cleanup);
     tpool_start(ScanCtx.pool);
     walk_directory_tree(ScanCtx.index.desc.root);
     tpool_wait(ScanCtx.pool);
@@ -126,9 +140,11 @@ void sist2_scan(scan_args_t *args) {
 }
 
 #ifndef SIST_SCAN_ONLY
+
 void sist2_index(index_args_t *args) {
 
     IndexCtx.es_url = args->es_url;
+    IndexCtx.batch_size = args->batch_size;
 
     if (!args->print) {
         elastic_init(args->force_reset);
@@ -198,6 +214,7 @@ void sist2_web(web_args_t *args) {
 
     serve(args->bind, args->port);
 }
+
 #endif
 
 
@@ -206,14 +223,14 @@ int main(int argc, const char *argv[]) {
     global_init();
 
     scan_args_t *scan_args = scan_args_create();
-    #ifndef SIST_SCAN_ONLY
+#ifndef SIST_SCAN_ONLY
     index_args_t *index_args = index_args_create();
     web_args_t *web_args = web_args_create();
-    #endif
+#endif
 
     int arg_version = 0;
 
-    char * common_es_url = NULL;
+    char *common_es_url = NULL;
 
     struct argparse_option options[] = {
             OPT_HELP(),
@@ -224,31 +241,36 @@ int main(int argc, const char *argv[]) {
             OPT_INTEGER('t', "threads", &scan_args->threads, "Number of threads. DEFAULT=1"),
             OPT_FLOAT('q', "quality", &scan_args->quality,
                       "Thumbnail quality, on a scale of 1.0 to 31.0, 1.0 being the best. DEFAULT=5"),
-            OPT_INTEGER(0, "size", &scan_args->size, "Thumbnail size, in pixels. DEFAULT=500"),
+            OPT_INTEGER(0, "size", &scan_args->size,
+                        "Thumbnail size, in pixels. Use negative value to disable. DEFAULT=500"),
             OPT_INTEGER(0, "content-size", &scan_args->content_size,
-                        "Number of bytes to be extracted from text documents. DEFAULT=4096"),
+                        "Number of bytes to be extracted from text documents. Use negative value to disable. DEFAULT=32768"),
             OPT_STRING(0, "incremental", &scan_args->incremental,
                        "Reuse an existing index and only scan modified files."),
             OPT_STRING('o', "output", &scan_args->output, "Output directory. DEFAULT=index.sist2/"),
             OPT_STRING(0, "rewrite-url", &scan_args->rewrite_url, "Serve files from this url instead of from disk."),
             OPT_STRING(0, "name", &scan_args->name, "Index display name. DEFAULT: (name of the directory)"),
             OPT_INTEGER(0, "depth", &scan_args->depth, "Scan up to DEPTH subdirectories deep. "
-                                                     "Use 0 to only scan files in PATH. DEFAULT: -1"),
+                                                       "Use 0 to only scan files in PATH. DEFAULT: -1"),
+            OPT_STRING(0, "archive", &scan_args->archive, "Archive file mode (skip|list|shallow|recurse). "
+                                                          "skip: Don't parse, list: only get file names as text, "
+                                                          "shallow: Don't parse archives inside archives. DEFAULT: recurse"),
 
-            #ifndef SIST_SCAN_ONLY
+#ifndef SIST_SCAN_ONLY
             OPT_GROUP("Index options"),
-            OPT_STRING(0, "es-url", &common_es_url, "Elasticsearch url. DEFAULT=http://localhost:9200"),
+            OPT_STRING(0, "es-url", &common_es_url, "Elasticsearch url with port. DEFAULT=http://localhost:9200"),
             OPT_BOOLEAN('p', "print", &index_args->print, "Just print JSON documents to stdout."),
             OPT_STRING(0, "script-file", &index_args->script_path, "Path to user script."),
+            OPT_INTEGER(0, "batch-size", &index_args->batch_size, "Index batch size. DEFAULT: 100"),
             OPT_BOOLEAN('f', "force-reset", &index_args->force_reset, "Reset Elasticsearch mappings and settings. "
-                                                              "(You must use this option the first time you use the index command)"),
+                                                                      "(You must use this option the first time you use the index command)"),
 
             OPT_GROUP("Web options"),
             OPT_STRING(0, "es-url", &common_es_url, "Elasticsearch url. DEFAULT=http://localhost:9200"),
             OPT_STRING(0, "bind", &web_args->bind, "Listen on this address. DEFAULT=localhost"),
             OPT_STRING(0, "port", &web_args->port, "Listen on this port. DEFAULT=4090"),
             OPT_STRING(0, "auth", &web_args->credentials, "Basic auth in user:password format"),
-            #endif
+#endif
 
             OPT_END(),
     };
@@ -263,10 +285,10 @@ int main(int argc, const char *argv[]) {
         exit(0);
     }
 
-    #ifndef SIST_SCAN_ONLY
+#ifndef SIST_SCAN_ONLY
     web_args->es_url = common_es_url;
     index_args->es_url = common_es_url;
-    #endif
+#endif
 
     if (argc == 0) {
         argparse_usage(&argparse);
@@ -281,7 +303,7 @@ int main(int argc, const char *argv[]) {
 
     }
 
-    #ifndef SIST_SCAN_ONLY
+#ifndef SIST_SCAN_ONLY
     else if (strcmp(argv[0], "index") == 0) {
 
         int err = index_args_validate(index_args, argc, argv);
@@ -299,12 +321,20 @@ int main(int argc, const char *argv[]) {
         sist2_web(web_args);
 
     }
-    #endif
+#endif
     else {
         fprintf(stderr, "Invalid command: '%s'\n", argv[0]);
         argparse_usage(&argparse);
         return 1;
     }
     printf("\n");
+
+    scan_args_destroy(scan_args);
+
+#ifndef SIST_SCAN_ONLY
+    index_args_destroy(index_args);
+    web_args_destroy(web_args);
+#endif
+
     return 0;
 }

src/parsing/arc.c

@@ -0,0 +1,152 @@
+#include "arc.h"
+#include "src/ctx.h"
+
+#define ARC_BUF_SIZE 8192
+
+int should_parse_filtered_file(const char *filepath, int ext) {
+    char tmp[PATH_MAX * 2];
+
+    if (ext == 0) {
+        return FALSE;
+    }
+
+    memcpy(tmp, filepath, ext - 1);
+    *(tmp + ext - 1) = '\0';
+
+    char *idx = strrchr(tmp, '.');
+
+    if (idx == NULL) {
+        return FALSE;
+    }
+
+    if (strcmp(idx, ".tar") == 0) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+int arc_read(struct vfile *f, void *buf, size_t size) {
+    return archive_read_data(f->arc, buf, size);
+}
+
+typedef struct arc_data {
+    vfile_t *f;
+    char buf[ARC_BUF_SIZE];
+} arc_data_f;
+
+int vfile_open_callback(struct archive *a, void *user_data) {
+    arc_data_f *data = user_data;
+
+    if (data->f->is_fs_file && data->f->fd == -1) {
+        data->f->fd = open(data->f->filepath, O_RDONLY);
+    }
+
+    return ARCHIVE_OK;
+}
+
+long vfile_read_callback(struct archive *a, void *user_data, const void **buf) {
+    arc_data_f *data = user_data;
+
+    *buf = data->buf;
+    return data->f->read(data->f, data->buf, ARC_BUF_SIZE);
+}
+
+int vfile_close_callback(struct archive *a, void *user_data) {
+    arc_data_f *data = user_data;
+
+    if (data->f->close != NULL) {
+        data->f->close(data->f);
+    }
+
+    return ARCHIVE_OK;
+}
+
+void parse_archive(vfile_t *f, document_t *doc) {
+
+    struct archive *a;
+    struct archive_entry *entry;
+
+    a = archive_read_new();
+
+    archive_read_support_filter_all(a);
+    archive_read_support_format_all(a);
+
+    arc_data_f data;
+    data.f = f;
+
+    int ret = 0;
+    if (data.f->is_fs_file) {
+        ret = archive_read_open_filename(a, doc->filepath, ARC_BUF_SIZE);
+    } else if (ScanCtx.archive_mode == ARC_MODE_RECURSE) {
+        ret = archive_read_open(
+                a, &data,
+                vfile_open_callback,
+                vfile_read_callback,
+                vfile_close_callback
+        );
+    } else {
+        archive_read_free(a);
+        return;
+    }
+
+    if (ret != ARCHIVE_OK) {
+        fprintf(stderr, "OPEN[%d]:%s %s\n", ret, archive_error_string(a), doc->filepath);
+        archive_read_free(a);
+        return;
+    }
+
+    if (ScanCtx.archive_mode == ARC_MODE_LIST) {
+
+        dyn_buffer_t buf = dyn_buffer_create();
+
+        while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
+            if (S_ISREG(archive_entry_stat(entry)->st_mode)) {
+
+                char *path = (char *) archive_entry_pathname(entry);
+
+                dyn_buffer_append_string(&buf, path);
+                dyn_buffer_write_char(&buf, '\n');
+            }
+        }
+        dyn_buffer_write_char(&buf, '\0');
+
+        meta_line_t *meta_list = malloc(sizeof(meta_line_t) + buf.cur);
+        meta_list->key = MetaContent;
+        strcpy(meta_list->strval, buf.buf);
+        APPEND_META(doc, meta_list);
+        dyn_buffer_destroy(&buf);
+
+    } else {
+
+        parse_job_t *sub_job = malloc(sizeof(parse_job_t) + PATH_MAX * 2);
+
+        sub_job->vfile.close = NULL;
+        sub_job->vfile.read = arc_read;
+        sub_job->vfile.arc = a;
+        sub_job->vfile.filepath = sub_job->filepath;
+        sub_job->vfile.is_fs_file = FALSE;
+        memcpy(sub_job->parent, doc->uuid, sizeof(uuid_t));
+
+        while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
+            sub_job->info = *archive_entry_stat(entry);
+            if (S_ISREG(sub_job->info.st_mode)) {
+                sprintf(sub_job->filepath, "%s#/%s", f->filepath, archive_entry_pathname(entry));
+                sub_job->base = (int) (strrchr(sub_job->filepath, '/') - sub_job->filepath) + 1;
+
+                char *p = strrchr(sub_job->filepath, '.');
+                if (p != NULL) {
+                    sub_job->ext = (int) (p - sub_job->filepath + 1);
+                } else {
+                    sub_job->ext = (int) strlen(sub_job->filepath);
+                }
+
+                parse(sub_job);
+            }
+        }
+
+        free(sub_job);
+    }
+
+    archive_read_free(a);
+}

src/parsing/arc.h

@@ -0,0 +1,12 @@
+#ifndef SIST2_ARC_H
+#define SIST2_ARC_H
+
+#include "src/sist.h"
+
+int should_parse_filtered_file(const char *filepath, int ext);
+
+void parse_archive(vfile_t *f, document_t *doc);
+
+int arc_read(struct vfile * f, void *buf, size_t size);
+
+#endif

src/parsing/doc.c

@@ -0,0 +1,98 @@
+#include "doc.h"
+
+static void dumpText(mceTextReader_t *reader, dyn_buffer_t *buf) {
+
+    mce_skip_attributes(reader);
+
+    mce_start_children(reader) {
+        mce_start_element(reader, NULL, _X("t")) {
+            mce_skip_attributes(reader);
+            mce_start_children(reader) {
+                mce_start_text(reader) {
+                    char *str = (char *) xmlTextReaderConstValue(reader->reader);
+                    dyn_buffer_append_string(buf, str);
+                    dyn_buffer_write_char(buf, ' ');
+                } mce_end_text(reader);
+            } mce_end_children(reader);
+        } mce_end_element(reader);
+
+        mce_start_element(reader, NULL, NULL) {
+            dumpText(reader, buf);
+        } mce_end_element(reader);
+
+    } mce_end_children(reader)
+}
+
+__always_inline
+int should_read_part(opcPart part) {
+
+    char *part_name = (char *) part;
+
+    if (part == NULL) {
+        return FALSE;
+    }
+
+    if (    // Word
+            strcmp(part_name, "word/document.xml") == 0
+            || strncmp(part_name, "word/footer", sizeof("word/footer") - 1) == 0
+            || strncmp(part_name, "word/header", sizeof("word/header") - 1) == 0
+            // PowerPoint
+            || strncmp(part_name, "ppt/slides/slide", sizeof("ppt/slides/slide") - 1) == 0
+            || strncmp(part_name, "ppt/notesSlides/notesSlide", sizeof("ppt/notesSlides/notesSlide") - 1) == 0
+            // Excel
+            || strncmp(part_name, "xl/worksheets/sheet", sizeof("xl/worksheets/sheet") - 1) == 0
+            || strcmp(part_name, "xl/sharedStrings.xml") == 0
+            || strcmp(part_name, "xl/workbook.xml") == 0
+            ) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+void read_part(opcContainer *c, dyn_buffer_t *buf, opcPart part) {
+
+    mceTextReader_t reader;
+    int ret = opcXmlReaderOpen(c, &reader, part, NULL, "UTF-8", 0);
+
+    if (ret != OPC_ERROR_NONE) {
+        //todo verbose
+        return;
+    }
+
+    mce_start_document(&reader) {
+        mce_start_element(&reader, NULL, NULL) {
+            dumpText(&reader, buf);
+        } mce_end_element(&reader);
+    }mce_end_document(&reader);
+
+    mceTextReaderCleanup(&reader);
+}
+
+void parse_doc(void *mem, size_t mem_len, document_t *doc) {
+
+    opcContainer *c = opcContainerOpenMem(mem, mem_len, OPC_OPEN_READ_ONLY, NULL);
+    if (c == NULL) {
+        //todo verbose
+        return;
+    }
+
+    dyn_buffer_t buf = dyn_buffer_create();
+
+    opcPart part = opcPartGetFirst(c);
+    do {
+        if (should_read_part(part)) {
+            read_part(c, &buf, part);
+        }
+    } while ((part = opcPartGetNext(c, part)));
+
+    opcContainerClose(c, OPC_CLOSE_NOW);
+    dyn_buffer_write_char(&buf, '\0');
+
+    meta_line_t *meta = malloc(sizeof(meta_line_t) + buf.cur);
+    meta->key = MetaContent;
+    strcpy(meta->strval, buf.buf);
+    APPEND_META(doc, meta)
+
+    dyn_buffer_destroy(&buf);
+}

src/parsing/doc.h

@@ -0,0 +1,8 @@
+#ifndef SIST2_DOC_H
+#define SIST2_DOC_H
+
+#include "src/sist.h"
+
+void parse_doc(void *buf, size_t buf_len, document_t *doc);
+
+#endif

src/parsing/font.c

@@ -1,11 +1,9 @@
 #include "font.h"
 
-#include "ft2build.h"
-#include "freetype/freetype.h"
 
 #include "src/ctx.h"
 
-__thread FT_Library library = NULL;
+__thread FT_Library ft_lib = NULL;
 
 
 typedef struct text_dimensions {
@@ -139,15 +137,15 @@ void bmp_format(dyn_buffer_t *buf, text_dimensions_t dimensions, const unsigned
 }
 
 void parse_font(const char *buf, size_t buf_len, document_t *doc) {
-    if (library == NULL) {
-        FT_Init_FreeType(&library);
+    if (ft_lib == NULL) {
+        FT_Init_FreeType(&ft_lib);
     }
     if (buf == NULL) {
         return;
     }
 
     FT_Face face;
-    FT_Error err = FT_New_Memory_Face(library, (unsigned char *) buf, buf_len, 0, &face);
+    FT_Error err = FT_New_Memory_Face(ft_lib, (unsigned char *) buf, buf_len, 0, &face);
     if (err != 0) {
         return;
     }
@@ -169,6 +167,10 @@ void parse_font(const char *buf, size_t buf_len, document_t *doc) {
     strcpy(meta_name->strval, font_name);
     APPEND_META(doc, meta_name)
 
+    if (ScanCtx.tn_size <= 0) {
+        return;
+    }
+
     int pixel = 64;
     int num_chars = (int) strlen(font_name);
 

src/parsing/media.c

@@ -2,6 +2,7 @@
 #include "src/ctx.h"
 
 #define MIN_SIZE 32
+#define AVIO_BUF_SIZE 8192
 
 __always_inline
 AVCodecContext *alloc_jpeg_encoder(int dstW, int dstH, float qscale) {
@@ -89,9 +90,9 @@ AVFrame *read_frame(AVFormatContext *pFormatCtx, AVCodecContext *decoder, int st
             int read_frame_ret = av_read_frame(pFormatCtx, &avPacket);
 
             if (read_frame_ret != 0) {
-                if (read_frame_ret != AVERROR_EOF) {
-                    fprintf(stderr, "Error reading frame: %d\n", read_frame_ret);
-                }
+//                if (read_frame_ret != AVERROR_EOF) {
+//                    fprintf(stderr, "Error reading frame: %d\n", read_frame_ret);
+//                }
                 av_frame_free(&frame);
                 av_packet_unref(&avPacket);
                 return NULL;
@@ -188,22 +189,11 @@ void append_video_meta(AVFormatContext *pFormatCtx, AVFrame *frame, document_t *
     }
 }
 
-void parse_media(const char *filepath, document_t *doc) {
+void parse_media(AVFormatContext *pFormatCtx, document_t *doc) {
 
     int video_stream = -1;
     int audio_stream = -1;
 
-    AVFormatContext *pFormatCtx = avformat_alloc_context();
-    if (pFormatCtx == NULL) {
-        fprintf(stderr, "Could not allocate AVFormatContext! %s \n", filepath);
-        return;
-    }
-    int res = avformat_open_input(&pFormatCtx, filepath, NULL, NULL);
-    if (res < 0) {
-        fprintf(stderr, "media error: %s %s\n", filepath, av_err2str(res));
-        return;
-    }
-
     avformat_find_stream_info(pFormatCtx, NULL);
 
     for (int i = (int) pFormatCtx->nb_streams - 1; i >= 0; i--) {
@@ -242,7 +232,7 @@ void parse_media(const char *filepath, document_t *doc) {
         }
     }
 
-    if (video_stream != -1) {
+    if (video_stream != -1 && ScanCtx.tn_size > 0) {
         AVStream *stream = pFormatCtx->streams[video_stream];
 
         if (stream->codecpar->width <= MIN_SIZE || stream->codecpar->height <= MIN_SIZE) {
@@ -314,3 +304,58 @@ void parse_media(const char *filepath, document_t *doc) {
     avformat_free_context(pFormatCtx);
 }
 
+void parse_media_filename(const char *filepath, document_t *doc) {
+
+    AVFormatContext *pFormatCtx = avformat_alloc_context();
+    if (pFormatCtx == NULL) {
+        fprintf(stderr, "Could not allocate AVFormatContext! %s \n", filepath);
+        return;
+    }
+    int res = avformat_open_input(&pFormatCtx, filepath, NULL, NULL);
+    if (res < 0) {
+        fprintf(stderr, "media error: %s %s\n", filepath, av_err2str(res));
+        return;
+    }
+
+    parse_media(pFormatCtx, doc);
+}
+
+
+int vfile_read(void *ptr, uint8_t *buf, int buf_size) {
+    struct vfile *f = ptr;
+
+    int ret = f->read(f, buf, buf_size);
+
+    if (ret == 0) {
+        return AVERROR_EOF;
+    }
+    return ret;
+}
+
+void parse_media_vfile(struct vfile *f, document_t *doc) {
+
+    AVFormatContext *pFormatCtx = avformat_alloc_context();
+    if (pFormatCtx == NULL) {
+        fprintf(stderr, "Could not allocate AVFormatContext! %s \n", f->filepath);
+        return;
+    }
+
+    unsigned char *buffer = (unsigned char *) av_malloc(AVIO_BUF_SIZE);
+    AVIOContext *io_ctx = avio_alloc_context(buffer, AVIO_BUF_SIZE, 0, f, vfile_read, NULL, NULL);
+
+    pFormatCtx->pb = io_ctx;
+    pFormatCtx->flags |= AVFMT_FLAG_CUSTOM_IO;
+
+    int res = avformat_open_input(&pFormatCtx, "", NULL, NULL);
+    if (res == -5) {
+        // Tried to parse media that requires seek
+        return;
+    } else if(res < 0) {
+        fprintf(stderr, "media error: %s %s\n", f->filepath, av_err2str(res));
+        return;
+    }
+
+    parse_media(pFormatCtx, doc);
+    av_free(io_ctx);
+}
+

src/parsing/media.h

@@ -7,6 +7,8 @@
 #define MIN_VIDEO_SIZE 1024 * 64
 #define MIN_IMAGE_SIZE 1024 * 2
 
-void parse_media(const char * filepath, document_t *doc);
+void parse_media_filename(const char * filepath, document_t *doc);
+
+void parse_media_vfile(struct vfile *f, document_t *doc);
 
 #endif

src/parsing/mime.h

@@ -8,7 +8,7 @@
 #define MIME_EMPTY 1
 
 #define DONT_PARSE 0x80000000
-#define SHOULD_PARSE(mime_id) (mime_id & DONT_PARSE) != DONT_PARSE
+#define SHOULD_PARSE(mime_id) (mime_id & DONT_PARSE) != DONT_PARSE && mime_id != 0
 
 #define PDF_MASK 0x40000000
 #define IS_PDF(mime_id) (mime_id & PDF_MASK) == PDF_MASK
@@ -16,6 +16,15 @@
 #define FONT_MASK 0x20000000
 #define IS_FONT(mime_id) (mime_id & FONT_MASK) == FONT_MASK
 
+#define ARC_MASK 0x10000000
+#define IS_ARC(mime_id) (mime_id & ARC_MASK) == ARC_MASK
+
+#define ARC_FILTER_MASK 0x08000000
+#define IS_ARC_FILTER(mime_id) (mime_id & ARC_FILTER_MASK) == ARC_FILTER_MASK
+
+#define DOC_MASK 0x04000000
+#define IS_DOC(mime_id) (mime_id & DOC_MASK) == DOC_MASK
+
 enum major_mime {
     MimeInvalid = 0,
     MimeModel = 1,

src/parsing/mime_generated.c

@@ -20,7 +20,7 @@ enum mime {
     application_freeloader=655372,
     application_futuresplash=655373,
     application_groupwise=655374,
-    application_gzip=655375,
+    application_gzip=655375 | 0x08000000,
     application_hta=655376,
     application_i_deas=655377,
     application_iges=655378,
@@ -72,9 +72,9 @@ enum mime {
     application_vnd_oasis_opendocument_presentation=655424,
     application_vnd_oasis_opendocument_spreadsheet=655425,
     application_vnd_oasis_opendocument_text=655426,
-    application_vnd_openxmlformats_officedocument_presentationml_presentation=655427,
-    application_vnd_openxmlformats_officedocument_spreadsheetml_sheet=655428,
-    application_vnd_openxmlformats_officedocument_wordprocessingml_document=655429,
+    application_vnd_openxmlformats_officedocument_presentationml_presentation=655427 | 0x04000000,
+    application_vnd_openxmlformats_officedocument_spreadsheetml_sheet=655428 | 0x04000000,
+    application_vnd_openxmlformats_officedocument_wordprocessingml_document=655429 | 0x04000000,
     application_vnd_symbian_install=655430,
     application_vnd_tcpdump_pcap=655431,
     application_vnd_wap_wmlc=655432,
@@ -82,342 +82,346 @@ enum mime {
     application_vnd_xara=655434,
     application_vocaltec_media_desc=655435,
     application_vocaltec_media_file=655436,
-    application_winhelp=655437,
-    application_wordperfect=655438,
-    application_wordperfect6_0=655439,
-    application_wordperfect6_1=655440,
-    application_x_123=655441,
-    application_x_7z_compressed=655442,
-    application_x_aim=655443,
-    application_x_apple_diskimage=655444,
-    application_x_arc=655445,
-    application_x_archive=655446,
-    application_x_atari_7800_rom=655447,
-    application_x_authorware_bin=655448,
-    application_x_authorware_map=655449,
-    application_x_authorware_seg=655450,
-    application_x_avira_qua=655451,
-    application_x_bcpio=655452,
-    application_x_bittorrent=655453,
-    application_x_bsh=655454,
-    application_x_bytecode_python=655455,
-    application_x_bzip=655456,
-    application_x_bzip2=655457,
-    application_x_cbr=655458,
-    application_x_cbz=655459 | 0x40000000,
-    application_x_cdlink=655460,
-    application_x_chat=655461,
-    application_x_chrome_extension=655462,
-    application_x_cocoa=655463,
-    application_x_conference=655464,
-    application_x_coredump=655465,
-    application_x_cpio=655466,
-    application_x_dbf=655467,
-    application_x_dbt=655468,
-    application_x_debian_package=655469,
-    application_x_deepv=655470,
-    application_x_director=655471,
-    application_x_dmp=655472,
-    application_x_dosdriver=655473,
-    application_x_dosexec=655474,
-    application_x_dvi=655475,
-    application_x_elc=655476,
+    application_warc=655437,
+    application_winhelp=655438,
+    application_wordperfect=655439,
+    application_wordperfect6_0=655440,
+    application_wordperfect6_1=655441,
+    application_x_123=655442,
+    application_x_7z_compressed=655443 | 0x10000000,
+    application_x_aim=655444,
+    application_x_apple_diskimage=655445,
+    application_x_arc=655446 | 0x10000000,
+    application_x_archive=655447,
+    application_x_atari_7800_rom=655448,
+    application_x_authorware_bin=655449,
+    application_x_authorware_map=655450,
+    application_x_authorware_seg=655451,
+    application_x_avira_qua=655452,
+    application_x_bcpio=655453,
+    application_x_bittorrent=655454,
+    application_x_bsh=655455,
+    application_x_bytecode_python=655456,
+    application_x_bzip=655457,
+    application_x_bzip2=655458 | 0x08000000,
+    application_x_cbr=655459,
+    application_x_cbz=655460 | 0x40000000,
+    application_x_cdlink=655461,
+    application_x_chat=655462,
+    application_x_chrome_extension=655463,
+    application_x_cocoa=655464,
+    application_x_conference=655465,
+    application_x_coredump=655466,
+    application_x_cpio=655467,
+    application_x_dbf=655468,
+    application_x_dbt=655469,
+    application_x_debian_package=655470,
+    application_x_deepv=655471,
+    application_x_director=655472,
+    application_x_dmp=655473,
+    application_x_dosdriver=655474,
+    application_x_dosexec=655475,
+    application_x_dvi=655476,
+    application_x_elc=655477,
     application_x_empty=1,
-    application_x_envoy=655478,
-    application_x_esrehber=655479,
-    application_x_excel=655480,
-    application_x_executable=655481,
-    application_x_font_gdos=655482,
-    application_x_font_pf2=655483,
-    application_x_font_pfm=655484,
-    application_x_font_sfn=655485,
-    application_x_font_ttf=655486 | 0x20000000,
-    application_x_freelance=655487,
-    application_x_gamecube_rom=655488,
-    application_x_gdbm=655489,
-    application_x_gettext_translation=655490,
-    application_x_git=655491,
-    application_x_gsp=655492,
-    application_x_gss=655493,
-    application_x_gtar=655494,
-    application_x_gzip=655495,
-    application_x_hdf=655496,
-    application_x_helpfile=655497,
-    application_x_httpd_imap=655498,
-    application_x_ima=655499,
-    application_x_innosetup=655500,
-    application_x_internett_signup=655501,
-    application_x_inventor=655502,
-    application_x_ip2=655503,
-    application_x_java_applet=655504,
-    application_x_java_commerce=655505,
-    application_x_java_image=655506,
-    application_x_java_jmod=655507,
-    application_x_java_keystore=655508,
-    application_x_kdelnk=655509,
-    application_x_koan=655510,
-    application_x_latex=655511,
-    application_x_livescreen=655512,
-    application_x_lotus=655513,
-    application_x_lz4=655514,
-    application_x_lz4_json=655515,
-    application_x_lzh=655516,
-    application_x_lzh_compressed=655517,
-    application_x_lzx=655518,
-    application_x_mach_binary=655519,
-    application_x_mach_executable=655520,
-    application_x_magic_cap_package_1_0=655521,
-    application_x_mathcad=655522,
-    application_x_maxis_dbpf=655523,
-    application_x_meme=655524,
-    application_x_midi=655525,
-    application_x_mif=655526,
-    application_x_mix_transfer=655527,
-    application_x_mobipocket_ebook=655528,
-    application_x_ms_compress_szdd=655529,
-    application_x_ms_pdb=655530,
-    application_x_ms_reader=655531,
-    application_x_msaccess=655532,
-    application_x_navi_animation=655533,
-    application_x_navidoc=655534,
-    application_x_navimap=655535,
-    application_x_navistyle=655536,
-    application_x_nes_rom=655537,
-    application_x_netcdf=655538,
-    application_x_newton_compatible_pkg=655539,
-    application_x_nintendo_ds_rom=655540,
-    application_x_object=655541,
-    application_x_omc=655542,
-    application_x_omcdatamaker=655543,
-    application_x_omcregerator=655544,
-    application_x_pagemaker=655545,
-    application_x_pcl=655546,
-    application_x_pgp_keyring=655547,
-    application_x_pixclscript=655548,
-    application_x_pkcs7_certreqresp=655549,
-    application_x_pkcs7_signature=655550,
-    application_x_project=655551,
-    application_x_qpro=655552,
-    application_x_rar=655553,
-    application_x_rpm=655554,
-    application_x_sdp=655555,
-    application_x_sea=655556,
-    application_x_seelogo=655557,
-    application_x_setupscript=655558,
-    application_x_shar=655559,
-    application_x_sharedlib=655560,
-    application_x_shockwave_flash=655561,
-    application_x_snappy_framed=655562,
-    application_x_sprite=655563,
-    application_x_sqlite3=655564,
-    application_x_sv4cpio=655565,
-    application_x_sv4crc=655566,
-    application_x_tar=655567,
-    application_x_tbook=655568,
-    application_x_terminfo=655569,
-    application_x_terminfo2=655570,
-    application_x_tex_tfm=655571,
-    application_x_texinfo=655572,
-    application_x_ustar=655573,
-    application_x_visio=655574,
-    application_x_vnd_audioexplosion_mzz=655575,
-    application_x_vnd_ls_xpix=655576,
-    application_x_vrml=655577,
-    application_x_wais_source=655578,
-    application_x_wine_extension_ini=655579,
-    application_x_wintalk=655580,
-    application_x_world=655581,
-    application_x_wri=655582,
-    application_x_x509_ca_cert=655583,
-    application_x_xz=655584,
-    application_x_zip=655585,
-    application_x_zstd=655586,
-    application_xml=655587,
-    application_zip=655588,
-    application_zlib=655589,
-    audio_it=458982,
-    audio_make=458983,
-    audio_mid=458984,
-    audio_midi=458985,
-    audio_mp4=458986,
-    audio_mpeg=458987,
-    audio_ogg=458988,
-    audio_s3m=458989,
-    audio_tsp_audio=458990,
-    audio_tsplayer=458991,
-    audio_vnd_qcelp=458992,
-    audio_voxware=458993,
-    audio_x_aiff=458994,
-    audio_x_flac=458995,
-    audio_x_gsm=458996,
-    audio_x_hx_aac_adts=458997,
-    audio_x_jam=458998,
-    audio_x_liveaudio=458999,
-    audio_x_m4a=459000,
-    audio_x_midi=459001,
-    audio_x_mod=459002,
-    audio_x_mp4a_latm=459003,
-    audio_x_mpeg_3=459004,
-    audio_x_mpequrl=459005,
-    audio_x_nspaudio=459006,
-    audio_x_pn_realaudio=459007,
-    audio_x_psid=459008,
-    audio_x_realaudio=459009,
-    audio_x_twinvq=459010,
-    audio_x_twinvq_plugin=459011,
-    audio_x_voc=459012,
-    audio_x_wav=459013,
-    audio_xm=459014,
-    font_otf=327943 | 0x20000000,
-    font_sfnt=327944 | 0x20000000,
-    font_woff=327945 | 0x20000000,
-    font_woff2=327946 | 0x20000000,
-    image_cmu_raster=524555,
-    image_fif=524556,
-    image_florian=524557,
-    image_g3fax=524558,
-    image_gif=524559,
-    image_heic=524560,
-    image_ief=524561,
-    image_jpeg=524562,
-    image_jutvision=524563,
-    image_naplps=524564,
-    image_pict=524565,
-    image_png=524566,
-    image_svg=524567 | 0x80000000,
-    image_svg_xml=524568 | 0x80000000,
-    image_tiff=524569,
-    image_vnd_adobe_photoshop=524570 | 0x80000000,
-    image_vnd_djvu=524571 | 0x80000000,
-    image_vnd_fpx=524572,
-    image_vnd_microsoft_icon=524573,
-    image_vnd_rn_realflash=524574,
-    image_vnd_rn_realpix=524575,
-    image_vnd_wap_wbmp=524576,
-    image_vnd_xiff=524577,
-    image_webp=524578,
-    image_wmf=524579,
-    image_x_3ds=524580,
-    image_x_cmu_raster=524581,
-    image_x_cur=524582,
-    image_x_dwg=524583,
-    image_x_eps=524584,
-    image_x_exr=524585,
-    image_x_gem=524586,
-    image_x_icns=524587,
-    image_x_icon=524588 | 0x80000000,
-    image_x_jg=524589,
-    image_x_jps=524590,
-    image_x_ms_bmp=524591,
-    image_x_niff=524592,
-    image_x_pcx=524593,
-    image_x_pict=524594,
-    image_x_portable_bitmap=524595,
-    image_x_portable_graymap=524596,
-    image_x_portable_pixmap=524597,
-    image_x_quicktime=524598,
-    image_x_rgb=524599,
-    image_x_tga=524600,
-    image_x_tiff=524601,
-    image_x_win_bitmap=524602,
-    image_x_xcf=524603 | 0x80000000,
-    image_x_xpixmap=524604 | 0x80000000,
-    image_x_xwindowdump=524605,
-    message_news=196926,
-    message_rfc822=196927,
-    model_vnd_dwf=65856,
-    model_vnd_gdl=65857,
-    model_vnd_gs_gdl=65858,
-    model_vrml=65859,
-    model_x_pov=65860,
-    text_PGP=590149,
-    text_asp=590150,
-    text_css=590151,
-    text_html=590152,
-    text_javascript=590153,
-    text_mcf=590154,
-    text_pascal=590155,
-    text_plain=590156,
-    text_richtext=590157,
-    text_rtf=590158,
-    text_scriplet=590159,
-    text_tab_separated_values=590160,
-    text_troff=590161,
-    text_uri_list=590162,
-    text_vnd_abc=590163,
-    text_vnd_fmi_flexstor=590164,
-    text_vnd_wap_wml=590165,
-    text_vnd_wap_wmlscript=590166,
-    text_webviewhtml=590167,
-    text_x_Algol68=590168,
-    text_x_asm=590169,
-    text_x_audiosoft_intra=590170,
-    text_x_awk=590171,
-    text_x_bcpl=590172,
-    text_x_c=590173,
-    text_x_c__=590174,
-    text_x_component=590175,
-    text_x_diff=590176,
-    text_x_fortran=590177,
-    text_x_java=590178,
-    text_x_la_asf=590179,
-    text_x_lisp=590180,
-    text_x_m=590181,
-    text_x_m4=590182,
-    text_x_makefile=590183,
-    text_x_ms_regedit=590184,
-    text_x_msdos_batch=590185,
-    text_x_objective_c=590186,
-    text_x_pascal=590187,
-    text_x_perl=590188,
-    text_x_php=590189,
-    text_x_po=590190,
-    text_x_python=590191,
-    text_x_ruby=590192,
-    text_x_sass=590193,
-    text_x_scss=590194,
-    text_x_server_parsed_html=590195,
-    text_x_setext=590196,
-    text_x_sgml=590197,
-    text_x_shellscript=590198,
-    text_x_speech=590199,
-    text_x_tcl=590200,
-    text_x_tex=590201,
-    text_x_uil=590202,
-    text_x_uuencode=590203,
-    text_x_vcalendar=590204,
-    text_x_vcard=590205,
-    text_xml=590206,
-    video_MP2T=393599,
-    video_animaflex=393600,
-    video_avi=393601,
-    video_avs_video=393602,
-    video_mp4=393603,
-    video_mpeg=393604,
-    video_quicktime=393605,
-    video_vdo=393606,
-    video_vivo=393607,
-    video_vnd_rn_realvideo=393608,
-    video_vosaic=393609,
-    video_webm=393610,
-    video_x_amt_demorun=393611,
-    video_x_amt_showrun=393612,
-    video_x_atomic3d_feature=393613,
-    video_x_dl=393614,
-    video_x_dv=393615,
-    video_x_fli=393616,
-    video_x_flv=393617,
-    video_x_isvideo=393618,
-    video_x_jng=393619 | 0x80000000,
-    video_x_m4v=393620,
-    video_x_matroska=393621,
-    video_x_mng=393622,
-    video_x_motion_jpeg=393623,
-    video_x_ms_asf=393624,
-    video_x_msvideo=393625,
-    video_x_qtc=393626,
-    video_x_sgi_movie=393627,
-    x_epoc_x_sisx_app=721308,
+    application_x_envoy=655479,
+    application_x_esrehber=655480,
+    application_x_excel=655481,
+    application_x_executable=655482,
+    application_x_font_gdos=655483,
+    application_x_font_pf2=655484,
+    application_x_font_pfm=655485,
+    application_x_font_sfn=655486,
+    application_x_font_ttf=655487 | 0x20000000,
+    application_x_freelance=655488,
+    application_x_gamecube_rom=655489,
+    application_x_gdbm=655490,
+    application_x_gettext_translation=655491,
+    application_x_git=655492,
+    application_x_gsp=655493,
+    application_x_gss=655494,
+    application_x_gtar=655495,
+    application_x_gzip=655496,
+    application_x_hdf=655497,
+    application_x_helpfile=655498,
+    application_x_httpd_imap=655499,
+    application_x_ima=655500,
+    application_x_innosetup=655501,
+    application_x_internett_signup=655502,
+    application_x_inventor=655503,
+    application_x_ip2=655504,
+    application_x_java_applet=655505,
+    application_x_java_commerce=655506,
+    application_x_java_image=655507,
+    application_x_java_jmod=655508,
+    application_x_java_keystore=655509,
+    application_x_kdelnk=655510,
+    application_x_koan=655511,
+    application_x_latex=655512,
+    application_x_livescreen=655513,
+    application_x_lotus=655514,
+    application_x_lz4=655515 | 0x08000000,
+    application_x_lz4_json=655516,
+    application_x_lzh=655517,
+    application_x_lzh_compressed=655518,
+    application_x_lzip=655519 | 0x08000000,
+    application_x_lzma=655520 | 0x08000000,
+    application_x_lzop=655521 | 0x08000000,
+    application_x_lzx=655522,
+    application_x_mach_binary=655523,
+    application_x_mach_executable=655524,
+    application_x_magic_cap_package_1_0=655525,
+    application_x_mathcad=655526,
+    application_x_maxis_dbpf=655527,
+    application_x_meme=655528,
+    application_x_midi=655529,
+    application_x_mif=655530,
+    application_x_mix_transfer=655531,
+    application_x_mobipocket_ebook=655532,
+    application_x_ms_compress_szdd=655533,
+    application_x_ms_pdb=655534,
+    application_x_ms_reader=655535,
+    application_x_msaccess=655536,
+    application_x_navi_animation=655537,
+    application_x_navidoc=655538,
+    application_x_navimap=655539,
+    application_x_navistyle=655540,
+    application_x_nes_rom=655541,
+    application_x_netcdf=655542,
+    application_x_newton_compatible_pkg=655543,
+    application_x_nintendo_ds_rom=655544,
+    application_x_object=655545,
+    application_x_omc=655546,
+    application_x_omcdatamaker=655547,
+    application_x_omcregerator=655548,
+    application_x_pagemaker=655549,
+    application_x_pcl=655550,
+    application_x_pgp_keyring=655551,
+    application_x_pixclscript=655552,
+    application_x_pkcs7_certreqresp=655553,
+    application_x_pkcs7_signature=655554,
+    application_x_project=655555,
+    application_x_qpro=655556,
+    application_x_rar=655557 | 0x10000000,
+    application_x_rpm=655558,
+    application_x_sdp=655559,
+    application_x_sea=655560,
+    application_x_seelogo=655561,
+    application_x_setupscript=655562,
+    application_x_shar=655563,
+    application_x_sharedlib=655564,
+    application_x_shockwave_flash=655565,
+    application_x_snappy_framed=655566,
+    application_x_sprite=655567,
+    application_x_sqlite3=655568,
+    application_x_sv4cpio=655569,
+    application_x_sv4crc=655570,
+    application_x_tar=655571 | 0x10000000,
+    application_x_tbook=655572,
+    application_x_terminfo=655573,
+    application_x_terminfo2=655574,
+    application_x_tex_tfm=655575,
+    application_x_texinfo=655576,
+    application_x_ustar=655577,
+    application_x_visio=655578,
+    application_x_vnd_audioexplosion_mzz=655579,
+    application_x_vnd_ls_xpix=655580,
+    application_x_vrml=655581,
+    application_x_wais_source=655582,
+    application_x_wine_extension_ini=655583,
+    application_x_wintalk=655584,
+    application_x_world=655585,
+    application_x_wri=655586,
+    application_x_x509_ca_cert=655587,
+    application_x_xz=655588 | 0x08000000,
+    application_x_zip=655589,
+    application_x_zstd=655590 | 0x08000000,
+    application_xml=655591,
+    application_zip=655592 | 0x10000000,
+    application_zlib=655593,
+    audio_it=458986,
+    audio_make=458987,
+    audio_mid=458988,
+    audio_midi=458989,
+    audio_mp4=458990,
+    audio_mpeg=458991,
+    audio_ogg=458992,
+    audio_s3m=458993,
+    audio_tsp_audio=458994,
+    audio_tsplayer=458995,
+    audio_vnd_qcelp=458996,
+    audio_voxware=458997,
+    audio_x_aiff=458998,
+    audio_x_flac=458999,
+    audio_x_gsm=459000,
+    audio_x_hx_aac_adts=459001,
+    audio_x_jam=459002,
+    audio_x_liveaudio=459003,
+    audio_x_m4a=459004,
+    audio_x_midi=459005,
+    audio_x_mod=459006,
+    audio_x_mp4a_latm=459007,
+    audio_x_mpeg_3=459008,
+    audio_x_mpequrl=459009,
+    audio_x_nspaudio=459010,
+    audio_x_pn_realaudio=459011,
+    audio_x_psid=459012,
+    audio_x_realaudio=459013,
+    audio_x_twinvq=459014,
+    audio_x_twinvq_plugin=459015,
+    audio_x_voc=459016,
+    audio_x_wav=459017,
+    audio_xm=459018,
+    font_otf=327947 | 0x20000000,
+    font_sfnt=327948 | 0x20000000,
+    font_woff=327949 | 0x20000000,
+    font_woff2=327950 | 0x20000000,
+    image_cmu_raster=524559,
+    image_fif=524560,
+    image_florian=524561,
+    image_g3fax=524562,
+    image_gif=524563,
+    image_heic=524564,
+    image_ief=524565,
+    image_jpeg=524566,
+    image_jutvision=524567,
+    image_naplps=524568,
+    image_pict=524569,
+    image_png=524570,
+    image_svg=524571 | 0x80000000,
+    image_svg_xml=524572 | 0x80000000,
+    image_tiff=524573,
+    image_vnd_adobe_photoshop=524574 | 0x80000000,
+    image_vnd_djvu=524575 | 0x80000000,
+    image_vnd_fpx=524576,
+    image_vnd_microsoft_icon=524577,
+    image_vnd_rn_realflash=524578,
+    image_vnd_rn_realpix=524579,
+    image_vnd_wap_wbmp=524580,
+    image_vnd_xiff=524581,
+    image_webp=524582,
+    image_wmf=524583,
+    image_x_3ds=524584,
+    image_x_cmu_raster=524585,
+    image_x_cur=524586,
+    image_x_dwg=524587,
+    image_x_eps=524588,
+    image_x_exr=524589,
+    image_x_gem=524590,
+    image_x_icns=524591,
+    image_x_icon=524592 | 0x80000000,
+    image_x_jg=524593,
+    image_x_jps=524594,
+    image_x_ms_bmp=524595,
+    image_x_niff=524596,
+    image_x_pcx=524597,
+    image_x_pict=524598,
+    image_x_portable_bitmap=524599,
+    image_x_portable_graymap=524600,
+    image_x_portable_pixmap=524601,
+    image_x_quicktime=524602,
+    image_x_rgb=524603,
+    image_x_tga=524604,
+    image_x_tiff=524605,
+    image_x_win_bitmap=524606,
+    image_x_xcf=524607 | 0x80000000,
+    image_x_xpixmap=524608 | 0x80000000,
+    image_x_xwindowdump=524609,
+    message_news=196930,
+    message_rfc822=196931,
+    model_vnd_dwf=65860,
+    model_vnd_gdl=65861,
+    model_vnd_gs_gdl=65862,
+    model_vrml=65863,
+    model_x_pov=65864,
+    text_PGP=590153,
+    text_asp=590154,
+    text_css=590155,
+    text_html=590156,
+    text_javascript=590157,
+    text_mcf=590158,
+    text_pascal=590159,
+    text_plain=590160,
+    text_richtext=590161,
+    text_rtf=590162,
+    text_scriplet=590163,
+    text_tab_separated_values=590164,
+    text_troff=590165,
+    text_uri_list=590166,
+    text_vnd_abc=590167,
+    text_vnd_fmi_flexstor=590168,
+    text_vnd_wap_wml=590169,
+    text_vnd_wap_wmlscript=590170,
+    text_webviewhtml=590171,
+    text_x_Algol68=590172,
+    text_x_asm=590173,
+    text_x_audiosoft_intra=590174,
+    text_x_awk=590175,
+    text_x_bcpl=590176,
+    text_x_c=590177,
+    text_x_c__=590178,
+    text_x_component=590179,
+    text_x_diff=590180,
+    text_x_fortran=590181,
+    text_x_java=590182,
+    text_x_la_asf=590183,
+    text_x_lisp=590184,
+    text_x_m=590185,
+    text_x_m4=590186,
+    text_x_makefile=590187,
+    text_x_ms_regedit=590188,
+    text_x_msdos_batch=590189,
+    text_x_objective_c=590190,
+    text_x_pascal=590191,
+    text_x_perl=590192,
+    text_x_php=590193,
+    text_x_po=590194,
+    text_x_python=590195,
+    text_x_ruby=590196,
+    text_x_sass=590197,
+    text_x_scss=590198,
+    text_x_server_parsed_html=590199,
+    text_x_setext=590200,
+    text_x_sgml=590201,
+    text_x_shellscript=590202,
+    text_x_speech=590203,
+    text_x_tcl=590204,
+    text_x_tex=590205,
+    text_x_uil=590206,
+    text_x_uuencode=590207,
+    text_x_vcalendar=590208,
+    text_x_vcard=590209,
+    text_xml=590210,
+    video_MP2T=393603,
+    video_animaflex=393604,
+    video_avi=393605,
+    video_avs_video=393606,
+    video_mp4=393607,
+    video_mpeg=393608,
+    video_quicktime=393609,
+    video_vdo=393610,
+    video_vivo=393611,
+    video_vnd_rn_realvideo=393612,
+    video_vosaic=393613,
+    video_webm=393614,
+    video_x_amt_demorun=393615,
+    video_x_amt_showrun=393616,
+    video_x_atomic3d_feature=393617,
+    video_x_dl=393618,
+    video_x_dv=393619,
+    video_x_fli=393620,
+    video_x_flv=393621,
+    video_x_isvideo=393622,
+    video_x_jng=393623 | 0x80000000,
+    video_x_m4v=393624,
+    video_x_matroska=393625,
+    video_x_mng=393626,
+    video_x_motion_jpeg=393627,
+    video_x_ms_asf=393628,
+    video_x_msvideo=393629,
+    video_x_qtc=393630,
+    video_x_sgi_movie=393631,
+    x_epoc_x_sisx_app=721312,
 };
 char *mime_get_mime_text(unsigned int mime_id) {switch (mime_id) {
 case application_arj: return "application/arj";
@@ -832,6 +836,10 @@ case audio_x_hx_aac_adts: return "audio/x-hx-aac-adts";
 case application_x_chrome_extension: return "application/x-chrome-extension";
 case image_heic: return "image/heic";
 case image_x_gem: return "image/x-gem";
+case application_x_lzma: return "application/x-lzma";
+case application_warc: return "application/warc";
+case application_x_lzip: return "application/x-lzip";
+case application_x_lzop: return "application/x-lzop";
 default: return NULL;}}
 GHashTable *mime_get_ext_table() {GHashTable *ext_table = g_hash_table_new(g_str_hash, g_str_equal);
 g_hash_table_insert(ext_table, "arj", (gpointer)application_arj);
@@ -1182,6 +1190,9 @@ g_hash_table_insert(ext_table, "d", (gpointer)text_plain);
 g_hash_table_insert(ext_table, "cs", (gpointer)text_plain);
 g_hash_table_insert(ext_table, "hpp", (gpointer)text_plain);
 g_hash_table_insert(ext_table, "srt", (gpointer)text_plain);
+g_hash_table_insert(ext_table, "nfo", (gpointer)text_plain);
+g_hash_table_insert(ext_table, "sfv", (gpointer)text_plain);
+g_hash_table_insert(ext_table, "m3u", (gpointer)text_plain);
 g_hash_table_insert(ext_table, "rt", (gpointer)text_richtext);
 g_hash_table_insert(ext_table, "rtf", (gpointer)text_richtext);
 g_hash_table_insert(ext_table, "rtx", (gpointer)text_richtext);
@@ -1334,6 +1345,10 @@ g_hash_table_insert(ext_table, "z", (gpointer)application_zlib);
 g_hash_table_insert(ext_table, "pf2", (gpointer)application_x_font_pf2);
 g_hash_table_insert(ext_table, "jmod", (gpointer)application_x_java_jmod);
 g_hash_table_insert(ext_table, "heic", (gpointer)image_heic);
+g_hash_table_insert(ext_table, "lzma", (gpointer)application_x_lzma);
+g_hash_table_insert(ext_table, "warc", (gpointer)application_warc);
+g_hash_table_insert(ext_table, "lz", (gpointer)application_x_lzip);
+g_hash_table_insert(ext_table, "lzo", (gpointer)application_x_lzop);
 return ext_table;}
 GHashTable *mime_get_mime_table() {GHashTable *mime_table = g_hash_table_new(g_str_hash, g_str_equal);
 g_hash_table_insert(mime_table, "application/arj", (gpointer)application_arj);
@@ -1748,5 +1763,9 @@ g_hash_table_insert(mime_table, "audio/x-hx-aac-adts", (gpointer)audio_x_hx_aac_
 g_hash_table_insert(mime_table, "application/x-chrome-extension", (gpointer)application_x_chrome_extension);
 g_hash_table_insert(mime_table, "image/heic", (gpointer)image_heic);
 g_hash_table_insert(mime_table, "image/x-gem", (gpointer)image_x_gem);
+g_hash_table_insert(mime_table, "application/x-lzma", (gpointer)application_x_lzma);
+g_hash_table_insert(mime_table, "application/warc", (gpointer)application_warc);
+g_hash_table_insert(mime_table, "application/x-lzip", (gpointer)application_x_lzip);
+g_hash_table_insert(mime_table, "application/x-lzop", (gpointer)application_x_lzop);
 return mime_table;}
 #endif

src/parsing/parse.c

@@ -1,9 +1,32 @@
+#include <src/ctx.h>
 #include "src/sist.h"
 #include "src/ctx.h"
 
 __thread magic_t Magic = NULL;
 
-void *read_all(parse_job_t *job, const char *buf, int bytes_read, int *fd) {
+int fs_read(struct vfile *f, void *buf, size_t size) {
+
+    if (f->fd == -1) {
+        f->fd = open(f->filepath, O_RDONLY);
+        if (f->fd == -1) {
+            perror("open");
+            printf("%s\n", f->filepath);
+            return -1;
+        }
+    }
+
+    return read(f->fd, buf, size);
+}
+
+#define CLOSE_FILE(f) if (f.close != NULL) {f.close(&f);};
+
+void fs_close(struct vfile *f) {
+    if (f->fd != -1) {
+        close(f->fd);
+    }
+}
+
+void *read_all(parse_job_t *job, const char *buf, int bytes_read) {
 
     void *full_buf;
 
@@ -11,17 +34,10 @@ void *read_all(parse_job_t *job, const char *buf, int bytes_read, int *fd) {
         full_buf = malloc(job->info.st_size);
         memcpy(full_buf, buf, job->info.st_size);
     } else {
-        if (*fd == -1) {
-            *fd = open(job->filepath, O_RDONLY);
-            if (*fd == -1) {
-                perror("open");
-                printf("%s\n", job->filepath);
-                return NULL;
-            }
-        }
         full_buf = malloc(job->info.st_size);
         memcpy(full_buf, buf, bytes_read);
-        int ret = read(*fd, full_buf + bytes_read, job->info.st_size - bytes_read);
+
+        int ret = job->vfile.read(&job->vfile, full_buf + bytes_read, job->info.st_size - bytes_read);
         if (ret == -1) {
             perror("read");
             return NULL;
@@ -36,15 +52,14 @@ void parse(void *arg) {
     parse_job_t *job = arg;
     document_t doc;
 
-    if (incremental_get(ScanCtx.original_table, job->info.st_ino) == job->info.st_mtim.tv_sec) {
+    int inc_ts = incremental_get(ScanCtx.original_table, job->info.st_ino);
+    if (inc_ts != 0 && inc_ts == job->info.st_mtim.tv_sec) {
         incremental_mark_file_for_copy(ScanCtx.copy_table, job->info.st_ino);
-        free(job);
         return;
     }
 
     if (Magic == NULL) {
         Magic = magic_open(MAGIC_MIME_TYPE);
-        magic_load(Magic, NULL);
     }
 
     doc.filepath = job->filepath;
@@ -66,24 +81,13 @@ void parse(void *arg) {
         doc.mime = mime_get_mime_by_ext(ScanCtx.ext_table, job->filepath + job->ext);
     }
 
-    int fd = -1;
     int bytes_read = 0;
 
     if (doc.mime == 0) {
         // Get mime type with libmagic
-        fd = open(job->filepath, O_RDONLY);
-        if (fd == -1) {
-            perror("open");
-            free(job);
-            return;
-        }
-
-        bytes_read = read(fd, buf, PARSE_BUF_SIZE);
-
+        bytes_read = job->vfile.read(&job->vfile, buf, PARSE_BUF_SIZE);
         if (bytes_read == -1) {
-            perror("read");
-            close(fd);
-            free(job);
+            CLOSE_FILE(job->vfile)
             return;
         }
 
@@ -101,11 +105,16 @@ void parse(void *arg) {
     if (!(SHOULD_PARSE(doc.mime))) {
 
     } else if ((mmime == MimeVideo && doc.size >= MIN_VIDEO_SIZE) ||
-    (mmime == MimeImage && doc.size >= MIN_IMAGE_SIZE) || mmime == MimeAudio) {
-        parse_media(job->filepath, &doc);
+               (mmime == MimeImage && doc.size >= MIN_IMAGE_SIZE) || mmime == MimeAudio) {
+
+        if (job->vfile.is_fs_file) {
+            parse_media_filename(job->filepath, &doc);
+        } else {
+            parse_media_vfile(&job->vfile, &doc);
+        }
 
     } else if (IS_PDF(doc.mime)) {
-        void *pdf_buf = read_all(job, (char *) buf, bytes_read, &fd);
+        void *pdf_buf = read_all(job, (char *) buf, bytes_read);
         parse_pdf(pdf_buf, doc.size, &doc);
 
         if (pdf_buf != buf && pdf_buf != NULL) {
@@ -113,22 +122,42 @@ void parse(void *arg) {
         }
 
     } else if (mmime == MimeText && ScanCtx.content_size > 0) {
-        parse_text(bytes_read, &fd, (char *) buf, &doc);
+        parse_text(bytes_read, &job->vfile, (char *) buf, &doc);
 
     } else if (IS_FONT(doc.mime)) {
-        void *font_buf = read_all(job, (char *) buf, bytes_read, &fd);
+        void *font_buf = read_all(job, (char *) buf, bytes_read);
         parse_font(font_buf, doc.size, &doc);
 
         if (font_buf != buf && font_buf != NULL) {
             free(font_buf);
         }
+    } else if (
+            ScanCtx.archive_mode != ARC_MODE_SKIP && (
+                    IS_ARC(doc.mime) ||
+                    (IS_ARC_FILTER(doc.mime) && should_parse_filtered_file(doc.filepath, doc.ext))
+            )) {
+        parse_archive(&job->vfile, &doc);
+    } else if (ScanCtx.content_size > 0 && IS_DOC(doc.mime)) {
+        void *doc_buf = read_all(job, (char *) buf, bytes_read);
+        parse_doc(doc_buf, doc.size, &doc);
+
+        if (doc_buf != buf && doc_buf != NULL) {
+            free(doc_buf);
+        }
+    }
+
+    //Parent meta
+    if (!uuid_is_null(job->parent)) {
+        char tmp[UUID_STR_LEN];
+        uuid_unparse(job->parent, tmp);
+
+        meta_line_t *meta_parent = malloc(sizeof(meta_line_t) + UUID_STR_LEN + 1);
+        meta_parent->key = MetaParent;
+        strcpy(meta_parent->strval, tmp);
+        APPEND_META((&doc), meta_parent)
     }
 
     write_document(&doc);
 
-    if (fd != -1) {
-        close(fd);
-    }
-
-    free(job);
+    CLOSE_FILE(job->vfile)
 }

src/parsing/parse.h

@@ -5,6 +5,9 @@
 
 #define PARSE_BUF_SIZE 4096
 
+int fs_read(struct vfile *f, void *buf, size_t size);
+void fs_close(struct vfile *f);
+
 void parse(void *arg);
 
 #endif

src/parsing/pdf.c

@@ -177,7 +177,17 @@ void parse_pdf(void *buf, size_t buf_len, document_t *doc) {
         return;
     }
 
-    fz_page *cover = render_cover(ctx, doc, fzdoc);
+    fz_page *cover = NULL;
+    if (ScanCtx.tn_size > 0) {
+        cover = render_cover(ctx, doc, fzdoc);
+    } else {
+        fz_var(cover);
+        fz_try(ctx)
+            cover = fz_load_page(ctx, fzdoc, 0);
+        fz_catch(ctx)
+            cover = NULL;
+    }
+
     if (cover == NULL) {
         fz_drop_stream(ctx, stream);
         fz_drop_document(ctx, fzdoc);
@@ -185,79 +195,81 @@ void parse_pdf(void *buf, size_t buf_len, document_t *doc) {
         return;
     }
 
-    fz_stext_options opts = {0};
-    text_buffer_t text_buf = text_buffer_create(ScanCtx.content_size);
+    if (ScanCtx.content_size > 0) {
+        fz_stext_options opts = {0};
+        text_buffer_t text_buf = text_buffer_create(ScanCtx.content_size);
+
+        for (int current_page = 0; current_page < page_count; current_page++) {
+            fz_page *page = NULL;
+            if (current_page == 0) {
+                page = cover;
+            } else {
+                fz_var(err);
+                fz_try(ctx)
+                            page = fz_load_page(ctx, fzdoc, current_page);
+                fz_catch(ctx)
+                    err = ctx->error.errcode;
+                if (err != 0) {
+                    text_buffer_destroy(&text_buf);
+                    fz_drop_page(ctx, page);
+                    fz_drop_stream(ctx, stream);
+                    fz_drop_document(ctx, fzdoc);
+                    fz_drop_context(ctx);
+                    return;
+                }
+            }
+
+            fz_stext_page *stext = fz_new_stext_page(ctx, fz_bound_page(ctx, page));
+            fz_device *dev = fz_new_stext_device(ctx, stext, &opts);
 
-    for (int current_page = 0; current_page < page_count; current_page++) {
-        fz_page *page = NULL;
-        if (current_page == 0) {
-            page = cover;
-        } else {
             fz_var(err);
             fz_try(ctx)
-                page = fz_load_page(ctx, fzdoc, current_page);
+                        fz_run_page(ctx, page, dev, fz_identity, NULL);
+            fz_always(ctx)
+                {
+                    fz_close_device(ctx, dev);
+                    fz_drop_device(ctx, dev);
+                }
             fz_catch(ctx)
                 err = ctx->error.errcode;
+
             if (err != 0) {
                 text_buffer_destroy(&text_buf);
                 fz_drop_page(ctx, page);
+                fz_drop_stext_page(ctx, stext);
                 fz_drop_stream(ctx, stream);
                 fz_drop_document(ctx, fzdoc);
                 fz_drop_context(ctx);
                 return;
             }
-        }
 
-        fz_stext_page *stext = fz_new_stext_page(ctx, fz_bound_page(ctx, page));
-        fz_device *dev = fz_new_stext_device(ctx, stext, &opts);
-
-        fz_var(err);
-        fz_try(ctx)
-            fz_run_page(ctx, page, dev, fz_identity, NULL);
-        fz_always(ctx)
-        {
-            fz_close_device(ctx, dev);
-            fz_drop_device(ctx, dev);
-        }
-        fz_catch(ctx)
-            err = ctx->error.errcode;
-
-        if (err != 0) {
-            text_buffer_destroy(&text_buf);
-            fz_drop_page(ctx, page);
+            fz_stext_block *block = stext->first_block;
+            while (block != NULL) {
+                int ret = read_stext_block(block, &text_buf);
+                if (ret == TEXT_BUF_FULL) {
+                    break;
+                }
+                block = block->next;
+            }
             fz_drop_stext_page(ctx, stext);
-            fz_drop_stream(ctx, stream);
-            fz_drop_document(ctx, fzdoc);
-            fz_drop_context(ctx);
-            return;
-        }
+            fz_drop_page(ctx, page);
 
-        fz_stext_block *block = stext->first_block;
-        while (block != NULL) {
-            int ret = read_stext_block(block, &text_buf);
-            if (ret == TEXT_BUF_FULL) {
+            if (text_buf.dyn_buffer.cur >= text_buf.dyn_buffer.size) {
                 break;
             }
-            block = block->next;
         }
-        fz_drop_stext_page(ctx, stext);
-        fz_drop_page(ctx, page);
+        text_buffer_terminate_string(&text_buf);
 
-        if (text_buf.dyn_buffer.cur >= text_buf.dyn_buffer.size) {
-            break;
-        }
+        meta_line_t *meta_content = malloc(sizeof(meta_line_t) + text_buf.dyn_buffer.cur);
+        meta_content->key = MetaContent;
+        memcpy(meta_content->strval, text_buf.dyn_buffer.buf, text_buf.dyn_buffer.cur);
+        APPEND_META(doc, meta_content)
+
+        text_buffer_destroy(&text_buf);
     }
-    text_buffer_terminate_string(&text_buf);
-
-    meta_line_t *meta_content = malloc(sizeof(meta_line_t) + text_buf.dyn_buffer.cur);
-    meta_content->key = MetaContent;
-    memcpy(meta_content->strval, text_buf.dyn_buffer.buf, text_buf.dyn_buffer.cur);
-    APPEND_META(doc, meta_content)
 
     fz_drop_stream(ctx, stream);
     fz_drop_document(ctx, fzdoc);
     fz_drop_context(ctx);
-
-    text_buffer_destroy(&text_buf);
 }
 

src/parsing/text.c

@@ -1,7 +1,7 @@
 #include "text.h"
 #include "src/ctx.h"
 
-void parse_text(int bytes_read, int *fd, char *buf, document_t *doc) {
+void parse_text(int bytes_read, struct vfile *f, char *buf, document_t *doc) {
 
     char *intermediate_buf;
     int intermediate_buf_len;
@@ -13,10 +13,6 @@ void parse_text(int bytes_read, int *fd, char *buf, document_t *doc) {
         memcpy(intermediate_buf, buf, to_copy);
 
     } else {
-        if (*fd == -1) {
-            *fd = open(doc->filepath, O_RDONLY);
-        }
-
         int to_read = MIN(ScanCtx.content_size, doc->size) - bytes_read;
 
         intermediate_buf = malloc(to_read + bytes_read);
@@ -25,7 +21,7 @@ void parse_text(int bytes_read, int *fd, char *buf, document_t *doc) {
             memcpy(intermediate_buf, buf, bytes_read);
         }
 
-        read(*fd, intermediate_buf + bytes_read, to_read);
+        f->read(f, intermediate_buf + bytes_read, to_read);
     }
     text_buffer_t tex = text_buffer_create(ScanCtx.content_size);
     text_buffer_append_string(&tex, intermediate_buf, intermediate_buf_len);

src/parsing/text.h

@@ -3,6 +3,6 @@
 
 #include "src/sist.h"
 
-void parse_text(int bytes_read, int *fd, char *buf, document_t *doc);
+void parse_text(int bytes_read, struct vfile *f, char *buf, document_t *doc);
 
 #endif

src/sist.h

@@ -26,6 +26,12 @@
 #include <pthread.h>
 #include <sys/stat.h>
 #include <wordexp.h>
+#include "ft2build.h"
+#include "freetype/freetype.h"
+#include <archive.h>
+#include <archive_entry.h>
+#include <opc/opc.h>
+#include <libxml/xmlstring.h>
 
 #ifndef SIST_SCAN_ONLY
 #include <onion/onion.h>
@@ -50,6 +56,8 @@
 #include "parsing/pdf.h"
 #include "parsing/media.h"
 #include "parsing/font.h"
+#include "parsing/arc.h"
+#include "parsing/doc.h"
 #include "cli.h"
 #include "utf8.h/utf8.h"
 

src/tpool.c

@@ -119,6 +119,7 @@ static void *tpool_worker(void *arg) {
             }
 
             work->func(work->arg);
+            free(work->arg);
             free(work);
         }
 
@@ -151,6 +152,7 @@ void tpool_wait(tpool_t *pool) {
             usleep(500000);
             if (pool->done_cnt == pool->work_cnt) {
                 pool->stop = 1;
+                usleep(1000000);
                 break;
             }
         }
@@ -178,7 +180,8 @@ void tpool_destroy(tpool_t *pool) {
     for (size_t i = 0; i < pool->thread_cnt; i++) {
         pthread_t thread = pool->threads[i];
         if (thread != 0) {
-            pthread_cancel(thread);
+            void *_;
+            pthread_join(thread, &_);
         }
     }
 
@@ -218,8 +221,6 @@ tpool_t *tpool_create(size_t thread_cnt, void cleanup_func()) {
 void tpool_start(tpool_t *pool) {
 
     for (size_t i = 0; i < pool->thread_cnt; i++) {
-        pthread_t thread = pool->threads[i];
-        pthread_create(&thread, NULL, tpool_worker, pool);
-        pthread_detach(thread);
+        pthread_create(&pool->threads[i], NULL, tpool_worker, pool);
     }
 }

src/types.h

@@ -9,6 +9,12 @@
 #define IS_META_LONG(key) (key & META_LONG_MASK) == META_LONG_MASK
 #define IS_META_STR(meta) (meta->key & META_STR_MASK) == META_STR_MASK
 
+#define ARC_MODE_SKIP 0
+#define ARC_MODE_LIST 1
+#define ARC_MODE_SHALLOW 2
+#define ARC_MODE_RECURSE 3
+typedef int archive_mode_t;
+
 // This is written to file as a 8bit char!
 enum metakey {
     MetaContent = 1 | META_STR_MASK,
@@ -24,6 +30,7 @@ enum metakey {
     MetaGenre = 11 | META_STR_MASK,
     MetaTitle = 12 | META_STR_MASK,
     MetaFontName = 13 | META_STR_MASK,
+    MetaParent = 14 | META_STR_MASK,
 };
 
 typedef struct index_descriptor {
@@ -63,13 +70,39 @@ typedef struct document {
     short ext;
     meta_line_t *meta_head;
     meta_line_t *meta_tail;
+    struct document *child_head;
+    struct document *child_tail;
     char *filepath;
 } document_t;
 
+typedef struct vfile vfile_t;
+
+typedef int (*read_func_t)(struct vfile *, void *buf, size_t size);
+
+typedef int (*seek_func_t)(struct vfile *, size_t size, int whence);
+
+typedef void (*close_func_t)(struct vfile *);
+
+typedef struct vfile {
+
+    union {
+        int fd;
+        struct archive *arc;
+    };
+
+    int is_fs_file;
+    char *filepath;
+
+    read_func_t read;
+    close_func_t close;
+} vfile_t;
+
 typedef struct parse_job_t {
     int base;
     int ext;
     struct stat info;
+    struct vfile vfile;
+    uuid_t parent;
     char filepath[1];
 } parse_job_t;
 

src/util.c

@@ -46,6 +46,10 @@ void dyn_buffer_write_str(dyn_buffer_t *buf, char *str) {
     dyn_buffer_write_char(buf, '\0');
 }
 
+void dyn_buffer_append_string(dyn_buffer_t *buf, char *str) {
+    dyn_buffer_write(buf, str, strlen(str));
+}
+
 void dyn_buffer_write_int(dyn_buffer_t *buf, int d) {
     grow_buffer_small(buf);
 

src/util.h

@@ -47,6 +47,8 @@ void dyn_buffer_write_char(dyn_buffer_t *buf, char c);
 
 void dyn_buffer_write_str(dyn_buffer_t *buf, char *str);
 
+void dyn_buffer_append_string(dyn_buffer_t *buf, char *str);
+
 void dyn_buffer_write_int(dyn_buffer_t *buf, int d);
 
 void dyn_buffer_write_short(dyn_buffer_t *buf, short s);

src/web/serve.c

@@ -360,12 +360,24 @@ int file(void *p, onion_request *req, onion_response *res) {
         return OCS_PROCESSED;
     }
 
-    cJSON *doc = elastic_get_document(arg_uuid);
-    cJSON *source = cJSON_GetObjectItem(doc, "_source");
-    cJSON *index_id = cJSON_GetObjectItem(source, "index");
-    if (index_id == NULL) {
-        cJSON_Delete(doc);
-        return OCS_NOT_PROCESSED;
+    char *next = arg_uuid;
+    cJSON *doc = NULL;
+    cJSON *index_id = NULL;
+    cJSON *source = NULL;
+
+    while (true) {
+        doc = elastic_get_document(next);
+        source = cJSON_GetObjectItem(doc, "_source");
+        index_id = cJSON_GetObjectItem(source, "index");
+        if (index_id == NULL) {
+            cJSON_Delete(doc);
+            return OCS_NOT_PROCESSED;
+        }
+        cJSON *parent = cJSON_GetObjectItem(source, "parent");
+        if (parent == NULL) {
+            break;
+        }
+        next = parent->valuestring;
     }
 
     index_t *idx = get_index_by_id(index_id->valuestring);

web/css/dark.css

@@ -23,6 +23,15 @@ body {
     border: none;
 }
 
+.sub-document {
+    background: #37474F;
+}
+
+.sub-document .text-muted {
+    color: #8a949c !important;
+}
+
+
 .list-group-item {
     background: #212121;
     color: #e0e0e0;

web/css/light.css

@@ -15,6 +15,10 @@ body {
     box-shadow: 0 .125rem .25rem rgba(0, 0, 0, .075) !important;
 }
 
+.sub-document {
+    background: #AB47BC1F;
+}
+
 .navbar-brand {
     font-size: 1.75rem;
     padding: 0;

web/js/dom.js

@@ -165,12 +165,19 @@ function createDocCard(hit) {
     let docCardBody = document.createElement("div");
     docCardBody.setAttribute("class", "card-body document");
 
+    //Title
+    let title = makeTitle(hit);
+    let isSubDocument = false;
+
     let link = document.createElement("a");
     link.setAttribute("href", "f/" + hit["_id"]);
     link.setAttribute("target", "_blank");
+    link.appendChild(title);
 
-    //Title
-    let title = makeTitle(hit);
+    if (hit["_source"].hasOwnProperty("parent")) {
+        docCard.classList.add("sub-document");
+        isSubDocument = true;
+    }
 
     let tagContainer = document.createElement("div");
     tagContainer.setAttribute("class", "card-text");
@@ -194,15 +201,17 @@ function createDocCard(hit) {
                 thumbnailOverlay.setAttribute("class", "card-img-overlay");
 
                 //Resolution
-                let resolutionBadge = document.createElement("span");
-                resolutionBadge.setAttribute("class", "badge badge-resolution");
-                if (hit["_source"].hasOwnProperty("width")) {
-                    resolutionBadge.appendChild(document.createTextNode(hit["_source"]["width"] + "x" + hit["_source"]["height"]));
+                if (hit["_source"].hasOwnProperty("width") && hit["_source"]["width"] > 32 && hit["_source"]["height"] > 32) {
+                    let resolutionBadge = document.createElement("span");
+                    resolutionBadge.setAttribute("class", "badge badge-resolution");
+                    if (hit["_source"].hasOwnProperty("width")) {
+                        resolutionBadge.appendChild(document.createTextNode(hit["_source"]["width"] + "x" + hit["_source"]["height"]));
+                    }
+                    thumbnailOverlay.appendChild(resolutionBadge);
                 }
-                thumbnailOverlay.appendChild(resolutionBadge);
 
                 // Hover
-                if (thumbnail && hit["_source"]["videoc"] === "gif") {
+                if (thumbnail && hit["_source"]["videoc"] === "gif" && !isSubDocument) {
                     gifOver(thumbnail, hit);
                 }
                 break;
@@ -239,7 +248,7 @@ function createDocCard(hit) {
         }
 
         //Audio
-        if (mimeCategory === "audio" && hit["_source"].hasOwnProperty("audioc")) {
+        if (mimeCategory === "audio" && hit["_source"].hasOwnProperty("audioc") && !isSubDocument) {
 
             let audio = document.createElement("audio");
             audio.setAttribute("preload", "none");
@@ -265,7 +274,6 @@ function createDocCard(hit) {
     docCardBody.appendChild(link);
     docCard.appendChild(docCardBody);
 
-    link.appendChild(title);
     docCardBody.appendChild(tagContainer);
 
     return docCard;
@@ -273,8 +281,9 @@ function createDocCard(hit) {
 
 function makeThumbnail(mimeCategory, hit, imgWrapper, small) {
     let thumbnail;
+    let isSubDocument = hit["_source"].hasOwnProperty("parent");
 
-    if (mimeCategory === "video" && shouldPlayVideo(hit)) {
+    if (mimeCategory === "video" && shouldPlayVideo(hit) && !isSubDocument) {
         thumbnail = document.createElement("video");
         addVidSrc("f/" + hit["_id"], hit["_source"]["mime"], thumbnail);
 
@@ -345,7 +354,8 @@ function makeThumbnail(mimeCategory, hit, imgWrapper, small) {
 
 function createDocLine(hit) {
 
-    let mimeCategory = hit["_source"]["mime"].split("/")[0];
+    const mime = hit["_source"]["mime"];
+    let mimeCategory = mime ? mime.split("/")[0] : null;
     let tags = getTags(hit, mimeCategory);
 
     let imgWrapper = document.createElement("div");

web/js/search.js

@@ -357,6 +357,7 @@ function search() {
             post_tags: ["</mark>"],
             fields: {
                 content: {},
+                // "content.nGram": {},
                 name: {},
                 "name.nGram": {},
                 font_name: {},

web/js/util.js

@@ -3,7 +3,7 @@
  */
 function humanFileSize(bytes) {
     if (bytes === 0) {
-        return "? B"
+        return "0 B"
     }
 
     let thresh = 1000;

web/search.html

@@ -11,7 +11,7 @@
 
 <nav class="navbar navbar-expand-lg">
     <a class="navbar-brand" href="/">sist2</a>
-    <span class="badge badge-pill version">v1.1.8</span>
+    <span class="badge badge-pill version">v1.1.11</span>
     <span class="tagline">Lightning-fast file system indexer and search tool </span>
     <a style="margin-left: auto" id="theme" class="btn" title="Toggle theme" href="/">Theme</a>
 </nav>