New version 8.1.0

Add Codecov badge to README

.clang-format

@@ -0,0 +1,12 @@
+BasedOnStyle:  Google
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Linux
+DerivePointerAlignment: false
+SpacesInContainerLiterals: false
+Standard: Cpp11
+
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

.codecov.yml

@@ -0,0 +1,12 @@
+codecov:
+  notify:
+    require_ci_to_pass: yes
+
+coverage:
+  status:
+    project:
+      default:
+        threshold: 1%
+
+ignore:
+  - "test"

.gitignore

@@ -0,0 +1,3 @@
+.idea/
+*.swp
+subprojects/googletest-release*

.travis.yml

@@ -0,0 +1,42 @@
+language: cpp
+dist: xenial
+sudo: true
+cache: ccache
+before_install:
+- PATH=$PATH:$HOME/bin
+install: travis/install_deps.sh
+script: travis/compile.sh
+env:
+  matrix:
+    - PLATFORM="native_static"
+    - PLATFORM="native_dyn"
+    - PLATFORM="win32_static"
+    - PLATFORM="win32_dyn"
+    - PLATFORM="android_arm"
+    - PLATFORM="android_arm64"
+addons:
+  apt:
+    packages:
+      - cmake
+      - python3.5
+      - python3-pip
+      - libbz2-dev
+      - ccache
+      - zlib1g-dev
+      - uuid-dev
+      - libctpp2-dev
+      - ctpp2-utils
+      - libmicrohttpd-dev
+      - g++-mingw-w64-i686
+      - gcc-mingw-w64-i686
+      - gcc-mingw-w64-base
+      - mingw-w64-tools
+      - gcovr
+  homebrew:
+    update: true
+    packages:
+      - gcovr
+matrix:
+  include:
+    - env: PLATFORM="native_dyn"
+      os: osx

AUTHORS

@@ -0,0 +1,17 @@
+Automactic <christopherliqd@gmail.com>
+Ayoub DARDORY <ayoubuto@gmail.com>
+Cristian Patrasciuc <cristip@google.com>
+Dattaz <taz@dattaz.fr>
+Elad Keyshawn <elad.keyshawn@gmail.com>
+Emmanuel Engelhart <kelson@kiwix.org>
+Isaac <mhutti1@gmail.com>
+jleow00 <leow.yonghan.jerome@gmail.com>
+Julian Harty <julianharty@gmail.com>
+Kiran Mathew Koshy <kiranmathewkoshy@gmail.com>
+Kunal Mehta <legoktm@member.fsf.org>
+Matthieu Gautier <mgautier@kymeria.fr>
+Rashiq Ahmad <rashiq.z@gmail.com>
+Renaud Gaudin <reg@kiwix.org>
+Shivam <ssarodia@gmail.com>
+Steve Wills <steve@mouf.net>
+Synhershko <synhershko@users.sourceforge.net>

ChangeLog

@@ -0,0 +1,288 @@
+kiwix-lib 8.1.0
+===============
+
+ * Fix pathTools manipulation.
+ * Add missing implementation of getArticleCount and getMediaCount on android.
+ * Correctly convert windows path to utf8.
+ * Add code coverage in the CI
+
+kiwix-lib 8.0.1
+===============
+
+ * Fix join function
+
+kiwix-lib 8.0.0
+===============
+
+ * Add new methods to get all (and new) metadata from the zim file.
+ * Add methods to get the value of a specific tag.
+ * [API Change] Convert tags value to the new convention.
+ * [API Change] Rename `getMatatag` method to `getMetadata`
+ * [ABI Change] Correctly detect executable path in appimage.
+
+kiwix-lib 7.0.0
+===============
+
+ * [API break] Add a argument to kiwix-serve to specify the library to use.
+
+kiwix-lib 6.0.4
+===============
+
+ * Fix HTML rendering of the search result if there is no result.
+ * Do not crash at html rendering if request ask for 0 results (start == end)
+ * Correctly find the executable path if we are using AppImage
+
+kiwix-lib 6.0.3
+===============
+
+ * force one column suggestion in kiwix-serve suggestions
+ * fix fulltext search link in suggestions
+ * UI fixes in kiwix-serve rendering
+
+kiwix-lib 6.0.2
+===============
+
+ * Correctly set the groupId in the pom file.
+
+kiwix-lib 6.0.1
+===============
+
+ * Generate the pom file for android/maven
+
+kiwix-lib 6.0.0
+===============
+
+ * Move the server code in kiwix-lib (from kiwix-serve).
+ * Add unit test on regex functions.
+ * Fix computerAbsolutePath (thread safe, memory leak).
+ * Correctly set the book's path as valid if we construct the book from a
+   reader.
+ * [JNI] Add a method to know if a article is a redirection.
+ * Do not embed the gtest dependency.
+ * [JNI] Add a constructor to JNIKiwixString.
+ * Change order of search of the favicon urls.
+ * Clean a lot of unecessary includes in headers. (potential "API break")
+
+kiwix-lib 5.2.0
+===============
+
+ * kiwix-serve integration (as a seperated process).
+ * Fix crash in the suggestion search.
+ * Better API to filter the library books.
+ * New kiwix-lib application for android. (.aar)
+ * Use ReLinker to link with libkiwix.so in android.
+ * Correctly set the verbosity of zim search.
+
+kiwix-lib 5.1.0
+===============
+
+ * Add function to pause, resume and stop downloads.
+ * Add zim's tags in the opds stream.
+ * Addapt to new libzim 5.0.0 API.
+
+kiwix-lib 5.0.0
+===============
+
+ * Remove error message when trying to open an wrong zim file.
+ * Rewrite `makeTmpDirectory` to not use uuid functions on windows.
+ * [API break] Remove `getNetworkInterfaces` and `getBestPublicIp`.
+ * Remove rpath
+ * Detect infinite (and too long) redirect loops.
+
+kiwix-lib 4.1.0
+===============
+
+ * Allow the library to be filtered by tags.
+ * Fix language mapping.
+ * Update README about mustache dependency.
+
+kiwix-lib 4.0.1
+===============
+
+ * Fix "maybe uninitialize variable" issue.
+ * Ensure path are stored correctly (absolute path) in the library.
+ * [CI] Use the new deps archive xz
+
+kiwix-lib 4.0.0
+===============
+
+ * [API break] Remove support for external index.
+ * Move to the mustache templating system instead of ctpp2.
+ * Make meson.build works for meson>=0.43.0
+ * [API break] Move the basic tools from the `common` directory to `tools`.
+
+kiwix-lib 3.1.1
+===============
+
+ * The OPDS feed book's date must be the date of the book, not the date of the
+ feed generation.
+ * Convert the standard opds date to our format (YYYY-MM-DD)
+ * Remove duplicate language attribute in the libxml dumper.
+ * Create the datadirectory to not fail to write a file in a non-existent
+   directory
+
+kiwix-lib 3.1.0
+===============
+
+ * Add a method to get the favicon url of book (if available).
+ * Move dump code of library.xml in a specific class.
+ * Add a first support to bookmarks
+
+kiwix-lib 3.0.3
+===============
+
+ * Add the 'en' language to the mapping alpha2-code ('en') to alpha3-code
+ ('eng').
+ * Correctly write the 'ArticleCount' and 'MediaCount' in the library.xml.
+ * Correctly fill the book size for the zim file size.
+ * Fix launch of aria2c.
+
+kiwix-lib 3.0.2
+===============
+
+ * Use the correct path separator when computing relativePath on Windows.
+
+kiwix-lib 3.0.1
+===============
+
+ * Small fix about parsing the opdsStream.
+
+kiwix-lib 3.0.0
+===============
+
+ * Change the downloader to use aria2 using a separated process (with rpc)
+   instead of using the libaria2. This simplify a lot the link process to
+   libaria2 on Windows.
+    - kiwix-lib doesn't depend on libaria2 anymore.
+    - kiwix-lib now depends on libcurl.
+ * [API break] Library class API has been updated :
+    - Books are referenced by id, not index. A lot of methods have been
+      updated this way.
+    - Books "list" is now private.
+    - There is no more "current" book.
+    - listBooksIds's filters have been updated.
+ * [API break] Book class API has been updated :
+    - Move the definition of Book in `book.h`.
+    - Use getter/setter methods instead public members.
+    - Size (getSize/setSize) is now returned in bytes, not kB.
+    - Dependending of how the book has been initialized (opdsfeed), the
+      faviconUrl may be stored in the book, the favicon being downloaded when
+      using `getFavicon`.
+    - The path (and indexPath) are always absolute path.
+    - Book has now a downloadId, corresponding to the aria2 download id (if
+      exists)
+  * [API break] Manager class API has been updated :
+    - The manager is mainly use to fill a Libray from a "library.xml" file or
+      opds feed. Other operations (has removeBookById, setBookPath, filter, ...)
+      have been removed.
+    - The manager use a intermediate class (LibraryManipulator) to add book to
+      the library. This dependency injection allow caller code to hook the add
+      of a book to the library.
+    - The manager work on a existing Library. It doesn't how a internal
+      Library.
+  * [API break] OpdsDumper class API has been updated :
+    - dumpOPDSFeed method now take the list of bookIds to dump instead of
+      dumping all books in the library.
+    - OpdsDumper can now dump openSearch result information (total result
+      count, start index, ...).
+  * [API break] Common tools API has been updated :
+    - `base64_encode` and `base64_decode` take std::string as arguments.
+    - New `download` function in networkTools.h using libcurl.
+    - New `getDataDirectory` function in pathTools.
+    - Better `beautifyInteger` and `beautifyFileSize` functions.
+    - New `nodeToString` function serializing a pugi::xml_node to a string.
+    - New `converta2toa3` function to convert alpha2 language code to aplha3
+      language code.
+
+
+kiwix-lib 2.0.2
+===============
+
+ * [Android] Forward c++ errors message de Java world.
+ * Follow redirection of favicon.
+ * Make aria2 dependency optional.
+ * Inculde unistd.h only on unix platform.
+
+kiwix-lib 2.0.1
+===============
+
+ * Fix parsing of url.
+ * Remove unused static resources.
+ * Correctly decode reserved characters in URLs.
+ * Explicitly use icu namespace to allow use of packaged icu lib.
+
+kiwix-lib 2.0.0
+===============
+
+ * Introduce a new API to retrive content from a reader.
+   * Introduce the `Entry` class.
+   * Reader's methods return an `Entry`.
+   * Content and other information can be retrieved from the `Entry`.
+   * Older Reader's methods are depreciated.
+ * Add an `OPDSDumper` class to dump a whole `Library` as an OPDS feed.
+ * Add a tool function to get the content of a file.
+ * Add a tool function to create a tempory directory.
+ * Add a `Downloader` class to download a file.
+ * Allow the manager to populate a `Library` from an OPDS feed.
+ * Try to locate libctpp2 in default system libdir and then fallback in 'lib'
+   directory.
+ * Build kiwix-lib setting RPATH.
+ * Build kiwix-lib without warning (werror=true)
+ * Build kiwix-lib on macos.
+
+kiwix-lib 1.1.1
+===============
+
+ * Correct the name of kiwix-lib (from `kiwixlib`) in meson.build to generate
+   dist archive with the correct name.
+ * Libzim version need to be at least 3.2.0
+
+kiwix-lib 1.1.0
+===============
+
+ * Allow for more than 70 search result per page in html results rendering
+   (kiwix/kiwix-tools#92)
+ * Add a small api to do geo queries.
+ * Add multi-search support in the JNI (#67)
+ * Add an API to get only one part of an article.
+ * Add an API to get direct location of an article content in the zim file.
+ * Improve urlencoding
+ * Fix pagination in html results rendering.
+ * Compile using gcc-5 on Travis.
+ * Allow JNI to access search snippets.
+ * JNI throw an exception instead of returning an invalid object if something
+   goes wrong.
+ * Add doctext documentation. (#116)
+ * Various bug fixes.
+
+kiwix-lib 1.0.0
+===============
+
+ * Correctly regenerate template resource using cttp2c at compilation time.
+ * Suggestion use xapian database when available
+ * Support multi-zim search in kiwix-lib (a search can now search on several
+   embedded database in zims in the same time)
+ * Fix some wording
+ * Fix license issues
+ * Add out argument to jni getContent* method to get the title of article in
+   the same time we get the content
+ * Rename `compile_resources.py` script to `kiwix-compile-resources`
+ * Use static lib when building for android or in "static mode"
+ * Make the ResourceNotFound exception public
+
+kiwix-lib 0.2.0
+===============
+
+ * Generate the snippet from the article content if the snippet is not
+ directly in the database.
+   This provide better snippets as they now depending of the query.
+ * Use the stopwords and the language stored in the fulltext index database to
+ parse the user query.
+ * Remove the indexer functionnality.
+ * Move to C++11 standard.
+ * Use the fulltext search of the zimlib.
+   We still have the fulltext search code in kiwix-lib to be able to search in
+   fulltext index by side of a zim file. (To be remove in the future)
+ * Few API hanges
+   * Change a lot of `Reader` methods to const methods.
+ * Fix some crashes.

README.md

@@ -1,8 +1,16 @@
 Kiwix library
 =============
 
-The Kiwix library provides the Kiwix software core. It contains the
-code shared by all Kiwix ports (Windows, Linux, OSX, Android, ...).
+The Kiwix library provides the [Kiwix](https://kiwix.org) software
+suite core. It contains the code shared by all Kiwix ports (Windows,
+GNU/Linux, macOS, Android, iOS, ...).
+
+[![Download](https://api.bintray.com/packages/kiwix/kiwix/kiwixlib/images/download.svg)](https://bintray.com/kiwix/kiwix/kiwixlib/_latestVersion)
+[![AUR version](https://img.shields.io/aur/version/kiwix-lib)](https://aur.archlinux.org/packages/kiwix-lib/)
+[![Build Status](https://travis-ci.org/kiwix/kiwix-lib.svg?branch=master)](https://travis-ci.org/kiwix/kiwix-lib)
+[![CodeFactor](https://www.codefactor.io/repository/github/kiwix/kiwix-lib/badge)](https://www.codefactor.io/repository/github/kiwix/kiwix-lib)
+[![Codecov](https://codecov.io/gh/kiwix/kiwix-lib/branch/master/graph/badge.svg)](https://codecov.io/gh/kiwix/kiwix-lib)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
 Disclaimer
 ----------
@@ -15,9 +23,9 @@ to [kiwix-build](https://github.com/kiwix/kiwix-build).
 Preamble
 --------
 
-Although the Kiwix library can be compiled/cross-compiled on/for many
+Although the Kiwix library can be (cross-)compiled on/for many
 sytems, the following documentation explains how to do it on POSIX
-ones. It is primarly though for GNU/Linux systems and has been tested
+ones. It is primarly thought for GNU/Linux systems and has been tested
 on recent releases of Ubuntu and Fedora.
 
 Dependencies
@@ -27,16 +35,13 @@ The Kiwix library relies on many third parts software libraries. They
 are prerequisites to the Kiwix library compilation. Following
 libraries need to be available:
 
-* ICU ................................... http://site.icu-project.org/
-(package libicu-dev on Ubuntu)
-* ZIM ........................................ http://www.openzim.org/
-(package libzim-dev on Ubuntu)
-* Pugixml ........................................ http://pugixml.org/
-(package libpugixml-dev on Ubuntu)
-* ctpp2 ........................................ http://ctpp.havoc.ru/
-(package libctpp2-dev on Ubuntu)
-* Xapian ......................................... https://xapian.org/
-(package libxapian-dev on Ubuntu)
+* [ICU](https://site.icu-project.org/) (package `libicu-dev` on Ubuntu)
+* [ZIM](https://openzim.org/) (package `libzim-dev` on Ubuntu)
+* [Pugixml](https://pugixml.org/) (package `libpugixml-dev` on Ubuntu)
+* [Aria2](https://aria2.github.io/) (package `aria2` on Ubuntu)
+* [Mustache](https://github.com/kainjow/Mustache) (Just copy the
+header `mustache.hpp` somewhere it can be found by the compiler and/or
+set CPPFLAGS with correct `-I` option)
 
 These dependencies may or may not be packaged by your operating
 system. They may also be packaged but only in an older version. The
@@ -45,76 +50,95 @@ In the worse case, you will have to download and compile bleeding edge
 version by hand.
 
 If you want to install these dependencies locally, then use the
-kiwix-lib directory as install prefix.
+`kiwix-lib` directory as install prefix.
 
-If you compile ctpp2 from source and want to compile the Kiwix library
-statically then you will probably need to rename ctpp2 static library
-from ctpp2-st.a to ctpp2.a.
-
-Environnement
+Environment
 -------------
 
-The Kiwix library builds using [Meson](http://mesonbuild.com/) version
-0.34 or higher. Meson relies itself on Ninja, pkg-config and few other
+The Kiwix library builds using [Meson](https://mesonbuild.com/) version
+0.43 or higher. Meson relies itself on Ninja, pkg-config and few other
 compilation tools.
 
 Install first the few common compilation tools:
-* Automake
-* Libtool
-* Virtualenv
-* Pkg-config
+* [Meson](https://mesonbuild.com/)
+* [Ninja](https://ninja-build.org/)
+* [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/)
 
-Then install Meson itself:
-```
-virtualenv -p python3 ./ # Create virtualenv
-source bin/activate      # Activate the virtualenv
-pip install meson        # Install Meson
-hash -r                  # Refresh bash paths
-```
-
-Finally download and build Ninja locally:
-```
-git clone git://github.com/ninja-build/ninja.git
-cd ninja
-git checkout release
-./configure.py --bootstrap
-mkdir ../bin                      
-cp ninja ../bin
-cd ..
-```
+These tools should be packaged if you use a cutting edge operating
+system. If not, have a look to the [Troubleshooting](#Troubleshooting)
+section.
 
 Compilation
 -----------
 
-Once all dependencies are installed, you can compile kiwix-lib with:
-```
-mkdir build
+Once all dependencies are installed, you can compile the Kiwix library
+with:
+```bash
 meson . build
-cd build
-ninja
+ninja -C build
 ```
 
-By default, it will compile dynamic linked libraries. If you want
-statically linked libraries, you can add `--default-library=static`
-option to the Meson command.
+By default, it will compile dynamic linked libraries. All binary files
+will be created in the "build" directory created automatically by
+Meson. If you want statically linked libraries, you can add
+`--default-library=static` option to the Meson command.
 
 Depending of you system, `ninja` may be called `ninja-build`.
 
 Installation
 ------------
 
-If you want to install the libraries you just have compiled on your
-system, here we go:
-
+If you want to install the Kiwix library and the headers you just have
+compiled on your system, here we go:
+```bash
+ninja -C build install
 ```
-ninja install
+
+You might need to run the command as root (or using `sudo`), depending
+where you want to install the libraries. After the installation
+succeeded, you may need to run `ldconfig` (as `root`).
+
+Uninstallation
+------------
+
+If you want to uninstall the Kiwix library:
+```bash
+ninja -C build uninstall
+```
+
+Like for the installation, you might need to run the command as `root`
+(or using `sudo`).
+
+Troubleshooting
+---------------
+
+If you need to install Meson "manually":
+```bash
+virtualenv -p python3 ./ # Create virtualenv
+source bin/activate      # Activate the virtualenv
+pip3 install meson       # Install Meson
+hash -r                  # Refresh bash paths
+```
+
+If you need to install Ninja "manually":
+```bash
+git clone git://github.com/ninja-build/ninja.git
+cd ninja
+git checkout release
+./configure.py --bootstrap
+mkdir ../bin
+cp ninja ../bin
 cd ..
 ```
 
-You might need to run the command as root, depending where you want to
-install the libraries.
+If the compilation still fails, you might need to get a more recent
+version of a dependency than the one packaged by your Linux
+distribution. Try then with a source tarball distributed by the
+problematic upstream project or even directly from the source code
+repository.
 
 License
 -------
 
-GPLv3 or later, see COPYING for more details.
+[GPLv3](https://www.gnu.org/licenses/gpl-3.0) or later, see
+[COPYING](COPYING) for more details.

android-kiwix-lib-publisher/.gitignore

@@ -0,0 +1,13 @@
+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+.DS_Store
+/build
+/captures
+.externalNativeBuild

android-kiwix-lib-publisher/build.gradle

@@ -0,0 +1,25 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.4.1'
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        jcenter()
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

android-kiwix-lib-publisher/gradle.properties

@@ -0,0 +1,15 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx1536m
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official

android-kiwix-lib-publisher/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Wed Jun 19 15:28:39 BST 2019
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-all.zip

android-kiwix-lib-publisher/gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

android-kiwix-lib-publisher/gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

android-kiwix-lib-publisher/kiwixLibAndroid/.gitignore

@@ -0,0 +1 @@
+/build

android-kiwix-lib-publisher/kiwixLibAndroid/build.gradle

@@ -0,0 +1,64 @@
+apply plugin: 'com.android.library'
+apply plugin: 'maven'
+
+android {
+    compileSdkVersion 28
+    defaultConfig {
+        minSdkVersion 15
+        targetSdkVersion 28
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.getkeepsafe.relinker:relinker:1.3.1'
+}
+
+task writePom {
+  pom {
+    project {
+        groupId 'org.kiwix.kiwixlib'
+        artifactId 'kiwixlib'
+        version '8.1.0' + (System.env.KIWIXLIB_BUILDVERSION == null ? '' : '-'+System.env.KIWIXLIB_BUILDVERSION)
+        packaging 'aar'
+        name 'kiwixlib'
+        url 'https://github.com/kiwix/kiwix-lib'
+        licenses {
+            license {
+                name 'GPLv3'
+                url 'https://www.gnu.org/licenses/gpl-3.0.en.html'
+            }
+        }
+      developers {
+          developer {
+              id 'kiwix'
+              name 'kiwix'
+              email 'contact@kiwix.org'
+          }
+      }
+      scm {
+          connection 'https://github.com/kiwix/kiwix-lib.git'
+          developerConnection 'https://github.com/kiwix/kiwix-lib.git'
+          url 'https://github.com/kiwix/kiwix-lib'
+      }
+    }
+  }.withXml {
+    def dependenciesNode = asNode().appendNode('dependencies')
+
+    //Iterate over the implementation dependencies, adding a <dependency> node for each
+    configurations.implementation.allDependencies.each {
+      def dependencyNode = dependenciesNode.appendNode('dependency')
+      dependencyNode.appendNode('groupId', it.group)
+      dependencyNode.appendNode('artifactId', it.name)
+      dependencyNode.appendNode('version', it.version)
+    }
+  }.writeTo("$buildDir/pom.xml")
+}
+

android-kiwix-lib-publisher/kiwixLibAndroid/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

android-kiwix-lib-publisher/kiwixLibAndroid/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="kiwix.org.kiwixlib">
+
+    <application
+        android:allowBackup="true"
+        android:supportsRtl="true">
+
+    </application>
+
+</manifest>

android-kiwix-lib-publisher/settings.gradle

@@ -0,0 +1 @@
+include ':kiwixLibAndroid'

format_code.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/bash
+
+files=(
+"include/library.h"
+"include/common/stringTools.h"
+"include/common/pathTools.h"
+"include/common/otherTools.h"
+"include/common/regexTools.h"
+"include/common/networkTools.h"
+"include/manager.h"
+"include/reader.h"
+"include/kiwix.h"
+"include/xapianSearcher.h"
+"include/searcher.h"
+"src/library.cpp"
+"src/android/kiwix.cpp"
+"src/android/org/kiwix/kiwixlib/JNIKiwixBool.java"
+"src/android/org/kiwix/kiwixlib/JNIKiwix.java"
+"src/android/org/kiwix/kiwixlib/JNIKiwixString.java"
+"src/android/org/kiwix/kiwixlib/JNIKiwixInt.java"
+"src/searcher.cpp"
+"src/common/pathTools.cpp"
+"src/common/regexTools.cpp"
+"src/common/otherTools.cpp"
+"src/common/networkTools.cpp"
+"src/common/stringTools.cpp"
+"src/xapianSearcher.cpp"
+"src/manager.cpp"
+"src/reader.cpp"
+)
+
+for i in "${files[@]}"
+do
+  echo $i
+  clang-format -i -style=file $i
+done

include/book.h

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_BOOK_H
+#define KIWIX_BOOK_H
+
+#include <string>
+
+namespace pugi {
+class xml_node;
+}
+
+namespace kiwix
+{
+
+class OPDSDumper;
+class Reader;
+
+/**
+ * A class to store information about a book (a zim file)
+ */
+class Book
+{
+ public:
+  Book();
+  ~Book();
+
+  bool update(const Book& other);
+  void update(const Reader& reader);
+  void updateFromXml(const pugi::xml_node& node, const std::string& baseDir);
+  void updateFromOpds(const pugi::xml_node& node, const std::string& urlHost);
+  std::string getHumanReadableIdFromPath() const;
+
+  bool readOnly() const { return m_readOnly; }
+  const std::string& getId() const { return m_id; }
+  const std::string& getPath() const { return m_path; }
+  bool isPathValid() const { return m_pathValid; }
+  const std::string& getTitle() const { return m_title; }
+  const std::string& getDescription() const { return m_description; }
+  const std::string& getLanguage() const { return m_language; }
+  const std::string& getCreator() const { return m_creator; }
+  const std::string& getPublisher() const { return m_publisher; }
+  const std::string& getDate() const { return m_date; }
+  const std::string& getUrl() const { return m_url; }
+  const std::string& getName() const { return m_name; }
+  const std::string& getTags() const { return m_tags; }
+  const std::string& getOrigId() const { return m_origId; }
+  const uint64_t& getArticleCount() const { return m_articleCount; }
+  const uint64_t& getMediaCount() const { return m_mediaCount; }
+  const uint64_t& getSize() const { return m_size; }
+  const std::string& getFavicon() const;
+  const std::string& getFaviconUrl() const { return m_faviconUrl; }
+  const std::string& getFaviconMimeType() const { return m_faviconMimeType; }
+  const std::string& getDownloadId() const { return m_downloadId; }
+
+  void setReadOnly(bool readOnly) { m_readOnly = readOnly; }
+  void setId(const std::string& id) { m_id = id; }
+  void setPath(const std::string& path);
+  void setPathValid(bool valid) { m_pathValid = valid; }
+  void setTitle(const std::string& title) { m_title = title; }
+  void setDescription(const std::string& description) { m_description = description; }
+  void setLanguage(const std::string& language) { m_language = language; }
+  void setCreator(const std::string& creator) { m_creator = creator; }
+  void setPublisher(const std::string& publisher) { m_publisher = publisher; }
+  void setDate(const std::string& date) { m_date = date; }
+  void setUrl(const std::string& url) { m_url = url; }
+  void setName(const std::string& name) { m_name = name; }
+  void setTags(const std::string& tags) { m_tags = tags; }
+  void setOrigId(const std::string& origId) { m_origId = origId; }
+  void setArticleCount(uint64_t articleCount) { m_articleCount = articleCount; }
+  void setMediaCount(uint64_t mediaCount) { m_mediaCount = mediaCount; }
+  void setSize(uint64_t size) { m_size = size; }
+  void setFavicon(const std::string& favicon) { m_favicon = favicon; }
+  void setFaviconMimeType(const std::string& faviconMimeType) { m_faviconMimeType = faviconMimeType; }
+  void setDownloadId(const std::string& downloadId) { m_downloadId = downloadId; }
+
+ protected:
+  std::string m_id;
+  std::string m_downloadId;
+  std::string m_path;
+  bool m_pathValid;
+  std::string m_title;
+  std::string m_description;
+  std::string m_language;
+  std::string m_creator;
+  std::string m_publisher;
+  std::string m_date;
+  std::string m_url;
+  std::string m_name;
+  std::string m_tags;
+  std::string m_origId;
+  uint64_t m_articleCount;
+  uint64_t m_mediaCount;
+  bool m_readOnly;
+  uint64_t m_size;
+  mutable std::string m_favicon;
+  std::string m_faviconUrl;
+  std::string m_faviconMimeType;
+};
+
+}
+
+#endif

include/bookmark.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_BOOKMARK_H
+#define KIWIX_BOOKMARK_H
+
+#include <string>
+
+namespace pugi {
+class xml_node;
+}
+
+namespace kiwix
+{
+
+/**
+ * A class to store information about a bookmark (an article in a book)
+ */
+class Bookmark
+{
+ public:
+  Bookmark();
+  ~Bookmark();
+
+  void updateFromXml(const pugi::xml_node& node);
+
+  const std::string& getBookId() const { return m_bookId; }
+  const std::string& getBookTitle()  const { return m_bookTitle; }
+  const std::string& getUrl() const { return m_url; }
+  const std::string& getTitle() const { return m_title; }
+  const std::string& getLanguage() const { return m_language; }
+  const std::string& getDate() const { return m_date; }
+
+  void setBookId(const std::string& bookId) { m_bookId = bookId; }
+  void setBookTitle(const std::string& bookTitle) { m_bookTitle = bookTitle; }
+  void setUrl(const std::string& url) { m_url = url; }
+  void setTitle(const std::string& title) { m_title = title; }
+  void setLanguage(const std::string& language) { m_language = language; }
+  void setDate(const std::string& date) { m_date = date; }
+
+ protected:
+  std::string m_bookId;
+  std::string m_bookTitle;
+  std::string m_url;
+  std::string m_title;
+  std::string m_language;
+  std::string m_date;
+};
+
+}
+
+#endif

include/common.h

@@ -0,0 +1,24 @@
+
+#ifndef _KIWIX_COMMON_H_
+#define _KIWIX_COMMON_H_
+
+#include <zim/zim.h>
+
+#ifdef __GNUC__
+#define DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#else
+#praga message("WARNING: You need to implement DEPRECATED for this compiler")
+#define DEPRECATED
+#endif
+
+
+namespace kiwix {
+
+typedef zim::size_type size_type;
+typedef zim::offset_type offset_type;
+
+}
+
+#endif //_KIWIX_COMMON_H_

include/common/base64.h

@@ -1,4 +0,0 @@
-#include <string>
-
-std::string base64_encode(unsigned char const* , unsigned int len);
-std::string base64_decode(std::string const& s);

include/common/pathTools.h

@@ -1,60 +0,0 @@
-/*
- * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#ifndef KIWIX_PATHTOOLS_H
-#define KIWIX_PATHTOOLS_H
-
-#include <string>
-#include <vector>
-#include <sstream>
-#include <iostream>
-#include <fstream>
-#include <string.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <ios>
-#include <limits.h>
-
-#ifdef _WIN32
-#include <direct.h>
-#endif
-
-#include "stringTools.h"
-
-using namespace std;
-
-bool isRelativePath(const string &path);
-string computeAbsolutePath(const string path, const string relativePath);
-string computeRelativePath(const string path, const string absolutePath);
-string removeLastPathElement(const string path, const bool removePreSeparator = false, 
-			     const bool removePostSeparator = false);
-string appendToDirectory(const string &directoryPath, const string &filename);
-
-unsigned int getFileSize(const string &path);
-string getFileSizeAsString(const string &path);
-bool fileExists(const string &path);
-bool makeDirectory(const string &path);
-bool copyFile(const string &sourcePath, const string &destPath);
-string getLastPathElement(const string &path);
-string getExecutablePath();
-string getCurrentDirectory();
-bool writeTextFile(const string &path, const string &content);
-#endif

include/common/stringTools.h

@@ -1,71 +0,0 @@
-/*
- * Copyright 2011-2012 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#ifndef KIWIX_STRINGTOOLS_H
-#define KIWIX_STRINGTOOLS_H
-
-#include <unicode/translit.h>
-#include <unicode/normlzr.h>
-#include <unicode/unistr.h>
-#include <unicode/rep.h>
-#include <unicode/uniset.h>
-#include <unicode/ustring.h>
-#include <unicode/ucnv.h>
-
-#include <iostream>
-#include <vector>
-#include <string>
-#include <fstream>
-#include <sstream>
-
-#include "pathTools.h"
-
-namespace kiwix {
-
-#ifndef __ANDROID__
-
-  std::string beautifyInteger(const unsigned int number);
-  std::string beautifyFileSize(const unsigned int number);
-  std::string urlEncode(const std::string &c);
-  void printStringInHexadecimal(const char *s);
-  void printStringInHexadecimal(UnicodeString s);
-  void stringReplacement(std::string& str, const std::string& oldStr, const std::string& newStr);
-  std::string encodeDiples(const std::string& str);
-
-#endif
-
-  std::string removeAccents(const std::string &text);
-  void loadICUExternalTables();
-  std::string urlDecode(const std::string &c);
-
-  std::vector<std::string> split(const std::string&, const std::string&);
-  std::vector<std::string> split(const char*, const char*);
-  std::vector<std::string> split(const std::string&, const char*);
-  std::vector<std::string> split(const char*, const std::string&);
-
-  std::string ucAll(const std::string &word);
-  std::string lcAll(const std::string &word);
-  std::string ucFirst(const std::string &word);
-  std::string lcFirst(const std::string &word);
-  std::string toTitle(const std::string &word);
-
-  std::string normalize(const std::string &word);
-}
-
-#endif

include/ctpp2/CTPP2VMStringLoader.hpp

@@ -1,79 +0,0 @@
-/*
- * Copyright 2013 Renaud Gaudin <reg@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#ifndef _CTPP2_VM_STRING_LOADER_HPP__
-#define _CTPP2_VM_STRING_LOADER_HPP__ 1
-
-#include <ctpp2/CTPP2VMLoader.hpp>
-#include <ctpp2/CTPP2Util.hpp>
-#include <ctpp2/CTPP2Exception.hpp>
-#include <ctpp2/CTPP2VMExecutable.hpp>
-#include <ctpp2/CTPP2VMInstruction.hpp>
-#include <ctpp2/CTPP2VMMemoryCore.hpp>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <iostream>
-#include <string>
-
-/**
-  @file VMStringLoader.hpp
-  @brief Load program core from file
-*/
-
-namespace CTPP // C++ Template Engine
-{
-// FWD
-struct VMExecutable;
-
-/**
-  @class VMStringLoader CTPP2VMStringLoader.hpp <CTPP2VMStringLoader.hpp>
-  @brief Load program core from file
-*/
-class CTPP2DECL VMStringLoader:
-  public VMLoader
-{
-public:
-	/**
-	*/
-	VMStringLoader(CCHAR_P rawContent, size_t rawContentSize);
-	/**
-	  @brief Get ready-to-run program
-	*/
-	const VMMemoryCore * GetCore() const;
-
-	/**
-	  @brief A destructor
-	*/
-	~VMStringLoader() throw();
-private:
-	/** Program core             */
-	VMExecutable  * oCore;
-	/** Ready-to-run program     */
-	VMMemoryCore  * pVMMemoryCore;
-};
-
-} // namespace CTPP
-#endif // _CTPP2_VM_STRING_LOADER_HPP__
-// End.

include/downloader.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_DOWNLOADER_H
+#define KIWIX_DOWNLOADER_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <pthread.h>
+#include <memory>
+
+namespace kiwix
+{
+
+class Aria2;
+struct DownloadedFile {
+  DownloadedFile()
+   : success(false) {}
+  bool success;
+  std::string path;
+};
+
+class AriaError : public std::runtime_error {
+ public:
+  AriaError(const std::string& message) : std::runtime_error(message) {}
+};
+
+
+class Download {
+ public:
+  typedef enum { K_ACTIVE, K_WAITING, K_PAUSED, K_ERROR, K_COMPLETE, K_REMOVED, K_UNKNOWN } StatusResult;
+
+  Download() :
+    m_status(K_UNKNOWN) {}
+  Download(std::shared_ptr<Aria2> p_aria, std::string did)
+    : mp_aria(p_aria),
+      m_status(K_UNKNOWN),
+      m_did(did) {};
+  void updateStatus(bool follow=false);
+  void pauseDownload();
+  void resumeDownload();
+  void cancelDownload();
+  StatusResult getStatus()          { return m_status; }
+  std::string  getDid()             { return m_did; }
+  std::string  getFollowedBy()      { return m_followedBy; }
+  uint64_t     getTotalLength()     { return m_totalLength; }
+  uint64_t     getCompletedLength() { return m_completedLength; }
+  uint64_t     getDownloadSpeed()   { return m_downloadSpeed; }
+  uint64_t     getVerifiedLength()  { return m_verifiedLength; }
+  std::string  getPath()            { return m_path; }
+  std::vector<std::string>&  getUris()             { return m_uris; }
+
+ protected:
+  std::shared_ptr<Aria2> mp_aria;
+  StatusResult m_status;
+  std::string m_did = "";
+  std::string m_followedBy = "";
+  uint64_t m_totalLength;
+  uint64_t m_completedLength;
+  uint64_t m_downloadSpeed;
+  uint64_t m_verifiedLength;
+  std::vector<std::string> m_uris;
+  std::string m_path;
+};
+
+/**
+ * A tool to download things.
+ *
+ */
+class Downloader
+{
+ public:
+  Downloader();
+  virtual ~Downloader();
+
+  void close();
+
+  Download* startDownload(const std::string& uri);
+  Download* getDownload(const std::string& did);
+
+  size_t getNbDownload() { return m_knownDownloads.size(); }
+  std::vector<std::string> getDownloadIds();
+
+ private:
+  std::map<std::string, std::unique_ptr<Download>> m_knownDownloads;
+  std::shared_ptr<Aria2> mp_aria;
+};
+}
+
+#endif

include/entry.h

@@ -0,0 +1,192 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_ENTRY_H
+#define KIWIX_ENTRY_H
+
+#include <stdio.h>
+#include <zim/article.h>
+#include <exception>
+#include <string>
+
+#include "common.h"
+
+using namespace std;
+
+namespace kiwix
+{
+
+
+class NoEntry : public std::exception {};
+
+/**
+ * A entry represent an.. entry in a zim file.
+ */
+class Entry
+{
+  public:
+    /**
+     * Default constructor.
+     *
+     * Construct an invalid entry.
+     */
+    Entry() = default;
+
+    /**
+     * Construct an entry making reference to an zim article.
+     *
+     * @param article a zim::Article object
+     */
+    Entry(zim::Article article);
+    virtual ~Entry() = default;
+
+    /**
+     * Get the path of the entry.
+     *
+     * The path is the "key" of an entry.
+     *
+     * @return the path of the entry.
+     */
+    std::string getPath() const;
+    
+    /**
+     * Get the title of the entry.
+     *
+     * @return the title of the entry.
+     */
+    std::string getTitle() const;
+        
+    /**
+     * Get the content of the entry.
+     *
+     * The string is a copy of the content.
+     * If you don't want to do a copy, use get_blob.
+     *
+     * @return the content of the entry.
+     */
+    std::string getContent() const;
+        
+    /**
+     * Get the blob of the entry.
+     *
+     * A blob make reference to the content without copying it.
+     *
+     * @param offset The starting offset of the blob.
+     * @return the blob of the entry.
+     */
+    zim::Blob   getBlob(offset_type offset = 0) const;
+        
+    /**
+     * Get the blob of the entry.
+     *
+     * A blob make reference to the content without copying it.
+     *
+     * @param offset The starting offset of the blob.
+     * @param size The size of the blob.
+     * @return the blob of the entry.
+     */
+    zim::Blob   getBlob(offset_type offset, size_type size) const;
+        
+    /**
+     * Get the info for direct access to the content of the entry.
+     *
+     * Some entry (ie binary ones) have their content plain stored
+     * in the zim file. Knowing the offset where the content is stored
+     * an user can directly read the content in the zim file bypassing the
+     * kiwix-lib/libzim.
+     *
+     * @return A pair specifying where to read the content.
+     *         The string is the real file to read (may be different that .zim
+     *         file if zim is cut).
+     *         The offset is the offset to read in the file.
+     *         Return <"",0> if is not possible to read directly.
+     */
+    std::pair<std::string, offset_type> getDirectAccessInfo() const;
+        
+    /**
+     * Get the size of the entry.
+     *
+     * @return the size of the entry.
+     */
+    size_type   getSize() const;
+
+    /**
+     * Get the mime_type of the entry.
+     *
+     * @return the mime_type of the entry.
+     */
+    std::string getMimetype() const;
+    
+    
+    /**
+     * Get if the entry is a redirect entry.
+     *
+     * @return True if the entry is a redirect.
+     */
+    bool isRedirect() const;
+
+    /**
+     * Get if the entry is a link target entry.
+     *
+     * @return True if the entry is a link target.
+     */
+    bool isLinkTarget() const;
+
+    /**
+     * Get if the entry is a deleted entry.
+     *
+     * @return True if the entry is a deleted entry.
+     */
+    bool isDeleted() const;
+
+    /**
+     * Get the entry pointed by this entry.
+     *
+     * @return the entry pointed.
+     * @throw NoEntry if the entry is not a redirected entry.
+     */
+    Entry getRedirectEntry() const;
+
+    /**
+     * Get the final entry pointed by this entry.
+     *
+     * Follow the redirection until a "not redirecting" entry is found.
+     * If the entry is not a redirected entry, return the entry itself.
+     *
+     * @return the final entry.
+     */
+    Entry getFinalEntry() const;
+
+    /**
+     * Convert the entry to a boolean value.
+     *
+     * @return True if the entry is valid.
+     */
+    explicit operator bool() const { return good(); }
+
+  private:
+    zim::Article article;
+    mutable zim::Article final_article;
+
+    bool good() const { return article.good(); }
+};
+
+}
+
+#endif // KIWIX_ENTRY_H

include/indexer.h

@@ -1,173 +0,0 @@
-/*
- * Copyright 2014 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#ifndef KIWIX_INDEXER_H
-#define KIWIX_INDEXER_H
-
-#include <string>
-#include <vector>
-#include <stack>
-#include <queue>
-#include <fstream>
-#include <iostream>
-#include <sstream>
-
-#include <pthread.h>
-#include "common/stringTools.h"
-#include "common/otherTools.h"
-#include <zim/file.h>
-#include <zim/article.h>
-#include <zim/fileiterator.h>
-#include "reader.h"
-
-using namespace std;
-
-namespace kiwix {
-
-  struct indexerToken {
-    string url;
-    string accentedTitle;
-    string title;
-    string keywords;
-    string content;
-    string snippet;
-    string size;
-    string wordCount;
-  };
-  
-  class Indexer {
-      
-  typedef void (* ProgressCallback)(const unsigned int processedArticleCount, const unsigned int totalArticleCount);
-      
-  public:
-    Indexer();
-    virtual ~Indexer();
-
-    bool start(const string zimPath, const string indexPath, ProgressCallback callback = NULL);
-    bool stop();
-    bool isRunning();
-    unsigned int getProgression();
-    void setVerboseFlag(const bool value);
-
-  protected:
-    virtual void indexingPrelude(const string indexPath) = 0;
-    virtual void index(const string &url, 
-		       const string &title, 
-		       const string &unaccentedTitle,
-		       const string &keywords, 
-		       const string &content,
-		       const string &snippet,
-		       const string &size,
-		       const string &wordCount) = 0;
-    virtual void flush() = 0;
-    virtual void indexingPostlude(const string indexPath) = 0;
-
-    /* Stop words */
-    std::vector<std::string> stopWords;
-    void readStopWords(const string languageCode);
-
-    /* Others */
-    unsigned int countWords(const string &text);
-
-    /* Boost factor */
-    unsigned int keywordsBoostFactor;
-    inline unsigned int getTitleBoostFactor(const unsigned int contentLength) {
-      return contentLength / 500 + 1;
-    }
-
-    /* Verbose */
-    pthread_mutex_t verboseMutex;
-    bool getVerboseFlag();
-    bool verboseFlag;
-
-  private:
-    ProgressCallback progressCallback;
-    pthread_mutex_t threadIdsMutex;
-
-    /* Article extraction */
-    pthread_t articleExtractor;
-    pthread_mutex_t articleExtractorRunningMutex;
-    static void *extractArticles(void *ptr);
-    bool articleExtractorRunningFlag;
-    bool isArticleExtractorRunning();
-    void articleExtractorRunning(bool value);
-
-    /* Article parsing */
-    pthread_t articleParser;
-    pthread_mutex_t articleParserRunningMutex;
-    static void *parseArticles(void *ptr);
-    bool articleParserRunningFlag;
-    bool isArticleParserRunning();
-    void articleParserRunning(bool value);
-
-    /* Index writting */
-    pthread_t articleIndexer;
-    pthread_mutex_t articleIndexerRunningMutex;
-    static void *indexArticles(void *ptr);
-    bool articleIndexerRunningFlag;
-    bool isArticleIndexerRunning();
-    void articleIndexerRunning(bool value);
-
-    /* To parse queue */
-    std::queue<indexerToken> toParseQueue;
-    pthread_mutex_t toParseQueueMutex;
-    void pushToParseQueue(indexerToken &token);
-    bool popFromToParseQueue(indexerToken &token);
-    bool isToParseQueueEmpty();
-
-    /* To index queue */
-    std::queue<indexerToken> toIndexQueue;
-    pthread_mutex_t toIndexQueueMutex;
-    void pushToIndexQueue(indexerToken &token);
-    bool popFromToIndexQueue(indexerToken &token);
-    bool isToIndexQueueEmpty();
-
-    /* Article Count & Progression */
-    unsigned int articleCount;
-    pthread_mutex_t articleCountMutex;
-    void setArticleCount(const unsigned int articleCount);
-    unsigned int getArticleCount();
-
-    /* Progression */
-    unsigned int progression;
-    pthread_mutex_t progressionMutex;
-    void setProgression(const unsigned int progression);
-    /* getProgression() is public */
-
-    /* ZIM path */
-    pthread_mutex_t zimPathMutex;
-    string zimPath;
-    void setZimPath(const string path);
-    string getZimPath();
-
-    /* Index path */
-    pthread_mutex_t indexPathMutex;
-    string indexPath;
-    void setIndexPath(const string path);
-    string getIndexPath();
-
-    /* ZIM id */
-    pthread_mutex_t zimIdMutex;
-    string zimId;
-    void setZimId(const string id);
-    string getZimId();
-  };
-}
-
-#endif

include/kiwix.h

@@ -22,5 +22,4 @@
 
 #include "library.h"
 
-
 #endif

include/kiwixserve.h

@@ -0,0 +1,29 @@
+#ifndef KIWIXLIB_KIWIX_SERVE_H_
+#define KIWIXLIB_KIWIX_SERVE_H_
+
+#include <memory>
+#include <string>
+
+class Subprocess;
+namespace kiwix {
+
+class KiwixServe
+{
+  public:
+    KiwixServe(const std::string& libraryPath, int port = 8181);
+    ~KiwixServe();
+
+    void run();
+    void shutDown();
+    bool isRunning();
+    int getPort() { return m_port; }
+
+  private:
+  std::unique_ptr<Subprocess> mp_kiwixServe;
+  int m_port;
+  std::string m_libraryPath;
+};
+
+}; //end namespace kiwix
+
+#endif // KIWIXLIB_KIWIX_SERVE_H_

include/library.h

@@ -20,88 +20,267 @@
 #ifndef KIWIX_LIBRARY_H
 #define KIWIX_LIBRARY_H
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <string>
-#include <string.h>
 #include <vector>
-#include <stack>
+#include <map>
+#include <memory>
 
-#include "common/stringTools.h"
-#include "common/regexTools.h"
+#include "book.h"
+#include "bookmark.h"
+#include "common.h"
 
 #define KIWIX_LIBRARY_VERSION "20110515"
 
-using namespace std;
+namespace kiwix
+{
 
-namespace kiwix {
+class OPDSDumper;
 
-  enum supportedIndexType { UNKNOWN, XAPIAN };
+enum supportedListSortBy { UNSORTED, TITLE, SIZE, DATE, CREATOR, PUBLISHER };
+enum supportedListMode {
+  ALL = 0,
+  LOCAL = 1,
+  REMOTE = 1 << 1,
+  NOLOCAL = 1 << 2,
+  NOREMOTE = 1 << 3,
+  VALID = 1 << 4,
+  NOVALID = 1 << 5
+};
 
-  class Book {
+class Filter {
+  private:
+    uint64_t activeFilters;
+    std::vector<std::string> _acceptTags;
+    std::vector<std::string> _rejectTags;
+    std::string _lang;
+    std::string _publisher;
+    std::string _creator;
+    size_t _maxSize;
+    std::string _query;
 
   public:
-    Book();
-    ~Book();
+    Filter();
+    ~Filter() = default;
 
-    static bool sortByLastOpen(const Book &a, const Book &b);
-    static bool sortByTitle(const Book &a, const Book &b);
-    static bool sortBySize(const Book &a, const Book &b);
-    static bool sortByDate(const Book &a, const Book &b);
-    static bool sortByCreator(const Book &a, const Book &b);
-    static bool sortByPublisher(const Book &a, const Book &b);
-    static bool sortByLanguage(const Book &a, const Book &b);
-    string getHumanReadableIdFromPath();
-
-    string id;
-    string path;
-    string pathAbsolute;
-    string last;
-    string indexPath;
-    string indexPathAbsolute;
-    supportedIndexType indexType;
-    string title;
-    string description;
-    string language;
-    string creator;
-    string publisher;
-    string date;
-    string url;
-    string name;
-    string tags;
-    string origId;
-    string articleCount;
-    string mediaCount;
-    bool readOnly;
-    string size;
-    string favicon;
-    string faviconMimeType;
-  };
-
-  class Library {
-
-  public:
-    Library();
-    ~Library();
-
-    string version;
-    bool addBook(const Book &book);
-    bool removeBookByIndex(const unsigned int bookIndex);
-    vector <kiwix::Book> books;
-
-    /*
-     * 'current' is the variable storing the current content/book id
-     * in the library. This is used to be able to load per default a
-     * content. As Kiwix may work with many library XML files, you may
-     * have "current" defined many time with different values. The
-     * last XML file read has the priority, Although we do not have an
-     * library object for each file, we want to be able to fallback to
-     * an 'old' current book if the one which should be load
-     * failed. That is the reason why we need a stack here
+    /**
+     *  Set the filter to check local.
+     *
+     *  A local book is a book with a path.
+     *  If accept is true, only local book are accepted.
+     *  If accept is false, only non local book are accepted.
      */
-    stack<string> current;
-  };
+    Filter& local(bool accept);
 
+    /**
+     *  Set the filter to check remote.
+     *
+     *  A remote book is a book with a url.
+     *  If accept is true, only remote book are accepted.
+     *  If accept is false, only non remote book are accepted.
+     */
+    Filter& remote(bool accept);
+
+    /**
+     *  Set the filter to check validity.
+     *
+     *  A valid book is a book with a path pointing to a existing zim file.
+     *  If accept is true, only valid book are accepted.
+     *  If accept is false, only non valid book are accepted.
+     */
+    Filter& valid(bool accept);
+
+    /**
+     * Set the filter to only accept book with corresponding tag.
+     */
+    Filter& acceptTags(std::vector<std::string> tags);
+    Filter& rejectTags(std::vector<std::string> tags);
+
+    Filter& lang(std::string lang);
+    Filter& publisher(std::string publisher);
+    Filter& creator(std::string creator);
+    Filter& maxSize(size_t size);
+    Filter& query(std::string query);
+
+    bool accept(const Book& book) const;
+};
+
+
+/**
+ * A Library store several books.
+ */
+class Library
+{
+  std::map<std::string, kiwix::Book> m_books;
+  std::map<std::string, std::shared_ptr<Reader>> m_readers;
+  std::vector<kiwix::Bookmark> m_bookmarks;
+
+ public:
+  Library();
+  ~Library();
+
+  /**
+   * Add a book to the library.
+   *
+   * If a book already exist in the library with the same id, update
+   * the existing book instead of adding a new one.
+   *
+   * @param book The book to add.
+   * @return True if the book has been added.
+   *         False if a book has been updated.
+   */
+  bool addBook(const Book& book);
+
+  /**
+   * Add a bookmark to the library.
+   *
+   * @param bookmark the book to add.
+   */
+  void addBookmark(const Bookmark& bookmark);
+
+  /**
+   * Remove a bookmarkk
+   *
+   * @param zimId The zimId of the bookmark.
+   * @param url The url of the bookmark.
+   * @return True if the bookmark has been removed.
+   */
+  bool removeBookmark(const std::string& zimId, const std::string& url);
+
+  Book& getBookById(const std::string& id);
+  std::shared_ptr<Reader> getReaderById(const std::string& id);
+
+  /**
+   * Remove a book from the library.
+   *
+   * @param id the id of the book to remove.
+   * @return True if the book were in the lirbrary and has been removed.
+   */
+  bool removeBookById(const std::string& id);
+
+  /**
+   * Write the library to a file.
+   *
+   * @param path the path of the file to write to.
+   * @return True if the library has been correctly saved.
+   */
+  bool writeToFile(const std::string& path);
+
+  /**
+   * Write the library bookmarks to a file.
+   *
+   * @param path the path of the file to write to.
+   * @return True if the library has been correctly saved.
+   */
+  bool writeBookmarksToFile(const std::string& path);
+
+  /**
+   * Get the number of book in the library.
+   *
+   * @param localBooks If we must count local books (books with a path).
+   * @param remoteBooks If we must count remote books (books with an url)
+   * @return The number of books.
+   */
+  unsigned int getBookCount(const bool localBooks, const bool remoteBooks);
+
+  /**
+   * Get all langagues of the books in the library.
+   *
+   * @return A list of languages.
+   */
+  std::vector<std::string> getBooksLanguages();
+
+  /**
+   * Get all book creators of the books in the library.
+   *
+   * @return A list of book creators.
+   */
+  std::vector<std::string> getBooksCreators();
+
+  /**
+   * Get all book publishers of the books in the library.
+   *
+   * @return A list of book publishers.
+   */
+  std::vector<std::string> getBooksPublishers();
+
+  /**
+   * Get all bookmarks.
+   *
+   * @return A list of bookmarks
+   */
+  const std::vector<kiwix::Bookmark>& getBookmarks() { return m_bookmarks; }
+
+  /**
+   * Get all book ids of the books in the library.
+   *
+   * @return A list of book ids.
+   */
+  std::vector<std::string> getBooksIds();
+
+  /**
+   * Filter the library and generate a new one with the keep elements.
+   *
+   * This is equivalent to `listBookIds(ALL, UNSORTED, search)`.
+   *
+   * @param search List only books with search in the title or description.
+   * @return The list of bookIds corresponding to the query.
+   */
+  DEPRECATED std::vector<std::string> filter(const std::string& search);
+
+
+  /**
+   * Filter the library and return the id of the keep elements.
+   *
+   * @param filter The filter to use.
+   * @return The list of bookIds corresponding to the filter.
+   */
+  std::vector<std::string> filter(const Filter& filter);
+
+
+  /**
+   * Sort (in place) bookIds using the given comparator.
+   *
+   * @param bookIds the list of book Ids to sort
+   * @param comparator how to sort the books
+   * @return The sorted list of books
+   */
+  void sort(std::vector<std::string>& bookIds, supportedListSortBy sortBy, bool ascending);
+
+  /**
+   * List books in the library.
+   *
+   * @param mode The mode of listing :
+   *             - LOCAL    : list only local books (with a path).
+   *             - REMOTE   : list only remote books (with an url).
+   *             - VALID    : list only valid books (without a path or with a
+   *                          path pointing to a valid zim file).
+   *             - NOLOCAL  : list only books without valid path.
+   *             - NOREMOTE : list only books without url.
+   *             - NOVALID  : list only books not valid.
+   *             - ALL : Do not do any filter (LOCAL or REMOTE)
+   *             - Flags can be combined.
+   * @param sortBy Attribute to sort by the book list.
+   * @param search List only books with search in the title, description.
+   * @param language List only books in this language.
+   * @param creator List only books of this creator.
+   * @param publisher List only books of this publisher.
+   * @param maxSize Do not list book bigger than maxSize.
+   *                Set to 0 to cancel this filter.
+   * @return The list of bookIds corresponding to the query.
+   */
+  DEPRECATED std::vector<std::string> listBooksIds(
+    int supportedListMode = ALL,
+    supportedListSortBy sortBy = UNSORTED,
+    const std::string& search = "",
+    const std::string& language = "",
+    const std::string& creator = "",
+    const std::string& publisher = "",
+    const std::vector<std::string>& tags = {},
+    size_t maxSize = 0);
+
+  friend class OPDSDumper;
+  friend class libXMLDumper;
+};
 }
 
 #endif

include/libxml_dumper.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_LIBXML_DUMPER_H
+#define KIWIX_LIBXML_DUMPER_H
+
+#include <string>
+#include <vector>
+
+#include <pugixml.hpp>
+
+#include "library.h"
+
+namespace kiwix
+{
+
+/**
+ * A tool to dump a `Library` into a basic library.xml
+ *
+ */
+class LibXMLDumper
+{
+ public:
+  LibXMLDumper() = default;
+  LibXMLDumper(Library* library);
+  ~LibXMLDumper();
+
+  /**
+   * Dump the library.xml
+   *
+   * @param id The id of the library.
+   * @return The library.xml content.
+   */
+  std::string dumpLibXMLContent(const std::vector<std::string>& bookIds);
+
+
+  /**
+   * Dump the bookmark of the library.
+   *
+   * @return The bookmark.xml content.
+   */
+  std::string dumpLibXMLBookmark();
+
+  /**
+   * Set the base directory used.
+   *
+   * @param baseDir the base directory to use.
+   */
+  void setBaseDir(const std::string& baseDir) { this->baseDir = baseDir; }
+
+  /**
+   * Set the library to dump.
+   *
+   * @param library The library to dump.
+   */
+  void setLibrary(Library* library) { this->library = library; }
+
+ protected:
+  kiwix::Library* library;
+  std::string baseDir;
+ private:
+  void handleBook(Book book, pugi::xml_node root_node);
+  void handleBookmark(Bookmark bookmark, pugi::xml_node root_node);
+};
+}
+
+#endif // KIWIX_OPDS_DUMPER_H

include/manager.h

@@ -20,73 +20,160 @@
 #ifndef KIWIX_MANAGER_H
 #define KIWIX_MANAGER_H
 
-#include <string>
-#include <sstream>
-#include <time.h>
-
-#include <pugixml.hpp>
-
-#include "common/base64.h"
-#include "common/regexTools.h"
-#include "common/pathTools.h"
+#include "book.h"
 #include "library.h"
 #include "reader.h"
 
-using namespace std;
+#include <string>
+#include <vector>
 
-namespace kiwix {
+namespace pugi {
+class xml_document;
+}
 
-  enum supportedListMode { LASTOPEN, REMOTE, LOCAL };
-  enum supportedListSortBy { TITLE, SIZE, DATE, CREATOR, PUBLISHER };
+namespace kiwix
+{
 
-  class Manager {
+class LibraryManipulator {
+ public:
+  virtual ~LibraryManipulator() {}
+  virtual bool addBookToLibrary(Book book) = 0;
+  virtual void addBookmarkToLibrary(Bookmark bookmark) = 0;
+};
 
-  public:
-    Manager();
-    ~Manager();
+class DefaultLibraryManipulator : public LibraryManipulator {
+ public:
+  DefaultLibraryManipulator(Library* library) :
+    library(library) {}
+  virtual ~DefaultLibraryManipulator() {}
+  bool addBookToLibrary(Book book) {
+    return library->addBook(book);
+  }
+  void addBookmarkToLibrary(Bookmark bookmark) {
+    library->addBookmark(bookmark);
+  }
+ private:
+   kiwix::Library* library;
+};
 
-    bool readFile(const string path, const bool readOnly = true);
-    bool readFile(const string nativePath, const string UTF8Path, const bool readOnly = true);
-    bool readXml(const string xml, const bool readOnly = true, const string libraryPath = "");
-    bool writeFile(const string path);
-    bool removeBookByIndex(const unsigned int bookIndex);
-    bool removeBookById(const string id);
-    bool setCurrentBookId(const string id);
-    string getCurrentBookId();
-    bool setBookIndex(const string id, const string path, const supportedIndexType type);
-    bool setBookIndex(const string id, const string path);
-    bool setBookPath(const string id, const string path);
-    string addBookFromPathAndGetId(const string pathToOpen, const string pathToSave = "", const string url = "",
-				   const bool checkMetaData = false);
-    bool addBookFromPath(const string pathToOpen, const string pathToSave = "", const string url = "",
-			 const bool checkMetaData = false);
-    Library cloneLibrary();
-    bool getBookById(const string id, Book &book);
-    bool getCurrentBook(Book &book);
-    unsigned int getBookCount(const bool localBooks, const bool remoteBooks);
-    bool updateBookLastOpenDateById(const string id);
-    void removeBookPaths();
-    bool listBooks(const supportedListMode mode, const supportedListSortBy sortBy, const unsigned int maxSize,
-		   const string language, const string creator, const string publisher, const string search);
-    vector<string> getBooksLanguages();
-    vector<string> getBooksCreators();
-    vector<string> getBooksPublishers();
-    vector<string> getBooksIds();
+/**
+ * A tool to manage a `Library`.
+ */
+class Manager
+{
+ public:
+  Manager(LibraryManipulator* manipulator);
+  Manager(Library* library);
+  ~Manager();
 
-    string writableLibraryPath;
+  /**
+   * Read a `library.xml` and add book in the file to the library.
+   *
+   * @param path The path to the `library.xml`.
+   * @param readOnly Set if the libray path could be overwritten latter with
+   *                 updated content.
+   * @return True if file has been properly parsed.
+   */
+  bool readFile(const std::string& path, const bool readOnly = true);
 
-    vector<std::string> bookIdList;
+  /**
+   * Read a `library.xml` and add book in the file to the library.
+   *
+   * @param nativePath The path of the `library.xml`
+   * @param UTF8Path The utf8 version (?) of the path. Also the path where the
+   *                 library will be writen i readOnly is False.
+   * @param readOnly Set if the libray path could be overwritten latter with
+   *                 updated content.
+   * @return True if file has been properly parsed.
+   */
+  bool readFile(const std::string& nativePath,
+                const std::string& UTF8Path,
+                const bool readOnly = true);
 
-  protected:
-    kiwix::Library library;
+  /**
+   * Load a library content store in the string.
+   *
+   * @param xml The content corresponding of the library xml
+   * @param readOnly Set if the libray path could be overwritten latter with
+   *                 updated content.
+   * @param libraryPath The library path (used to resolve relative path)
+   * @return True if the content has been properly parsed.
+   */
+  bool readXml(const std::string& xml,
+               const bool readOnly = true,
+               const std::string& libraryPath = "");
 
-    bool readBookFromPath(const string path, Book *book = NULL);
-    bool parseXmlDom(const pugi::xml_document &doc, const bool readOnly, const string libraryPath);
+  /**
+   * Load a library content stored in a OPDS stream.
+   *
+   * @param content The content of the OPDS stream.
+   * @param readOnly Set if the library path could be overwritten later with
+   *                 updated content.
+   * @param libraryPath The library path (used to resolve relative path)
+   * @return True if the content has been properly parsed.
+   */
+  bool readOpds(const std::string& content, const std::string& urlHost);
 
-  private:
-    void checkAndCleanBookPaths(Book &book, const string &libraryPath);
-  };
 
+  /**
+   * Load a bookmark file.
+   *
+   * @param path The path of the file to read.
+   * @return True if the content has been properly parsed.
+   */
+  bool readBookmarkFile(const std::string& path);
+
+  /**
+   * Add a book to the library.
+   *
+   * @param pathToOpen The path to the zim file to add.
+   * @param pathToSave The path to store in the library in place of pathToOpen.
+   * @param url        The url of the book to store in the library.
+   * @param checMetaData Tell if we check metadata before adding book to the
+   *                     library.
+   * @return The id of the book if the book has been added to the library.
+   *         Else, an empty string.
+   */
+  std::string addBookFromPathAndGetId(const std::string& pathToOpen,
+                                 const std::string& pathToSave = "",
+                                 const std::string& url = "",
+                                 const bool checkMetaData = false);
+
+  /**
+   * Add a book to the library.
+   *
+   * @param pathToOpen The path to the zim file to add.
+   * @param pathToSave The path to store in the library in place of pathToOpen.
+   * @param url        The url of the book to store in the library.
+   * @param checMetaData Tell if we check metadata before adding book to the
+   *                     library.
+   * @return True if the book has been added to the library.
+   */
+
+  bool addBookFromPath(const std::string& pathToOpen,
+                       const std::string& pathToSave = "",
+                       const std::string& url = "",
+                       const bool checkMetaData = false);
+
+  std::string writableLibraryPath;
+
+  bool m_hasSearchResult = false;
+  uint64_t m_totalBooks = 0;
+  uint64_t m_startIndex = 0;
+  uint64_t m_itemsPerPage = 0;
+
+ protected:
+  kiwix::LibraryManipulator* manipulator;
+  bool mustDeleteManipulator;
+
+  bool readBookFromPath(const std::string& path, Book* book);
+  bool parseXmlDom(const pugi::xml_document& doc,
+                   const bool readOnly,
+                   const std::string& libraryPath);
+  bool parseOpdsDom(const pugi::xml_document& doc,
+                    const std::string& urlHost);
+
+};
 }
 
 #endif

include/meson.build

@@ -1,35 +1,31 @@
 headers = [
+  'book.h',
+  'bookmark.h',
+  'common.h',
   'library.h',
   'manager.h',
+  'libxml_dumper.h',
+  'opds_dumper.h',
+  'downloader.h',
   'reader.h',
-  'searcher.h'
+  'entry.h',
+  'searcher.h',
+  'search_renderer.h',
+  'server.h',
+  'kiwixserve.h',
+  'name_mapper.h'
 ]
 
-if not get_option('android')
-  headers += ['indexer.h']
-endif
-
-if xapian_dep.found()
-  headers += ['xapianIndexer.h', 'xapianSearcher.h']
-endif
-
 install_headers(headers, subdir:'kiwix')
 
 install_headers(
-  'common/base64.h',
-  'common/networkTools.h',
-  'common/otherTools.h',
-  'common/pathTools.h',
-  'common/regexTools.h',
-  'common/stringTools.h',
-  'common/tree.h',
-  subdir:'kiwix/common'
+  'tools/base64.h',
+  'tools/networkTools.h',
+  'tools/otherTools.h',
+  'tools/pathTools.h',
+  'tools/regexTools.h',
+  'tools/stringTools.h',
+  'tools/lock.h',
+  subdir:'kiwix/tools'
 )
 
-if has_ctpp2_dep
-  install_headers(
-    'ctpp2/CTPP2VMStringLoader.hpp',
-    subdir:'kiwix/ctpp2'
-  )
-endif
-

include/name_mapper.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_NAMEMAPPER_H
+#define KIWIX_NAMEMAPPER_H
+
+#include <string>
+#include <map>
+
+namespace kiwix
+{
+
+class Library;
+
+class NameMapper {
+  public:
+    virtual ~NameMapper() = default;
+    virtual std::string getNameForId(const std::string& id) = 0;
+    virtual std::string getIdForName(const std::string& name) = 0;
+};
+
+
+class IdNameMapper : public NameMapper {
+  public:
+    virtual std::string getNameForId(const std::string& id) { return id; };
+    virtual std::string getIdForName(const std::string& name) { return name; };
+};
+
+class HumanReadableNameMapper : public NameMapper {
+  private:
+    std::map<std::string, std::string> m_idToName;
+    std::map<std::string, std::string> m_nameToId;
+
+  public:
+    HumanReadableNameMapper(kiwix::Library& library, bool withAlias);
+    virtual ~HumanReadableNameMapper() = default;
+    virtual std::string getNameForId(const std::string& id);
+    virtual std::string getIdForName(const std::string& name);
+};
+
+
+
+}
+
+#endif

include/opds_dumper.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_OPDS_DUMPER_H
+#define KIWIX_OPDS_DUMPER_H
+
+#include <time.h>
+#include <sstream>
+#include <string>
+
+#include <pugixml.hpp>
+
+#include "tools/base64.h"
+#include "tools/pathTools.h"
+#include "tools/regexTools.h"
+#include "library.h"
+#include "reader.h"
+
+using namespace std;
+
+namespace kiwix
+{
+
+/**
+ * A tool to dump a `Library` into a opds stream.
+ *
+ */
+class OPDSDumper
+{
+ public:
+  OPDSDumper() = default;
+  OPDSDumper(Library* library);
+  ~OPDSDumper();
+
+  /**
+   * Dump the OPDS feed.
+   *
+   * @param id The id of the library.
+   * @return The OPDS feed.
+   */
+  std::string dumpOPDSFeed(const std::vector<std::string>& bookIds);
+
+  /**
+   * Set the id of the opds stream.
+   *
+   * @param id the id to use.
+   */
+  void setId(const std::string& id) { this->id = id;}
+
+  /**
+   * Set the title oft the opds stream.
+   *
+   * @param title the title to use.
+   */
+  void setTitle(const std::string& title) { this->title = title; }
+
+  /**
+   * Set the root location used when generating url.
+   *
+   * @param rootLocation the root location to use.
+   */
+  void setRootLocation(const std::string& rootLocation) { this->rootLocation = rootLocation; }
+
+  /**
+   * Set the search url.
+   *
+   * @param searchUrl the search url to use.
+   */
+  void setSearchDescriptionUrl(const std::string& searchDescriptionUrl) { this->searchDescriptionUrl = searchDescriptionUrl; }
+
+  /**
+   * Set some informations about the search results.
+   *
+   * @param totalResult the total number of results of the search.
+   * @param startIndex the start index of the result.
+   * @param count the number of result of the current set (or page).
+   */
+  void setOpenSearchInfo(int totalResult, int startIndex, int count);
+
+  /**
+   * Set the library to dump.
+   *
+   * @param library The library to dump.
+   */
+  void setLibrary(Library* library) { this->library = library; }
+
+ protected:
+  kiwix::Library* library;
+  std::string id;
+  std::string title;
+  std::string date;
+  std::string rootLocation;
+  std::string searchDescriptionUrl;
+  int m_totalResults;
+  int m_startIndex;
+  int m_count;
+  bool m_isSearchResult = false;
+
+ private:
+  pugi::xml_node handleBook(Book book, pugi::xml_node root_node);
+};
+}
+
+#endif // KIWIX_OPDS_DUMPER_H

include/reader.h

@@ -20,85 +20,551 @@
 #ifndef KIWIX_READER_H
 #define KIWIX_READER_H
 
-#include <zim/zim.h>
-#include <zim/file.h>
-#include <zim/article.h>
-#include <zim/fileiterator.h>
 #include <stdio.h>
-#include <string>
+#include <zim/article.h>
+#include <zim/file.h>
+#include <zim/fileiterator.h>
+#include <zim/zim.h>
 #include <exception>
-#include <sstream>
 #include <map>
-#include "common/pathTools.h"
-#include "common/stringTools.h"
+#include <sstream>
+#include <string>
+#include "common.h"
+#include "entry.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 
 using namespace std;
 
-namespace kiwix {
+namespace kiwix
+{
 
-  class Reader {
+/**
+ * The Reader class is the class who allow to get an entry content from a zim
+ * file.
+ */
+class Reader
+{
+ public:
+  /**
+   * Create a Reader to read a zim file specified by zimFilePath.
+   *
+   * @param zimFilePath The path to the zim file to read.
+   *                    The zim file can be splitted (.zimaa, .zimab, ...).
+   *                    In this case, the file path must still point to the
+   *                    unsplitted path as if the file were not splitted
+   *                    (.zim extesion).
+   */
+  Reader(const string zimFilePath);
+  ~Reader();
 
-  public:
-    Reader(const string zimFilePath);
-    ~Reader();
+  /**
+   * Get the number of "displayable" entries in the zim file.
+   *
+   * @return If the zim file has a /M/Counter metadata, return the number of
+   *         entries with the 'text/html' MIMEtype specified in the metadata.
+   *         Else return the number of entries in the 'A' namespace.
+   */
+  unsigned int getArticleCount() const;
 
-    void reset();
-    unsigned int getArticleCount();
-    unsigned int getMediaCount();
-    unsigned int getGlobalCount();
-    string getZimFilePath();
-    string getId();
-    string getRandomPageUrl();
-    string getFirstPageUrl();
-    string getMainPageUrl();
-    bool getMetatag(const string &url, string &content);
-    string getTitle();
-    string getDescription();
-    string getLanguage();
-    string getName();
-    string getTags();
-    string getDate();
-    string getCreator();
-    string getPublisher();
-    string getOrigId();
-    bool getFavicon(string &content, string &mimeType);
-    bool getPageUrlFromTitle(const string &title, string &url);
-    bool getMimeTypeByUrl(const string &url, string &mimeType);
-    bool getContentByUrl(const string &url, string &content, unsigned int &contentLength, string &contentType);
-    bool getContentByEncodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType, string &baseUrl);
-    bool getContentByEncodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType);
-    bool getContentByDecodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType, string &baseUrl);
-    bool getContentByDecodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType);
-    bool searchSuggestions(const string &prefix, unsigned int suggestionsCount, const bool reset = true);
-    bool searchSuggestionsSmart(const string &prefix, unsigned int suggestionsCount);
-    bool urlExists(const string &url);
-    bool hasFulltextIndex();
-    std::vector<std::string> getTitleVariants(const std::string &title);
-    bool getNextSuggestion(string &title);
-    bool getNextSuggestion(string &title, string &url);
-    bool canCheckIntegrity();
-    bool isCorrupted();
-    bool parseUrl(const string &url, char *ns, string &title);
-    unsigned int getFileSize();
-    zim::File* getZimFileHandler();
-    bool getArticleObjectByDecodedUrl(const string &url, zim::Article &article);
+  /**
+   * Get the number of media in the zim file.
+   *
+   * @return If the zim file has a /M/Counter metadata, return the number of
+   *         entries with the 'image/jpeg', 'image/gif' and 'image/png' in
+   *         the metadata.
+   *         Else return the number of entries in the 'I' namespace.
+   */
+  unsigned int getMediaCount() const;
 
-  protected:
-    zim::File* zimFileHandler;
-    zim::size_type firstArticleOffset;
-    zim::size_type lastArticleOffset;
-    zim::size_type currentArticleOffset;
-    zim::size_type nsACount;
-    zim::size_type nsICount;
-    std::string zimFilePath;
-    
-    std::vector< std::vector<std::string> > suggestions;
-    std::vector< std::vector<std::string> >::iterator suggestionsOffset;
+  /**
+   * Get the number of all entries in the zim file.
+   *
+   * @return Return the number of all the entries, whatever their MIMEtype or
+   *         their namespace.
+   */
+  unsigned int getGlobalCount() const;
 
-  private:
-    std::map<std::string, unsigned int> parseCounterMetadata();
-  };
+  /**
+   * Get the path of the zim file.
+   *
+   * @return the path of the zim file as given in the constructor.
+   */
+  string getZimFilePath() const;
 
+  /**
+   * Get the Id of the zim file.
+   *
+   * @return The uuid stored in the zim file.
+   */
+  string getId() const;
+
+  /**
+   * Get the url of a random page.
+   *
+   * Deprecated : Use `getRandomPage` instead.
+   *
+   * @return Url of a random page. The page is picked from all entries in
+   *         the 'A' namespace.
+   *         The main page is excluded from the potential results.
+   */
+  DEPRECATED string getRandomPageUrl() const;
+
+  /**
+   * Get a random page.
+   *
+   * @return A random Entry. The entry is picked from all entries in
+   *         the 'A' namespace.
+   *         The main entry is excluded from the potential results.
+   */
+  Entry getRandomPage() const;
+
+  /**
+   * Get the url of the first page.
+   *
+   * Deprecated : Use `getFirstPage` instead.
+   *
+   * @return Url of the first entry in the 'A' namespace.
+   */
+  DEPRECATED string getFirstPageUrl() const;
+
+  /**
+   * Get the entry of the first page.
+   *
+   * @return The first entry in the 'A' namespace.
+   */
+  Entry getFirstPage() const;
+
+  /**
+   * Get the url of the main page.
+   *
+   * Deprecated : Use `getMainPage` instead.
+   *
+   * @return Url of the main page as specified in the zim file.
+   */
+  DEPRECATED string getMainPageUrl() const;
+
+  /**
+   * Get the entry of the main page.
+   *
+   * @return Entry of the main page as specified in the zim file.
+   */
+  Entry getMainPage() const;
+
+  /**
+   * Get the content of a metadata.
+   *
+   * @param[in]  name The name of the metadata.
+   * @param[out] value The value will be set to the content of the metadata.
+   * @return True if it was possible to get the content of the metadata.
+   */
+  bool getMetadata(const string& name, string& value) const;
+
+  /**
+   * Get the name of the zim file.
+   *
+   * @return The name of the zim file as specified in the zim metadata.
+   */
+  string getName() const;
+
+  /**
+   * Get the title of the zim file.
+   *
+   * @return The title of zim file as specified in the zim metadata.
+   *         If no title has been set, return a title computed from the
+   *         file path.
+   */
+  string getTitle() const;
+
+  /**
+   * Get the creator of the zim file.
+   *
+   * @return The creator of the zim file as specified in the zim metadata.
+   */
+  string getCreator() const;
+
+  /**
+   * Get the publisher of the zim file.
+   *
+   * @return The publisher of the zim file as specified in the zim metadata.
+   */
+  string getPublisher() const;
+
+  /**
+   * Get the date of the zim file.
+   *
+   * @return The date of the zim file as specified in the zim metadata.
+   */
+  string getDate() const;
+
+  /**
+   * Get the description of the zim file.
+   *
+   * @return The description of the zim file as specified in the zim metadata.
+   *         If no description has been set, return the subtitle.
+   */
+  string getDescription() const;
+
+  /**
+   * Get the long description of the zim file.
+   *
+   * @return The long description of the zim file as specifed in the zim metadata.
+   */
+  string getLongDescription() const;
+
+  /**
+   * Get the language of the zim file.
+   *
+   * @return The language of the zim file as specified in the zim metadata.
+   */
+  string getLanguage() const;
+
+  /**
+   * Get the license of the zim file.
+   *
+   * @return The license of the zim file as specified in the zim metadata.
+   */
+  string getLicense() const;
+
+  /**
+   * Get the tags of the zim file.
+   *
+   * @param original If true, return the original tags as specified in the zim metadata.
+   *                 Else, try to convert it to the new 'normalized' format.
+   * @return The tags of the zim file.
+   */
+  string getTags(bool original=false) const;
+
+  /**
+   * Get the value (as a string) of a specific tag.
+   *
+   * According to https://wiki.openzim.org/wiki/Tags
+   *
+   * @return The value of the specified tag.
+   * @throw  std::out_of_range if the specified tag is not found.
+   */
+  string getTagStr(const std::string& tagName) const;
+
+  /**
+   * Get the boolean value of a specific tag.
+   *
+   * According to https://wiki.openzim.org/wiki/Tags
+   *
+   * @return The boolean value of the specified tag.
+   * @throw  std::out_of_range if the specified tag is not found.
+   *         std::domain_error if the value of the tag cannot be convert to bool.
+   */
+  bool getTagBool(const std::string& tagName) const;
+
+  /**
+   * Get the relations of the zim file.
+   *
+   * @return The relation of the zim file as specified in the zim metadata.
+   */
+  string getRelation() const;
+
+  /**
+   * Get the flavour of the zim file.
+   *
+   * @return The flavour of the zim file as specified in the zim metadata.
+   */
+  string getFlavour() const;
+
+  /**
+   * Get the source of the zim file.
+   *
+   * @return The source of the zim file as specified in the zim metadata.
+   */
+  string getSource() const;
+
+  /**
+   * Get the scraper of the zim file.
+   *
+   * @return The scraper of the zim file as specified in the zim metadata.
+   */
+  string getScraper() const;
+
+  /**
+   * Get the origId of the zim file.
+   *
+   * The origId is only used in the case of patch zim file and is the Id
+   * of the original zim file.
+   *
+   * @return The origId of the zim file as specified in the zim metadata.
+   */
+  string getOrigId() const;
+
+  /**
+   * Get the favicon of the zim file.
+   *
+   * @param[out] content The content of the favicon.
+   * @param[out] mimeType The mimeType of the favicon.
+   * @return True if a favicon has been found.
+   */
+  bool getFavicon(string& content, string& mimeType) const;
+
+  /**
+   * Get an entry associated to an path.
+   *
+   * @param path The path of the entry.
+   * @return The entry.
+   * @throw NoEntry If no entry correspond to the path.
+   */
+  Entry getEntryFromPath(const std::string& path) const;
+
+  /**
+   * Get an entry associated to an url encoded path.
+   *
+   * Equivalent to `getEntryFromPath(urlDecode(path));`
+   *
+   * @param path The url encoded path.
+   * @return The entry.
+   * @throw NoEntry If no entry correspond to the path.
+   */
+  Entry getEntryFromEncodedPath(const std::string& path) const;
+
+  /**
+   * Get un entry associated to a title.
+   *
+   * @param title The title.
+   * @return The entry
+   * throw NoEntry If no entry correspond to the url.
+   */
+  Entry getEntryFromTitle(const std::string& title) const;
+
+  /**
+   * Get the url of a page specified by a title.
+   *
+   * @param[in] title the title of the page.
+   * @param[out] url the url of the page.
+   * @return True if the page can be found.
+   */
+  DEPRECATED bool getPageUrlFromTitle(const string& title, string& url) const;
+
+  /**
+   * Get the mimetype of a entry specified by a url.
+   *
+   * @param[in] url the url of the entry.
+   * @param[out] mimeType the mimeType of the entry.
+   * @return True if the mimeType has been found.
+   */
+  DEPRECATED bool getMimeTypeByUrl(const string& url, string& mimeType) const;
+
+  /**
+   * Get the content of an entry specifed by a url.
+   *
+   * Alias to `getContentByEncodedUrl`
+   */
+  DEPRECATED bool getContentByUrl(const string& url,
+                       string& content,
+                       string& title,
+                       unsigned int& contentLength,
+                       string& contentType) const;
+
+  /**
+   * Get the content of an entry specified by a url encoded url.
+   *
+   * Equivalent to getContentByDecodedUrl(urlDecode(url), ...).
+   */
+  DEPRECATED bool getContentByEncodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType,
+                              string& baseUrl) const;
+
+  /**
+   * Get the content of an entry specified by an url encoded url.
+   *
+   * Equivalent to getContentByEncodedUrl but without baseUrl.
+   */
+  DEPRECATED bool getContentByEncodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType) const;
+
+  /**
+   * Get the content of an entry specified by a url.
+   *
+   * @param[in] url The url of the entry.
+   * @param[out] content The content of the entry.
+   * @param[out] title the title of the entry.
+   * @param[out] contentLength The size of the entry (size of content).
+   * @param[out] contentType The mimeType of the entry.
+   * @param[out] baseUrl Return the true url of the entry.
+   *                     If the specified entry is a redirection, contains
+   *                     the url of the targeted entry.
+   * @return True if the entry has been found.
+   */
+  DEPRECATED bool getContentByDecodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType,
+                              string& baseUrl) const;
+  /**
+   * Get the content of an entry specified by a url.
+   *
+   * Equivalent to getContentByDecodedUrl but withou the baseUrl.
+   */
+  DEPRECATED bool getContentByDecodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType) const;
+
+  /**
+   * Search for entries with title starting with prefix (case sensitive).
+   *
+   * Suggestions are stored in an internal vector and can be retrieved using
+   * `getNextSuggestion` method.
+   *
+   * @param prefix The prefix to search.
+   * @param suggestionsCount How many suggestions to search for.
+   * @param reset If true, remove previous suggestions in the internal vector.
+   *              If false, add suggestions to the internal vector
+   *              (until internal vector size is suggestionCount (or no more
+   *               suggestion))
+   * @return True if some suggestions where added to the internal vector.
+   */
+  bool searchSuggestions(const string& prefix,
+                         unsigned int suggestionsCount,
+                         const bool reset = true);
+
+  /**
+   * Search for entries for the given prefix.
+   *
+   * If the zim file has a internal fulltext index, the suggestions will be
+   * searched using it.
+   * Else the suggestions will be search using `searchSuggestions` while trying
+   * to be smart about case sensitivity (using `getTitleVariants`).
+   *
+   * In any case, suggestions are stored in an internal vector and can be
+   * retrieved using `getNextSuggestion` method.
+   * The internal vector will be reset.
+   *
+   * @param prefix The prefix to search for.
+   * @param suggestionsCount How many suggestions to search for.
+   */
+  bool searchSuggestionsSmart(const string& prefix,
+                              unsigned int suggestionsCount);
+
+  /**
+   * Check if the url exists in the zim file.
+   *
+   * Deprecated : Use `pathExists` instead.
+   *
+   * @param url the url to check.
+   * @return True if the url exits in the zim file.
+   */
+  DEPRECATED bool urlExists(const string& url) const;
+
+  /**
+   * Check if the path exists in the zim file.
+   *
+   * @param path the path to check.
+   * @return True if the path exists in the zim file.
+   */
+  bool pathExists(const string& path) const;
+
+  /**
+   * Check if the zim file has a embedded fulltext index.
+   *
+   * @return True if the zim file has a embedded fulltext index
+   *         and is not split (else the fulltext is not accessible).
+   */
+  bool hasFulltextIndex() const;
+
+  /**
+   * Get potential case title variations for a title.
+   *
+   * @param title a title.
+   * @return the list of variantions.
+   */
+  std::vector<std::string> getTitleVariants(const std::string& title) const;
+
+  /**
+   * Get the next suggestion title.
+   *
+   * @param[out] title the title of the suggestion.
+   * @return True if title has been set.
+   */
+  bool getNextSuggestion(string& title);
+
+  /**
+   * Get the next suggestion title and url.
+   *
+   * @param[out] title the title of the suggestion.
+   * @param[out] url the url of the suggestion.
+   * @return True if title and url have been set.
+   */
+  bool getNextSuggestion(string& title, string& url);
+
+  /**
+   * Get if we can check zim file integrity (has a checksum).
+   *
+   * @return True if zim file have a checksum.
+   */
+  bool canCheckIntegrity() const;
+
+  /**
+   * Check is zim file is corrupted.
+   *
+   * @return True if zim file is corrupted.
+   */
+  bool isCorrupted() const;
+
+  /**
+   * Parse a full url into a namespace and url.
+   *
+   * @param[in] url The full url ("/N/url").
+   * @param[out] ns The namespace (N).
+   * @param[out] title The url (url).
+   * @return True
+   */
+  DEPRECATED bool parseUrl(const string& url, char* ns, string& title) const;
+
+  /**
+   * Return the total size of the zim file.
+   *
+   * If zim file is split, return the sum of all parts' size.
+   *
+   * @return Size of the size file is KiB.
+   */
+  unsigned int getFileSize() const;
+
+  /**
+   * Get the zim file handler.
+   *
+   * @return The libzim file handler.
+   */
+  zim::File* getZimFileHandler() const;
+
+  /**
+   * Get the zim article object associated to a url.
+   *
+   * @param[in] url The url of the article.
+   * @param[out] article The libzim article object.
+   * @return True if the url is good (article.good()).
+   */
+  DEPRECATED bool getArticleObjectByDecodedUrl(const string& url,
+                                    zim::Article& article) const;
+
+ protected:
+  zim::File* zimFileHandler;
+  zim::size_type firstArticleOffset;
+  zim::size_type lastArticleOffset;
+  zim::size_type nsACount;
+  zim::size_type nsICount;
+  std::string zimFilePath;
+
+  std::vector<std::vector<std::string>> suggestions;
+  std::vector<std::vector<std::string>>::iterator suggestionsOffset;
+
+ private:
+  std::map<const std::string, unsigned int> parseCounterMetadata() const;
+};
 }
 
 #endif

include/search_renderer.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_SEARCH_RENDERER_H
+#define KIWIX_SEARCH_RENDERER_H
+
+#include <string>
+
+namespace kiwix
+{
+
+class Searcher;
+class NameMapper;
+/**
+ * The SearcherRenderer class is used to render a search result to a html page.
+ */
+class SearchRenderer
+{
+ public:
+  /**
+   * The default constructor.
+   *
+   * @param humanReadableName The global zim's humanReadableName.
+   *                          Used to generate pagination links.
+   */
+  SearchRenderer(Searcher* searcher, NameMapper* mapper);
+
+  ~SearchRenderer();
+
+  void setSearchPattern(const std::string& pattern);
+
+  /**
+   * Set the search content id.
+   */
+  void setSearchContent(const std::string& name);
+
+  /**
+   * Set protocol prefix.
+   */
+  void setProtocolPrefix(const std::string& prefix);
+
+  /**
+   * Set search protocol prefix.
+   */
+  void setSearchProtocolPrefix(const std::string& prefix);
+
+  /**
+   * Generate the html page with the resutls of the search.
+   */
+  std::string getHtml();
+
+ protected:
+  std::string beautifyInteger(const unsigned int number);
+  Searcher* mp_searcher;
+  NameMapper* mp_nameMapper;
+  std::string searchContent;
+  std::string searchPattern;
+  std::string protocolPrefix;
+  std::string searchProtocolPrefix;
+  unsigned int resultCountPerPage;
+  unsigned int estimatedResultCount;
+  unsigned int resultStart;
+  unsigned int resultEnd;
+};
+
+
+}
+
+#endif

include/searcher.h

@@ -22,68 +22,150 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string>
-#include <algorithm>
-#include <vector>
-#include <locale>
-#include <cctype>
-#include <vector>
-#include "common/pathTools.h"
-#include "common/stringTools.h"
 #include <unicode/putil.h>
+#include <algorithm>
+#include <cctype>
+#include <locale>
+#include <string>
+#include <vector>
+#include <vector>
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 #include "kiwix_config.h"
 
 using namespace std;
 
-struct Result
+namespace kiwix
 {
-  string url;
-  string title;
-  int score;
-  string snippet;
-  int wordCount;
-  int size;
+class Reader;
+class Result
+{
+ public:
+  virtual ~Result(){};
+  virtual std::string get_url() = 0;
+  virtual std::string get_title() = 0;
+  virtual int get_score() = 0;
+  virtual std::string get_snippet() = 0;
+  virtual std::string get_content() = 0;
+  virtual int get_wordCount() = 0;
+  virtual int get_size() = 0;
+  virtual int get_readerIndex() = 0;
 };
 
-namespace kiwix {
+struct SearcherInternal;
+/**
+ * The Searcher class is reponsible to do different kind of search using the
+ * fulltext index.
+ */
+class Searcher
+{
+ public:
+  /**
+   * The default constructor.
+   */
+  Searcher();
 
-  class Searcher {
+  ~Searcher();
 
-  public:
-    Searcher();
-    virtual ~Searcher();
+  /**
+   * Add a reader (containing embedded fulltext index) to the search.
+   *
+   * @param reader The Reader for the zim containing the fulltext index.
+   * @return true if the reader has been added.
+   *         false if the reader cannot be added (no embedded fulltext index present)
+   */
+  bool add_reader(Reader* reader);
 
-    void search(std::string &search, unsigned int resultStart,
-		unsigned int resultEnd, const bool verbose=false);
-    bool getNextResult(string &url, string &title, unsigned int &score);
-    unsigned int getEstimatedResultCount();
-    bool setProtocolPrefix(const std::string prefix);
-    bool setSearchProtocolPrefix(const std::string prefix);
-    void reset();
-    void setContentHumanReadableId(const string &contentHumanReadableId);
 
-#ifdef ENABLE_CTPP2
-    string getHtml();
-#endif
-    
-  protected:
-    std::string beautifyInteger(const unsigned int number);
-    virtual void closeIndex() = 0;
-    virtual void searchInIndex(string &search, const unsigned int resultStart,
-			       const unsigned int resultEnd, const bool verbose=false) = 0;
+  Reader* get_reader(int index);
+
+  /**
+   * Start a search on the zim associated to the Searcher.
+   *
+   * Search results should be retrived using the getNextResult method.
+   *
+   * @param search The search query.
+   * @param resultStart the start offset of the search results (used for pagination).
+   * @param resultEnd the end offset of the search results (used for pagination).
+   * @param verbose print some info on stdout if true.
+   */
+  void search(std::string& search,
+              unsigned int resultStart,
+              unsigned int resultEnd,
+              const bool verbose = false);
+
+  /**
+   * Start a geographique search.
+   * The search return result for entry in a disc of center latitude/longitude
+   * and radius distance.
+   *
+   * Search results should be retrived using the getNextResult method.
+   *
+   * @param latitude The latitude of the center point.
+   * @param longitude The longitude of the center point.
+   * @param distance The radius of the disc.
+   * @param resultStart the start offset of the search results (used for pagination).
+   * @param resultEnd the end offset of the search results (used for pagination).
+   * @param verbose print some info on stdout if true.
+   */
+  void geo_search(float latitude, float longitude, float distance,
+                  unsigned int resultStart,
+                  unsigned int resultEnd,
+                  const bool verbose = false);
+
+  /**
+   * Start a suggestion search.
+   * The search made depend of the "version" of the embedded index.
+   *  - If the index is newer enough and have a title namespace, the search is
+   *    made in the titles only.
+   *  - Else the search is made on the whole article content.
+   * In any case, the search is made "partial" (as adding '*' at the end of the query)
+   *
+   * @param search The search query.
+   * @param verbose print some info on stdout if true.
+   */
+  void suggestions(std::string& search, const bool verbose = false);
+
+  /**
+   * Get the next result of a started search.
+   * This is the method to use to loop hover the search results.
+   */
+  Result* getNextResult();
+
+  /**
+   * Restart the previous search.
+   * Next call to getNextResult will return the first result.
+   */
+  void restart_search();
+
+  /**
+   * Get a estimation of the result count.
+   */
+  unsigned int getEstimatedResultCount();
+
+  unsigned int getResultStart() { return resultStart; }
+  unsigned int getResultEnd() { return resultEnd; }
+
+ protected:
+  std::string beautifyInteger(const unsigned int number);
+  void closeIndex();
+  void searchInIndex(string& search,
+                     const unsigned int resultStart,
+                     const unsigned int resultEnd,
+                     const bool verbose = false);
+
+  std::vector<Reader*> readers;
+  SearcherInternal* internal;
+  std::string searchPattern;
+  unsigned int estimatedResultCount;
+  unsigned int resultStart;
+  unsigned int resultEnd;
+
+ private:
+  void reset();
+
+};
 
-    std::vector<Result> results;
-    std::vector<Result>::iterator resultOffset;
-    std::string searchPattern;
-    std::string protocolPrefix;
-    std::string searchProtocolPrefix;
-    std::string template_ct2;
-    unsigned int resultCountPerPage;
-    unsigned int estimatedResultCount;
-    unsigned int resultStart;
-    unsigned int resultEnd;
-    std::string contentHumanReadableId;
-  };
 
 }
 

include/server.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2019 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_SERVER_H
+#define KIWIX_SERVER_H
+
+#include <string>
+#include <memory>
+
+namespace kiwix
+{
+  class Library;
+  class NameMapper;
+  class InternalServer;
+
+  class Server {
+     public:
+       /**
+        * The default constructor.
+        *
+        * @param library The library to serve.
+        */
+       Server(Library* library, NameMapper* nameMapper=nullptr);
+
+       virtual ~Server();
+
+       /**
+        * Serve the content.
+        */
+       bool start();
+
+       /**
+        * Stop the daemon.
+        */
+       void stop();
+
+       void setRoot(const std::string& root);
+       void setAddress(const std::string& addr) { m_addr = addr; }
+       void setPort(int port) { m_port = port; }
+       void setNbThreads(int threads) { m_nbThreads = threads; }
+       void setVerbose(bool verbose) { m_verbose = verbose; }
+       void setTaskbar(bool withTaskbar, bool withLibraryButton)
+         { m_withTaskbar = withTaskbar; m_withLibraryButton = withLibraryButton; }
+
+     protected:
+       Library* mp_library;
+       NameMapper* mp_nameMapper;
+       std::string m_root = "";
+       std::string m_addr = "";
+       int m_port = 80;
+       int m_nbThreads = 1;
+       bool m_verbose = false;
+       bool m_withTaskbar = true;
+       bool m_withLibraryButton = true;
+       std::unique_ptr<InternalServer> mp_server;
+  };
+}
+
+#endif

include/tools/base64.h

@@ -0,0 +1,4 @@
+#include <string>
+
+std::string base64_encode(const std::string& inString);
+std::string base64_decode(const std::string& s);

include/tools/lock.h

@@ -0,0 +1,46 @@
+
+
+#ifndef KIWIXLIB_TOOL_LOCK_H
+#define KIWIXLIB_TOOL_LOCK_H
+
+#include <pthread.h>
+
+namespace kiwix {
+
+class Lock
+{
+  public:
+    explicit Lock(pthread_mutex_t* mutex) :
+      mp_mutex(mutex)
+    {
+      pthread_mutex_lock(mp_mutex);
+    }
+    ~Lock() {
+      if (mp_mutex != nullptr) {
+        pthread_mutex_unlock(mp_mutex);
+      }
+    }
+    Lock(Lock && other) :
+      mp_mutex(other.mp_mutex)
+    {
+      other.mp_mutex = nullptr;
+    }
+    Lock & operator=(Lock && other)
+    {
+      mp_mutex = other.mp_mutex;
+      other.mp_mutex = nullptr;
+      return *this;
+    }
+
+
+  private:
+    pthread_mutex_t* mp_mutex;
+
+    Lock(Lock const &) = delete;
+    Lock & operator=(Lock const &) = delete;
+};
+
+
+}
+
+#endif //KIWIXLIB_TOOL_LOCK_H

include/tools/networkTools.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright 2012 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -17,12 +17,14 @@
  * MA 02110-1301, USA.
  */
 
-#include <common/otherTools.h>
+#ifndef KIWIX_NETWORKTOOLS_H
+#define KIWIX_NETWORKTOOLS_H
 
-void kiwix::sleep(unsigned int milliseconds) {
-#ifdef _WIN32
-      Sleep(milliseconds);
-#else
-      usleep(1000 * milliseconds);
-#endif
+#include <string>
+
+namespace kiwix
+{
+std::string download(const std::string& url);
 }
+
+#endif

include/tools/otherTools.h

@@ -20,14 +20,17 @@
 #ifndef KIWIX_OTHERTOOLS_H
 #define KIWIX_OTHERTOOLS_H
 
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <unistd.h>
-#endif
+#include <string>
 
-namespace kiwix {
-  void sleep(unsigned int milliseconds);
+namespace pugi {
+  class xml_node;
+}
+
+namespace kiwix
+{
+void sleep(unsigned int milliseconds);
+std::string nodeToString(const pugi::xml_node& node);
+std::string converta2toa3(const std::string& a2code);
 }
 
 #endif

include/tools/pathTools.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_PATHTOOLS_H
+#define KIWIX_PATHTOOLS_H
+
+#include <string>
+
+bool isRelativePath(const std::string& path);
+std::string computeAbsolutePath(const std::string& path, const std::string& relativePath);
+std::string computeRelativePath(const std::string& path, const std::string& absolutePath);
+std::string removeLastPathElement(const std::string& path);
+std::string appendToDirectory(const std::string& directoryPath, const std::string& filename);
+
+unsigned int getFileSize(const std::string& path);
+std::string getFileSizeAsString(const std::string& path);
+std::string getFileContent(const std::string& path);
+bool fileExists(const std::string& path);
+bool makeDirectory(const std::string& path);
+std::string makeTmpDirectory();
+bool copyFile(const std::string& sourcePath, const std::string& destPath);
+std::string getLastPathElement(const std::string& path);
+std::string getExecutablePath(bool realPathOnly = false);
+std::string getCurrentDirectory();
+std::string getDataDirectory();
+bool writeTextFile(const std::string& path, const std::string& content);
+std::string getMimeTypeForFile(const std::string& filename);
+#endif

include/tools/regexTools.h

@@ -20,13 +20,14 @@
 #ifndef KIWIX_REGEXTOOLS_H
 #define KIWIX_REGEXTOOLS_H
 
-#include <unicode/regex.h>
-#include <unicode/ucnv.h>
 #include <string>
-#include <map>
 
-bool matchRegex(const std::string &content, const std::string &regex);
-std::string replaceRegex(const std::string &content, const std::string &replacement, const std::string &regex);
-std::string appendToFirstOccurence(const std::string &content, const std::string regex, const std::string &replacement);
+bool matchRegex(const std::string& content, const std::string& regex);
+std::string replaceRegex(const std::string& content,
+                         const std::string& replacement,
+                         const std::string& regex);
+std::string appendToFirstOccurence(const std::string& content,
+                                   const std::string& regex,
+                                   const std::string& replacement);
 
 #endif

include/tools/stringTools.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2011-2012 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_STRINGTOOLS_H
+#define KIWIX_STRINGTOOLS_H
+
+#include <unicode/unistr.h>
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+namespace kiwix
+{
+std::string beautifyInteger(uint64_t number);
+std::string beautifyFileSize(uint64_t number);
+void printStringInHexadecimal(const char* s);
+void printStringInHexadecimal(icu::UnicodeString s);
+void stringReplacement(std::string& str,
+                       const std::string& oldStr,
+                       const std::string& newStr);
+std::string encodeDiples(const std::string& str);
+
+std::string removeAccents(const std::string& text);
+void loadICUExternalTables();
+
+std::string urlEncode(const std::string& value, bool encodeReserved = false);
+std::string urlDecode(const std::string& value, bool component = false);
+
+std::vector<std::string> split(const std::string&, const std::string&, bool trimEmpty = true);
+std::string join(const std::vector<std::string>& list, const std::string& sep);
+
+std::string ucAll(const std::string& word);
+std::string lcAll(const std::string& word);
+std::string ucFirst(const std::string& word);
+std::string lcFirst(const std::string& word);
+std::string toTitle(const std::string& word);
+
+std::string normalize(const std::string& word);
+template<typename T>
+std::string to_string(T value)
+{
+    std::ostringstream oss;
+    oss << value;
+    return oss.str();
+}
+
+template<typename T>
+T extractFromString(const std::string& str) {
+    std::istringstream iss(str);
+    T ret;
+    iss >> ret;
+    return ret;
+}
+
+bool startsWith(const std::string& base, const std::string& start);
+} //namespace kiwix
+#endif

include/xapianIndexer.h

@@ -1,56 +0,0 @@
-/*
- * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#ifndef KIWIX_XAPIAN_INDEXER_H
-#define KIWIX_XAPIAN_INDEXER_H
-
-#include <xapian.h>
-#include "indexer.h"
-
-using namespace std;
-
-namespace kiwix {
-  
-  class XapianIndexer : public Indexer {
-    
-  public:
-    XapianIndexer();
-    
-  protected:
-    void indexingPrelude(const string indexPath);
-    void index(const string &url, 
-	       const string &title, 
-	       const string &unaccentedTitle,
-	       const string &keywords, 
-	       const string &content,
-	       const string &snippet,
-	       const string &size,
-	       const string &wordCount);
-    void flush();
-    void indexingPostlude(const string indexPath);
-    
-    Xapian::WritableDatabase writableDatabase;
-    Xapian::Stem stemmer;
-    Xapian::SimpleStopper stopper;
-    Xapian::TermGenerator indexer;
-  };
-
-}
-
-#endif

include/xapianSearcher.h

@@ -1,54 +0,0 @@
-/*
- * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#ifndef KIWIX_XAPIAN_SEARCHER_H
-#define KIWIX_XAPIAN_SEARCHER_H
-
-#include <xapian.h>
-#include "searcher.h"
-
-using namespace std;
-
-namespace kiwix {
-
-  class NoXapianIndexInZim: public exception {
-    virtual const char* what() const throw() {
-      return "There is no fulltext index in the zim file";
-    }
-  };
-
-  class XapianSearcher : public Searcher {
-    
-  public:
-    XapianSearcher(const string &xapianDirectoryPath);
-    virtual ~XapianSearcher() {};
-    void searchInIndex(string &search, const unsigned int resultStart, const unsigned int resultEnd, 
-		       const bool verbose=false);
-
-  protected:
-    void closeIndex();
-    void openIndex(const string &xapianDirectoryPath);
-
-    Xapian::Database readableDatabase;
-    Xapian::Stem stemmer;
-  };
-
-}
-
-#endif

kiwix.pc.in

@@ -4,7 +4,7 @@ includedir=${prefix}/include
 
 Name: libkiwix
 Description: A library that contains a lot of things used by used by other kiwix programs
-Version: 1.0
+Version: @version@
 Requires: @requires@
 Libs: -L${libdir} -lkiwix @extra_libs@
 Cflags: -I${includedir}/ @extra_cflags@

meson.build

@@ -1,103 +1,61 @@
-project('kiwixlib', 'cpp',
-  version : '0.1.0',
-  license : 'GPL')
+project('kiwix-lib', 'cpp',
+  version : '8.1.0', # Also change this in android-kiwix-lib-publisher/kiwixLibAndroid/build.gradle
+  license : 'GPL',
+  default_options : ['c_std=c11', 'cpp_std=c++11', 'werror=true'])
 
 compiler = meson.get_compiler('cpp')
-find_library_in_compiler = meson.version().version_compare('>=0.31.0')
+
+static_deps = get_option('android') or get_option('default_library') == 'static'
+if get_option('android')
+  extra_libs = ['-llog']
+else
+  extra_libs = []
+endif
 
 thread_dep = dependency('threads')
-libicu_dep = dependency('icu-i18n')
-libzim_dep = dependency('libzim')
-pugixml_dep = dependency('pugixml')
+libicu_dep = dependency('icu-i18n', static:static_deps)
+libzim_dep = dependency('libzim', version : '>=5.0.0', static:static_deps)
+pugixml_dep = dependency('pugixml', static:static_deps)
+libcurl_dep = dependency('libcurl', static:static_deps)
+microhttpd_dep = dependency('libmicrohttpd', static:static_deps)
 
-
-has_ctpp2_dep = false
-ctpp2_prefix_install = get_option('ctpp2-install-prefix')
-ctpp2_link_args = []
-if ctpp2_prefix_install == ''
-  if compiler.has_header('ctpp2/CTPP2Logger.hpp')
-    if find_library_in_compiler
-      ctpp2_lib = compiler.find_library('ctpp2')
-    else
-      ctpp2_lib = find_library('ctpp2')
-    endif
-    ctpp2_link_args = ['-lctpp2']
-    if meson.is_cross_build() and host_machine.system() == 'windows'
-      if find_library_in_compiler
-        iconv_lib = compiler.find_library('iconv', required:false)
-      else
-        iconv_lib = find_library('iconv', required:false)
-      endif
-      if iconv_lib.found()
-        ctpp2_link_args += ['-liconv']
-      endif
-    endif
-    has_ctpp2_dep = true
-    ctpp2_dep = declare_dependency(link_args:ctpp2_link_args)
-  else
-    message('ctpp2/CTPP2Logger.hpp not found. Compiling without CTPP2 support')
-  endif
-else
-  if not find_library_in_compiler
-    error('For custom ctpp2_prefix_install you need a meson version >=0.31.0')
-  endif
-  ctpp2_include_path = ctpp2_prefix_install + '/include'
-  ctpp2_include_args = ['-I'+ctpp2_include_path]
-  if compiler.has_header('ctpp2/CTPP2Logger.hpp', args:ctpp2_include_args)
-    ctpp2_include_dir = include_directories(ctpp2_include_path, is_system:true)
-    ctpp2_lib_path = ctpp2_prefix_install+'/lib'
-    ctpp2_lib = compiler.find_library('ctpp2', dirs:ctpp2_lib_path)
-    ctpp2_link_args = ['-L'+ctpp2_lib_path, '-lctpp2']
-    if meson.is_cross_build() and host_machine.system() == 'windows'
-      iconv_lib = compiler.find_library('iconv', required:false)
-      if iconv_lib.found()
-        ctpp2_link_args += ['-liconv']
-      endif
-    endif
-    has_ctpp2_dep = true
-    ctpp2_dep = declare_dependency(include_directories:ctpp2_include_dir, link_args:ctpp2_link_args)
-  else
-    message('ctpp2/CTPP2Logger.hpp not found. Compiling without CTPP2 support')
-  endif
+if not compiler.has_header('mustache.hpp')
+  error('Cannot found header mustache.hpp')
 endif
 
-xapian_dep = dependency('xapian-core', required:false)
-
-all_deps = [thread_dep, libicu_dep, libzim_dep, xapian_dep, pugixml_dep]
-if has_ctpp2_dep
-  all_deps += [ctpp2_dep]
+extra_cflags = ''
+if target_machine.system() == 'windows' and static_deps
+  add_project_arguments('-DCURL_STATICLIB', language : 'cpp')
+  extra_cflags += '-DCURL_STATICLIB'
 endif
 
+all_deps = [thread_dep, libicu_dep, libzim_dep, pugixml_dep, libcurl_dep, microhttpd_dep]
+
 inc = include_directories('include')
 
 conf = configuration_data()
 conf.set('VERSION', '"@0@"'.format(meson.project_version()))
-conf.set('ENABLE_CTPP2', has_ctpp2_dep)
+
+if build_machine.system() == 'windows'
+     extra_link_args = ['-lshlwapi', '-lwinmm']
+else
+     extra_link_args = []
+endif
 
 subdir('include')
 subdir('scripts')
 subdir('static')
 subdir('src')
+subdir('test')
 
-pkg_requires = ['libzim', 'icu-i18n', 'pugixml']
-if xapian_dep.found()
-    pkg_requires += ['xapian-core']
-endif
-
-extra_libs = []
-extra_cflags = ''
-if has_ctpp2_dep
-  extra_libs += ctpp2_link_args
-  if ctpp2_include_path != ''
-    extra_cflags = '-I'+ctpp2_include_path
-  endif
-endif
+pkg_requires = ['libzim', 'icu-i18n', 'pugixml', 'libcurl']
 
 pkg_conf = configuration_data()
 pkg_conf.set('prefix', get_option('prefix'))
 pkg_conf.set('requires', ' '.join(pkg_requires))
 pkg_conf.set('extra_libs', ' '.join(extra_libs))
 pkg_conf.set('extra_cflags', extra_cflags)
+pkg_conf.set('version', meson.project_version())
 configure_file(output : 'kiwix.pc',
                configuration : pkg_conf,
                input : 'kiwix.pc.in',

meson_options.txt

@@ -1,4 +1,2 @@
-option('ctpp2-install-prefix', type : 'string', value : '',
-  description : 'Prefix where ctpp libs has been installed')
 option('android', type : 'boolean', value : false,
   description : 'Do we make a kiwix-lib for android')

scripts/kiwix-compile-resources

@@ -1,5 +1,24 @@
 #!/usr/bin/env python3
 
+'''
+Copyright 2016 Matthieu Gautier <mgautier@kymeria.fr>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3 of the License, or any
+later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.
+'''
+
 import argparse
 import os.path
 import re
@@ -38,12 +57,21 @@ extern const std::string {identifier};
 {namespaces_close}"""
 
 class Resource:
-    def __init__(self, base_dir, filename):
+    def __init__(self, base_dirs, filename):
         filename = filename.strip()
         self.filename = filename
         self.identifier = full_identifier(filename)
-        with open(os.path.join(base_dir, filename), 'rb') as f:
-            self.data = f.read()
+        found = False
+        for base_dir in base_dirs:
+            try:
+                with open(os.path.join(base_dir, filename), 'rb') as f:
+                    self.data = f.read()
+                found = True
+                break
+            except FileNotFoundError:
+                continue
+        if not found:
+            raise Exception("Impossible to found {}".format(filename))
 
     def dump_impl(self):
         nb_row = len(self.data)//16 + (1 if len(self.data) % 16 else 0)
@@ -78,16 +106,8 @@ master_c_template = """//This file is automaically generated. Do not modify it.
 
 #include <stdlib.h>
 #include <fstream>
-#include <stdexcept>
 #include "{include_file}"
 
-class ResourceNotFound : public std::runtime_error {{
-  public:
-    ResourceNotFound(const std::string& what_arg):
-      std::runtime_error(what_arg)
-    {{ }};
-}};
-
 static std::string init_resource(const char* name, const unsigned char* content, int len)
 {{
     char * resPath = getenv(name);
@@ -125,11 +145,19 @@ master_h_template = """//This file is automaically generated. Do not modify it.
 #define KIWIX_{BASENAME}
 
 #include <string>
+#include <stdexcept>
 
 namespace RESOURCE {{
     {RESOURCES}
 }};
 
+class ResourceNotFound : public std::runtime_error {{
+  public:
+    ResourceNotFound(const std::string& what_arg):
+      std::runtime_error(what_arg)
+    {{ }};
+}};
+
 const std::string& getResource_{basename}(const std::string& name);
 
 #define getResource(a) (getResource_{basename}(a))
@@ -151,13 +179,18 @@ if __name__ == "__main__":
                         help='The Cpp file name to generate')
     parser.add_argument('--hfile',
                         help='The h file name to generate')
+    parser.add_argument('--source_dir',
+                        help="Additional directory where to look for resources.",
+                        action='append')
     parser.add_argument('resource_file',
                         help='The list of resources to compile.')
     args = parser.parse_args()
 
     base_dir = os.path.dirname(os.path.realpath(args.resource_file))
+    source_dir = args.source_dir or []
     with open(args.resource_file, 'r') as f:
-        resources = [Resource(base_dir, filename) for filename in f.readlines()]
+        resources = [Resource([base_dir]+source_dir, filename)
+                        for filename in f.readlines()]
 
     h_identifier = to_identifier(os.path.basename(args.hfile))
     with open(args.hfile, 'w') as f:

scripts/meson.build

@@ -1,4 +1,4 @@
 
-res_compiler = find_program('compile_resources.py')
+res_compiler = find_program('kiwix-compile-resources')
 
 install_data(res_compiler.path(), install_dir:get_option('bindir'))

src/android/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+
+  package="kiwix.org.kiwixlib"
+>
+
+  <application android:allowBackup="true"
+    android:label="@string/app_name"
+    android:supportsRtl="true"
+  >
+
+  </application>
+
+</manifest>

src/android/gen_kiwix.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-BUILD_PATH=$(pwd)
-
-javac -d $BUILD_PATH/src/android $1 $2 $3 $4
-
-cd $BUILD_PATH/src/android
-javah -jni org.kiwix.kiwixlib.JNIKiwix
-cd $BUILD_PATH

src/android/kiwix.cpp

@@ -1,486 +0,0 @@
-#include <jni.h>
-#include "org_kiwix_kiwixlib_JNIKiwix.h"
-
-#include <stdio.h>
-#include <string.h>
-
-#include <iostream>
-#include <string>
-
-#include "unicode/putil.h"
-#include "reader.h"
-#include "xapianSearcher.h"
-#include "common/base64.h"
-
-#include <android/log.h>
-#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO, "kiwix", __VA_ARGS__)
-
-#include <xapian.h>
-#include <zim/zim.h>
-#include <zim/file.h>
-#include <zim/article.h>
-#include <zim/error.h>
-
-/* global variables */
-kiwix::Reader *reader = NULL;
-kiwix::XapianSearcher *searcher = NULL;
-
-static pthread_mutex_t readerLock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t searcherLock = PTHREAD_MUTEX_INITIALIZER;
-
-/* c2jni type conversion functions */
-jboolean c2jni(const bool &val) {
-  return val ? JNI_TRUE : JNI_FALSE;
-}
-
-jstring c2jni(const std::string &val, JNIEnv *env) {
-  return env->NewStringUTF(val.c_str());
-}
-
-jint c2jni(const int val) {
-  return (jint)val;
-}
-
-jint c2jni(const unsigned val) {
-  return (unsigned)val;
-}
-
-/* jni2c type conversion functions */
-bool jni2c(const jboolean &val) {
-  return val == JNI_TRUE;
-}
-
-std::string jni2c(const jstring &val, JNIEnv *env) {
-  return std::string(env->GetStringUTFChars(val, 0));
-}
-
-int jni2c(const jint val) {
-  return (int)val;
-}
-
-/* Method to deal with variable passed by reference */
-void setStringObjValue(const std::string &value, const jobject obj, JNIEnv *env) {
-  jclass objClass = env->GetObjectClass(obj);
-  jfieldID objFid = env->GetFieldID(objClass, "value", "Ljava/lang/String;");
-  env->SetObjectField(obj, objFid, c2jni(value, env));
-}
-
-void setIntObjValue(const int value, const jobject obj, JNIEnv *env) {
-  jclass objClass = env->GetObjectClass(obj);
-  jfieldID objFid = env->GetFieldID(objClass, "value", "I");
-  env->SetIntField(obj, objFid, value);
-}
-
-void setBoolObjValue(const bool value, const jobject obj, JNIEnv *env) {
-  jclass objClass = env->GetObjectClass(obj);
-  jfieldID objFid = env->GetFieldID(objClass, "value", "Z");
-  env->SetIntField(obj, objFid, c2jni(value));
-}
-
-/* Kiwix library functions */
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getMainPage(JNIEnv *env, jobject obj) {
-  jstring url;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cUrl = reader->getMainPageUrl();
-      url = c2jni(cUrl, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM main page" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return url;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getId(JNIEnv *env, jobject obj) {
-  jstring id;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cId = reader->getId();
-      id = c2jni(cId, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM id" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return id;
-}
-
-JNIEXPORT jint JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getFileSize(JNIEnv *env, jobject obj) {
-  jint size;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      int cSize = reader->getFileSize();
-      size = c2jni(cSize);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM file size" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return size;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getCreator(JNIEnv *env, jobject obj) {
-  jstring creator;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cCreator = reader->getCreator();
-      creator = c2jni(cCreator, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM creator" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return creator;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getPublisher(JNIEnv *env, jobject obj) {
-  jstring publisher;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cPublisher = reader->getPublisher();
-      publisher = c2jni(cPublisher, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM creator" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return publisher;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getName(JNIEnv *env, jobject obj) {
-  jstring name;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cName = reader->getName();
-      name = c2jni(cName, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM name" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return name;
-}
-
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getFavicon(JNIEnv *env, jobject obj) {
-  jstring favicon;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cContent;
-      std::string cMime;
-      reader->getFavicon(cContent, cMime);
-      favicon = c2jni(base64_encode(reinterpret_cast<const unsigned char*>(cContent.c_str()), cContent.length()), env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM favicon" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return favicon;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getDate(JNIEnv *env, jobject obj) {
-  jstring date;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cDate = reader->getDate();
-      date = c2jni(cDate, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM date" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return date;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getLanguage(JNIEnv *env, jobject obj) {
-  jstring language;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cLanguage = reader->getLanguage();
-      language = c2jni(cLanguage, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM language" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return language;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getMimeType(JNIEnv *env, jobject obj, jstring url) {
-  jstring mimeType;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    std::string cUrl = jni2c(url, env);
-    try {
-      std::string cMimeType;
-      reader->getMimeTypeByUrl(cUrl, cMimeType);
-      mimeType = c2jni(cMimeType, env);
-    } catch (...) {
-      std::cerr << "Unable to get mime-type for url " << cUrl << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return mimeType;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_loadZIM(JNIEnv *env, jobject obj, jstring path) {
-  jboolean retVal = JNI_TRUE;
-  std::string cPath = jni2c(path, env);
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) delete reader;
-    reader = new kiwix::Reader(cPath);
-  } catch (...) {
-    std::cerr << "Unable to load ZIM " << cPath << std::endl;
-    reader = NULL;
-    retVal = JNI_FALSE;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getContent(JNIEnv *env, jobject obj, jstring url, jobject mimeTypeObj, jobject sizeObj) {
-
-  /* Default values */
-  setStringObjValue("", mimeTypeObj, env);
-  setIntObjValue(0, sizeObj, env);
-  jbyteArray data = env->NewByteArray(0);
-
-  /* Retrieve the content */
-  if (reader != NULL) {
-    std::string cUrl = jni2c(url, env);
-    std::string cData;
-    std::string cMimeType;
-    unsigned int cSize = 0;
-
-    pthread_mutex_lock(&readerLock);
-    try {
-      if (reader->getContentByUrl(cUrl, cData, cSize, cMimeType)) {
-        data = env->NewByteArray(cSize);
-        env->SetByteArrayRegion(data, 0, cSize, reinterpret_cast<const jbyte*>(cData.c_str()));
-        setStringObjValue(cMimeType, mimeTypeObj, env);
-        setIntObjValue(cSize, sizeObj, env);
-      }
-    } catch (...) {
-      std::cerr << "Unable to get content for url " << cUrl << std::endl;
-    }
-    pthread_mutex_unlock(&readerLock);
-  }
-  
-  return data;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_searchSuggestions
-(JNIEnv *env, jobject obj, jstring prefix, jint count) {
-  jboolean retVal = JNI_FALSE;
-  std::string cPrefix = jni2c(prefix, env);
-  unsigned int cCount = jni2c(count);
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      if (reader->searchSuggestionsSmart(cPrefix, cCount)) {
-        retVal = JNI_TRUE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to search suggestions for pattern " << cPrefix << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getNextSuggestion
-(JNIEnv *env, jobject obj, jobject titleObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cTitle;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      if (reader->getNextSuggestion(cTitle)) {
-        setStringObjValue(cTitle, titleObj, env);
-        retVal = JNI_TRUE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to get next suggestion" << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getPageUrlFromTitle
-(JNIEnv *env, jobject obj, jstring title, jobject urlObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cTitle = jni2c(title, env);
-  std::string cUrl;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      if (reader->getPageUrlFromTitle(cTitle, cUrl)) {
-        setStringObjValue(cUrl, urlObj, env);
-        retVal = JNI_TRUE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to get URL for title " << cTitle << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-    
-  return retVal;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getTitle
-(JNIEnv *env , jobject obj, jobject titleObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cTitle;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      std::string cTitle = reader->getTitle();
-      setStringObjValue(cTitle, titleObj, env);
-      retVal = JNI_TRUE;
-    }
-  } catch (...) {
-    std::cerr << "Unable to get ZIM title" << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getDescription(JNIEnv *env, jobject obj) {
-  jstring description;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cDescription = reader->getDescription();
-      description = c2jni(cDescription, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM description" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return description;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getRandomPage
-(JNIEnv *env, jobject obj, jobject urlObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cUrl;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      std::string cUrl = reader->getRandomPageUrl();
-      setStringObjValue(cUrl, urlObj, env);
-      retVal = JNI_TRUE;
-    }
-  } catch (...) {
-    std::cerr << "Unable to get random page" << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_setDataDirectory
-  (JNIEnv *env, jobject obj, jstring dirStr) {
-  std::string cPath = jni2c(dirStr, env);
-
-  pthread_mutex_lock(&readerLock); 
-  try {
-    u_setDataDirectory(cPath.c_str());
-  } catch (...) {
-    std::cerr << "Unable to set data directory " << cPath << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_loadFulltextIndex(JNIEnv *env, jobject obj, jstring path) {
-  jboolean retVal = JNI_TRUE;
-  std::string cPath = jni2c(path, env);
-
-  pthread_mutex_lock(&searcherLock);
-  searcher = NULL;
-  try {
-    if (searcher != NULL) delete searcher;
-    searcher = new kiwix::XapianSearcher(cPath);
-  } catch (...) {
-    searcher = NULL;
-    retVal = JNI_FALSE;
-    std::cerr << "Unable to load full text index " << cPath << std::endl;
-  }
-  pthread_mutex_unlock(&searcherLock);
-
-  return retVal;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_indexedQuery
-  (JNIEnv *env, jclass obj, jstring query, jint count) {
-  std::string cQuery = jni2c(query, env);
-  unsigned int cCount = jni2c(count);
-  std::string url;
-  std::string title;
-  std::string result;
-  unsigned int score;
-      
-  pthread_mutex_lock(&searcherLock);
-  try {
-    if (searcher != NULL) {
-      searcher->search(cQuery, 0, count);
-      while (searcher->getNextResult(url, title, score) &&
-	     !title.empty() &&
-	     !url.empty()) {
-	result += title + "\n";
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to make indexed query " << cQuery << std::endl;
-  }
-  pthread_mutex_unlock(&searcherLock);
-
-  return env->NewStringUTF(result.c_str());
-}
-
-

src/android/kiwixicu.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <jni.h>
+#include "org_kiwix_kiwixlib_JNIICU.h"
+
+#include <iostream>
+#include <string>
+
+#include "unicode/putil.h"
+
+#include "utils.h"
+
+pthread_mutex_t globalLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
+
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIICU_setDataDirectory(
+    JNIEnv* env, jclass kclass, jstring dirStr)
+{
+  std::string cPath = jni2c(dirStr, env);
+
+  Lock l;
+  try {
+    u_setDataDirectory(cPath.c_str());
+  } catch (...) {
+    std::cerr << "Unable to set data directory " << cPath << std::endl;
+  }
+}

src/android/kiwixlibrary.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#include <jni.h>
+#include <android/log.h>
+#include "org_kiwix_kiwixlib_JNIKiwixLibrary.h"
+
+#include "library.h"
+#include "reader.h"
+#include "utils.h"
+
+/* Kiwix Reader JNI functions */
+JNIEXPORT jlong JNICALL Java_org_kiwix_kiwixlib_JNIKiwixLibrary_getNativeLibrary(
+    JNIEnv* env, jobject obj)
+{
+  __android_log_print(ANDROID_LOG_INFO, "kiwix", "Attempting to create library");
+  Lock l;
+  try {
+    kiwix::Library* library = new kiwix::Library();
+    return reinterpret_cast<jlong>(new Handle<kiwix::Library>(library));
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", "Error creating ZIM library");
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", e.what());
+    return 0;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixLibrary_dispose(JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Library>::dispose(env, obj);
+}
+
+#define LIBRARY (Handle<kiwix::Library>::getHandle(env, obj))
+
+/* Kiwix library functions */
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixLibrary_addBook(JNIEnv* env, jobject obj, jstring path)
+{
+  std::string cPath = jni2c(path, env);
+  bool ret;
+
+  try {
+    kiwix::Reader reader(cPath);
+    kiwix::Book book;
+    book.update(reader);
+    ret = LIBRARY->addBook(book);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to add the book");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    ret = false;
+  }
+  return ret;
+}

src/android/kiwixreader.cpp

@@ -0,0 +1,471 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#include <jni.h>
+#include <zim/file.h>
+#include <android/log.h>
+#include "org_kiwix_kiwixlib_JNIKiwixReader.h"
+
+#include "tools/base64.h"
+#include "reader.h"
+#include "utils.h"
+
+/* Kiwix Reader JNI functions */
+JNIEXPORT jlong JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getNativeReader(
+    JNIEnv* env, jobject obj, jstring filename)
+{
+  std::string cPath = jni2c(filename, env);
+
+  __android_log_print(ANDROID_LOG_INFO, "kiwix", "Attempting to create reader with: %s", cPath.c_str());
+  Lock l;
+  try {
+    kiwix::Reader* reader = new kiwix::Reader(cPath);
+    return reinterpret_cast<jlong>(new Handle<kiwix::Reader>(reader));
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", "Error opening ZIM file");
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", e.what());
+    return 0;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_dispose(JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Reader>::dispose(env, obj);
+}
+
+#define READER (Handle<kiwix::Reader>::getHandle(env, obj))
+
+/* Kiwix library functions */
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getMainPage(JNIEnv* env, jobject obj)
+{
+  jstring url;
+
+  try {
+    std::string cUrl = READER->getMainPage().getPath();
+    url = c2jni(cUrl, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM main page");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    url = NULL;
+  }
+  return url;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getId(JNIEnv* env, jobject obj)
+{
+  jstring id;
+
+  try {
+    std::string cId = READER->getId();
+    id = c2jni(cId, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM id");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    id = NULL;
+  }
+
+  return id;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getFileSize(JNIEnv* env, jobject obj)
+{
+  jint size = 0;
+
+  try {
+    int cSize = READER->getFileSize();
+    size = c2jni(cSize);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM file size");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+
+  return size;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getCreator(JNIEnv* env, jobject obj)
+{
+  jstring creator;
+
+  try {
+    std::string cCreator = READER->getCreator();
+    creator = c2jni(cCreator, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM creator");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    creator = NULL;
+  }
+
+  return creator;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getPublisher(JNIEnv* env, jobject obj)
+{
+  jstring publisher;
+
+  try {
+    std::string cPublisher = READER->getPublisher();
+    publisher = c2jni(cPublisher, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM publish");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    publisher = NULL;
+  }
+  return publisher;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getName(JNIEnv* env, jobject obj)
+{
+  jstring name;
+
+  try {
+    std::string cName = READER->getName();
+    name = c2jni(cName, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM name");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    name = NULL;
+  }
+  return name;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getFavicon(JNIEnv* env, jobject obj)
+{
+  jstring favicon;
+
+  try {
+    std::string cContent;
+    std::string cMime;
+    READER->getFavicon(cContent, cMime);
+    favicon = c2jni(
+        base64_encode(cContent),
+        env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM favicon");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    favicon = NULL;
+  }
+  return favicon;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getDate(JNIEnv* env, jobject obj)
+{
+  jstring date;
+
+  try {
+    std::string cDate = READER->getDate();
+    date = c2jni(cDate, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM date");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    date = NULL;
+  }
+  return date;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getLanguage(JNIEnv* env, jobject obj)
+{
+  jstring language;
+
+  try {
+    std::string cLanguage = READER->getLanguage();
+    language = c2jni(cLanguage, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get ZIM language");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    language = NULL;
+  }
+
+  return language;
+}
+
+JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getMimeType(
+    JNIEnv* env, jobject obj, jstring url)
+{
+  jstring mimeType;
+
+  std::string cUrl = jni2c(url, env);
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    auto cMimeType = entry.getMimetype();
+    mimeType = c2jni(cMimeType, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get mime-type for url: %s", cUrl.c_str());
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    mimeType = NULL;
+  }
+  return mimeType;
+}
+
+JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_checkUrl(
+     JNIEnv* env, jobject obj, jstring url)
+{
+  jstring finalUrl;
+  std::string cUrl = jni2c(url, env);
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    entry = entry.getFinalEntry();
+    finalUrl = c2jni(entry.getPath(), env);
+  } catch (std::exception& e) {
+    finalUrl = c2jni("", env);
+  }
+  return finalUrl;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getContent(
+    JNIEnv* env, jobject obj, jobject url, jobject titleObj, jobject mimeTypeObj, jobject sizeObj)
+{
+  /* Default values */
+  setStringObjValue("", titleObj, env);
+  setStringObjValue("", mimeTypeObj, env);
+  setIntObjValue(0, sizeObj, env);
+  jbyteArray data = env->NewByteArray(0);
+
+  /* Retrieve the content */
+  std::string cUrl = getStringObjValue(url, env);
+  unsigned int cSize = 0;
+
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    bool isRedirect = entry.isRedirect();
+    entry = entry.getFinalEntry();
+    cSize = entry.getSize();
+    setIntObjValue(cSize, sizeObj, env);
+    setStringObjValue(entry.getMimetype(), mimeTypeObj, env);
+    setStringObjValue(entry.getTitle(), titleObj, env);
+    if (isRedirect) {
+      setStringObjValue(entry.getPath(), url, env);
+    } else {
+      data = env->NewByteArray(cSize);
+      env->SetByteArrayRegion(
+          data, 0, cSize, reinterpret_cast<const jbyte*>(entry.getBlob().data()));
+    }
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get content for url: %s", cUrl.c_str());
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+
+  return data;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getContentPart(
+    JNIEnv* env, jobject obj, jstring url, jint offset, jint len, jobject sizeObj)
+{
+  jbyteArray data = env->NewByteArray(0);
+  setIntObjValue(0, sizeObj, env);
+
+  /* Default values */
+  /* Retrieve the content */
+  std::string cUrl = jni2c(url, env);
+  unsigned int cOffset = jni2c(offset);
+  unsigned int cLen = jni2c(len);
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    entry = entry.getFinalEntry();
+
+    if (cLen == 0) {
+      setIntObjValue(entry.getSize(), sizeObj, env);
+    } else if (cOffset+cLen < entry.getSize()) {
+      auto blob = entry.getBlob(cOffset, cLen);
+      data = env->NewByteArray(cLen);
+      env->SetByteArrayRegion(
+          data, 0, cLen, reinterpret_cast<const jbyte*>(blob.data()));
+      setIntObjValue(cLen, sizeObj, env);
+    }
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get partial content for url: %s (%u : %u)", cUrl.c_str(), cOffset, cLen);
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return data;
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getDirectAccessInformation(
+    JNIEnv* env, jobject obj, jstring url)
+{
+   jclass classPair = env->FindClass("org/kiwix/kiwixlib/Pair");
+   jmethodID midPairinit = env->GetMethodID(classPair, "<init>", "()V");
+   jobject pair = env->NewObject(classPair, midPairinit);
+   setPairObjValue("", 0, pair, env);
+
+   std::string cUrl = jni2c(url, env);
+   try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    entry = entry.getFinalEntry();
+    auto part_info = entry.getDirectAccessInfo();
+    setPairObjValue(part_info.first, part_info.second, pair, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get direct access info for url: %s", cUrl.c_str());
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return pair;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_searchSuggestions(JNIEnv* env,
+                                                         jobject obj,
+                                                         jstring prefix,
+                                                         jint count)
+{
+  jboolean retVal = JNI_FALSE;
+  std::string cPrefix = jni2c(prefix, env);
+  unsigned int cCount = jni2c(count);
+
+  try {
+    if (READER->searchSuggestionsSmart(cPrefix, cCount)) {
+      retVal = JNI_TRUE;
+    }
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", "Unable to get search results for pattern: %s", cPrefix.c_str());
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", e.what());
+  }
+
+  return retVal;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getNextSuggestion(JNIEnv* env,
+                                                         jobject obj,
+                                                         jobject titleObj)
+{
+  jboolean retVal = JNI_FALSE;
+  std::string cTitle;
+
+  try {
+    if (READER->getNextSuggestion(cTitle)) {
+      setStringObjValue(cTitle, titleObj, env);
+      retVal = JNI_TRUE;
+    }
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", "Unable to get next suggestion");
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", e.what());
+  }
+
+  return retVal;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getPageUrlFromTitle(JNIEnv* env,
+                                                           jobject obj,
+                                                           jstring title,
+                                                           jobject urlObj)
+{
+  std::string cTitle = jni2c(title, env);
+
+  try {
+    auto entry = READER->getEntryFromTitle(cTitle);
+    entry = entry.getFinalEntry();
+    setStringObjValue(entry.getPath(), urlObj, env);
+    return JNI_TRUE;
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", "Unable to get url for title %s: ", cTitle.c_str());
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", e.what());
+  }
+
+  return JNI_FALSE;
+}
+
+JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getTitle(
+    JNIEnv* env, jobject obj)
+{
+  jstring title;
+
+  try {
+    std::string cTitle = READER->getTitle();
+    title = c2jni(cTitle, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get zim title");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    title = NULL;
+  }
+  return title;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getDescription(JNIEnv* env, jobject obj)
+{
+  jstring description;
+
+  try {
+    std::string cDescription = READER->getDescription();
+    description = c2jni(cDescription, env);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get zim description");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+    description = NULL;
+  }
+  return description;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getArticleCount(JNIEnv* env, jobject obj)
+{
+  jint articleCount = 0;
+  try {
+    auto cArticleCount = READER->getArticleCount();
+    articleCount = c2jni(cArticleCount);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get article count.");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return articleCount;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getMediaCount(JNIEnv* env, jobject obj)
+{
+  jint mediaCount = 0;
+  try {
+    auto cMediaCount = READER->getMediaCount();
+    mediaCount = c2jni(cMediaCount);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get media count.");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return mediaCount;
+}
+
+
+JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getRandomPage(
+    JNIEnv* env, jobject obj, jobject urlObj)
+{
+  jboolean retVal = JNI_FALSE;
+  std::string cUrl;
+
+  try {
+    std::string cUrl = READER->getRandomPage().getPath();
+    setStringObjValue(cUrl, urlObj, env);
+    retVal = JNI_TRUE;
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get random page");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return retVal;
+}

src/android/kiwixsearcher.cpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#include <zim/file.h>
+#include "org_kiwix_kiwixlib_JNIKiwixSearcher.h"
+#include "org_kiwix_kiwixlib_JNIKiwixSearcher_Result.h"
+
+#include "reader.h"
+#include "searcher.h"
+#include "utils.h"
+
+#define SEARCHER (Handle<kiwix::Searcher>::getHandle(env, obj))
+#define RESULT (Handle<kiwix::Result>::getHandle(env, obj))
+
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_dispose(JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Searcher>::dispose(env, obj);
+}
+
+/* Kiwix Reader JNI functions */
+JNIEXPORT jlong JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_getNativeHandle(JNIEnv* env,
+                                                          jobject obj)
+{
+  kiwix::Searcher* searcher = new kiwix::Searcher();
+  return reinterpret_cast<jlong>(new Handle<kiwix::Searcher>(searcher));
+}
+
+/* Kiwix library functions */
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_addReader(
+    JNIEnv* env, jobject obj, jobject reader)
+{
+  auto searcher = SEARCHER;
+
+  searcher->add_reader(*(Handle<kiwix::Reader>::getHandle(env, reader)));
+}
+
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_search(
+    JNIEnv* env, jobject obj, jstring query, jint count)
+{
+  std::string cquery = jni2c(query, env);
+  unsigned int ccount = jni2c(count);
+
+  SEARCHER->search(cquery, 0, ccount);
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_getNextResult(JNIEnv* env,
+                                                         jobject obj)
+{
+  jobject result = nullptr;
+
+  kiwix::Result* cresult = SEARCHER->getNextResult();
+  if (cresult != nullptr) {
+    jclass resultclass
+        = env->FindClass("org/kiwix/kiwixlib/JNIKiwixSearcher$Result");
+    jmethodID ctor = env->GetMethodID(
+        resultclass, "<init>", "(Lorg/kiwix/kiwixlib/JNIKiwixSearcher;JLorg/kiwix/kiwixlib/JNIKiwixSearcher;)V");
+    result = env->NewObject(resultclass, ctor, obj, reinterpret_cast<jlong>(new Handle<kiwix::Result>(cresult)), obj);
+  }
+  return result;
+}
+
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_dispose(
+    JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Result>::dispose(env, obj);
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getUrl(JNIEnv* env,
+                                                        jobject obj)
+{
+  try {
+    return c2jni(RESULT->get_url(), env);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getTitle(JNIEnv* env,
+                                                          jobject obj)
+{
+  try {
+    return c2jni(RESULT->get_title(), env);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getSnippet(JNIEnv* env,
+                                                            jobject obj)
+{
+  return c2jni(RESULT->get_snippet(), env);
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getContent(JNIEnv* env,
+                                                            jobject obj)
+{
+  return c2jni(RESULT->get_content(), env);
+}

src/android/kiwixserver.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#include <jni.h>
+#include <zim/file.h>
+#include <android/log.h>
+#include "org_kiwix_kiwixlib_JNIKiwixServer.h"
+
+#include "tools/base64.h"
+#include "server.h"
+#include "utils.h"
+
+/* Kiwix Reader JNI functions */
+JNIEXPORT jlong JNICALL Java_org_kiwix_kiwixlib_JNIKiwixServer_getNativeServer(
+    JNIEnv* env, jobject obj, jobject jLibrary)
+{
+  __android_log_print(ANDROID_LOG_INFO, "kiwix", "Attempting to create server");
+  Lock l;
+  try {
+    auto library = Handle<kiwix::Library>::getHandle(env, jLibrary);
+    kiwix::Server* server = new kiwix::Server(*library);
+    return reinterpret_cast<jlong>(new Handle<kiwix::Server>(server));
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", "Error creating the server");
+    __android_log_print(ANDROID_LOG_WARN, "kiwix", e.what());
+    return 0;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_dispose(JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Server>::dispose(env, obj);
+}
+
+#define SERVER (Handle<kiwix::Server>::getHandle(env, obj))
+
+/* Kiwix library functions */
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_setRoot(JNIEnv* env, jobject obj, jstring jRoot)
+{
+  std::string root = jni2c(jRoot, env);
+  SERVER->setRoot(root);
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_setAddress(JNIEnv* env, jobject obj, jstring jAddress)
+{
+  std::string address = jni2c(jAddress, env);
+  SERVER->setAddress(address);
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_setPort(JNIEnv* env, jobject obj, int port)
+{
+  SERVER->setPort(port);
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_setNbThreads(JNIEnv* env, jobject obj, int threads)
+{
+  SERVER->setNbThreads(threads);
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_setTaskbar(JNIEnv* env, jobject obj, jboolean withTaskbar, jboolean withLibraryButton)
+{
+  SERVER->setTaskbar(withTaskbar, withLibraryButton);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_start(JNIEnv* env, jobject obj)
+{
+  return SERVER->start();
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixServer_stop(JNIEnv* env, jobject obj)
+{
+  SERVER->stop();
+}

src/android/meson.build

@@ -1,13 +1,32 @@
 
-jni_generator = find_program('gen_kiwix.sh')
-
 kiwix_jni = custom_target('jni',
-  input: ['org/kiwix/kiwixlib/JNIKiwix.java',
+  input: ['org/kiwix/kiwixlib/JNIICU.java',
+          'org/kiwix/kiwixlib/JNIKiwixReader.java',
+          'org/kiwix/kiwixlib/JNIKiwixLibrary.java',
+          'org/kiwix/kiwixlib/JNIKiwixSearcher.java',
+          'org/kiwix/kiwixlib/JNIKiwixServer.java',
           'org/kiwix/kiwixlib/JNIKiwixInt.java',
           'org/kiwix/kiwixlib/JNIKiwixString.java',
-          'org/kiwix/kiwixlib/JNIKiwixBool.java'],
-  output: ['org_kiwix_kiwixlib_JNIKiwix.h'],
-  command:[jni_generator, '@INPUT@']
+          'org/kiwix/kiwixlib/JNIKiwixBool.java',
+          'org/kiwix/kiwixlib/JNIKiwixException.java',
+          'org/kiwix/kiwixlib/Pair.java'],
+  output: ['org_kiwix_kiwixlib_JNIKiwix.h',
+           'org_kiwix_kiwixlib_JNIKiwixReader.h',
+           'org_kiwix_kiwixlib_JNIKiwixLibrary.h',
+           'org_kiwix_kiwixlib_JNIKiwixServer.h',
+           'org_kiwix_kiwixlib_JNIKiwixSearcher.h',
+           'org_kiwix_kiwixlib_JNIKiwixSearcher_Result.h'],
+  command:['javac', '-d', '@OUTDIR@', '-h', '@OUTDIR@', '@INPUT@']
 )
 
-kiwix_sources += ['android/kiwix.cpp', kiwix_jni]
+kiwix_sources += [
+    'android/kiwixicu.cpp',
+    'android/kiwixreader.cpp',
+    'android/kiwixlibrary.cpp',
+    'android/kiwixsearcher.cpp',
+    'android/kiwixserver.cpp',
+    kiwix_jni]
+
+install_subdir('org', install_dir: 'kiwix-lib/java')
+install_subdir('res', install_dir: 'kiwix-lib')
+install_data('AndroidManifest.xml', install_dir: 'kiwix-lib')

src/android/org/kiwix/kiwixlib/JNIICU.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+public class JNIICU
+{
+  static public native void setDataDirectory(String icuDataDir);
+}

src/android/org/kiwix/kiwixlib/JNIKiwix.java

@@ -1,5 +1,6 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,59 +20,17 @@
 
 package org.kiwix.kiwixlib;
 
-import org.kiwix.kiwixlib.JNIKiwixString;
-import org.kiwix.kiwixlib.JNIKiwixBool;
-import org.kiwix.kiwixlib.JNIKiwixInt;
+import android.content.Context;
+import com.getkeepsafe.relinker.ReLinker;
+import org.kiwix.kiwixlib.JNIICU;
 
-public class JNIKiwix {
-
-  static {
-    System.loadLibrary("kiwix");
+public class JNIKiwix
+{
+  public JNIKiwix(final Context context){
+    ReLinker.loadLibrary(context, "kiwix");
   }
 
-  public native String getMainPage();
-
-  public native String getId();
-
-  public native String getLanguage();
-
-  public native String getMimeType(String url);
-
-  public native boolean loadZIM(String path);
-
-    public native boolean loadFulltextIndex(String path);
-    
-  public native byte[] getContent(String url, JNIKiwixString mimeType, JNIKiwixInt size);
-
-  public native boolean searchSuggestions(String prefix, int count);
-
-  public native boolean getNextSuggestion(JNIKiwixString title);
-
-  public native boolean getPageUrlFromTitle(String title, JNIKiwixString url);
-
-  public native boolean getTitle(JNIKiwixString title);
-
-  public native String getDescription();
-
-  public native String getDate();
-
-  public native String getFavicon();
-
-  public native String getCreator();
-
-  public native String getPublisher();
-
-  public native String getName();
-
-  public native int getFileSize();
-
-  public native int getArticleCount();
-
-  public native int getMediaCount();
-
-  public native boolean getRandomPage(JNIKiwixString url);
-
-  public native void setDataDirectory(String icuDataDir);
-
-  public static native String indexedQuery(String db, int count);
+  public void setDataDirectory(String icuDataDir) {
+    JNIICU.setDataDirectory(icuDataDir);
+  }
 }

src/android/org/kiwix/kiwixlib/JNIKiwixBool.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,7 +19,7 @@
 
 package org.kiwix.kiwixlib;
 
-public class JNIKiwixBool {
-
+public class JNIKiwixBool
+{
   public boolean value;
 }

src/android/org/kiwix/kiwixlib/JNIKiwixException.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+public class JNIKiwixException extends Exception
+{
+  public JNIKiwixException(String message) {
+    super(message);
+  }
+}

src/android/org/kiwix/kiwixlib/JNIKiwixInt.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,8 +19,7 @@
 
 package org.kiwix.kiwixlib;
 
-public class JNIKiwixInt {
-
+public class JNIKiwixInt
+{
   public int value;
 }
-

src/android/org/kiwix/kiwixlib/JNIKiwixLibrary.java

@@ -1,5 +1,6 @@
 /*
- * Copyright 2012 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -17,32 +18,21 @@
  * MA 02110-1301, USA.
  */
 
-#ifndef KIWIX_NETWORKTOOLS_H
-#define KIWIX_NETWORKTOOLS_H
+package org.kiwix.kiwixlib;
 
-#ifdef _WIN32
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <net/if.h>
-#include <netdb.h>
-#endif
+import org.kiwix.kiwixlib.JNIKiwixException;
 
-#include <iostream>
-#include <vector>
-#include <string>
-#include <map>
+public class JNIKiwixLibrary
+{
+  public native boolean addBook(String path) throws JNIKiwixException;
 
-namespace kiwix {
-  std::map<std::string, std::string> getNetworkInterfaces();
-  std::string getBestPublicIp();
+  public JNIKiwixLibrary()
+  {
+    nativeHandle = getNativeLibrary();
+  }
+
+  public native void dispose();
+
+  private native long getNativeLibrary();
+  private long nativeHandle;
 }
-
-#endif

src/android/org/kiwix/kiwixlib/JNIKiwixReader.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+import org.kiwix.kiwixlib.JNIKiwixException;
+import org.kiwix.kiwixlib.JNIKiwixString;
+import org.kiwix.kiwixlib.JNIKiwixInt;
+import org.kiwix.kiwixlib.JNIKiwixSearcher;
+import org.kiwix.kiwixlib.Pair;
+
+public class JNIKiwixReader
+{
+  public native String getMainPage();
+
+  public native String getTitle();
+
+  public native String getId();
+
+  public native String getLanguage();
+
+  public native String getMimeType(String url);
+
+  /**
+   * Check if a url exists and is a redirect or not.
+   *
+   * Return an empty string if the url doesn't exist in the reader.
+   * Return the url of the "final" entry.
+   * - equal to the input url if the entry is not a redirection.
+   * - different if the url is a redirection (and the webview should redirect to it).
+   */
+  public native String checkUrl(String url);
+
+  /**
+   * Get the content of a article.
+   *
+   * Return a byte array of the content of the article.
+   * Set the title, mimeType to the title and mimeType of the article.
+   * Set the size to the size of the returned array.
+   *
+   * If the entry doesn't exist :
+   *  - return a empty byte array
+   *  - set all arguments (except url) to empty/0.
+   * If the entry exist but is a redirection :
+   *  - return an empty byte array
+   *  - set all arguments (including url) to information of the targeted article.
+   */
+  public native byte[] getContent(JNIKiwixString url,
+                                  JNIKiwixString title,
+                                  JNIKiwixString mimeType,
+                                  JNIKiwixInt size);
+
+  /**
+   * getContentPart.
+   *
+   * Get only a part of the content of the article.
+   * Return a byte array of `len` size starting from offset `offset`.
+   * Set `size` to the number of bytes read
+   * (`len` if everything is ok, 0 in case of error).
+   * If `len` == 0, no bytes are read but `size` is set to the total size of the
+   * article.
+   */
+  public native byte[] getContentPart(String url,
+                                      int offest,
+                                      int len,
+                                      JNIKiwixInt size);
+
+  /**
+   * getDirectAccessInformation.
+   *
+   * Return information giving where the content is located in the zim file.
+   *
+   * Some contents (binary content) are stored uncompressed in the zim file.
+   * Knowing this information, it could be interesting to directly open
+   * the zim file (or zim part) and directly read the content from it (and so
+   * bypassing the libzim).
+   *
+   * Return a `Pair` (filename, offset) where the content is located.
+   *
+   * If the content cannot be directly accessed (content is compressed or zim
+   * file is cut in the middle of the content), the filename is an empty string
+   * and offset is zero.
+   */
+  public native Pair getDirectAccessInformation(String url);
+
+  public native boolean searchSuggestions(String prefix, int count);
+
+  public native boolean getNextSuggestion(JNIKiwixString title);
+
+  public native boolean getPageUrlFromTitle(String title, JNIKiwixString url);
+
+  public native String getDescription();
+
+  public native String getDate();
+
+  public native String getFavicon();
+
+  public native String getCreator();
+
+  public native String getPublisher();
+
+  public native String getName();
+
+  public native int getFileSize();
+
+  public native int getArticleCount();
+
+  public native int getMediaCount();
+
+  public native boolean getRandomPage(JNIKiwixString url);
+
+  public JNIKiwixSearcher search(String query, int count)
+  {
+    JNIKiwixSearcher searcher = new JNIKiwixSearcher();
+    searcher.addKiwixReader(this);
+    searcher.search(query, count);
+    return searcher;
+  }
+
+  public JNIKiwixReader(String filename) throws JNIKiwixException
+  {
+    nativeHandle = getNativeReader(filename);
+    if (nativeHandle == 0) {
+        throw new JNIKiwixException("Cannot open zimfile "+filename);
+    }
+  }
+  public JNIKiwixReader() {
+
+  }
+  public native void dispose();
+
+  private native long getNativeReader(String filename);
+  private long nativeHandle;
+}

src/android/org/kiwix/kiwixlib/JNIKiwixSearcher.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+package org.kiwix.kiwixlib;
+
+import org.kiwix.kiwixlib.JNIKiwixReader;
+import java.util.Vector;
+
+public class JNIKiwixSearcher
+{
+  public class Result
+  {
+    private long nativeHandle;
+    private JNIKiwixSearcher searcher;
+    public Result(long handle, JNIKiwixSearcher _searcher)
+    {
+      nativeHandle = handle;
+      searcher = _searcher;
+    }
+    public native String getUrl();
+    public native String getTitle();
+    public native String getContent();
+    public native String getSnippet();
+    public native void dispose();
+  }
+
+  public JNIKiwixSearcher()
+  {
+    nativeHandle = getNativeHandle();
+    usedReaders = new Vector();
+  }
+  public native void dispose();
+
+  private native long getNativeHandle();
+  private long nativeHandle;
+  private Vector usedReaders;
+
+  public native void addReader(JNIKiwixReader reader);
+  public void addKiwixReader(JNIKiwixReader reader)
+  {
+    addReader(reader);
+    usedReaders.addElement(reader);
+  };
+
+  public native void search(String query, int count);
+
+  public native Result getNextResult();
+  public native boolean hasMoreResult();
+}

src/android/org/kiwix/kiwixlib/JNIKiwixServer.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2019 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+import org.kiwix.kiwixlib.JNIKiwixException;
+import org.kiwix.kiwixlib.JNIKiwixLibrary;
+
+public class JNIKiwixServer
+{
+  public native void setRoot(String root);
+
+  public native void setAddress(String address);
+
+  public native void setPort(int port);
+
+  public native void setNbThreads(int nbTreads);
+
+  public native void setTaskbar(boolean withTaskBar, boolean witLibraryButton);
+
+  public native boolean start();
+
+  public native void stop();
+
+  public JNIKiwixServer(JNIKiwixLibrary library)
+  {
+    nativeHandle = getNativeServer(library);
+  }
+
+  private native long getNativeServer(JNIKiwixLibrary library);
+  private long nativeHandle;
+}

src/android/org/kiwix/kiwixlib/JNIKiwixString.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,7 +19,19 @@
 
 package org.kiwix.kiwixlib;
 
-public class JNIKiwixString {
-
+public class JNIKiwixString
+{
   public String value;
+
+  public JNIKiwixString(String value) {
+    this.value = value;
+  }
+
+  public JNIKiwixString() {
+    this("");
+  }
+
+  public String getValue() {
+    return value;
+  }
 }

src/android/org/kiwix/kiwixlib/Pair.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+public class Pair
+{
+  public String filename;
+  public int offset;
+}

src/android/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+  <string name="app_name">Kiwix Lib</string>
+</resources>

src/android/utils.h

@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#ifndef _ANDROID_JNI_UTILS_H
+#define _ANDROID_JNI_UTILS_H
+
+#include <jni.h>
+
+#include <pthread.h>
+#include <string>
+
+extern pthread_mutex_t globalLock;
+
+inline jfieldID getHandleField(JNIEnv* env, jobject obj)
+{
+  jclass c = env->GetObjectClass(obj);
+  // J is the type signature for long:
+  return env->GetFieldID(c, "nativeHandle", "J");
+}
+
+class Lock
+{
+ protected:
+  pthread_mutex_t* lock;
+
+ public:
+  Lock() : lock(&globalLock) { pthread_mutex_lock(lock); }
+  Lock(const Lock&) = delete;
+  Lock& operator=(const Lock&) = delete;
+  Lock(Lock&& other) : lock(&globalLock) { other.lock = nullptr; }
+  virtual ~Lock()
+  {
+    if (lock) {
+      pthread_mutex_unlock(lock);
+    }
+  }
+};
+
+template <class T>
+class LockedHandle;
+
+template <class T>
+class Handle
+{
+ protected:
+  T* h;
+
+ public:
+  Handle(T* h) : h(h){};
+
+  // No destructor. This must and will be handled by dispose method.
+
+  static LockedHandle<T> getHandle(JNIEnv* env, jobject obj)
+  {
+    jlong handle = env->GetLongField(obj, getHandleField(env, obj));
+    return LockedHandle<T>(reinterpret_cast<Handle<T>*>(handle));
+  }
+
+  static void dispose(JNIEnv* env, jobject obj)
+  {
+    auto lHandle = getHandle(env, obj);
+    auto handle = lHandle.h;
+    delete handle->h;
+    delete handle;
+  }
+  friend class LockedHandle<T>;
+};
+
+template <class T>
+struct LockedHandle : public Lock {
+  Handle<T>* h;
+  LockedHandle(Handle<T>* h) : h(h) {}
+  T* operator->() { return h->h; }
+  T* operator*() { return h->h; }
+  operator bool() const { return (h->h != nullptr); }
+};
+
+/* c2jni type conversion functions */
+inline jboolean c2jni(const bool& val) { return val ? JNI_TRUE : JNI_FALSE; }
+inline jstring c2jni(const std::string& val, JNIEnv* env)
+{
+  return env->NewStringUTF(val.c_str());
+}
+
+inline jint c2jni(const int val) { return (jint)val; }
+inline jint c2jni(const unsigned val) { return (unsigned)val; }
+/* jni2c type conversion functions */
+inline bool jni2c(const jboolean& val) { return val == JNI_TRUE; }
+inline std::string jni2c(const jstring& val, JNIEnv* env)
+{
+  const char* chars = env->GetStringUTFChars(val, 0);
+  std::string ret(chars);
+  env->ReleaseStringUTFChars(val, chars);
+  return ret;
+}
+
+inline int jni2c(const jint val) { return (int)val; }
+/* Method to deal with variable passed by reference */
+inline std::string getStringObjValue(const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "Ljava/lang/String;");
+  jstring jstr = (jstring)env->GetObjectField(obj, objFid);
+  return jni2c(jstr, env);
+}
+inline void setStringObjValue(const std::string& value,
+                              const jobject obj,
+                              JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "Ljava/lang/String;");
+  env->SetObjectField(obj, objFid, c2jni(value, env));
+}
+
+inline void setIntObjValue(const int value, const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "I");
+  env->SetIntField(obj, objFid, value);
+}
+
+inline void setBoolObjValue(const bool value, const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "Z");
+  env->SetIntField(obj, objFid, c2jni(value));
+}
+
+inline void setPairObjValue(const std::string& filename, const int offset,
+                            const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID filenameFid = env->GetFieldID(objClass, "filename", "Ljava/lang/String;");
+  env->SetObjectField(obj, filenameFid, c2jni(filename, env));
+  jfieldID offsetFid = env->GetFieldID(objClass, "offset", "I");
+  env->SetIntField(obj, offsetFid, offset);
+}
+
+#endif // _ANDROID_JNI_UTILS_H

src/aria2.cpp

@@ -0,0 +1,247 @@
+
+
+#include "aria2.h"
+#include "xmlrpc.h"
+#include <iostream>
+#include <sstream>
+#include <thread>
+#include <chrono>
+#include <tools/otherTools.h>
+#include <tools/pathTools.h>
+#include <tools/stringTools.h>
+#include <downloader.h> // For AriaError
+
+#ifdef _WIN32
+# define ARIA2_CMD "aria2c.exe"
+#else
+# define ARIA2_CMD "aria2c"
+# include <unistd.h>
+#endif
+
+
+
+namespace kiwix {
+
+Aria2::Aria2():
+  mp_aria(nullptr),
+  m_port(42042),
+  m_secret("kiwixariarpc"),
+  mp_curl(nullptr),
+  m_lock(PTHREAD_MUTEX_INITIALIZER)
+{
+  m_downloadDir = getDataDirectory();
+  makeDirectory(m_downloadDir);
+  std::vector<const char*> callCmd;
+
+  std::string rpc_port = "--rpc-listen-port=" + to_string(m_port);
+  std::string download_dir = "--dir=" + getDataDirectory();
+  std::string session_file = appendToDirectory(getDataDirectory(), "kiwix.session");
+  std::string session = "--save-session=" + session_file;
+  std::string inputFile = "--input-file=" + session_file;
+//  std::string log_dir = "--log=\"" + logDir + "\"";
+#ifdef _WIN32
+  int pid = GetCurrentProcessId();
+#else
+  pid_t pid = getpid();
+#endif
+  std::string stop_with_pid = "--stop-with-process=" + to_string(pid);
+  std::string rpc_secret = "--rpc-secret=" + m_secret;
+  m_secret = "token:"+m_secret;
+
+  std::string aria2cmd = appendToDirectory(
+    removeLastPathElement(getExecutablePath(true)),
+    ARIA2_CMD);
+  if (fileExists(aria2cmd)) {
+    // A local aria2c exe exists (packaged with kiwix-desktop), use it.
+    callCmd.push_back(aria2cmd.c_str());
+  } else {
+    // Try to use a potential installed aria2c.
+    callCmd.push_back(ARIA2_CMD);
+  }
+  callCmd.push_back("--enable-rpc");
+  callCmd.push_back(rpc_secret.c_str());
+  callCmd.push_back(rpc_port.c_str());
+  callCmd.push_back(download_dir.c_str());
+  if (fileExists(session_file)) {
+    callCmd.push_back(inputFile.c_str());
+  }
+  callCmd.push_back(session.c_str());
+//  callCmd.push_back(log_dir.c_str());
+  callCmd.push_back("--auto-save-interval=10");
+  callCmd.push_back(stop_with_pid.c_str());
+  callCmd.push_back("--allow-overwrite=true");
+  callCmd.push_back("--dht-entry-point=router.bittorrent.com:6881");
+  callCmd.push_back("--dht-entry-point6=router.bittorrent.com:6881");
+  callCmd.push_back("--quiet=true");
+  callCmd.push_back("--bt-enable-lpd=true");
+  callCmd.push_back("--always-resume=true");
+  callCmd.push_back("--max-concurrent-downloads=42");
+  callCmd.push_back("--rpc-max-request-size=6M");
+  callCmd.push_back("--file-allocation=none");
+  mp_aria = Subprocess::run(callCmd);
+  mp_curl = curl_easy_init();
+  curl_easy_setopt(mp_curl, CURLOPT_URL, "http://localhost/rpc");
+  curl_easy_setopt(mp_curl, CURLOPT_PORT, m_port);
+  curl_easy_setopt(mp_curl, CURLOPT_POST, 1L);
+
+  int watchdog = 50;
+  while(--watchdog) {
+    sleep(10);
+    auto res = curl_easy_perform(mp_curl);
+    if (res == CURLE_OK) {
+      break;
+    }
+  }
+  if (!watchdog) {
+    curl_easy_cleanup(mp_curl);
+    throw std::runtime_error("Cannot connect to aria2c rpc");
+  }
+}
+
+Aria2::~Aria2()
+{
+  curl_easy_cleanup(mp_curl);
+}
+
+void Aria2::close()
+{
+  saveSession();
+  shutdown();
+}
+
+size_t write_callback_to_iss(char* ptr, size_t size, size_t nmemb, void* userdata)
+{
+  auto str = static_cast<std::stringstream*>(userdata);
+  str->write(ptr, nmemb);
+  return nmemb;
+}
+
+std::string Aria2::doRequest(const MethodCall& methodCall)
+{
+  pthread_mutex_lock(&m_lock);
+  auto requestContent = methodCall.toString();
+  std::stringstream stringstream;
+  CURLcode res;
+  curl_easy_setopt(mp_curl, CURLOPT_POSTFIELDSIZE, requestContent.size());
+  curl_easy_setopt(mp_curl, CURLOPT_POSTFIELDS, requestContent.c_str());
+  curl_easy_setopt(mp_curl, CURLOPT_WRITEFUNCTION, &write_callback_to_iss);
+  curl_easy_setopt(mp_curl, CURLOPT_WRITEDATA, &stringstream);
+  res = curl_easy_perform(mp_curl);
+  if (res == CURLE_OK) {
+    long response_code;
+    curl_easy_getinfo(mp_curl, CURLINFO_RESPONSE_CODE, &response_code);
+    pthread_mutex_unlock(&m_lock);
+    if (response_code != 200) {
+      throw std::runtime_error("Invalid return code from aria");
+    }
+    auto responseContent = stringstream.str();
+    MethodResponse response(responseContent);
+    if (response.isFault()) {
+      throw AriaError(response.getFault().getFaultString());
+    }
+    return responseContent;
+  }
+  pthread_mutex_unlock(&m_lock);
+  throw std::runtime_error("Cannot perform request");
+}
+
+std::string Aria2::addUri(const std::vector<std::string>& uris)
+{
+  MethodCall methodCall("aria2.addUri", m_secret);
+  auto uriParams = methodCall.newParamValue().getArray();
+  for (auto& uri : uris) {
+    uriParams.addValue().set(uri);
+  }
+  auto ret = doRequest(methodCall);
+  MethodResponse response(ret);
+  return response.getParamValue(0).getAsS();
+}
+
+std::string Aria2::tellStatus(const std::string& gid, const std::vector<std::string>& statusKey)
+{
+  MethodCall methodCall("aria2.tellStatus", m_secret);
+  methodCall.newParamValue().set(gid);
+  if (!statusKey.empty()) {
+    auto statusArray = methodCall.newParamValue().getArray();
+    for (auto& key : statusKey) {
+      statusArray.addValue().set(key);
+    }
+  }
+  return doRequest(methodCall);
+}
+
+std::vector<std::string> Aria2::tellActive()
+{
+  MethodCall methodCall("aria2.tellActive", m_secret);
+  auto statusArray = methodCall.newParamValue().getArray();
+  statusArray.addValue().set(std::string("gid"));
+  auto responseContent = doRequest(methodCall);
+  MethodResponse response(responseContent);
+  std::vector<std::string> activeGID;
+  int index = 0;
+  while(true) {
+    try {
+      auto structNode = response.getParamValue(0).getArray().getValue(index++).getStruct();
+      auto gidNode = structNode.getMember("gid");
+      activeGID.push_back(gidNode.getValue().getAsS());
+    } catch (InvalidRPCNode& e) { break; }
+  }
+  return activeGID;
+}
+
+std::vector<std::string> Aria2::tellWaiting()
+{
+  MethodCall methodCall("aria2.tellWaiting", m_secret);
+  methodCall.newParamValue().set(0);
+  methodCall.newParamValue().set(99); // max number of downloads to be returned, don't know how to set this properly assumed that there will not be more than 99 paused downloads.
+  auto statusArray = methodCall.newParamValue().getArray();
+  statusArray.addValue().set(std::string("gid"));
+  auto responseContent = doRequest(methodCall);
+  MethodResponse response(responseContent);
+  std::vector<std::string> waitingGID;
+  int index = 0;
+  while(true) {
+    try {
+      auto structNode = response.getParamValue(0).getArray().getValue(index++).getStruct();
+      auto gidNode = structNode.getMember("gid");
+      waitingGID.push_back(gidNode.getValue().getAsS());
+    } catch (InvalidRPCNode& e) { break; }
+  }
+  return waitingGID;
+}
+
+void Aria2::saveSession()
+{
+  MethodCall methodCall("aria2.saveSession", m_secret);
+  doRequest(methodCall);
+  std::cout << "session saved" << std::endl;
+}
+
+void Aria2::shutdown()
+{
+  MethodCall methodCall("aria2.shutdown", m_secret);
+  doRequest(methodCall);
+}
+
+void Aria2::pause(const std::string& gid)
+{
+    MethodCall methodCall("aria2.pause", m_secret);
+    methodCall.newParamValue().set(gid);
+    doRequest(methodCall);
+}
+
+void Aria2::unpause(const std::string& gid)
+{
+    MethodCall methodCall("aria2.unpause", m_secret);
+    methodCall.newParamValue().set(gid);
+    doRequest(methodCall);
+}
+
+void Aria2::remove(const std::string& gid)
+{
+    MethodCall methodCall("aria2.remove", m_secret);
+    methodCall.newParamValue().set(gid);
+    doRequest(methodCall);
+}
+
+} // end namespace kiwix

src/aria2.h

@@ -0,0 +1,50 @@
+
+
+#ifndef KIWIXLIB_ARIA2_H_
+#define KIWIXLIB_ARIA2_H_
+
+#ifdef _WIN32
+// winsock2.h need to be included before windows.h (included by curl.h)
+# include <winsock2.h>
+#endif
+
+#include "subprocess.h"
+#include "xmlrpc.h"
+
+#include <memory>
+#include <curl/curl.h>
+#include <pthread.h>
+
+namespace kiwix {
+
+class Aria2
+{
+  private:
+    std::unique_ptr<Subprocess> mp_aria;
+    int m_port;
+    std::string m_secret;
+    std::string m_downloadDir;
+    CURL* mp_curl;
+    pthread_mutex_t m_lock;
+
+    std::string doRequest(const MethodCall& methodCall);
+
+  public:
+    Aria2();
+    virtual ~Aria2();
+    void close();
+
+    std::string addUri(const std::vector<std::string>& uri);
+    std::string tellStatus(const std::string& gid, const std::vector<std::string>& statusKey);
+    std::vector<std::string> tellActive();
+    std::vector<std::string> tellWaiting();
+    void saveSession();
+    void shutdown();
+    void pause(const std::string& gid);
+    void unpause(const std::string& gid);
+    void remove(const std::string& gid);
+};
+
+}; //end namespace kiwix
+
+#endif // KIWIXLIB_ARIA2_H_

src/book.cpp

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "book.h"
+#include "reader.h"
+
+#include "tools/base64.h"
+#include "tools/regexTools.h"
+#include "tools/networkTools.h"
+
+#include <pugixml.hpp>
+
+namespace kiwix
+{
+/* Constructor */
+Book::Book() :
+  m_pathValid(false),
+  m_readOnly(false)
+{
+}
+/* Destructor */
+Book::~Book()
+{
+}
+
+bool Book::update(const kiwix::Book& other)
+{
+  if (m_readOnly)
+    return false;
+
+  m_readOnly = other.m_readOnly;
+
+  if (m_path.empty()) {
+    m_path = other.m_path;
+    m_pathValid = other.m_pathValid;
+  }
+
+  if (m_url.empty()) {
+    m_url = other.m_url;
+  }
+
+  if (m_tags.empty()) {
+    m_tags = other.m_tags;
+  }
+
+  if (m_name.empty()) {
+    m_name = other.m_name;
+  }
+
+  if (m_faviconMimeType.empty()) {
+    m_favicon = other.m_favicon;
+    m_faviconMimeType = other.m_faviconMimeType;
+  }
+  return true;
+}
+
+void Book::update(const kiwix::Reader& reader)
+{
+  m_path = reader.getZimFilePath();
+  m_id = reader.getId();
+  m_description = reader.getDescription();
+  m_language = reader.getLanguage();
+  m_date = reader.getDate();
+  m_creator = reader.getCreator();
+  m_publisher = reader.getPublisher();
+  m_title = reader.getTitle();
+  m_name = reader.getName();
+  m_tags = reader.getTags();
+  m_origId = reader.getOrigId();
+  m_articleCount = reader.getArticleCount();
+  m_mediaCount = reader.getMediaCount();
+  m_size = static_cast<uint64_t>(reader.getFileSize()) << 10;
+  m_pathValid = true;
+
+  reader.getFavicon(m_favicon, m_faviconMimeType);
+}
+
+#define ATTR(name) node.attribute(name).value()
+void Book::updateFromXml(const pugi::xml_node& node, const std::string& baseDir)
+{
+  m_id = ATTR("id");
+  std::string path = ATTR("path");
+  if (isRelativePath(path)) {
+    path = computeAbsolutePath(baseDir, path);
+  }
+  m_path = path;
+  m_title = ATTR("title");
+  m_name = ATTR("name");
+  m_tags = ATTR("tags");
+  m_description = ATTR("description");
+  m_language = ATTR("language");
+  m_date = ATTR("date");
+  m_creator = ATTR("creator");
+  m_publisher = ATTR("publisher");
+  m_url = ATTR("url");
+  m_origId = ATTR("origId");
+  m_articleCount = strtoull(ATTR("articleCount"), 0, 0);
+  m_mediaCount = strtoull(ATTR("mediaCount"), 0, 0);
+  m_size = strtoull(ATTR("size"), 0, 0) << 10;
+  m_favicon = base64_decode(ATTR("favicon"));
+  m_faviconMimeType = ATTR("faviconMimeType");
+  try {
+    m_downloadId = ATTR("downloadId");
+  } catch(...) {}
+}
+#undef ATTR
+
+
+static std::string fromOpdsDate(const std::string& date)
+{
+  //The opds date use the standard <YYYY>-<MM>-<DD>T<HH>:<mm>:<SS>Z
+  //and we want <YYYY>-<MM>-<DD>. That's easy, let's take the first 10 char
+  return date.substr(0, 10);
+}
+
+
+#define VALUE(name) node.child(name).child_value()
+void Book::updateFromOpds(const pugi::xml_node& node, const std::string& urlHost)
+{
+  m_id = VALUE("id");
+  if (!m_id.compare(0, 9, "urn:uuid:")) {
+    m_id.erase(0, 9);
+  }
+  m_title = VALUE("title");
+  m_description = VALUE("description");
+  m_language = VALUE("language");
+  m_date = fromOpdsDate(VALUE("updated"));
+  m_creator = node.child("author").child("name").child_value();
+  m_tags = VALUE("tags");
+  for(auto linkNode = node.child("link"); linkNode;
+           linkNode = linkNode.next_sibling("link")) {
+    std::string rel = linkNode.attribute("rel").value();
+
+    if (rel == "http://opds-spec.org/acquisition/open-access") {
+      m_url = linkNode.attribute("href").value();
+      m_size = strtoull(linkNode.attribute("length").value(), 0, 0);
+    }
+    if (rel == "http://opds-spec.org/image/thumbnail") {
+      m_faviconUrl = urlHost + linkNode.attribute("href").value();
+      m_faviconMimeType = linkNode.attribute("type").value();
+    }
+ }
+
+}
+#undef VALUE
+
+std::string Book::getHumanReadableIdFromPath() const
+{
+  std::string id = m_path;
+  if (!id.empty()) {
+    kiwix::removeAccents(id);
+
+#ifdef _WIN32
+    id = replaceRegex(id, "", "^.*\\\\");
+#else
+    id = replaceRegex(id, "", "^.*/");
+#endif
+
+    id = replaceRegex(id, "", "\\.zim[a-z]*$");
+    id = replaceRegex(id, "_", " ");
+    id = replaceRegex(id, "plus", "\\+");
+  }
+  return id;
+}
+
+void Book::setPath(const std::string& path)
+{
+ m_path = isRelativePath(path)
+   ? computeAbsolutePath(getCurrentDirectory(), path)
+   : path;
+}
+
+const std::string& Book::getFavicon() const {
+  if (m_favicon.empty() && !m_faviconUrl.empty()) {
+    try {
+      m_favicon = download(m_faviconUrl);
+    } catch(...) {
+      std::cerr << "Cannot download favicon from " << m_faviconUrl;
+    }
+  }
+  return m_favicon;
+}
+
+}

src/bookmark.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "bookmark.h"
+
+#include <pugixml.hpp>
+
+namespace kiwix
+{
+/* Constructor */
+Bookmark::Bookmark()
+{
+}
+
+/* Destructor */
+Bookmark::~Bookmark()
+{
+}
+
+void Bookmark::updateFromXml(const pugi::xml_node& node)
+{
+  auto bookNode = node.child("book");
+  m_bookId = bookNode.child("id").child_value();
+  m_bookTitle = bookNode.child("title").child_value();
+  m_language = bookNode.child("language").child_value();
+  m_date = bookNode.child("date").child_value();
+  m_title = node.child("title").child_value();
+  m_url = node.child("url").child_value();
+}
+
+}

src/common/networkTools.cpp

@@ -1,137 +0,0 @@
-/*
- * Copyright 2012 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#include <common/networkTools.h>
-
-std::map<std::string, std::string> kiwix::getNetworkInterfaces() {
-  std::map<std::string, std::string> interfaces;
-
-#ifdef _WIN32
-  SOCKET sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
-  if (sd == SOCKET_ERROR) {
-    std::cerr << "Failed to get a socket. Error " << WSAGetLastError() <<
-      std::endl;
-    return interfaces;
-  }
-
-  INTERFACE_INFO InterfaceList[20];
-  unsigned long nBytesReturned;
-  if (WSAIoctl(sd, SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList,
-	       sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR) {
-    std::cerr << "Failed calling WSAIoctl: error " << WSAGetLastError() <<
-      std::endl;
-    return interfaces;
-  }
-
-  int nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
-  for (int i = 0; i < nNumInterfaces; ++i) {
-    sockaddr_in *pAddress;
-    pAddress = (sockaddr_in *) & (InterfaceList[i].iiAddress);
-
-    /* Add to the map */
-    std::string interfaceName = std::string(inet_ntoa(pAddress->sin_addr));
-    std::string interfaceIp = std::string(inet_ntoa(pAddress->sin_addr));
-    interfaces.insert(std::pair<std::string, std::string>(interfaceName, interfaceIp));
-  }
-#else
-  /* Get Network interfaces information */
-  char buf[16384];
-  struct ifconf ifconf;
-  int fd = socket(PF_INET, SOCK_DGRAM, 0); /* Only IPV4 */
-  ifconf.ifc_len=sizeof buf;
-  ifconf.ifc_buf=buf;
-  if(ioctl(fd, SIOCGIFCONF, &ifconf)!=0) {
-    perror("ioctl(SIOCGIFCONF)");
-    exit(EXIT_FAILURE);
-  }
-
-  /* Go through each interface */
-  int i;
-  size_t len;
-  struct ifreq *ifreq;
-  ifreq = ifconf.ifc_req;
-  for (i = 0; i < ifconf.ifc_len; ) {
-    if (ifreq->ifr_addr.sa_family == AF_INET) {
-      /* Get the network interface ip */
-      char host[128] = { 0 };
-      const int error = getnameinfo(&(ifreq->ifr_addr), sizeof ifreq->ifr_addr,
-                                    host, sizeof host,
-                                    0, 0, NI_NUMERICHOST);
-      if (!error) {
-        std::string interfaceName = std::string(ifreq->ifr_name);
-        std::string interfaceIp = std::string(host);
-        /* Add to the map */
-        interfaces.insert(std::pair<std::string, std::string>(interfaceName, interfaceIp));
-      } else {
-        perror("getnameinfo()");
-      }
-    }
-
-    /* some systems have ifr_addr.sa_len and adjust the length that
-     * way, but not mine. weird */
-#ifndef linux
-    len=IFNAMSIZ + ifreq->ifr_addr.sa_len;
-#else
-    len=sizeof *ifreq;
-#endif
-    ifreq=(struct ifreq*)((char*)ifreq+len);
-    i+=len;
-  }
-#endif
-  return interfaces;
-}
-
-std::string kiwix::getBestPublicIp() {
-  std::map<std::string, std::string> interfaces = kiwix::getNetworkInterfaces();
-
-#ifndef _WIN32
-  const char* const prioritizedNames[] =
-      { "eth0", "eth1", "wlan0", "wlan1", "en0", "en1" };
-  const int count = (sizeof prioritizedNames) / (sizeof prioritizedNames[0]);
-  for (int i = 0; i < count; ++i) {
-    std::map<std::string, std::string>::const_iterator it =
-        interfaces.find(prioritizedNames[i]);
-    if (it != interfaces.end())
-      return it->second;
-  }
-#endif
-
-  for (std::map<std::string, std::string>::iterator iter = interfaces.begin();
-      iter != interfaces.end(); ++iter) {
-    std::string interfaceIp = iter->second;
-    if (interfaceIp.length() >= 7 && interfaceIp.substr(0, 7) == "192.168")
-      return interfaceIp;
-  }
-
-  for (std::map<std::string, std::string>::iterator iter = interfaces.begin();
-      iter != interfaces.end(); ++iter) {
-    std::string interfaceIp = iter->second;
-    if (interfaceIp.length() >= 7 && interfaceIp.substr(0, 7) == "172.16.")
-      return interfaceIp;
-  }
-
-  for (std::map<std::string, std::string>::iterator iter = interfaces.begin();
-      iter != interfaces.end(); ++iter) {
-    std::string interfaceIp = iter->second;
-    if (interfaceIp.length() >= 3 && interfaceIp.substr(0, 3) == "10.")
-      return interfaceIp;
-  }
-
-  return "127.0.0.1";
-}

src/common/pathTools.cpp

@@ -1,252 +0,0 @@
-/*
- * Copyright 2011-2014 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#include <common/pathTools.h>
-
-#ifdef __APPLE__
-#include <mach-o/dyld.h>
-#include <limits.h>
-#elif _WIN32
-#include <windows.h>
-#include "shlwapi.h"
-#include <direct.h>
-#define getcwd _getcwd // stupid MSFT "deprecation" warning
-#endif
-
-#ifdef _WIN32
-#else
-#include <unistd.h>
-#endif
-
-#ifdef _WIN32
-#define SEPARATOR "\\"
-#else
-#define SEPARATOR "/"
-#include <unistd.h>
-#endif
-
-#include <stdlib.h>
-
-#ifndef PATH_MAX
-#define PATH_MAX 1024
-#endif
-
-bool isRelativePath(const string &path) {
-#ifdef _WIN32
-  return path.empty() || path.substr(1, 2) == ":\\" ? false : true;
-#else
-  return path.empty() || path.substr(0, 1) == "/" ? false : true;
-#endif
-}
-
-string computeRelativePath(const string path, const string absolutePath) {
-  std::vector<std::string> pathParts = kiwix::split(path, SEPARATOR);
-  std::vector<std::string> absolutePathParts = kiwix::split(absolutePath, SEPARATOR);
-
-  unsigned int commonCount = 0;
-  while (commonCount < pathParts.size() && 
-	 commonCount < absolutePathParts.size() && 
-	 pathParts[commonCount] == absolutePathParts[commonCount]) {
-    if (!pathParts[commonCount].empty()) {
-      commonCount++;
-    }
-  }
-  
-  string relativePath;
-#ifdef _WIN32
-  /* On Windows you have a token more because the root is represented
-     by a letter */
-  if (commonCount == 0) {
-    relativePath = "../";
-  }
-#endif
-
-  for (unsigned int i = commonCount ; i < pathParts.size() ; i++) {
-    relativePath += "../";
-  }
-  for (unsigned int i = commonCount ; i < absolutePathParts.size() ; i++) {
-    relativePath += absolutePathParts[i];
-    relativePath += i + 1 < absolutePathParts.size() ? "/" : "";
-  }
-
-  return relativePath;
-}
-
-/* Warning: the relative path must be with slashes */
-string computeAbsolutePath(const string path, const string relativePath) {
-  string absolutePath;
-
-  if (path.empty()) {
-    char *path=NULL;
-    size_t size = 0;
-
-#ifdef _WIN32
-    path = _getcwd(path, size);
-#else
-    path = getcwd(path, size);
-#endif
-
-    absolutePath = string(path) + SEPARATOR;
-  } else {
-    absolutePath = path.substr(path.length() - 1, 1) == SEPARATOR ? path : path + SEPARATOR;
-  }
-
-#if _WIN32
-  char *cRelativePath = _strdup(relativePath.c_str());
-#else
-  char *cRelativePath = strdup(relativePath.c_str());
-#endif
-  char *token = strtok(cRelativePath, "/");
-
-  while (token != NULL) {
-    if (string(token) == "..") {
-      absolutePath = removeLastPathElement(absolutePath, true, false);
-      token = strtok(NULL, "/");
-    } else if (strcmp(token, ".") && strcmp(token, "")) {
-      absolutePath += string(token);
-      token = strtok(NULL, "/");
-      if (token != NULL)
-	absolutePath += SEPARATOR;
-    } else {
-      token = strtok(NULL, "/");
-    }
-  }
-
-  return absolutePath;
-}
-
-string removeLastPathElement(const string path, const bool removePreSeparator, const bool removePostSeparator) {
-  string newPath = path;
-  size_t offset = newPath.find_last_of(SEPARATOR);
-  if (removePreSeparator && 
-#ifndef _WIN32
-      offset != newPath.find_first_of(SEPARATOR) && 
-#endif
-      offset == newPath.length()-1) {
-    newPath = newPath.substr(0, offset);
-    offset = newPath.find_last_of(SEPARATOR);
-  }
-  newPath = removePostSeparator ? newPath.substr(0, offset) : newPath.substr(0, offset+1);
-  return newPath;
-}
-
-string appendToDirectory(const string &directoryPath, const string &filename) {
-  string newPath = directoryPath + SEPARATOR + filename;
-  return newPath;
-}
-
-string getLastPathElement(const string &path) {
-  return path.substr(path.find_last_of(SEPARATOR) + 1);
-}
-
-unsigned int getFileSize(const string &path) {
-#ifdef _WIN32
-  struct _stat filestatus;
-  _stat(path.c_str(), &filestatus);
-#else
-  struct stat filestatus;
-  stat(path.c_str(), &filestatus);
-#endif
-
-  return filestatus.st_size / 1024;
-}
-
-string getFileSizeAsString(const string &path) {
-  ostringstream convert; convert << getFileSize(path);
-  return convert.str();
-}
-
-bool fileExists(const string &path) {
-#ifdef _WIN32
-  return PathFileExists(path.c_str());
-#else
-  bool flag = false;
-  fstream fin;
-  fin.open(path.c_str(), ios::in);
-  if (fin.is_open()) {
-    flag = true;
-  }
-  fin.close();
-  return flag;
-#endif
-}
-
-bool makeDirectory(const string &path) {
-#ifdef _WIN32
-  int status = _mkdir(path.c_str());
-#else
-  int status = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-#endif
-  return status == 0;
-}
-
-/* Try to create a link and if does not work then make a copy */
-bool copyFile(const string &sourcePath, const string &destPath) {
-  try {
-#ifndef _WIN32
-    if (link(sourcePath.c_str(), destPath.c_str()) != 0) {
-#endif
-	std::ifstream infile(sourcePath.c_str(), std::ios_base::binary);
-	std::ofstream outfile(destPath.c_str(), std::ios_base::binary);
-	outfile << infile.rdbuf();
-#ifndef _WIN32
-    }
-#endif
-  } catch (exception &e) {
-    cerr << e.what() << endl;
-    return false;
-  }
-
-  return true;
-}
-
-string getExecutablePath() {
-  char binRootPath[PATH_MAX];
-  
-#ifdef _WIN32
-  GetModuleFileName( NULL, binRootPath, PATH_MAX);
-  return std::string(binRootPath);
-#elif __APPLE__
-  uint32_t max = (uint32_t)PATH_MAX;
-  _NSGetExecutablePath(binRootPath, &max);
-  return std::string(binRootPath);
-#else
-  ssize_t size =  readlink("/proc/self/exe", binRootPath, PATH_MAX);
-  if (size != -1) {
-    return std::string(binRootPath, size);
-  }
-#endif
-
-  return "";
-}
-
-bool writeTextFile(const string &path, const string &content) {
-  std::ofstream file;
-  file.open(path.c_str());
-  file << content;
-  file.close();
-  return true;
-}
-
-string getCurrentDirectory() {
-  char* a_cwd = getcwd(NULL,0);
-  string s_cwd(a_cwd);
-  free(a_cwd);
-  return s_cwd;
-}

src/common/regexTools.cpp

@@ -1,86 +0,0 @@
-/*
- * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#include <common/regexTools.h>
-
-std::map<std::string, RegexMatcher*> regexCache;
-
-RegexMatcher *buildRegex(const std::string &regex) {
-  RegexMatcher *matcher;
-  std::map<std::string, RegexMatcher*>::iterator itr = regexCache.find(regex);
-  
-  /* Regex is in cache */
-  if (itr != regexCache.end()) {
-    matcher = itr->second;
-  }
-
-  /* Regex needs to be parsed (and cached) */
-  else {
-    UErrorCode status = U_ZERO_ERROR;
-    UnicodeString uregex = UnicodeString(regex.c_str());
-    matcher = new RegexMatcher(uregex, UREGEX_CASE_INSENSITIVE, status);
-    regexCache[regex] = matcher;
-  }
-
-  return matcher;
-}
-
-/* todo */
-void freeRegexCache() {
-}
-
-bool matchRegex(const std::string &content, const std::string &regex) {
-  ucnv_setDefaultName("UTF-8");
-  UnicodeString ucontent = UnicodeString(content.c_str());
-  RegexMatcher *matcher = buildRegex(regex);
-  matcher->reset(ucontent);
-  return matcher->find();
-}
-
-std::string replaceRegex(const std::string &content, const std::string &replacement, const std::string &regex) {
-  ucnv_setDefaultName("UTF-8");
-  UnicodeString ucontent = UnicodeString(content.c_str());
-  UnicodeString ureplacement = UnicodeString(replacement.c_str());
-  RegexMatcher *matcher = buildRegex(regex);
-  matcher->reset(ucontent);
-  UErrorCode status = U_ZERO_ERROR;
-  UnicodeString uresult = matcher->replaceAll(ureplacement, status);
-  std::string tmp;
-  uresult.toUTF8String(tmp);
-  return tmp;
-}
-
-std::string appendToFirstOccurence(const std::string &content, const  std::string regex, const std::string &replacement) {
-  ucnv_setDefaultName("UTF-8");
-  UnicodeString ucontent = UnicodeString(content.c_str());
-  UnicodeString ureplacement = UnicodeString(replacement.c_str());
-  RegexMatcher *matcher = buildRegex(regex);
-  matcher->reset(ucontent);
-
-  if (matcher->find()) {
-    UErrorCode status = U_ZERO_ERROR;
-    ucontent.insert(matcher->end(status), ureplacement);   
-    std::string tmp;
-    ucontent.toUTF8String(tmp);
-    return tmp;
-  }
-
-  return content;
-}
-

src/common/stringTools.cpp

@@ -1,272 +0,0 @@
-/*
- * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#include <common/stringTools.h>
-
-/* tell ICU where to find its dat file (tables) */
-void kiwix::loadICUExternalTables() {
-#ifdef __APPLE__
-    std::string executablePath = getExecutablePath();
-    std::string executableDirectory = removeLastPathElement(executablePath);
-    std::string datPath = computeAbsolutePath(executableDirectory, "icudt49l.dat");
-    try {
-        u_setDataDirectory(datPath.c_str());
-    } catch (exception &e) {
-        std::cerr << e.what() << std::endl;
-    }
-#endif
-}
-
-std::string kiwix::removeAccents(const std::string &text) {
-  loadICUExternalTables();
-  ucnv_setDefaultName("UTF-8");
-  UErrorCode status = U_ZERO_ERROR;
-  Transliterator *removeAccentsTrans = Transliterator::createInstance("Lower; NFD; [:M:] remove; NFC", UTRANS_FORWARD, status);
-  UnicodeString ustring = UnicodeString(text.c_str());
-  removeAccentsTrans->transliterate(ustring);
-  delete removeAccentsTrans;
-  std::string unaccentedText;
-  ustring.toUTF8String(unaccentedText);
-  return unaccentedText;
-}
-
-#ifndef __ANDROID__
-
-/* Prepare integer for display */
-std::string kiwix::beautifyInteger(const unsigned int number) {
-  std::stringstream numberStream;
-  numberStream << number;
-  std::string numberString = numberStream.str();
-
-  signed int offset = numberString.size() - 3;
-  while (offset > 0) {
-    numberString.insert(offset, ",");
-    offset -= 3;
-  }
-
-  return numberString;
-}
-
-std::string kiwix::beautifyFileSize(const unsigned int number) {
-  if (number > 1024*1024) {
-    return kiwix::beautifyInteger(number/(1024*1024)) + " GB";
-  } else {
-    return kiwix::beautifyInteger(number/1024 !=
-				  0 ? number/1024 : 1) + " MB";
-  }
-}
-
-void kiwix::printStringInHexadecimal(UnicodeString s) {
-  std::cout << std::showbase << std::hex;
-  for (int i=0; i<s.length(); i++) {
-    char c = (char)((s.getTerminatedBuffer())[i]);
-    if (c & 0x80)
-      std::cout << (c & 0xffff) << " ";
-    else
-      std::cout << c << " ";
-  }
-  std::cout << std::endl;
-}
-
-void kiwix::printStringInHexadecimal(const char *s) {
-  std::cout << std::showbase << std::hex;
-  for (char const* pc = s; *pc; ++pc) {
-    if (*pc & 0x80)
-      std::cout << (*pc & 0xffff);
-    else
-      std::cout << *pc;
-    std::cout << ' ';
-  }
-  std::cout << std::endl;
-}
-
-void kiwix::stringReplacement(std::string& str, const std::string& oldStr, const std::string& newStr) {
-  size_t pos = 0;
-  while((pos = str.find(oldStr, pos)) != std::string::npos) {
-    str.replace(pos, oldStr.length(), newStr);
-    pos += newStr.length();
-  }
-}
-
-/* Encode string to avoid XSS attacks */
-std::string kiwix::encodeDiples(const std::string& str) {
-  std::string result = str;
-  kiwix::stringReplacement(result, "<", "&lt;");
-  kiwix::stringReplacement(result, ">", "&gt;");
-  return result;
-}
-
-// Urlencode
-//based on javascript encodeURIComponent()
-
-std::string char2hex(char dec) {
-  char dig1 = (dec&0xF0)>>4;
-  char dig2 = (dec&0x0F);
-  if ( 0<= dig1 && dig1<= 9) dig1+=48;    //0,48inascii
-  if (10<= dig1 && dig1<=15) dig1+=97-10; //a,97inascii
-  if ( 0<= dig2 && dig2<= 9) dig2+=48;
-  if (10<= dig2 && dig2<=15) dig2+=97-10;
-
-  std::string r;
-  r.append( &dig1, 1);
-  r.append( &dig2, 1);
-  return r;
-}
-
-std::string kiwix::urlEncode(const std::string &c) {
-  std::string escaped="";
-  int max = c.length();
-  for(int i=0; i<max; i++)
-    {
-      if ( (48 <= c[i] && c[i] <= 57) ||//0-9
-	   (65 <= c[i] && c[i] <= 90) ||//abc...xyz
-	   (97 <= c[i] && c[i] <= 122) || //ABC...XYZ
-	   (c[i]=='~' || c[i]=='!' || c[i]=='*' || c[i]=='(' || c[i]==')' || c[i]=='\'')
-	   )
-        {
-	  escaped.append( &c[i], 1);
-        }
-      else
-        {
-	  escaped.append("%");
-	  escaped.append( char2hex(c[i]) );//converts char 255 to string "ff"
-        }
-    }
-  return escaped;
-}
-
-#endif
-
-static char charFromHex(std::string a) {
-  std::istringstream Blat(a);
-  int Z;
-  Blat >> std::hex >> Z;
-  return char (Z);
-}
-
-std::string kiwix::urlDecode(const std::string &originalUrl) {
-  std::string url = originalUrl;
-  std::string::size_type pos = 0;
-  while ((pos = url.find('%', pos)) != std::string::npos &&
-	 pos + 2 < url.length()) {
-    url.replace(pos, 3, 1, charFromHex(url.substr(pos + 1, 2)));
-    ++pos;
-  }
-  return url;
-}
-
-/* Split string in a token array */
-std::vector<std::string> kiwix::split(const std::string & str,
-                                      const std::string & delims=" *-")
-{
-  std::string::size_type lastPos = str.find_first_not_of(delims, 0);
-  std::string::size_type pos = str.find_first_of(delims, lastPos);
-  std::vector<std::string> tokens;
-
-  while (std::string::npos != pos || std::string::npos != lastPos)
-    {
-      tokens.push_back(str.substr(lastPos, pos - lastPos));
-      lastPos = str.find_first_not_of(delims, pos);
-      pos     = str.find_first_of(delims, lastPos);
-    }
-
-  return tokens;
-}
-
-std::vector<std::string> kiwix::split(const char* lhs, const char* rhs){
-  const std::string m1 (lhs), m2 (rhs);
-  return split(m1, m2);
-}
-
-std::vector<std::string> kiwix::split(const char* lhs, const std::string& rhs){
-  return split(lhs, rhs.c_str());
-}
-
-std::vector<std::string> kiwix::split(const std::string& lhs, const char* rhs){
-  return split(lhs.c_str(), rhs);
-}
-
-std::string kiwix::ucFirst (const std::string &word) {
-  if (word.empty())
-    return "";
-
-  std::string result;
-
-  UnicodeString unicodeWord(word.c_str());
-  UnicodeString unicodeFirstLetter = UnicodeString(unicodeWord, 0, 1).toUpper();
-  unicodeWord.replace(0, 1, unicodeFirstLetter);
-  unicodeWord.toUTF8String(result);
-
-  return result;
-}
-
-std::string kiwix::ucAll (const std::string &word) {
-  if (word.empty())
-    return "";
-
-  std::string result;
-
-  UnicodeString unicodeWord(word.c_str());
-  unicodeWord.toUpper().toUTF8String(result);
-
-  return result;
-}
-
-std::string kiwix::lcFirst (const std::string &word) {
-  if (word.empty())
-    return "";
-
-  std::string result;
-
-  UnicodeString unicodeWord(word.c_str());
-  UnicodeString unicodeFirstLetter = UnicodeString(unicodeWord, 0, 1).toLower();
-  unicodeWord.replace(0, 1, unicodeFirstLetter);
-  unicodeWord.toUTF8String(result);
-
-  return result;
-}
-
-std::string kiwix::lcAll (const std::string &word) {
-  if (word.empty())
-    return "";
-
-  std::string result;
-
-  UnicodeString unicodeWord(word.c_str());
-  unicodeWord.toLower().toUTF8String(result);
-
-  return result;
-}
-
-std::string kiwix::toTitle (const std::string &word) {
-  if (word.empty())
-    return "";
-
-  std::string result;
-
-  UnicodeString unicodeWord(word.c_str());
-  unicodeWord = unicodeWord.toTitle(0);
-  unicodeWord.toUTF8String(result);
-
-  return result;
-}
-
-std::string kiwix::normalize (const std::string &word) {
-  return kiwix::lcAll(word);
-}

src/config.h.in

@@ -1,4 +1,3 @@
 
 #mesondefine VERSION
 
-#mesondefine ENABLE_CTPP2

src/ctpp2/CTPP2VMStringLoader.cpp

@@ -1,210 +0,0 @@
-/*
- * Copyright 2013 Renaud Gaudin <reg@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#include <ctpp2/CTPP2VMStringLoader.hpp>
-
-namespace CTPP // C++ Template Engine
-{
-
-//
-// Convert byte order
-//
-static void ConvertExecutable(VMExecutable * oCore)
-{
-	// Code entry point
-	oCore -> entry_point = Swap32(oCore -> entry_point);
-	// Offset of code segment
-	oCore -> code_offset = Swap32(oCore -> code_offset);
-
-	// Code segment size
-	oCore -> code_size   = Swap32(oCore -> code_size);
-
-	// Offset of static text segment
-	oCore -> syscalls_offset    = Swap32(oCore -> syscalls_offset);
-	// Static text segment size
-	oCore -> syscalls_data_size = Swap32(oCore -> syscalls_data_size);
-
-	// Offset of static text index segment
-	oCore -> syscalls_index_offset = Swap32(oCore -> syscalls_index_offset);
-	// Static text index segment size
-	oCore -> syscalls_index_size   = Swap32(oCore -> syscalls_index_size);
-
-	// Offset of static data segment
-	oCore -> static_data_offset    = Swap32(oCore -> static_data_offset);
-
-	// Static data segment size
-	oCore -> static_data_data_size = Swap32(oCore -> static_data_data_size);
-
-	// Offset of static text segment
-	oCore -> static_text_offset    = Swap32(oCore -> static_text_offset);
-	// Static text segment size
-	oCore -> static_text_data_size = Swap32(oCore -> static_text_data_size);
-
-	// Offset of static text index segment
-	oCore -> static_text_index_offset = Swap32(oCore -> static_text_index_offset);
-	// Static text index segment size
-	oCore -> static_text_index_size   = Swap32(oCore -> static_text_index_size);
-
-	// Version 2.2+
-	// Offset of static data bit index
-	oCore -> static_data_bit_index_offset = Swap32(oCore -> static_data_bit_index_offset);
-	/// Offset of static data bit index
-	oCore -> static_data_bit_index_size = Swap32(oCore -> static_data_bit_index_size);
-
-	// Platform
-	oCore -> platform      = Swap64(oCore -> platform);
-
-	// Ugly-jolly hack!
-	// ... dereferencing type-punned pointer will break strict-aliasing rules ...
-	UINT_64 iTMP;
-	memcpy(&iTMP, &(oCore -> ieee754double), sizeof(UINT_64));
-	iTMP = Swap64(iTMP);
-	memcpy(&(oCore -> ieee754double), &iTMP, sizeof(UINT_64));
-
-	// Cyclic Redundancy Check
-	oCore -> crc = 0;
-
-	// Convert data structures
-
-	// Convert code segment
-	VMInstruction * pInstructions = const_cast<VMInstruction *>(VMExecutable::GetCodeSeg(oCore));
-	UINT_32 iI = 0;
-	UINT_32 iSteps = oCore -> code_size / sizeof(VMInstruction);
-	for(iI = 0; iI < iSteps; ++iI)
-	{
-		pInstructions -> instruction = Swap32(pInstructions -> instruction);
-		pInstructions -> argument    = Swap32(pInstructions -> argument);
-		pInstructions -> reserved    = Swap64(pInstructions -> reserved);
-		++pInstructions;
-	}
-
-	// Convert syscalls index
-	TextDataIndex * pTextIndex = const_cast<TextDataIndex *>(VMExecutable::GetSyscallsIndexSeg(oCore));
-	iSteps = oCore -> syscalls_index_size / sizeof(TextDataIndex);
-	for(iI = 0; iI < iSteps; ++iI)
-	{
-		pTextIndex -> offset = Swap32(pTextIndex -> offset);
-		pTextIndex -> length = Swap32(pTextIndex -> length);
-		++pTextIndex;
-	}
-
-	// Convert static text index
-	pTextIndex = const_cast<TextDataIndex *>(VMExecutable::GetStaticTextIndexSeg(oCore));
-	iSteps = oCore -> static_text_index_size / sizeof(TextDataIndex);
-	for(iI = 0; iI < iSteps; ++iI)
-	{
-		pTextIndex -> offset = Swap32(pTextIndex -> offset);
-		pTextIndex -> length = Swap32(pTextIndex -> length);
-		++pTextIndex;
-	}
-
-	// Convert static data
-	StaticDataVar * pStaticDataVar = const_cast<StaticDataVar *>(VMExecutable::GetStaticDataSeg(oCore));
-	iSteps = oCore -> static_data_data_size / sizeof(StaticDataVar);
-	for(iI = 0; iI < iSteps; ++iI)
-	{
-		(*pStaticDataVar).i_data = Swap64((*pStaticDataVar).i_data);
-		++pStaticDataVar;
-	}
-}
-
-//
-// Constructor
-//
-VMStringLoader::VMStringLoader(CCHAR_P rawContent, size_t rawContentSize)
-{
-    oCore = (VMExecutable *)malloc(rawContentSize + 1);
-    memcpy(oCore, rawContent, rawContentSize);
-
-	if (oCore -> magic[0] == 'C' &&
-	    oCore -> magic[1] == 'T' &&
-	    oCore -> magic[2] == 'P' &&
-	    oCore -> magic[3] == 'P')
-	{
-		// Check version
-		if (oCore -> version[0] >= 1)
-		{
-			// Platform-dependent data (byte order)
-			if (oCore -> platform == 0x4142434445464748ull)
-			{
-#ifdef _DEBUG
-				fprintf(stderr, "Big/Little Endian conversion: Nothing to do\n");
-#endif
-
-				// Nothing to do, only check crc
-				UINT_32 iCRC = oCore -> crc;
-				oCore -> crc = 0;
-
-				// Calculate CRC of file
-                // KELSON: next line used to refer to oStat.st_size
-                // changed it to rawContentSize
-				if (iCRC != crc32((UCCHAR_P)oCore, rawContentSize))
-				{
-					free(oCore);
-					throw CTPPLogicError("CRC checksum invalid");
-				}
-			}
-			// Platform-dependent data (byte order)
-			else if (oCore -> platform == 0x4847464544434241ull)
-			{
-				// Need to reconvert data
-#ifdef _DEBUG
-				fprintf(stderr, "Big/Little Endian conversion: Need to reconvert core\n");
-#endif
-				ConvertExecutable(oCore);
-			}
-			else
-			{
-				free(oCore);
-				throw CTPPLogicError("Conversion of middle-end architecture does not supported.");
-			}
-
-			// Check IEEE 754 format
-			if (oCore -> ieee754double != 15839800103804824402926068484019465486336.0)
-			{
-				free(oCore);
-				throw CTPPLogicError("IEEE 754 format is broken, cannot convert file");
-			}
-		}
-
-		pVMMemoryCore = new VMMemoryCore(oCore);
-	}
-	else
-	{
-		free(oCore);
-		throw CTPPLogicError("Not an CTPP bytecode file.");
-	}
-}
-
-//
-// Get ready-to-run program
-//
-const VMMemoryCore * VMStringLoader::GetCore() const { return pVMMemoryCore; }
-
-//
-// A destructor
-//
-VMStringLoader::~VMStringLoader() throw()
-{
-	delete pVMMemoryCore;
-	free(oCore);
-}
-
-} // namespace CTPP
-// End.

src/downloader.cpp

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "downloader.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
+
+#include <algorithm>
+#include <thread>
+#include <chrono>
+
+#include <iostream>
+
+#include "aria2.h"
+#include "xmlrpc.h"
+#include "tools/otherTools.h"
+#include <pugixml.hpp>
+
+namespace kiwix
+{
+
+void Download::updateStatus(bool follow)
+{
+  if (m_status == Download::K_REMOVED)
+    return;
+  static std::vector<std::string> statusKey = {"status", "files", "totalLength",
+                                               "completedLength", "followedBy",
+                                               "downloadSpeed", "verifiedLength"};
+  std::string strStatus;
+  if(follow && !m_followedBy.empty()) {
+    strStatus = mp_aria->tellStatus(m_followedBy, statusKey);
+  } else {
+    strStatus = mp_aria->tellStatus(m_did, statusKey);
+  }
+//  std::cout << strStatus << std::endl;
+  MethodResponse response(strStatus);
+  if (response.isFault()) {
+    m_status = Download::K_UNKNOWN;
+    return;
+  }
+  auto structNode = response.getParams().getParam(0).getValue().getStruct();
+  auto _status = structNode.getMember("status").getValue().getAsS();
+  auto status = _status == "active" ? Download::K_ACTIVE
+              : _status == "waiting" ? Download::K_WAITING
+              : _status == "paused" ? Download::K_PAUSED
+              : _status == "error" ? Download::K_ERROR
+              : _status == "complete" ? Download::K_COMPLETE
+              : _status == "removed" ? Download::K_REMOVED
+              : Download::K_UNKNOWN;
+  if (status == K_COMPLETE) {
+    try {
+      auto followedByMember = structNode.getMember("followedBy");
+      m_followedBy = followedByMember.getValue().getArray().getValue(0).getAsS();
+      if (follow) {
+        status = K_ACTIVE;
+        updateStatus(true);
+        return;
+      }
+    } catch (InvalidRPCNode& e) { }
+  }
+  m_status = status;
+  m_totalLength = extractFromString<uint64_t>(structNode.getMember("totalLength").getValue().getAsS());
+  m_completedLength = extractFromString<uint64_t>(structNode.getMember("completedLength").getValue().getAsS());
+  m_downloadSpeed = extractFromString<uint64_t>(structNode.getMember("downloadSpeed").getValue().getAsS());
+  try {
+    auto verifiedLengthValue = structNode.getMember("verifiedLength").getValue();
+    m_verifiedLength = extractFromString<uint64_t>(verifiedLengthValue.getAsS());
+  } catch (InvalidRPCNode& e) { m_verifiedLength = 0; }
+  auto filesMember = structNode.getMember("files");
+  auto fileStruct = filesMember.getValue().getArray().getValue(0).getStruct();
+  m_path = fileStruct.getMember("path").getValue().getAsS();
+  auto urisArray = fileStruct.getMember("uris").getValue().getArray();
+  int index = 0;
+  m_uris.clear();
+  while(true) {
+    try {
+      auto uriNode = urisArray.getValue(index++).getStruct().getMember("uri");
+      m_uris.push_back(uriNode.getValue().getAsS());
+    } catch(InvalidRPCNode& e) { break; }
+  }
+}
+
+void Download::resumeDownload()
+{
+    if (!m_followedBy.empty())
+        mp_aria->unpause(m_followedBy);
+    else
+        mp_aria->unpause(m_did);
+    updateStatus(true);
+}
+
+void Download::pauseDownload()
+{
+    if (!m_followedBy.empty())
+        mp_aria->pause(m_followedBy);
+    else
+        mp_aria->pause(m_did);
+    updateStatus(true);
+}
+
+void Download::cancelDownload()
+{
+    if (!m_followedBy.empty())
+        mp_aria->remove(m_followedBy);
+    else
+        mp_aria->remove(m_did);
+    m_status = Download::K_REMOVED;
+}
+
+/* Constructor */
+Downloader::Downloader() :
+  mp_aria(new Aria2())
+{
+  for (auto gid : mp_aria->tellActive()) {
+    m_knownDownloads[gid] = std::unique_ptr<Download>(new Download(mp_aria, gid));
+    m_knownDownloads[gid]->updateStatus();
+  }
+  for (auto gid : mp_aria->tellWaiting()) {
+    m_knownDownloads[gid] = std::unique_ptr<Download>(new Download(mp_aria, gid));
+    m_knownDownloads[gid]->updateStatus();
+  }
+}
+
+
+/* Destructor */
+Downloader::~Downloader()
+{
+}
+
+void Downloader::close()
+{
+  mp_aria->close();
+}
+
+std::vector<std::string> Downloader::getDownloadIds() {
+  std::vector<std::string> ret;
+  for(auto& p:m_knownDownloads) {
+    ret.push_back(p.first);
+  }
+  return ret;
+}
+
+Download* Downloader::startDownload(const std::string& uri)
+{
+  for (auto& p: m_knownDownloads) {
+    auto& d = p.second;
+    auto& uris = d->getUris();
+    if (std::find(uris.begin(), uris.end(), uri) != uris.end())
+      return d.get();
+  }
+  std::vector<std::string> uris = {uri};
+  auto gid = mp_aria->addUri(uris);
+  m_knownDownloads[gid] = std::unique_ptr<Download>(new Download(mp_aria, gid));
+  return m_knownDownloads[gid].get();
+}
+
+Download* Downloader::getDownload(const std::string& did)
+{
+  try {
+    m_knownDownloads.at(did).get()->updateStatus(true);
+    return m_knownDownloads.at(did).get();
+  } catch(std::exception& e) {
+    for (auto gid : mp_aria->tellActive()) {
+      if (gid == did) {
+        m_knownDownloads[gid] = std::unique_ptr<Download>(new Download(mp_aria, gid));
+        m_knownDownloads.at(gid).get()->updateStatus(true);
+        return m_knownDownloads[gid].get();
+      }
+    }
+    for (auto gid : mp_aria->tellWaiting()) {
+      if (gid == did) {
+        m_knownDownloads[gid] = std::unique_ptr<Download>(new Download(mp_aria, gid));
+        m_knownDownloads.at(gid).get()->updateStatus(true);
+        return m_knownDownloads[gid].get();
+      }
+  }
+    throw e;
+  }
+}
+
+}

src/entry.cpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "reader.h"
+#include <time.h>
+
+#include <zim/search.h>
+
+namespace kiwix
+{
+
+Entry::Entry(zim::Article article)
+  : article(article)
+{
+}
+
+#define RETURN_IF_INVALID(WHAT) if(!good()) { return (WHAT); }
+
+std::string Entry::getPath() const
+{
+  RETURN_IF_INVALID("");
+  return article.getLongUrl();
+}
+
+std::string Entry::getTitle() const
+{
+  RETURN_IF_INVALID("");
+  return article.getTitle();
+}
+
+std::string Entry::getContent() const
+{
+  RETURN_IF_INVALID("");
+  return article.getData();
+}
+
+zim::Blob Entry::getBlob(offset_type offset) const
+{
+  RETURN_IF_INVALID(zim::Blob());
+  return article.getData(offset);
+}
+
+zim::Blob Entry::getBlob(offset_type offset, size_type size) const
+{
+  RETURN_IF_INVALID(zim::Blob());
+  return article.getData(offset, size);
+}
+
+std::pair<std::string, offset_type> Entry::getDirectAccessInfo() const
+{
+  RETURN_IF_INVALID(std::make_pair("", 0));
+  return article.getDirectAccessInformation();
+}
+
+size_type Entry::getSize() const
+{
+  RETURN_IF_INVALID(0);
+  return article.getArticleSize();
+}
+
+std::string Entry::getMimetype() const
+{
+  RETURN_IF_INVALID("");
+  try {
+    return article.getMimeType();
+  } catch (exception& e) {
+    return "application/octet-stream";
+  }
+}
+
+bool Entry::isRedirect() const
+{
+  RETURN_IF_INVALID(false);
+  return article.isRedirect();
+}
+
+bool Entry::isLinkTarget() const
+{
+  RETURN_IF_INVALID(false);
+  return article.isLinktarget();
+}
+
+bool Entry::isDeleted() const
+{
+  RETURN_IF_INVALID(false);
+  return article.isDeleted();
+}
+
+Entry Entry::getRedirectEntry() const
+{
+  RETURN_IF_INVALID(Entry());
+  if ( !article.isRedirect() ) {
+    throw NoEntry();
+  }
+
+  auto targeted_article = article.getRedirectArticle();
+  if ( !targeted_article.good()) {
+    throw NoEntry();
+  }
+  return targeted_article;
+}
+
+Entry Entry::getFinalEntry() const
+{
+  RETURN_IF_INVALID(Entry());
+  if (final_article.good()) {
+    return final_article;
+  }
+  int loopCounter = 42;
+  final_article = article;
+  while (final_article.isRedirect() && loopCounter--) {
+    final_article = final_article.getRedirectArticle();
+    if ( !final_article.good()) {
+      throw NoEntry();
+    }
+  }
+  // Prevent infinite loops.
+  if (final_article.isRedirect()) {
+    throw NoEntry();
+  }
+  return final_article;
+}
+
+}

src/indexer.cpp

@@ -1,528 +0,0 @@
-/*
- * Copyright 2011-2014 Emmanuel Engelhart <kelson@kiwix.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU  General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- */
-
-#include "indexer.h"
-#include "xapian/myhtmlparse.h"
-#include "kiwixlib-resources.h"
-
-namespace kiwix {
-
-  /* Count word */
-  unsigned int Indexer::countWords(const string &text) {
-    unsigned int numWords = 1;
-    unsigned int length = text.size();
-
-    for(unsigned int i=0; i<length;) {
-      while(i<length && text[i] != ' ') {
-	i++;
-      }
-      numWords++;
-      i++;
-    }
-
-    return numWords;
-  }
-  
-  /* Constructor */
-  Indexer::Indexer() :
-    keywordsBoostFactor(3),
-    verboseFlag(false) {
-
-    /* Initialize mutex */
-    pthread_mutex_init(&threadIdsMutex, NULL);
-    pthread_mutex_init(&toParseQueueMutex, NULL);
-    pthread_mutex_init(&toIndexQueueMutex, NULL);
-    pthread_mutex_init(&articleExtractorRunningMutex, NULL);
-    pthread_mutex_init(&articleParserRunningMutex, NULL);
-    pthread_mutex_init(&articleIndexerRunningMutex, NULL);
-    pthread_mutex_init(&articleCountMutex, NULL);
-    pthread_mutex_init(&zimPathMutex, NULL);
-    pthread_mutex_init(&zimIdMutex, NULL);
-    pthread_mutex_init(&indexPathMutex, NULL);
-    pthread_mutex_init(&progressionMutex, NULL);
-    pthread_mutex_init(&verboseMutex, NULL);
-  }
-
-  /* Destructor */
-  Indexer::~Indexer() {
-  }
-
-  /* Read the stopwords */
-  void Indexer::readStopWords(const string languageCode) {
-    std::string stopWord;
-    std::istringstream file(getResource("stopwords/" + languageCode));
-
-    this->stopWords.clear();
-
-    while (getline(file, stopWord, '\n')) {
-      this->stopWords.push_back(stopWord);
-    }
-    
-    if (this->verboseFlag) {
-      std::cout << "Read stop words, lang code:" << languageCode << ", count:" << this->stopWords.size() << std::endl;
-    }
-  }
-  
-#pragma mark - Extractor
-  
-  /* Article extractor methods */
-  void *Indexer::extractArticles(void *ptr) {
-    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
-    kiwix::Indexer *self = (kiwix::Indexer *)ptr;
-
-    /* Get the number of article to index and the ZIM id */
-    kiwix::Reader reader(self->getZimPath());
-    unsigned int articleCount = reader.getArticleCount();
-    self->setArticleCount(articleCount);
-    string zimId = reader.getId();
-    self->setZimId(zimId);
-
-    /* Progression */
-    unsigned int readArticleCount = 0;
-    unsigned int currentProgression = 0;
-    self->setProgression(currentProgression);
-    unsigned int newProgress;
-
-    /* StopWords */
-    self->readStopWords(reader.getLanguage());
-
-    /* Goes trough all articles */
-    zim::File *zimHandler = reader.getZimFileHandler();
-    unsigned int currentOffset = zimHandler->getNamespaceBeginOffset('A');
-    unsigned int lastOffset = zimHandler->getNamespaceEndOffset('A');
-    zim::Article currentArticle;
-
-    while (currentOffset < lastOffset) {
-      currentArticle = zimHandler->getArticle(currentOffset);
-      
-      if (!currentArticle.isRedirect()) {
-        /* Add articles to the queue */
-        indexerToken token;
-        token.title = currentArticle.getTitle();
-        token.url = currentArticle.getLongUrl();
-        token.content = string(currentArticle.getData().data(), currentArticle.getData().size());
-        self->pushToParseQueue(token);
-        readArticleCount += 1;
-        
-        /* Update progress */
-        if (self->progressCallback) {
-            self->progressCallback(readArticleCount, articleCount);
-        }
-        newProgress = (unsigned int)((float)readArticleCount / (float)articleCount * 100);
-        if (newProgress != currentProgression) {
-          self->setProgression(newProgress);
-        }
-      }
-        
-      currentOffset += 1;
-
-      /* Test if the thread should be cancelled */
-      pthread_testcancel();
-    } 
-
-    self->articleExtractorRunning(false);
-    pthread_exit(NULL);
-    return NULL;
-  }
-  
-  void Indexer::articleExtractorRunning(bool value) {
-    pthread_mutex_lock(&articleExtractorRunningMutex);
-    this->articleExtractorRunningFlag = value;
-    pthread_mutex_unlock(&articleExtractorRunningMutex); 
-  }
-  
-  bool Indexer::isArticleExtractorRunning() {
-    pthread_mutex_lock(&articleExtractorRunningMutex);
-    bool retVal = this->articleExtractorRunningFlag;
-    pthread_mutex_unlock(&articleExtractorRunningMutex); 
-    return retVal;
-  }
-  
-#pragma mark - Parser
-  
-  /* Article parser methods */
-  void *Indexer::parseArticles(void *ptr) {
-    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
-    kiwix::Indexer *self = (kiwix::Indexer *)ptr;
-    size_t found;
-    indexerToken token;
-
-    while (self->popFromToParseQueue(token)) {
-      MyHtmlParser htmlParser;
-
-      /* The parser generate a lot of exceptions which should be avoided */
-      try {
-	htmlParser.parse_html(token.content, "UTF-8", true);
-      } catch (...) {
-      }
-
-      /* If content does not have the noindex meta tag */
-      /* Seems that the parser generates an exception in such case */
-      found = htmlParser.dump.find("NOINDEX");
-      
-      if (found == string::npos) {
-	/* Get the accented title */
-	token.accentedTitle = (htmlParser.title.empty() ? token.title : htmlParser.title);
-
-	/* count words */
-	stringstream countWordStringStream;
-	countWordStringStream << self->countWords(htmlParser.dump);
-	token.wordCount = countWordStringStream.str();
-	
-	/* snippet */
-	std::string snippet = std::string(htmlParser.dump, 0, 300);
-	std::string::size_type last = snippet.find_last_of('.');
-	if (last == snippet.npos)
-	  last = snippet.find_last_of(' ');
-	if (last != snippet.npos)
-	  snippet = snippet.substr(0, last);
-	token.snippet = snippet;
-
-	/* size */
-	stringstream sizeStringStream;
-	sizeStringStream << token.content.size() / 1024;
-	token.size = sizeStringStream.str();
-
-	/* Remove accent */
-	token.title = kiwix::removeAccents(token.accentedTitle);
-	token.keywords = kiwix::removeAccents(htmlParser.keywords);
-	token.content = kiwix::removeAccents(htmlParser.dump);
-	self->pushToIndexQueue(token);
-      }
-
-      /* Test if the thread should be cancelled */
-      pthread_testcancel(); 
-    }
-    
-    self->articleParserRunning(false);
-    pthread_exit(NULL);
-    return NULL;
-  }
-
-  void Indexer::articleParserRunning(bool value) {
-    pthread_mutex_lock(&articleParserRunningMutex);
-    this->articleParserRunningFlag = value;
-    pthread_mutex_unlock(&articleParserRunningMutex); 
-  }
-  
-  bool Indexer::isArticleParserRunning() {
-    pthread_mutex_lock(&articleParserRunningMutex);
-    bool retVal = this->articleParserRunningFlag;
-    pthread_mutex_unlock(&articleParserRunningMutex); 
-    return retVal;
-  }
-  
-#pragma mark - Indexer
-
-  /* Article indexer methods */
-  void *Indexer::indexArticles(void *ptr) {
-    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
-    kiwix::Indexer *self = (kiwix::Indexer *)ptr;
-    unsigned int indexedArticleCount = 0;
-    indexerToken token;
-
-    self->indexingPrelude(self->getIndexPath()); 
-
-    while (self->popFromToIndexQueue(token)) {
-      self->index(token.url, 
-		  token.accentedTitle,
-		  token.title, 
-		  token.keywords,
-		  token.content,
-		  token.snippet,
-		  token.size,
-		  token.wordCount
-		  );
-
-      indexedArticleCount += 1;
-
-      /* Make a hard-disk flush every 10.000 articles */
-      if (indexedArticleCount % 5000 == 0) {
-	self->flush();
-      }
-
-      /* Test if the thread should be cancelled */
-      pthread_testcancel();
-    }
-    self->indexingPostlude(self->getIndexPath());
-
-    /* Write content id file */
-    string path = appendToDirectory(self->getIndexPath(), "content.id");
-    writeTextFile(path, self->getZimId());
-
-    self->setProgression(100);
-    kiwix::sleep(100);
-
-    self->articleIndexerRunning(false);
-    pthread_exit(NULL);
-    return NULL;
-  }
-
-  void Indexer::articleIndexerRunning(bool value) {
-    pthread_mutex_lock(&articleIndexerRunningMutex);
-    this->articleIndexerRunningFlag = value;
-    pthread_mutex_unlock(&articleIndexerRunningMutex); 
-  }
-  
-  bool Indexer::isArticleIndexerRunning() {
-    pthread_mutex_lock(&articleIndexerRunningMutex);
-    bool retVal = this->articleIndexerRunningFlag;
-    pthread_mutex_unlock(&articleIndexerRunningMutex); 
-    return retVal;
-  }
-  
-#pragma mark - Parse Queue
-
-  /* ToParseQueue methods */
-  bool Indexer::isToParseQueueEmpty() {
-    pthread_mutex_lock(&toParseQueueMutex);
-    bool retVal = this->toParseQueue.empty();
-    pthread_mutex_unlock(&toParseQueueMutex);
-    return retVal;
-  }
-
-  void Indexer::pushToParseQueue(indexerToken &token) {
-    pthread_mutex_lock(&toParseQueueMutex); 
-    this->toParseQueue.push(token);
-    pthread_mutex_unlock(&toParseQueueMutex); 
-    kiwix::sleep(int(this->toParseQueue.size() / 200) / 10 * 1000);
-  }
-
-  bool Indexer::popFromToParseQueue(indexerToken &token) {
-    while (this->isToParseQueueEmpty() && this->isArticleExtractorRunning()) {
-      kiwix::sleep(500);
-      if (this->getVerboseFlag()) {
-	std::cout << "Waiting... ToParseQueue is empty for now..." << std::endl;
-      }
-
-      pthread_testcancel();
-    }
-
-    if (!this->isToParseQueueEmpty()) {
-      pthread_mutex_lock(&toParseQueueMutex); 
-      token = this->toParseQueue.front();
-      this->toParseQueue.pop();
-      pthread_mutex_unlock(&toParseQueueMutex); 
-    } else {
-      return false;
-    }
-
-    return true;
-  }
-  
-#pragma mark - Index Queue
-
-  /* ToIndexQueue methods */
-  bool Indexer::isToIndexQueueEmpty() {
-    pthread_mutex_lock(&toIndexQueueMutex);
-    bool retVal = this->toIndexQueue.empty();
-    pthread_mutex_unlock(&toIndexQueueMutex);
-    return retVal;
-  }
-
-  void Indexer::pushToIndexQueue(indexerToken &token) {
-    pthread_mutex_lock(&toIndexQueueMutex); 
-    this->toIndexQueue.push(token);
-    pthread_mutex_unlock(&toIndexQueueMutex);
-    kiwix::sleep(int(this->toIndexQueue.size() / 200) / 10 * 1000);
-  }
-
-  bool Indexer::popFromToIndexQueue(indexerToken &token) {
-    while (this->isToIndexQueueEmpty() && this->isArticleParserRunning()) {
-      kiwix::sleep(500);
-      if (this->getVerboseFlag()) {
-	std::cout << "Waiting... ToIndexQueue is empty for now..." << std::endl;
-      }
-
-      pthread_testcancel();
-    }
-
-    if (!this->isToIndexQueueEmpty()) {
-      pthread_mutex_lock(&toIndexQueueMutex); 
-      token = this->toIndexQueue.front();
-      this->toIndexQueue.pop();
-      pthread_mutex_unlock(&toIndexQueueMutex); 
-    } else {
-      return false;
-    }
-
-    return true;
-  }
-  
-#pragma mark - Properties Getter & Setter
-
-  /* ZIM & Index methods */
-  void Indexer::setZimPath(const string path) {
-    pthread_mutex_lock(&zimPathMutex);
-    this->zimPath = path;
-    pthread_mutex_unlock(&zimPathMutex); 
-  }
-
-  string Indexer::getZimPath() {
-    pthread_mutex_lock(&zimPathMutex); 
-    string retVal = this->zimPath;
-    pthread_mutex_unlock(&zimPathMutex);
-    return retVal;
-  }
-
-  void Indexer::setIndexPath(const string path) {
-    pthread_mutex_lock(&indexPathMutex); 
-    this->indexPath = path;
-    pthread_mutex_unlock(&indexPathMutex); 
-  }
-
-  string Indexer::getIndexPath() {
-    pthread_mutex_lock(&indexPathMutex); 
-    string retVal = this->indexPath;
-    pthread_mutex_unlock(&indexPathMutex);
-    return retVal;
-  }
-
-  void Indexer::setArticleCount(const unsigned int articleCount) {
-    pthread_mutex_lock(&articleCountMutex);
-    this->articleCount = articleCount;
-    pthread_mutex_unlock(&articleCountMutex); 
-  }
-
-  unsigned int Indexer::getArticleCount() {
-    pthread_mutex_lock(&articleCountMutex);
-    unsigned int retVal = this->articleCount;
-    pthread_mutex_unlock(&articleCountMutex);
-    return retVal;
-  }
-
-  void Indexer::setProgression(const unsigned int progression) {
-    pthread_mutex_lock(&progressionMutex); 
-    this->progression = progression;
-    pthread_mutex_unlock(&progressionMutex); 
-  }
-
-  unsigned int Indexer::getProgression() {
-    pthread_mutex_lock(&progressionMutex); 
-    unsigned int retVal = this->progression;
-    pthread_mutex_unlock(&progressionMutex); 
-    return retVal;
-  }
-
-  void Indexer::setZimId(const string id) {
-    pthread_mutex_lock(&zimIdMutex);
-    this->zimId = id;
-    pthread_mutex_unlock(&zimIdMutex); 
-  }
-
-  string Indexer::getZimId() {
-    pthread_mutex_lock(&zimIdMutex); 
-    string retVal = this->zimId;
-    pthread_mutex_unlock(&zimIdMutex);
-    return retVal;
-  }
-  
-#pragma mark - Status Management
-
-  /* Manage */
-  bool Indexer::start(const string zimPath, const string indexPath, ProgressCallback callback) {
-    if (this->getVerboseFlag()) {
-      std::cout << "Indexing of '" << zimPath << "' starting..." <<std::endl;
-    }
-    
-    if (callback) {
-        this->progressCallback = callback;
-    }
-
-    this->setArticleCount(0);
-    this->setProgression(0);
-    this->setZimPath(zimPath);
-    this->setIndexPath(indexPath);
-
-    pthread_mutex_lock(&threadIdsMutex); 
-    this->articleExtractorRunning(true);
-    pthread_create(&(this->articleExtractor), NULL, Indexer::extractArticles, (void*)this);
-    pthread_detach(this->articleExtractor);
-
-    while(this->isArticleExtractorRunning() && this->getArticleCount() == 0) {
-      kiwix::sleep(100);
-    }
-    
-    this->articleParserRunning(true);
-    pthread_create(&(this->articleParser), NULL, Indexer::parseArticles, (void*)this);
-    pthread_detach(this->articleParser);
-
-    this->articleIndexerRunning(true);
-    pthread_create(&(this->articleIndexer), NULL, Indexer::indexArticles, (void*)this);
-    pthread_detach(this->articleIndexer);
-    pthread_mutex_unlock(&threadIdsMutex);
-
-    return true;
-  }
-
-  bool Indexer::isRunning() {
-      if (this->getVerboseFlag()) {
-	std::cout << "isArticleExtractor running: " << (this->isArticleExtractorRunning() ? "yes" : "no") << std::endl;
-	std::cout << "isArticleParser running: " << (this->isArticleParserRunning() ? "yes" : "no") << std::endl;
-	std::cout << "isArticleIndexer running: " << (this->isArticleIndexerRunning() ? "yes" : "no") << std::endl;
-      }
-
-    return this->isArticleExtractorRunning() || this->isArticleIndexerRunning() || this->isArticleParserRunning();
-  }
-
-  bool Indexer::stop() {
-    if (this->isRunning()) {
-      bool isArticleExtractorRunning = this->isArticleExtractorRunning();
-      bool isArticleIndexerRunning = this->isArticleIndexerRunning();
-      bool isArticleParserRunning = this->isArticleParserRunning();
-      
-      pthread_mutex_lock(&threadIdsMutex); 
-      
-      if (isArticleIndexerRunning) {
-	pthread_cancel(this->articleIndexer);
-	this->articleIndexerRunning(false);
-      }
-      if (isArticleParserRunning) {
-	pthread_cancel(this->articleParser);
-	this->articleParserRunning(false);
-      }
-      if (isArticleExtractorRunning) {
-	pthread_cancel(this->articleExtractor);
-	this->articleExtractorRunning(false);
-      }
-
-      pthread_mutex_unlock(&threadIdsMutex); 
-    }
-
-    return true;
-  }
-  
-#pragma mark - verbose
-
-  /* Manage the verboseFlag */
-  void Indexer::setVerboseFlag(const bool value) {
-    pthread_mutex_lock(&verboseMutex);
-    this->verboseFlag = value;
-    pthread_mutex_unlock(&verboseMutex);
-  }
-
-  bool Indexer::getVerboseFlag() {
-    bool value;
-    pthread_mutex_lock(&verboseMutex);
-    value = this->verboseFlag;
-    pthread_mutex_unlock(&verboseMutex);
-    return value;
-  }
-
-}

src/kiwixserve.cpp

@@ -0,0 +1,71 @@
+#include "kiwixserve.h"
+#include "subprocess.h"
+
+#ifdef _WIN32
+    # define KIWIXSERVE_CMD "kiwix-serve.exe"
+    # include <windows.h>
+#else
+    # define KIWIXSERVE_CMD "kiwix-serve"
+    # include <unistd.h>
+#endif
+
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
+
+namespace kiwix {
+
+KiwixServe::KiwixServe(const std::string& libraryPath, int port)
+  : m_port(port),
+    m_libraryPath(libraryPath)
+{
+}
+
+KiwixServe::~KiwixServe()
+{
+    shutDown();
+}
+
+void KiwixServe::run()
+{
+    #ifdef _WIN32
+        int pid = GetCurrentProcessId();
+    #else
+        pid_t pid = getpid();
+
+    #endif
+
+    std::vector<const char*> callCmd;
+    std::string kiwixServeCmd = appendToDirectory(
+        removeLastPathElement(getExecutablePath(true)),
+        KIWIXSERVE_CMD);
+    if (fileExists(kiwixServeCmd)) {
+        // A local kiwix-serve exe exists (packaged with kiwix-desktop), use it.
+        callCmd.push_back(kiwixServeCmd.c_str());
+    } else {
+        // Try to use a potential installed kiwix-serve.
+        callCmd.push_back(KIWIXSERVE_CMD);
+    }
+    std::string attachProcessOpt = "-a" + to_string(pid);
+    std::string portOpt = "-p" + to_string(m_port);
+    callCmd.push_back(attachProcessOpt.c_str());
+    callCmd.push_back(portOpt.c_str());
+    callCmd.push_back("-l");
+    callCmd.push_back(m_libraryPath.c_str());
+    mp_kiwixServe = Subprocess::run(callCmd);
+}
+
+void KiwixServe::shutDown()
+{
+    if (mp_kiwixServe)
+        mp_kiwixServe->kill();
+}
+
+bool KiwixServe::isRunning()
+{
+    if (mp_kiwixServe) {
+        return (mp_kiwixServe->isRunning());
+    }
+    return false;
+}
+
+}

src/library.cpp

@@ -18,126 +18,497 @@
  */
 
 #include "library.h"
+#include "book.h"
+#include "reader.h"
+#include "libxml_dumper.h"
 
-namespace kiwix {
+#include "tools/base64.h"
+#include "tools/regexTools.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 
-  /* Constructor */
-  Book::Book():
-    readOnly(false) {
-  }
-  
-  /* Destructor */
-  Book::~Book() {
+#include <pugixml.hpp>
+#include <algorithm>
+#include <set>
+
+namespace kiwix
+{
+
+/* Constructor */
+Library::Library()
+{
+}
+/* Destructor */
+Library::~Library()
+{
+}
+
+
+bool Library::addBook(const Book& book)
+{
+  /* Try to find it */
+  try {
+    auto& oldbook = m_books.at(book.getId());
+    oldbook.update(book);
+    return false;
+  } catch (std::out_of_range&) {
+    m_books[book.getId()] = book;
+    return true;
   }
+}
 
-  /* Sort functions */
-  bool Book::sortByLastOpen(const kiwix::Book &a, const kiwix::Book &b) {
-    return atoi(a.last.c_str()) > atoi(b.last.c_str());
-  }
+void Library::addBookmark(const Bookmark& bookmark)
+{
+  m_bookmarks.push_back(bookmark);
+}
 
-  bool Book::sortByTitle(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.title.c_str(), b.title.c_str()) < 0;
-  }
-
-  bool Book::sortByDate(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.date.c_str(), b.date.c_str()) > 0;
-  }
-
-  bool Book::sortBySize(const kiwix::Book &a, const kiwix::Book &b) {
-    return atoi(a.size.c_str()) < atoi(b.size.c_str());
-  }
-
-  bool Book::sortByPublisher(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.publisher.c_str(), b.publisher.c_str()) < 0;
-  }
-
-  bool Book::sortByCreator(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.creator.c_str(), b.creator.c_str()) < 0;
-  }
-
-  bool Book::sortByLanguage(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.language.c_str(), b.language.c_str()) < 0;
-  }
-
-  std::string Book::getHumanReadableIdFromPath() {
-    std::string id = pathAbsolute;
-    if (!id.empty()) {
-      kiwix::removeAccents(id);
-
-#ifdef _WIN32
-      id = replaceRegex(id, "", "^.*\\\\");
-#else
-      id = replaceRegex(id, "", "^.*/");
-#endif
-
-      id = replaceRegex(id, "", "\\.zim[a-z]*$");
-      id = replaceRegex(id, "_", " ");
-      id = replaceRegex(id, "plus", "\\+");
+bool Library::removeBookmark(const std::string& zimId, const std::string& url)
+{
+  for(auto it=m_bookmarks.begin(); it!=m_bookmarks.end(); it++) {
+    if (it->getBookId() == zimId && it->getUrl() == url) {
+      m_bookmarks.erase(it);
+      return true;
     }
-    return id;
   }
+  return false;
+}
 
-  /* Constructor */
-  Library::Library():
-    version(KIWIX_LIBRARY_VERSION) {
-  }
-  
-  /* Destructor */
-  Library::~Library() {
+
+
+bool Library::removeBookById(const std::string& id)
+{
+  return m_books.erase(id) == 1;
+}
+
+Book& Library::getBookById(const std::string& id)
+{
+  return m_books.at(id);
+}
+
+std::shared_ptr<Reader> Library::getReaderById(const std::string& id)
+{
+  try {
+    return m_readers.at(id);
+  } catch (std::out_of_range& e) {}
+
+  auto book = getBookById(id);
+  if (!book.isPathValid())
+    return nullptr;
+  auto sptr = make_shared<Reader>(book.getPath());
+  m_readers[id] = sptr;
+  return sptr;
+}
+
+unsigned int Library::getBookCount(const bool localBooks,
+                                   const bool remoteBooks)
+{
+  unsigned int result = 0;
+  for (auto& pair: m_books) {
+    auto& book = pair.second;
+    if ((!book.getPath().empty() && localBooks)
+        || (book.getPath().empty() && remoteBooks)) {
+      result++;
+    }
   }
+  return result;
+}
 
-  bool Library::addBook(const Book &book) {
+bool Library::writeToFile(const std::string& path)
+{
+  auto baseDir = removeLastPathElement(path);
+  LibXMLDumper dumper(this);
+  dumper.setBaseDir(baseDir);
+  return writeTextFile(path, dumper.dumpLibXMLContent(getBooksIds()));
+}
 
-    /* Try to find it */
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = this->books.begin(); itr != this->books.end(); ++itr ) {
-      if (itr->id == book.id) {
-	if (!itr->readOnly) {
-	  itr->readOnly = book.readOnly;
-	  
-	  if (itr->path.empty())
-	    itr->path = book.path;
-	  
-	  if (itr->pathAbsolute.empty()) 
-	    itr->pathAbsolute = book.pathAbsolute;
-	  
-	  if (itr->url.empty())
-	    itr->url = book.url;
+bool Library::writeBookmarksToFile(const std::string& path)
+{
+  LibXMLDumper dumper(this);
+  return writeTextFile(path, dumper.dumpLibXMLBookmark());
+}
 
-	  if (itr->tags.empty())
-	    itr->tags = book.tags;
+std::vector<std::string> Library::getBooksLanguages()
+{
+  std::vector<std::string> booksLanguages;
+  std::map<std::string, bool> booksLanguagesMap;
 
-	  if (itr->name.empty())
-	    itr->name = book.name;
-	  
-	  if (itr->indexPath.empty()) {
-	    itr->indexPath = book.indexPath;
-	    itr->indexType = book.indexType;
-	  }
-	  
-	  if (itr->indexPathAbsolute.empty()) {
-	    itr->indexPathAbsolute = book.indexPathAbsolute;
-	    itr->indexType = book.indexType;
-	  }
-	  
-	  if (itr->faviconMimeType.empty()) {
-	    itr->favicon = book.favicon;
-	    itr->faviconMimeType = book.faviconMimeType;
-	  }
-	}
-
-	return false;
+  for (auto& pair: m_books) {
+    auto& book = pair.second;
+    auto& language = book.getLanguage();
+    if (booksLanguagesMap.find(language) == booksLanguagesMap.end()) {
+      if (book.getOrigId().empty()) {
+        booksLanguagesMap[language] = true;
+        booksLanguages.push_back(language);
       }
     }
-
-    /* otherwise */
-    this->books.push_back(book);
-    return true;
   }
 
-  bool Library::removeBookByIndex(const unsigned int bookIndex) {
-    books.erase(books.begin()+bookIndex);
-    return true;
+  return booksLanguages;
+}
+
+std::vector<std::string> Library::getBooksCreators()
+{
+  std::vector<std::string> booksCreators;
+  std::map<std::string, bool> booksCreatorsMap;
+
+  for (auto& pair: m_books) {
+    auto& book = pair.second;
+    auto& creator = book.getCreator();
+    if (booksCreatorsMap.find(creator) == booksCreatorsMap.end()) {
+      if (book.getOrigId().empty()) {
+        booksCreatorsMap[creator] = true;
+        booksCreators.push_back(creator);
+      }
+    }
   }
 
+  return booksCreators;
+}
+
+std::vector<std::string> Library::getBooksPublishers()
+{
+  std::vector<std::string> booksPublishers;
+  std::map<std::string, bool> booksPublishersMap;
+
+  for (auto& pair:m_books) {
+    auto& book = pair.second;
+    auto& publisher = book.getPublisher();
+    if (booksPublishersMap.find(publisher) == booksPublishersMap.end()) {
+      if (book.getOrigId().empty()) {
+        booksPublishersMap[publisher] = true;
+        booksPublishers.push_back(publisher);
+      }
+    }
+  }
+
+  return booksPublishers;
+}
+
+std::vector<std::string> Library::getBooksIds()
+{
+  std::vector<std::string> bookIds;
+
+  for (auto& pair: m_books) {
+    bookIds.push_back(pair.first);
+  }
+
+  return bookIds;
+}
+
+std::vector<std::string> Library::filter(const std::string& search)
+{
+  if (search.empty()) {
+    return getBooksIds();
+  }
+
+  return filter(Filter().query(search));
+}
+
+
+std::vector<std::string> Library::filter(const Filter& filter)
+{
+  std::vector<std::string> bookIds;
+  for(auto& pair:m_books) {
+    auto book = pair.second;
+    if(filter.accept(book)) {
+      bookIds.push_back(pair.first);
+    }
+  }
+  return bookIds;
+}
+
+template<supportedListSortBy SORT>
+struct KEY_TYPE {
+  typedef std::string TYPE;
+};
+
+template<>
+struct KEY_TYPE<SIZE> {
+  typedef size_t TYPE;
+};
+
+template<supportedListSortBy sort>
+class Comparator {
+  private:
+    Library* lib;
+    bool     ascending;
+
+    inline typename KEY_TYPE<sort>::TYPE get_key(const std::string& id);
+
+  public:
+    Comparator(Library* lib, bool ascending) : lib(lib), ascending(ascending) {}
+    inline bool operator() (const std::string& id1, const std::string& id2) {
+      if (ascending) {
+        return get_key(id1) < get_key(id2);
+      } else {
+        return get_key(id2) < get_key(id1);
+      }
+    }
+};
+
+template<>
+std::string Comparator<TITLE>::get_key(const std::string& id)
+{
+  return lib->getBookById(id).getTitle();
+}
+
+template<>
+size_t Comparator<SIZE>::get_key(const std::string& id)
+{
+  return lib->getBookById(id).getSize();
+}
+
+template<>
+std::string Comparator<DATE>::get_key(const std::string& id)
+{
+  return lib->getBookById(id).getDate();
+}
+
+template<>
+std::string Comparator<CREATOR>::get_key(const std::string& id)
+{
+  return lib->getBookById(id).getCreator();
+}
+
+template<>
+std::string Comparator<PUBLISHER>::get_key(const std::string& id)
+{
+  return lib->getBookById(id).getPublisher();
+}
+
+void Library::sort(std::vector<std::string>& bookIds, supportedListSortBy sort, bool ascending)
+{
+  switch(sort) {
+    case TITLE:
+      std::sort(bookIds.begin(), bookIds.end(), Comparator<TITLE>(this, ascending));
+      break;
+    case SIZE:
+      std::sort(bookIds.begin(), bookIds.end(), Comparator<SIZE>(this, ascending));
+      break;
+    case DATE:
+      std::sort(bookIds.begin(), bookIds.end(), Comparator<DATE>(this, ascending));
+      break;
+    case CREATOR:
+      std::sort(bookIds.begin(), bookIds.end(), Comparator<CREATOR>(this, ascending));
+      break;
+    case PUBLISHER:
+      std::sort(bookIds.begin(), bookIds.end(), Comparator<PUBLISHER>(this, ascending));
+      break;
+    default:
+      break;
+  }
+}
+
+
+std::vector<std::string> Library::listBooksIds(
+    int mode,
+    supportedListSortBy sortBy,
+    const std::string& search,
+    const std::string& language,
+    const std::string& creator,
+    const std::string& publisher,
+    const std::vector<std::string>& tags,
+    size_t maxSize) {
+
+  Filter _filter;
+  if (mode & LOCAL)
+    _filter.local(true);
+  if (mode & NOLOCAL)
+    _filter.local(false);
+  if (mode & VALID)
+    _filter.valid(true);
+  if (mode & NOVALID)
+    _filter.valid(false);
+  if (mode & REMOTE)
+    _filter.remote(true);
+  if (mode & NOREMOTE)
+    _filter.remote(false);
+  if (!tags.empty())
+    _filter.acceptTags(tags);
+  if (maxSize != 0)
+    _filter.maxSize(maxSize);
+  if (!language.empty())
+    _filter.lang(language);
+  if (!publisher.empty())
+    _filter.publisher(publisher);
+  if (!creator.empty())
+    _filter.creator(creator);
+  if (!search.empty())
+    _filter.query(search);
+
+  auto bookIds = filter(_filter);
+
+  sort(bookIds, sortBy, true);
+  return bookIds;
+}
+
+Filter::Filter()
+  : activeFilters(0),
+    _maxSize(0)
+{};
+
+#define FLAG(x) (1 << x)
+enum filterTypes {
+  NONE = 0,
+  _LOCAL = FLAG(0),
+  _REMOTE = FLAG(1),
+  _NOLOCAL = FLAG(2),
+  _NOREMOTE = FLAG(3),
+  _VALID = FLAG(4),
+  _NOVALID = FLAG(5),
+  ACCEPTTAGS = FLAG(6),
+  REJECTTAGS = FLAG(7),
+  LANG = FLAG(8),
+  _PUBLISHER = FLAG(9),
+  _CREATOR = FLAG(10),
+  MAXSIZE = FLAG(11),
+  QUERY = FLAG(12),
+};
+
+Filter& Filter::local(bool accept)
+{
+  if (accept) {
+    activeFilters |= _LOCAL;
+    activeFilters &= ~_NOLOCAL;
+  } else {
+    activeFilters |= _NOLOCAL;
+    activeFilters &= ~_LOCAL;
+  }
+  return *this;
+}
+
+Filter& Filter::remote(bool accept)
+{
+  if (accept) {
+    activeFilters |= _REMOTE;
+    activeFilters &= ~_NOREMOTE;
+  } else {
+    activeFilters |= _NOREMOTE;
+    activeFilters &= ~_REMOTE;
+  }
+  return *this;
+}
+
+Filter& Filter::valid(bool accept)
+{
+  if (accept) {
+    activeFilters |= _VALID;
+    activeFilters &= ~_NOVALID;
+  } else {
+    activeFilters |= _NOVALID;
+    activeFilters &= ~_VALID;
+  }
+  return *this;
+}
+
+Filter& Filter::acceptTags(std::vector<std::string> tags)
+{
+  _acceptTags = tags;
+  activeFilters |= ACCEPTTAGS;
+  return *this;
+}
+
+Filter& Filter::rejectTags(std::vector<std::string> tags)
+{
+  _rejectTags = tags;
+  activeFilters |= REJECTTAGS;
+  return *this;
+}
+
+Filter& Filter::lang(std::string lang)
+{
+  _lang = lang;
+  activeFilters |= LANG;
+  return *this;
+}
+
+Filter& Filter::publisher(std::string publisher)
+{
+  _publisher = publisher;
+  activeFilters |= _PUBLISHER;
+  return *this;
+}
+
+Filter& Filter::creator(std::string creator)
+{
+  _creator = creator;
+  activeFilters |= _CREATOR;
+  return *this;
+}
+
+Filter& Filter::maxSize(size_t maxSize)
+{
+  _maxSize = maxSize;
+  activeFilters |= MAXSIZE;
+  return *this;
+}
+
+Filter& Filter::query(std::string query)
+{
+  _query = query;
+  activeFilters |= QUERY;
+  return *this;
+}
+
+#define ACTIVE(X) (activeFilters & (X))
+bool Filter::accept(const Book& book) const
+{
+  auto local = !book.getPath().empty();
+  if (ACTIVE(_LOCAL) && !local)
+    return false;
+  if (ACTIVE(_NOLOCAL) && local)
+    return false;
+  auto valid = book.isPathValid();
+  if (ACTIVE(_VALID) && !valid)
+    return false;
+  if (ACTIVE(_NOVALID) && valid)
+    return false;
+  auto remote = !book.getUrl().empty();
+  if (ACTIVE(_REMOTE) && !remote)
+    return false;
+  if (ACTIVE(_NOREMOTE) && remote)
+    return false;
+  if (ACTIVE(ACCEPTTAGS)) {
+    if (!_acceptTags.empty()) {
+      auto vBookTags = split(book.getTags(), ";");
+      std::set<std::string> sBookTags(vBookTags.begin(), vBookTags.end());
+      for (auto& t: _acceptTags) {
+        if (sBookTags.find(t) == sBookTags.end()) {
+          return false;
+        }
+      }
+    }
+  }
+  if (ACTIVE(REJECTTAGS)) {
+    if (!_rejectTags.empty()) {
+      auto vBookTags = split(book.getTags(), ";");
+      std::set<std::string> sBookTags(vBookTags.begin(), vBookTags.end());
+      for (auto& t: _rejectTags) {
+        if (sBookTags.find(t) != sBookTags.end()) {
+          return false;
+        }
+      }
+    }
+  }
+  if (ACTIVE(MAXSIZE) && book.getSize() > _maxSize)
+    return false;
+
+  if (ACTIVE(LANG) && book.getLanguage() != _lang)
+    return false;
+
+  if (ACTIVE(_PUBLISHER) && book.getPublisher() != _publisher)
+    return false;
+
+  if (ACTIVE(_CREATOR) && book.getCreator() != _creator)
+    return false;
+
+  if ( ACTIVE(QUERY)
+    && !(matchRegex(book.getTitle(), "\\Q" + _query + "\\E")
+        || matchRegex(book.getDescription(), "\\Q" + _query + "\\E")))
+    return false;
+
+  return true;
+
+}
+
 }

src/libxml_dumper.cpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "libxml_dumper.h"
+#include "book.h"
+
+#include "tools/base64.h"
+#include "tools/stringTools.h"
+#include "tools/otherTools.h"
+#include "tools/pathTools.h"
+
+namespace kiwix
+{
+/* Constructor */
+LibXMLDumper::LibXMLDumper(Library* library)
+  : library(library)
+{
+}
+/* Destructor */
+LibXMLDumper::~LibXMLDumper()
+{
+}
+
+#define ADD_ATTRIBUTE(node, name, value) { (node).append_attribute((name)) = (value).c_str(); }
+#define ADD_ATTR_NOT_EMPTY(node, name, value) { if (!(value).empty()) ADD_ATTRIBUTE(node, name, value); }
+
+void LibXMLDumper::handleBook(Book book, pugi::xml_node root_node) {
+  if (book.readOnly())
+    return;
+
+  auto entry_node = root_node.append_child("book");
+  ADD_ATTRIBUTE(entry_node, "id", book.getId());
+
+  if (!book.getPath().empty()) {
+    ADD_ATTRIBUTE(entry_node, "path", computeRelativePath(baseDir, book.getPath()));
+  }
+
+  if (book.getOrigId().empty()) {
+    ADD_ATTR_NOT_EMPTY(entry_node, "title", book.getTitle());
+    ADD_ATTR_NOT_EMPTY(entry_node, "name", book.getName());
+    ADD_ATTR_NOT_EMPTY(entry_node, "tags", book.getTags());
+    ADD_ATTR_NOT_EMPTY(entry_node, "description", book.getDescription());
+    ADD_ATTR_NOT_EMPTY(entry_node, "language", book.getLanguage());
+    ADD_ATTR_NOT_EMPTY(entry_node, "creator", book.getCreator());
+    ADD_ATTR_NOT_EMPTY(entry_node, "publisher", book.getPublisher());
+    ADD_ATTR_NOT_EMPTY(entry_node, "faviconMimeType", book.getFaviconMimeType());
+    if (!book.getFavicon().empty())
+      ADD_ATTRIBUTE(entry_node, "favicon", base64_encode(book.getFavicon()));
+  } else {
+    ADD_ATTRIBUTE(entry_node, "origId", book.getOrigId());
+  }
+
+  ADD_ATTR_NOT_EMPTY(entry_node, "date", book.getDate());
+  ADD_ATTR_NOT_EMPTY(entry_node, "url", book.getUrl());
+
+  if (book.getArticleCount())
+    ADD_ATTRIBUTE(entry_node, "articleCount", to_string(book.getArticleCount()));
+
+  if (book.getMediaCount())
+    ADD_ATTRIBUTE(entry_node, "mediaCount", to_string(book.getMediaCount()));
+
+  if (book.getSize())
+    ADD_ATTRIBUTE(entry_node, "size", to_string(book.getSize()>>10));
+
+  ADD_ATTR_NOT_EMPTY(entry_node, "downloadId", book.getDownloadId());
+}
+
+#define ADD_TEXT_ENTRY(node, child, value) (node).append_child((child)).append_child(pugi::node_pcdata).set_value((value).c_str())
+
+void LibXMLDumper::handleBookmark(Bookmark bookmark, pugi::xml_node root_node) {
+
+  auto entry_node = root_node.append_child("bookmark");
+  auto book_node = entry_node.append_child("book");
+
+  try {
+    auto book = library->getBookById(bookmark.getBookId());
+    ADD_TEXT_ENTRY(book_node, "id", book.getId());
+    ADD_TEXT_ENTRY(book_node, "title", book.getTitle());
+    ADD_TEXT_ENTRY(book_node, "language", book.getLanguage());
+    ADD_TEXT_ENTRY(book_node, "date", book.getDate());
+  } catch (...) {
+    ADD_TEXT_ENTRY(book_node, "id", bookmark.getBookId());
+    ADD_TEXT_ENTRY(book_node, "title", bookmark.getBookTitle());
+    ADD_TEXT_ENTRY(book_node, "language", bookmark.getLanguage());
+    ADD_TEXT_ENTRY(book_node, "date", bookmark.getDate());
+  }
+  ADD_TEXT_ENTRY(entry_node, "title", bookmark.getTitle());
+  ADD_TEXT_ENTRY(entry_node, "url", bookmark.getUrl());
+}
+
+
+std::string LibXMLDumper::dumpLibXMLContent(const std::vector<std::string>& bookIds)
+{
+  pugi::xml_document doc;
+
+  /* Add the library node */
+  pugi::xml_node libraryNode = doc.append_child("library");
+
+  libraryNode.append_attribute("version") = KIWIX_LIBRARY_VERSION;
+
+  if (library) {
+    for (auto& bookId: bookIds) {
+      handleBook(library->getBookById(bookId), libraryNode);
+    }
+  }
+  return nodeToString(libraryNode);
+}
+
+std::string LibXMLDumper::dumpLibXMLBookmark()
+{
+  pugi::xml_document doc;
+
+  /* Add the library node */
+  pugi::xml_node bookmarksNode = doc.append_child("bookmarks");
+
+  if (library) {
+    for (auto& bookmark: library->getBookmarks()) {
+      handleBookmark(bookmark, bookmarksNode);
+    }
+  }
+  return nodeToString(bookmarksNode);
+}
+
+}

src/manager.cpp

@@ -19,544 +19,232 @@
 
 #include "manager.h"
 
-namespace kiwix {
+#include <pugixml.hpp>
 
-  /* Constructor */
-  Manager::Manager() :
-    writableLibraryPath("") {
+namespace kiwix
+{
+/* Constructor */
+Manager::Manager(LibraryManipulator* manipulator):
+  writableLibraryPath(""),
+  manipulator(manipulator),
+  mustDeleteManipulator(false)
+{
+}
+
+Manager::Manager(Library* library) :
+  writableLibraryPath(""),
+  manipulator(new DefaultLibraryManipulator(library)),
+  mustDeleteManipulator(true)
+{
+}
+
+/* Destructor */
+Manager::~Manager()
+{
+  if (mustDeleteManipulator) {
+    delete manipulator;
   }
+}
+bool Manager::parseXmlDom(const pugi::xml_document& doc,
+                          const bool readOnly,
+                          const std::string& libraryPath)
+{
+  pugi::xml_node libraryNode = doc.child("library");
 
-  /* Destructor */
-  Manager::~Manager() {
-  }
+  std::string libraryVersion = libraryNode.attribute("version").value();
 
-  bool Manager::parseXmlDom(const pugi::xml_document &doc, const bool readOnly, const string libraryPath) {
-    pugi::xml_node libraryNode = doc.child("library");
-
-    if (strlen(libraryNode.attribute("current").value()))
-      this->setCurrentBookId(libraryNode.attribute("current").value());
-
-    string libraryVersion = libraryNode.attribute("version").value();
-
-    for (pugi::xml_node bookNode = libraryNode.child("book"); bookNode; bookNode = bookNode.next_sibling("book")) {
-      bool ok = true;
-      kiwix::Book book;
-
-      book.readOnly = readOnly;
-      book.id = bookNode.attribute("id").value();
-      book.path = bookNode.attribute("path").value();
-      book.last = (std::string(bookNode.attribute("last").value()) != "undefined" ?
-		   bookNode.attribute("last").value() : "");
-      book.indexPath = bookNode.attribute("indexPath").value();
-      book.indexType = XAPIAN;
-      book.title = bookNode.attribute("title").value();
-      book.name = bookNode.attribute("name").value();
-      book.tags = bookNode.attribute("tags").value();
-      book.description = bookNode.attribute("description").value();
-      book.language = bookNode.attribute("language").value();
-      book.date = bookNode.attribute("date").value();
-      book.creator = bookNode.attribute("creator").value();
-      book.publisher = bookNode.attribute("publisher").value();
-      book.url = bookNode.attribute("url").value();
-      book.origId = bookNode.attribute("origId").value();
-      book.articleCount = bookNode.attribute("articleCount").value();
-      book.mediaCount = bookNode.attribute("mediaCount").value();
-      book.size = bookNode.attribute("size").value();
-      book.favicon = bookNode.attribute("favicon").value();
-      book.faviconMimeType = bookNode.attribute("faviconMimeType").value();
-
-      /* Check absolute and relative paths */
-      this->checkAndCleanBookPaths(book, libraryPath);
-
-      /* Update the book properties with the new importer */
-      if (libraryVersion.empty() || atoi(libraryVersion.c_str()) <= atoi(KIWIX_LIBRARY_VERSION)) {
-	if (!book.path.empty()) {
-	  ok = this->readBookFromPath(book.pathAbsolute);
-	}
-      }
-
-      if (ok) {
-	library.addBook(book);
-      }
-    }
-
-    return true;
-  }
-
-  bool Manager::readXml(const string xml, const bool readOnly, const string libraryPath) {
-    pugi::xml_document doc;
-    pugi::xml_parse_result result = doc.load_buffer_inplace((void*)xml.data(), xml.size());
-
-    if (result) {
-      this->parseXmlDom(doc, readOnly, libraryPath);
-    }
-
-    return true;
-  }
-
-  bool Manager::readFile(const string path, const bool readOnly) {
-    return this->readFile(path, path, readOnly);
-  }
-
-  bool Manager::readFile(const string nativePath, const string UTF8Path, const bool readOnly) {
-    bool retVal = true;
-    pugi::xml_document doc;
-    pugi::xml_parse_result result = doc.load_file(nativePath.c_str());
-
-    if (result) {
-      this->parseXmlDom(doc, readOnly, UTF8Path);
-    } else {
-      retVal = false;
-    }
-
-    /* This has to be set (although if the file does not exists) to be
-     * able to know where to save the library if new content are
-     * available */
-    if (!readOnly) {
-      this->writableLibraryPath = UTF8Path;
-    }
-
-    return retVal;
-  }
-
-  bool Manager::writeFile(const string path) {
-    pugi::xml_document doc;
-
-    /* Add the library node */
-    pugi::xml_node libraryNode = doc.append_child("library");
-
-    if (!getCurrentBookId().empty()) {
-      libraryNode.append_attribute("current") = getCurrentBookId().c_str();
-    }
-
-    if (!library.version.empty())
-      libraryNode.append_attribute("version") = library.version.c_str();
-
-    /* Add each book */
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-
-      if (!itr->readOnly) {
-	this->checkAndCleanBookPaths(*itr, path);
-
-	pugi::xml_node bookNode = libraryNode.append_child("book");
-	bookNode.append_attribute("id") = itr->id.c_str();
-
-	if (!itr->path.empty())
-	  bookNode.append_attribute("path") = itr->path.c_str();
-
-	if (!itr->last.empty() && itr->last != "undefined") {
-	  bookNode.append_attribute("last") = itr->last.c_str();
-	}
-
-	if (!itr->indexPath.empty())
-	  bookNode.append_attribute("indexPath") = itr->indexPath.c_str();
-
-	if (!itr->indexPath.empty() || !itr->indexPathAbsolute.empty()) {
-	  if (itr->indexType == XAPIAN)
-	    bookNode.append_attribute("indexType") = "xapian";
-	}
-
-	if (itr->origId.empty()) {
-	  if (!itr->title.empty())
-	    bookNode.append_attribute("title") = itr->title.c_str();
-
-	  if (!itr->name.empty())
-	    bookNode.append_attribute("name") = itr->name.c_str();
-
-	  if (!itr->tags.empty())
-	    bookNode.append_attribute("tags") = itr->tags.c_str();
-	  
-	  if (!itr->description.empty())
-	    bookNode.append_attribute("description") = itr->description.c_str();
-	  
-	  if (!itr->language.empty())
-	    bookNode.append_attribute("language") = itr->language.c_str();
-	  
-	  if (!itr->creator.empty())
-	    bookNode.append_attribute("creator") = itr->creator.c_str();
-	  
-	  if (!itr->publisher.empty())
-	    bookNode.append_attribute("publisher") = itr->publisher.c_str();
-	  
-	  if (!itr->favicon.empty())
-	    bookNode.append_attribute("favicon") = itr->favicon.c_str();
-	  
-	  if (!itr->faviconMimeType.empty())
-	    bookNode.append_attribute("faviconMimeType") = itr->faviconMimeType.c_str();
-	}
-
-	if (!itr->date.empty())
-	  bookNode.append_attribute("date") = itr->date.c_str();
-
-	if (!itr->url.empty())
-	  bookNode.append_attribute("url") = itr->url.c_str();
-	
-	if (!itr->origId.empty())
-	  bookNode.append_attribute("origId") = itr->origId.c_str();
-	
-	if (!itr->articleCount.empty())
-	  bookNode.append_attribute("articleCount") = itr->articleCount.c_str();
-
-	if (!itr->mediaCount.empty())
-	  bookNode.append_attribute("mediaCount") = itr->mediaCount.c_str();
-
-	if (!itr->size.empty())
-	  bookNode.append_attribute("size") = itr->size.c_str();
-      }
-    }
-
-    /* saving file */
-    doc.save_file(path.c_str());
-
-    return true;
-  }
-
-  bool Manager::setCurrentBookId(const string id) {
-    if (library.current.empty() || library.current.top() != id) {
-      if (id.empty() && !library.current.empty())
-	library.current.pop();
-      else
-	library.current.push(id);
-    }
-    return true;
-  }
-
-  string Manager::getCurrentBookId() {
-    return library.current.empty() ?
-      "" : library.current.top();
-  }
-
-  /* Add a book to the library. Return empty string if failed, book id otherwise */
-  string Manager::addBookFromPathAndGetId(const string pathToOpen, const string pathToSave,
-					  const string url, const bool checkMetaData) {
+  for (pugi::xml_node bookNode = libraryNode.child("book"); bookNode;
+       bookNode = bookNode.next_sibling("book")) {
     kiwix::Book book;
 
-    if (this->readBookFromPath(pathToOpen, &book)) {
+    book.setReadOnly(readOnly);
+    book.updateFromXml(bookNode,
+                       removeLastPathElement(libraryPath));
 
-      if (pathToSave != pathToOpen) {
-	book.path = pathToSave;
-	book.pathAbsolute = isRelativePath(pathToSave) ?
-	  computeAbsolutePath(removeLastPathElement(writableLibraryPath, true, false), pathToSave) : pathToSave;
-      }
-
-      if (!checkMetaData ||
-	  (checkMetaData && !book.title.empty() && !book.language.empty() && !book.date.empty())) {
-	book.url = url;
-	library.addBook(book);
-	return book.id;
+    /* Update the book properties with the new importer */
+    if (libraryVersion.empty()
+        || atoi(libraryVersion.c_str()) <= atoi(KIWIX_LIBRARY_VERSION)) {
+      if (!book.getPath().empty()) {
+        this->readBookFromPath(book.getPath(), &book);
       }
     }
-
-    return "";
+    manipulator->addBookToLibrary(book);
   }
 
-  /* Wrapper over Manager::addBookFromPath which return a bool instead of a string */
-  bool Manager::addBookFromPath(const string pathToOpen, const string pathToSave, const string url, const bool checkMetaData) {
-    return !(this->addBookFromPathAndGetId(pathToOpen, pathToSave, url, checkMetaData).empty());
+  return true;
+}
+
+bool Manager::readXml(const std::string& xml,
+                      const bool readOnly,
+                      const std::string& libraryPath)
+{
+  pugi::xml_document doc;
+  pugi::xml_parse_result result
+      = doc.load_buffer_inplace((void*)xml.data(), xml.size());
+
+  if (result) {
+    this->parseXmlDom(doc, readOnly, libraryPath);
   }
 
-  bool Manager::readBookFromPath(const string path, kiwix::Book *book) {
-    try {
-      kiwix::Reader *reader = new kiwix::Reader(path);
+  return true;
+}
 
-      if (book != NULL) {
-	book->path = path;
-	book->pathAbsolute = path;
-	book->id = reader->getId();
-	book->description = reader->getDescription();
-	book->language = reader->getLanguage();
-	book->date = reader->getDate();
-	book->creator = reader->getCreator();
-	book->publisher = reader->getPublisher();
-	book->title = reader->getTitle();
-	book->name = reader->getName();
-	book->tags = reader->getTags();
-	book->origId = reader->getOrigId();
-	std::ostringstream articleCountStream;
-	articleCountStream << reader->getArticleCount();
-	book->articleCount = articleCountStream.str();
 
-	std::ostringstream mediaCountStream;
-	mediaCountStream << reader->getMediaCount();
-	book->mediaCount = mediaCountStream.str();
 
-	ostringstream convert; convert << reader->getFileSize();
-	book->size = convert.str();
+bool Manager::parseOpdsDom(const pugi::xml_document& doc, const std::string& urlHost)
+{
+  pugi::xml_node libraryNode = doc.child("feed");
 
-	string favicon;
-	string faviconMimeType;
-	if (reader->getFavicon(favicon, faviconMimeType)) {
-	  book->favicon = base64_encode(reinterpret_cast<const unsigned char*>(favicon.c_str()), favicon.length());
-	  book->faviconMimeType = faviconMimeType;
-	}
-      }
+  try {
+    m_totalBooks = strtoull(libraryNode.child("totalResults").child_value(), 0, 0);
+    m_startIndex = strtoull(libraryNode.child("startIndex").child_value(), 0, 0);
+    m_itemsPerPage = strtoull(libraryNode.child("itemsPerPage").child_value(), 0, 0);
+    m_hasSearchResult = true;
+  } catch(...) {
+    m_hasSearchResult = false;
+  }
 
-      delete reader;
-    } catch (const std::exception& e) {
-      std::cerr << e.what() << std::endl;
-      return false;
-    }
+  for (pugi::xml_node entryNode = libraryNode.child("entry"); entryNode;
+       entryNode = entryNode.next_sibling("entry")) {
+    kiwix::Book book;
 
+    book.setReadOnly(false);
+    book.updateFromOpds(entryNode, urlHost);
+
+    /* Update the book properties with the new importer */
+    manipulator->addBookToLibrary(book);
+  }
+
+  return true;
+}
+
+
+
+bool Manager::readOpds(const std::string& content, const std::string& urlHost)
+{
+  pugi::xml_document doc;
+  pugi::xml_parse_result result
+      = doc.load_buffer_inplace((void*)content.data(), content.size());
+
+  if (result) {
+    this->parseOpdsDom(doc, urlHost);
     return true;
   }
 
-  bool Manager::removeBookByIndex(const unsigned int bookIndex) {
-    return this->library.removeBookByIndex(bookIndex);
+  return false;
+}
+
+bool Manager::readFile(const std::string& path, const bool readOnly)
+{
+  return this->readFile(path, path, readOnly);
+}
+
+bool Manager::readFile(const std::string& nativePath,
+                       const std::string& UTF8Path,
+                       const bool readOnly)
+{
+  bool retVal = true;
+  pugi::xml_document doc;
+  pugi::xml_parse_result result = doc.load_file(nativePath.c_str());
+
+  if (result) {
+    this->parseXmlDom(doc, readOnly, UTF8Path);
+  } else {
+    retVal = false;
   }
 
-  bool Manager::removeBookById(const string id) {
-    unsigned int bookIndex = 0;
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if ( itr->id == id) {
-	return this->library.removeBookByIndex(bookIndex);
-      }
-      bookIndex++;
+  /* This has to be set (although if the file does not exists) to be
+   * able to know where to save the library if new content are
+   * available */
+  if (!readOnly) {
+    this->writableLibraryPath = UTF8Path;
+  }
+
+  return retVal;
+}
+
+
+/* Add a book to the library. Return empty string if failed, book id otherwise
+ */
+std::string Manager::addBookFromPathAndGetId(const std::string& pathToOpen,
+                                             const std::string& pathToSave,
+                                             const std::string& url,
+                                             const bool checkMetaData)
+{
+  kiwix::Book book;
+
+  if (this->readBookFromPath(pathToOpen, &book)) {
+    if (pathToSave != pathToOpen) {
+      book.setPath(isRelativePath(pathToSave)
+                ? computeAbsolutePath(
+                      removeLastPathElement(writableLibraryPath),
+                      pathToSave)
+                : pathToSave);
     }
+
+    if (!checkMetaData
+        || (checkMetaData && !book.getTitle().empty() && !book.getLanguage().empty()
+            && !book.getDate().empty())) {
+      book.setUrl(url);
+      manipulator->addBookToLibrary(book);
+      return book.getId();
+    }
+  }
+
+  return "";
+}
+
+/* Wrapper over Manager::addBookFromPath which return a bool instead of a string
+ */
+bool Manager::addBookFromPath(const std::string& pathToOpen,
+                              const std::string& pathToSave,
+                              const std::string& url,
+                              const bool checkMetaData)
+{
+  return !(
+      this->addBookFromPathAndGetId(pathToOpen, pathToSave, url, checkMetaData)
+          .empty());
+}
+
+bool Manager::readBookFromPath(const std::string& path, kiwix::Book* book)
+{
+  std::string tmp_path = path;
+  if (isRelativePath(path)) {
+    tmp_path = computeAbsolutePath(getCurrentDirectory(), path);
+  }
+  try {
+    kiwix::Reader reader(tmp_path);
+    book->update(reader);
+    book->setPathValid(true);
+  } catch (const std::exception& e) {
+    book->setPathValid(false);
     return false;
   }
 
-  vector<string> Manager::getBooksLanguages() {
-    std::vector<string> booksLanguages;
-    std::vector<kiwix::Book>::iterator itr;
-    std::map<string, bool> booksLanguagesMap;
+  return true;
+}
 
-    std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByLanguage);
-    for (itr = library.books.begin(); itr != library.books.end(); ++itr) {
-      if (booksLanguagesMap.find(itr->language) == booksLanguagesMap.end()) {
-        if (itr->origId.empty()) {
-	  booksLanguagesMap[itr->language] = true;
-	  booksLanguages.push_back(itr->language);
-        }
-      }
-    }
+bool Manager::readBookmarkFile(const std::string& path)
+{
+  pugi::xml_document doc;
+  pugi::xml_parse_result result = doc.load_file(path.c_str());
 
-    return booksLanguages;
-  }
-
-  vector<string> Manager::getBooksCreators() {
-    std::vector<string> booksCreators;
-    std::vector<kiwix::Book>::iterator itr;
-    std::map<string, bool> booksCreatorsMap;
-
-    std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByCreator);
-    for (itr = library.books.begin(); itr != library.books.end(); ++itr) {
-      if (booksCreatorsMap.find(itr->creator) == booksCreatorsMap.end()) {
-        if (itr->origId.empty()) {
-	  booksCreatorsMap[itr->creator] = true;
-	  booksCreators.push_back(itr->creator);
-        }
-      }
-    }
-
-    return booksCreators;
-  }
-
-
-  vector<string> Manager::getBooksIds() {
-    std::vector<string> booksIds;
-    std::vector<kiwix::Book>::iterator itr;
-
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      booksIds.push_back(itr->id);
-    }
-
-    return booksIds;
-  }
-
-  vector<string> Manager::getBooksPublishers() {
-    std::vector<string> booksPublishers;
-    std::vector<kiwix::Book>::iterator itr;
-    std::map<string, bool> booksPublishersMap;
-
-    std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByPublisher);
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if (booksPublishersMap.find(itr->publisher) == booksPublishersMap.end()) {
-        if (itr->origId.empty()) {
-	  booksPublishersMap[itr->publisher] = true;
-	  booksPublishers.push_back(itr->publisher);
-        }
-      }
-    }
-
-    return booksPublishers;
-  }
-
-  kiwix::Library Manager::cloneLibrary() {
-    return this->library;
-  }
-
-  bool Manager::getCurrentBook(Book &book) {
-    string currentBookId = getCurrentBookId();
-    if (currentBookId.empty()) {
-      return false;
-    } else {
-      getBookById(currentBookId, book);
-      return true;
-    }
-  }
-
-  bool Manager::getBookById(const string id, Book &book) {
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if ( itr->id == id) {
-	book = *itr;
-	return true;
-      }
-    }
+  if (!result) {
     return false;
   }
 
-  bool Manager::updateBookLastOpenDateById(const string id) {
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if ( itr->id == id) {
-	char unixdate[12];
-	sprintf (unixdate, "%d", (int)time(NULL));
-	itr->last = unixdate;
-	return true;
-      }
-    }
+  pugi::xml_node libraryNode = doc.child("bookmarks");
 
-    return false;
+  for (pugi::xml_node node = libraryNode.child("bookmark"); node;
+       node = node.next_sibling("bookmark")) {
+    kiwix::Bookmark bookmark;
+
+    bookmark.updateFromXml(node);
+
+    manipulator->addBookmarkToLibrary(bookmark);
   }
 
-  bool Manager::setBookIndex(const string id, const string path, const supportedIndexType type) {
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if ( itr->id == id) {
-	itr->indexPath = path;
-	itr->indexPathAbsolute = isRelativePath(path) ?
-	  computeAbsolutePath(removeLastPathElement(writableLibraryPath, true, false), path) : path;
-	itr->indexType = type;
-	return true;
-      }
-    }
-
-    return false;
-  }
-
-  bool Manager::setBookIndex(const string id, const string path) {
-    return this->setBookIndex(id, path, XAPIAN);
-  }
-
-  bool Manager::setBookPath(const string id, const string path) {
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if ( itr->id == id) {
-	itr->path = path;
-	itr->pathAbsolute = isRelativePath(path) ?
-	  computeAbsolutePath(removeLastPathElement(writableLibraryPath, true, false), path) : path;
-	return true;
-      }
-    }
-
-    return false;
-  }
-
-  void Manager::removeBookPaths() {
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      itr->path = "";
-      itr->pathAbsolute = "";
-    }
-  }
-
-  unsigned int Manager::getBookCount(const bool localBooks, const bool remoteBooks) {
-    unsigned int result = 0;
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-      if ((!itr->path.empty() && localBooks) || (itr->path.empty() && remoteBooks))
-	result++;
-    }
-    return result;
-  }
-
-  bool Manager::listBooks(const supportedListMode mode, const supportedListSortBy sortBy,
-			  const unsigned int maxSize, const string language, const string creator,
-			  const string publisher, const string search) {
-    this->bookIdList.clear();
-    std::vector<kiwix::Book>::iterator itr;
-
-    /* Sort */
-    if (sortBy == TITLE) {
-      std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByTitle);
-    } else if (sortBy == SIZE) {
-      std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortBySize);
-    } else if (sortBy == DATE) {
-      std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByDate);
-    } else if (sortBy == CREATOR) {
-      std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByCreator);
-    } else if (sortBy == PUBLISHER) {
-      std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByPublisher);
-    }
-
-    /* Special sort for LASTOPEN */
-    if (mode == LASTOPEN) {
-      std::sort(library.books.begin(), library.books.end(), kiwix::Book::sortByLastOpen);
-      for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-	if (!itr->last.empty())
-	  this->bookIdList.push_back(itr->id);
-      }
-    } else {
-      /* Generate the list of book id */
-      for ( itr = library.books.begin(); itr != library.books.end(); ++itr ) {
-	bool ok = true;
-
-	if (mode == LOCAL && itr->path.empty())
-	  ok = false;
-
-	if (ok == true && mode == REMOTE && (!itr->path.empty() || itr->url.empty()))
-	  ok = false;
-
-	if (ok == true && maxSize != 0 && (unsigned int)atoi(itr->size.c_str()) > maxSize * 1024 * 1024)
-	  ok = false;
-
-	if (ok == true && !language.empty() && !matchRegex(itr->language, language))
-	  ok = false;
-
-	if (ok == true && !creator.empty() && itr->creator != creator)
-	  ok = false;
-
-	if (ok == true && !publisher.empty() && itr->publisher != publisher)
-	  ok = false;
-
-	if ((ok == true && !search.empty()) && !(matchRegex(itr->title, "\\Q" + search + "\\E") || 
-						 matchRegex(itr->description,  "\\Q" + search + "\\E") ||
-						 matchRegex(itr->language,  "\\Q" + search + "\\E")
-						 ))
-	  ok = false;
-
-	if (ok == true) {
-	  this->bookIdList.push_back(itr->id);
-	}
-      }
-    }
-
-    return true;
-  }
-
-  void Manager::checkAndCleanBookPaths(Book &book, const string &libraryPath) {
-    if (!book.path.empty()) {
-      if (isRelativePath(book.path)) {
-	book.pathAbsolute = computeAbsolutePath(removeLastPathElement(libraryPath, true, false), book.path);
-      } else {
-	book.pathAbsolute = book.path;
-	book.path = computeRelativePath(removeLastPathElement(libraryPath, true, false), book.pathAbsolute);
-      }
-    }
-
-    if (!book.indexPath.empty()) {
-      if (isRelativePath(book.indexPath)) {
-	book.indexPathAbsolute =
-	  computeAbsolutePath(removeLastPathElement(libraryPath, true, false), book.indexPath);
-      } else {
-	book.indexPathAbsolute = book.indexPath;
-	book.indexPath =
-	  computeRelativePath(removeLastPathElement(libraryPath, true, false), book.indexPathAbsolute);
-      }
-    }
-  }
+  return true;
+}
 
 }

src/meson.build

@@ -1,34 +1,42 @@
 kiwix_sources = [
+  'book.cpp',
+  'bookmark.cpp',
   'library.cpp',
   'manager.cpp',
+  'libxml_dumper.cpp',
+  'opds_dumper.cpp',
+  'downloader.cpp',
   'reader.cpp',
+  'entry.cpp',
+  'server.cpp',
   'searcher.cpp',
-  'common/base64.cpp',
-  'common/pathTools.cpp',
-  'common/regexTools.cpp',
-  'common/stringTools.cpp',
-  'common/networkTools.cpp',
-  'common/otherTools.cpp',
-  'xapian/htmlparse.cc',
-  'xapian/myhtmlparse.cc'
+  'search_renderer.cpp',
+  'subprocess.cpp',
+  'aria2.cpp',
+  'tools/base64.cpp',
+  'tools/pathTools.cpp',
+  'tools/regexTools.cpp',
+  'tools/stringTools.cpp',
+  'tools/networkTools.cpp',
+  'tools/otherTools.cpp',
+  'kiwixserve.cpp',
+  'name_mapper.cpp',
+  'server/request_context.cpp',
+  'server/response.cpp'
 ]
 kiwix_sources += lib_resources
 
-if xapian_dep.found()
-  kiwix_sources += ['xapianSearcher.cpp']
-  if not get_option('android')
-    kiwix_sources += ['xapianIndexer.cpp']
-  endif
-endif
-
-if not get_option('android')
-  kiwix_sources += ['indexer.cpp']
+if host_machine.system() == 'windows'
+  kiwix_sources += 'subprocess_windows.cpp'
 else
-  subdir('android')
+  kiwix_sources += 'subprocess_unix.cpp'
 endif
 
-if has_ctpp2_dep
-  kiwix_sources += ['ctpp2/CTPP2VMStringLoader.cpp']
+if get_option('android')
+  subdir('android')
+  install_dir = 'kiwix-lib/jniLibs/' + meson.get_cross_property('android_abi')
+else
+  install_dir = get_option('libdir')
 endif
 
 config_h = configure_file(output : 'kiwix_config.h',
@@ -40,5 +48,6 @@ kiwixlib = library('kiwix',
                    kiwix_sources,
                    include_directories : inc,
                    dependencies : all_deps,
-                   version: '1.0.0',
-                   install : true)
+                   version: meson.project_version(),
+                   install: true,
+                   install_dir: install_dir)

src/name_mapper.cpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2019 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "name_mapper.h"
+#include "library.h"
+#include "tools/regexTools.h"
+#include <iostream>
+
+namespace kiwix {
+
+HumanReadableNameMapper::HumanReadableNameMapper(kiwix::Library& library, bool withAlias) {
+  for (auto& bookId: library.filter(kiwix::Filter().local(true).valid(true))) {
+    auto& currentBook = library.getBookById(bookId);
+    auto bookName = currentBook.getHumanReadableIdFromPath();
+    m_idToName[bookId] = bookName;
+    m_nameToId[bookName] = bookId;
+
+    if (!withAlias)
+      continue;
+
+    auto aliasName = replaceRegex(bookName, "", "_[[:digit:]]{4}-[[:digit:]]{2}$");
+    if (aliasName == bookName) {
+      continue;
+    }
+    if (m_nameToId.find(aliasName) == m_nameToId.end()) {
+      m_nameToId[aliasName] = bookId;
+    } else {
+      auto alreadyPresentPath = library.getBookById(m_nameToId[aliasName]).getPath();
+      std::cerr << "Path collision: " << alreadyPresentPath
+                << " and " << currentBook.getPath()
+                << " can't share the same URL path '" << aliasName << "'."
+                << " Therefore, only " << alreadyPresentPath
+                << " will be served." << std::endl;
+    }
+  }
+}
+
+std::string HumanReadableNameMapper::getNameForId(const std::string& id) {
+  return m_idToName.at(id);
+}
+
+std::string HumanReadableNameMapper::getIdForName(const std::string& name) {
+  return m_nameToId.at(name);
+}
+
+}

src/opds_dumper.cpp

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "opds_dumper.h"
+#include "book.h"
+
+#include "tools/otherTools.h"
+#include <iomanip>
+
+namespace kiwix
+{
+/* Constructor */
+OPDSDumper::OPDSDumper(Library* library)
+  : library(library)
+{
+}
+/* Destructor */
+OPDSDumper::~OPDSDumper()
+{
+}
+
+std::string gen_date_str()
+{
+  auto now = time(0);
+  auto tm = localtime(&now);
+
+  std::stringstream is;
+  is << std::setw(2) << std::setfill('0')
+     << 1900+tm->tm_year << "-"
+     << std::setw(2) << std::setfill('0') << tm->tm_mon << "-"
+     << std::setw(2) << std::setfill('0') << tm->tm_mday << "T"
+     << std::setw(2) << std::setfill('0') << tm->tm_hour << ":"
+     << std::setw(2) << std::setfill('0') << tm->tm_min << ":"
+     << std::setw(2) << std::setfill('0') << tm->tm_sec << "Z";
+  return is.str();
+}
+
+static std::string gen_date_from_yyyy_mm_dd(const std::string& date)
+{
+  std::stringstream is;
+  is << date << "T00:00::00:Z";
+  return is.str();
+}
+
+void OPDSDumper::setOpenSearchInfo(int totalResults, int startIndex, int count)
+{
+  m_totalResults = totalResults;
+  m_startIndex = startIndex,
+  m_count = count;
+  m_isSearchResult = true;
+}
+
+#define ADD_TEXT_ENTRY(node, child, value) (node).append_child((child)).append_child(pugi::node_pcdata).set_value((value).c_str())
+
+pugi::xml_node OPDSDumper::handleBook(Book book, pugi::xml_node root_node) {
+  auto entry_node = root_node.append_child("entry");
+  ADD_TEXT_ENTRY(entry_node, "title", book.getTitle());
+  ADD_TEXT_ENTRY(entry_node, "id", "urn:uuid:"+book.getId());
+  ADD_TEXT_ENTRY(entry_node, "icon", rootLocation + "/meta?name=favicon&content=" + book.getHumanReadableIdFromPath());
+  ADD_TEXT_ENTRY(entry_node, "updated", gen_date_from_yyyy_mm_dd(book.getDate()));
+  ADD_TEXT_ENTRY(entry_node, "summary", book.getDescription());
+  ADD_TEXT_ENTRY(entry_node, "tags", book.getTags());
+
+  auto content_node = entry_node.append_child("link");
+  content_node.append_attribute("type") = "text/html";
+  content_node.append_attribute("href") = (rootLocation + "/" + book.getHumanReadableIdFromPath()).c_str();
+
+  auto author_node = entry_node.append_child("author");
+  ADD_TEXT_ENTRY(author_node, "name", book.getCreator());
+
+  if (! book.getUrl().empty()) {
+    auto acquisition_link = entry_node.append_child("link");
+    acquisition_link.append_attribute("rel") = "http://opds-spec.org/acquisition/open-access";
+    acquisition_link.append_attribute("type") = "application/x-zim";
+    acquisition_link.append_attribute("href") = book.getUrl().c_str();
+    acquisition_link.append_attribute("length") = to_string(book.getSize()).c_str();
+  }
+
+  if (! book.getFaviconMimeType().empty() ) {
+    auto image_link = entry_node.append_child("link");
+    image_link.append_attribute("rel") = "http://opds-spec.org/image/thumbnail";
+    image_link.append_attribute("type") = book.getFaviconMimeType().c_str();
+    image_link.append_attribute("href") = (rootLocation + "/meta?name=favicon&content=" + book.getHumanReadableIdFromPath()).c_str();
+  }
+  return entry_node;
+}
+
+string OPDSDumper::dumpOPDSFeed(const std::vector<std::string>& bookIds)
+{
+  date = gen_date_str();
+  pugi::xml_document doc;
+
+  auto root_node = doc.append_child("feed");
+  root_node.append_attribute("xmlns") = "http://www.w3.org/2005/Atom";
+  root_node.append_attribute("xmlns:opds") = "http://opds-spec.org/2010/catalog";
+
+  ADD_TEXT_ENTRY(root_node, "id", id);
+
+  ADD_TEXT_ENTRY(root_node, "title", title);
+  ADD_TEXT_ENTRY(root_node, "updated", date);
+
+  if (m_isSearchResult) {
+    ADD_TEXT_ENTRY(root_node, "totalResults", to_string(m_totalResults));
+    ADD_TEXT_ENTRY(root_node, "startIndex", to_string(m_startIndex));
+    ADD_TEXT_ENTRY(root_node, "itemsPerPage", to_string(m_count));
+  }
+
+  auto self_link_node = root_node.append_child("link");
+  self_link_node.append_attribute("rel") = "self";
+  self_link_node.append_attribute("href") = "";
+  self_link_node.append_attribute("type") = "application/atom+xml";
+
+
+  if (!searchDescriptionUrl.empty() ) {
+    auto search_link = root_node.append_child("link");
+    search_link.append_attribute("rel") = "search";
+    search_link.append_attribute("type") = "application/opensearchdescription+xml";
+    search_link.append_attribute("href") = searchDescriptionUrl.c_str();
+  }
+
+  if (library) {
+    for (auto& bookId: bookIds) {
+      handleBook(library->getBookById(bookId), root_node);
+    }
+  }
+
+  return nodeToString(root_node);
+}
+
+}