New version 6.0.1

Generate the pom file from gradle

.gitignore

@@ -0,0 +1,2 @@
+.idea/
+*.swp

.travis.yml

@@ -1,6 +1,6 @@
 language: cpp
-dist: trusty
-sudo: false
+dist: xenial
+sudo: true
 cache: ccache
 before_install:
 - PATH=$PATH:$HOME/bin
@@ -18,6 +18,7 @@ addons:
   apt:
     packages:
       - cmake
+      - python3.5
       - python3-pip
       - libbz2-dev
       - ccache

ChangeLog

@@ -1,3 +1,70 @@
+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
 ===============
 

README.md

@@ -4,6 +4,11 @@ Kiwix library
 The Kiwix library provides the Kiwix software core. It contains the
 code shared by all Kiwix ports (Windows, Linux, OSX, Android, ...).
 
+[![Download](https://api.bintray.com/packages/kiwix/kiwix/kiwixlib/images/download.svg)](https://bintray.com/kiwix/kiwix/kiwixlib/_latestVersion)
+[![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)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+
 Disclaimer
 ----------
 
@@ -27,18 +32,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)
-* libaria2 .................................. https://aria2.github.io/
-(no package 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
@@ -47,17 +47,13 @@ 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.
-
-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.
+`kiwix-lib` directory as install prefix.
 
 Environment
 -------------
 
-The Kiwix library builds using [Meson](http://mesonbuild.com/) version
-0.39 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:
@@ -66,14 +62,16 @@ Install first the few common compilation tools:
 * Pkg-config
 
 These tools should be packaged if you use a cutting edge operating
-system. If not, have a look to the "Troubleshooting" section.
+system. If not, have a look to the [Troubleshooting](#Troubleshooting)
+section.
 
 Compilation
 -----------
 
 Once all dependencies are installed, you can compile the Kiwix library
 with:
-```
+
+```bash
 meson . build
 ninja -C build
 ```
@@ -91,31 +89,32 @@ Installation
 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
 ```
 
-You might need to run the command as root (or using 'sudo'), depending
+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).
+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').
+(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
@@ -123,7 +122,8 @@ 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

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 {
+        group 'org.kiwix.kiwixlib'
+        artifactId 'kiwixlib'
+        version '6.0.1'
+        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'

include/book.h

@@ -28,7 +28,6 @@ class xml_node;
 
 namespace kiwix
 {
-enum supportedIndexType { UNKNOWN, XAPIAN };
 
 class OPDSDumper;
 class Reader;
@@ -46,14 +45,12 @@ class Book
   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();
+  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& getIndexPath() const { return m_indexPath; }
-  const supportedIndexType& getIndexType() const { return m_indexType; }
   const std::string& getTitle() const { return m_title; }
   const std::string& getDescription() const { return m_description; }
   const std::string& getLanguage() const { return m_language; }
@@ -76,8 +73,6 @@ class Book
   void setId(const std::string& id) { m_id = id; }
   void setPath(const std::string& path);
   void setPathValid(bool valid) { m_pathValid = valid; }
-  void setIndexPath(const std::string& indexPath);
-  void setIndexType(supportedIndexType indexType) { m_indexType = indexType;}
   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; }
@@ -100,8 +95,6 @@ class Book
   std::string m_downloadId;
   std::string m_path;
   bool m_pathValid;
-  std::string m_indexPath;
-  supportedIndexType m_indexType;
   std::string m_title;
   std::string m_description;
   std::string m_language;

include/common/pathTools.h

@@ -1,64 +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 <fcntl.h>
-#include <limits.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <fstream>
-#include <ios>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#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);
-string getFileContent(const string& path);
-bool fileExists(const string& path);
-bool makeDirectory(const string& path);
-string makeTmpDirectory();
-bool copyFile(const string& sourcePath, const string& destPath);
-string getLastPathElement(const string& path);
-string getExecutablePath();
-string getCurrentDirectory();
-string getDataDirectory();
-bool writeTextFile(const string& path, const string& content);
-#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

@@ -54,6 +54,9 @@ class Download {
       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; }

include/entry.h

@@ -24,6 +24,7 @@
 #include <zim/article.h>
 #include <exception>
 #include <string>
+
 #include "common.h"
 
 using namespace std;

include/kiwixserve.h

@@ -0,0 +1,27 @@
+#ifndef KIWIXLIB_KIWIX_SERVE_H_
+#define KIWIXLIB_KIWIX_SERVE_H_
+
+#include <memory>
+
+class Subprocess;
+namespace kiwix {
+
+class KiwixServe
+{
+  public:
+    KiwixServe(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;
+};
+
+}; //end namespace kiwix
+
+#endif // KIWIXLIB_KIWIX_SERVE_H_

include/library.h

@@ -23,9 +23,11 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <memory>
 
 #include "book.h"
 #include "bookmark.h"
+#include "common.h"
 
 #define KIWIX_LIBRARY_VERSION "20110515"
 
@@ -44,12 +46,72 @@ enum supportedListMode {
   VALID = 1 << 4,
   NOVALID = 1 << 5
 };
+
+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:
+    Filter();
+    ~Filter() = default;
+
+    /**
+     *  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.
+     */
+    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:
@@ -85,6 +147,7 @@ class Library
   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.
@@ -162,9 +225,27 @@ class Library
    * @param search List only books with search in the title or description.
    * @return The list of bookIds corresponding to the query.
    */
-  std::vector<std::string> filter(const std::string& search);
+  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.
    *
@@ -187,13 +268,14 @@ class Library
    *                Set to 0 to cancel this filter.
    * @return The list of bookIds corresponding to the query.
    */
-  std::vector<std::string> listBooksIds(
+  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;

include/manager.h

@@ -58,9 +58,6 @@ class DefaultLibraryManipulator : public LibraryManipulator {
 
 /**
  * A tool to manage a `Library`.
- *
- * A `Manager` handle a internal `Library`.
- * This `Library` can be retrived with `cloneLibrary` method.
  */
 class Manager
 {
@@ -158,55 +155,6 @@ class Manager
                        const std::string& url = "",
                        const bool checkMetaData = false);
 
-  /**
-   * Get the book corresponding to an id.
-   *
-   * @param[in] id The id of the book
-   * @param[out] book The book corresponding to the id.
-   * @return True if the book has been found.
-   */
-  bool getBookById(const std::string& id, Book& book);
-
-  /**
-   * Update the "last open date" of a book
-   *
-   * @param id the id of the book.
-   * @return True if the book is in the library.
-   */
-  bool updateBookLastOpenDateById(const std::string& id);
-
-  /**
-   * Remove (set to empty) paths of all books in the library.
-   */
-  void removeBookPaths();
-
-  /**
-   * List books in the library.
-   *
-   * The books list will be available in public vector member `bookIdList`.
-   *
-   * @param mode The mode of listing :
-   *             - LASTOPEN sort by last opened book.
-   *             - LOCAL list only local file.
-   *             - REMOTE list only remote file.
-   * @param sortBy Attribute to sort by the book list.
-   * @param maxSize Do not list book bigger than maxSize MiB.
-   *                Set to 0 to cancel this filter.
-   * @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 search List only books with search in the title, description or
-   *               language.
-   * @return True
-   */
-  bool listBooks(const supportedListMode mode,
-                 const supportedListSortBy sortBy,
-                 const unsigned int maxSize,
-                 const std::string& language,
-                 const std::string& creator,
-                 const std::string& publisher,
-                 const std::string& search);
-
   std::string writableLibraryPath;
 
   bool m_hasSearchResult = false;
@@ -225,8 +173,6 @@ class Manager
   bool parseOpdsDom(const pugi::xml_document& doc,
                     const std::string& urlHost);
 
- private:
-  void checkAndCleanBookPaths(Book& book, const std::string& libraryPath);
 };
 }
 

include/meson.build

@@ -9,29 +9,23 @@ headers = [
   'downloader.h',
   'reader.h',
   'entry.h',
-  'searcher.h'
+  'searcher.h',
+  'search_renderer.h',
+  'server.h',
+  'kiwixserve.h',
+  'name_mapper.h'
 ]
 
-if xapian_dep.found()
-  headers += ['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',
-  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

@@ -26,9 +26,9 @@
 
 #include <pugixml.hpp>
 
-#include "common/base64.h"
-#include "common/pathTools.h"
-#include "common/regexTools.h"
+#include "tools/base64.h"
+#include "tools/pathTools.h"
+#include "tools/regexTools.h"
 #include "library.h"
 #include "reader.h"
 

include/reader.h

@@ -31,8 +31,8 @@
 #include <string>
 #include "common.h"
 #include "entry.h"
-#include "common/pathTools.h"
-#include "common/stringTools.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 
 using namespace std;
 

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

@@ -29,8 +29,8 @@
 #include <string>
 #include <vector>
 #include <vector>
-#include "common/pathTools.h"
-#include "common/stringTools.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 #include "kiwix_config.h"
 
 using namespace std;
@@ -56,65 +56,28 @@ struct SearcherInternal;
 /**
  * The Searcher class is reponsible to do different kind of search using the
  * fulltext index.
- *
- * Historically, there are two kind of fulltext index :
- *  - The legacy one, is the external fulltext index. A directory stored outside
- *    of the zim file.
- *  - The new one, a embedded fulltext index in the zim file.
- *
- * Legacy external fulltext index has to be considered as obsolet format with
- * less functionnalities:
- *  - No multi zim search ;
- *  - No geo_search ;
- *  - No suggestions search ;
- *
- * To reflect this, there is two Search creation "API":
- *  - One for the external fulltext index, using the constructor taking a
- *    xapianDirectoryPath) ;
- *  - One for the embedded fulltext index, using a "empty" constructor and the
- *  `add_reader` method".
- *
- *  On top of that, the Searcher may (if compiled with ctpp2) be used to
- *  generate a html page for the search result. This use a template that need a
- *  humanReaderName. This feature is only used by kiwix-serve and this should be
- *  move outside of Searcher (and with a better API). If you don't use the html
- *  rendering (getHtml method), you better should simply ignore the different
- *  humanReadeableName attributes (or give an empty string).
  */
 class Searcher
 {
  public:
   /**
    * The default constructor.
-   *
-   * @param humanReadableName The global zim's humanReadableName.
-   *                          Used to generate pagination links.
    */
-  Searcher(const string& humanReadableName = "");
+  Searcher();
 
-  /**
-   * The constructor for legacy external fulltext index.
-   *
-   * @param xapianDirectoryPath The path to the external index directory.
-   * @param reader The reader associated to the external index.
-   *               It will be used retrive the article content or generate
-   *               the snippet.
-   * @param humanReadableName The humanReadableName for the zim.
-   */
-  Searcher(const string& xapianDirectoryPath,
-           Reader* reader,
-           const string& humanReadableName);
   ~Searcher();
 
   /**
    * Add a reader (containing embedded fulltext index) to the search.
    *
    * @param reader The Reader for the zim containing the fulltext index.
-   * @param humanReaderName The human readable name of the reader.
    * @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, const std::string& humanReaderName);
+  bool add_reader(Reader* reader);
+
+
+  Reader* get_reader(int index);
 
   /**
    * Start a search on the zim associated to the Searcher.
@@ -180,24 +143,8 @@ class Searcher
    */
   unsigned int getEstimatedResultCount();
 
-  /**
-   * Set protocol prefix.
-   * Only used by getHtml.
-   */
-  bool setProtocolPrefix(const std::string prefix);
-
-  /**
-   * Set search protocol prefix.
-   * Only used by getHtml.
-   */
-  bool setSearchProtocolPrefix(const std::string prefix);
-
-#ifdef ENABLE_CTPP2
-  /**
-   * Generate the html page with the resutls of the search.
-   */
-  string getHtml();
-#endif
+  unsigned int getResultStart() { return resultStart; }
+  unsigned int getResultEnd() { return resultEnd; }
 
  protected:
   std::string beautifyInteger(const unsigned int number);
@@ -208,16 +155,11 @@ class Searcher
                      const bool verbose = false);
 
   std::vector<Reader*> readers;
-  std::vector<std::string> humanReaderNames;
   SearcherInternal* internal;
   std::string searchPattern;
-  std::string protocolPrefix;
-  std::string searchProtocolPrefix;
-  unsigned int resultCountPerPage;
   unsigned int estimatedResultCount;
   unsigned int resultStart;
   unsigned int resultEnd;
-  std::string contentHumanReadableId;
 
  private:
   void reset();

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/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

@@ -20,13 +20,10 @@
 #ifndef KIWIX_NETWORKTOOLS_H
 #define KIWIX_NETWORKTOOLS_H
 
-#include <map>
 #include <string>
 
 namespace kiwix
 {
-std::map<std::string, std::string> getNetworkInterfaces();
-std::string getBestPublicIp();
 std::string download(const std::string& url);
 }
 

include/tools/otherTools.h

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

include/tools/pathTools.h

@@ -0,0 +1,46 @@
+/*
+ * 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,
+                                  const bool removePreSeparator = false,
+                                  const bool removePostSeparator = false);
+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();
+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,9 +20,6 @@
 #ifndef KIWIX_REGEXTOOLS_H
 #define KIWIX_REGEXTOOLS_H
 
-#include <unicode/regex.h>
-#include <unicode/ucnv.h>
-#include <map>
 #include <string>
 
 bool matchRegex(const std::string& content, const std::string& regex);
@@ -30,7 +27,7 @@ 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& regex,
                                    const std::string& replacement);
 
 #endif

include/tools/stringTools.h

@@ -22,19 +22,12 @@
 
 #include <unicode/unistr.h>
 
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
 #include <string>
 #include <vector>
-
-#include "pathTools.h"
+#include <sstream>
 
 namespace kiwix
 {
-#ifndef __ANDROID__
-
 std::string beautifyInteger(uint64_t number);
 std::string beautifyFileSize(uint64_t number);
 void printStringInHexadecimal(const char* s);
@@ -44,8 +37,6 @@ void stringReplacement(std::string& str,
                        const std::string& newStr);
 std::string encodeDiples(const std::string& str);
 
-#endif
-
 std::string removeAccents(const std::string& text);
 void loadICUExternalTables();
 
@@ -79,5 +70,7 @@ T extractFromString(const std::string& str) {
     iss >> ret;
     return ret;
 }
+
+bool startsWith(const std::string& base, const std::string& start);
 } //namespace kiwix
 #endif

include/xapianSearcher.h

@@ -1,98 +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 "reader.h"
-#include "searcher.h"
-
-#include <map>
-#include <string>
-
-using namespace std;
-
-namespace kiwix
-{
-class XapianSearcher;
-
-class XapianResult : public Result
-{
- public:
-  XapianResult(XapianSearcher* searcher, Xapian::MSetIterator& iterator);
-  virtual ~XapianResult(){};
-
-  virtual std::string get_url();
-  virtual std::string get_title();
-  virtual int get_score();
-  virtual std::string get_snippet();
-  virtual std::string get_content();
-  virtual int get_wordCount();
-  virtual int get_size();
-  virtual int get_readerIndex() { return 0; };
-
- private:
-  XapianSearcher* searcher;
-  Xapian::MSetIterator iterator;
-  Xapian::Document document;
-};
-
-class NoXapianIndexInZim : public exception
-{
-  virtual const char* what() const throw()
-  {
-    return "There is no fulltext index in the zim file";
-  }
-};
-
-class XapianSearcher
-{
-  friend class XapianResult;
-
- public:
-  XapianSearcher(const string& xapianDirectoryPath, Reader* reader);
-  virtual ~XapianSearcher(){};
-  void searchInIndex(string& search,
-                     const unsigned int resultStart,
-                     const unsigned int resultEnd,
-                     const bool verbose = false);
-  virtual Result* getNextResult();
-  void restart_search();
-
-  Xapian::MSet results;
-
- protected:
-  void closeIndex();
-  void openIndex(const string& xapianDirectoryPath);
-  void setup_queryParser();
-
-  Reader* reader;
-  Xapian::Database readableDatabase;
-  std::string language;
-  std::string stopwords;
-  Xapian::QueryParser queryParser;
-  Xapian::Stem stemmer;
-  Xapian::SimpleStopper stopper;
-  Xapian::MSetIterator current_result;
-  std::map<std::string, int> valuesmap;
-};
-}
-
-#endif

meson.build

@@ -1,10 +1,9 @@
 project('kiwix-lib', 'cpp',
-  version : '3.1.1',
+  version : '6.0.1',
   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')
@@ -15,9 +14,14 @@ endif
 
 thread_dep = dependency('threads')
 libicu_dep = dependency('icu-i18n', static:static_deps)
-libzim_dep = dependency('libzim', version : '>=4.0.0', 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)
+
+if not compiler.has_header('mustache.hpp')
+  error('Cannot found header mustache.hpp')
+endif
 
 extra_cflags = ''
 if target_machine.system() == 'windows' and static_deps
@@ -25,77 +29,12 @@ if target_machine.system() == 'windows' and static_deps
   extra_cflags += '-DCURL_STATICLIB'
 endif
 
-
-
-ctpp2_include_path = ''
-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 = join_paths(ctpp2_prefix_install, get_option('libdir'))
-    message(ctpp2_lib_path)
-    ctpp2_lib = compiler.find_library('ctpp2', dirs:ctpp2_lib_path, required:false)
-    if not ctpp2_lib.found()
-      ctpp2_lib_path = join_paths(ctpp2_prefix_install, 'lib')
-      message(ctpp2_lib_path)
-      ctpp2_lib = compiler.find_library('ctpp2', dirs:ctpp2_lib_path)
-    endif
-    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
-endif
-
-xapian_dep = dependency('xapian-core', required:false, static:static_deps)
-
-all_deps = [thread_dep, libicu_dep, libzim_dep, xapian_dep, pugixml_dep, libcurl_dep]
-if has_ctpp2_dep
-  all_deps += [ctpp2_dep]
-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']
@@ -110,16 +49,6 @@ subdir('src')
 subdir('test')
 
 pkg_requires = ['libzim', 'icu-i18n', 'pugixml', 'libcurl']
-if xapian_dep.found()
-    pkg_requires += ['xapian-core']
-endif
-
-if has_ctpp2_dep
-  extra_libs += ctpp2_link_args
-  if ctpp2_include_path != ''
-    extra_cflags = ' -I'+ctpp2_include_path
-  endif
-endif
 
 pkg_conf = configuration_data()
 pkg_conf.set('prefix', get_option('prefix'))

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/ctpp2c.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-
-ctpp2c=$1
-SOURCE=$(pwd)/$2
-DEST=$3
-
-$ctpp2c $SOURCE $DEST

scripts/meson.build

@@ -1,5 +1,4 @@
 
 res_compiler = find_program('kiwix-compile-resources')
-intermediate_ctpp2c = find_program('ctpp2c.sh')
 
 install_data(res_compiler.path(), install_dir:get_option('bindir'))

src/android/kiwixicu.cpp

@@ -19,7 +19,7 @@
  */
 
 #include <jni.h>
-#include "org_kiwix_kiwixlib_JNIKiwix.h"
+#include "org_kiwix_kiwixlib_JNIICU.h"
 
 #include <iostream>
 #include <string>
@@ -30,8 +30,8 @@
 
 pthread_mutex_t globalLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
 
-JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_setDataDirectory(
-    JNIEnv* env, jobject obj, jstring dirStr)
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIICU_setDataDirectory(
+    JNIEnv* env, jclass kclass, jstring dirStr)
 {
   std::string cPath = jni2c(dirStr, env);
 

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

@@ -24,7 +24,7 @@
 #include <android/log.h>
 #include "org_kiwix_kiwixlib_JNIKiwixReader.h"
 
-#include "common/base64.h"
+#include "tools/base64.h"
 #include "reader.h"
 #include "utils.h"
 
@@ -91,7 +91,7 @@ Java_org_kiwix_kiwixlib_JNIKiwixReader_getId(JNIEnv* env, jobject obj)
 JNIEXPORT jint JNICALL
 Java_org_kiwix_kiwixlib_JNIKiwixReader_getFileSize(JNIEnv* env, jobject obj)
 {
-  jint size;
+  jint size = 0;
 
   try {
     int cSize = READER->getFileSize();
@@ -224,8 +224,23 @@ JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getMimeType(
   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, jstring url, jobject titleObj, jobject mimeTypeObj, jobject sizeObj)
+    JNIEnv* env, jobject obj, jobject url, jobject titleObj, jobject mimeTypeObj, jobject sizeObj)
 {
   /* Default values */
   setStringObjValue("", titleObj, env);
@@ -234,21 +249,24 @@ JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getContent(
   jbyteArray data = env->NewByteArray(0);
 
   /* Retrieve the content */
-  std::string cUrl = jni2c(url, env);
+  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);
-
-    data = env->NewByteArray(cSize);
-    env->SetByteArrayRegion(
-        data, 0, cSize, reinterpret_cast<const jbyte*>(entry.getBlob().data()));
-
     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());

src/android/kiwixsearcher.cpp

@@ -52,7 +52,7 @@ JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_addReader(
 {
   auto searcher = SEARCHER;
 
-  searcher->add_reader(*(Handle<kiwix::Reader>::getHandle(env, reader)), "");
+  searcher->add_reader(*(Handle<kiwix::Reader>::getHandle(env, reader)));
 }
 
 JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_search(

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,8 +1,10 @@
 
 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',
@@ -10,15 +12,19 @@ kiwix_jni = custom_target('jni',
           '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',
+    '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')

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

@@ -20,12 +20,17 @@
 
 package org.kiwix.kiwixlib;
 
-import org.kiwix.kiwixlib.JNIKiwixReader;
-import org.kiwix.kiwixlib.JNIKiwixString;
+import android.content.Context;
+import com.getkeepsafe.relinker.ReLinker;
+import org.kiwix.kiwixlib.JNIICU;
 
 public class JNIKiwix
 {
-  static { System.loadLibrary("kiwix"); }
+  public JNIKiwix(final Context context){
+    ReLinker.loadLibrary(context, "kiwix");
+  }
 
-  public native void setDataDirectory(String icuDataDir);
+  public void setDataDirectory(String icuDataDir) {
+    JNIICU.setDataDirectory(icuDataDir);
+  }
 }

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

@@ -0,0 +1,38 @@
+/*
+ * 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;
+
+public class JNIKiwixLibrary
+{
+  public native boolean addBook(String path) throws JNIKiwixException;
+
+  public JNIKiwixLibrary()
+  {
+    nativeHandle = getNativeLibrary();
+  }
+
+  public native void dispose();
+
+  private native long getNativeLibrary();
+  private long nativeHandle;
+}

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

@@ -38,7 +38,31 @@ public class JNIKiwixReader
 
   public native String getMimeType(String url);
 
-  public native byte[] getContent(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);

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

@@ -22,4 +22,16 @@ package org.kiwix.kiwixlib;
 public class JNIKiwixString
 {
   public String value;
+
+  public JNIKiwixString(String value) {
+    this.value = value;
+  }
+
+  public JNIKiwixString() {
+    this("");
+  }
+
+  public String getValue() {
+    return value;
+  }
 }

src/android/utils.h

@@ -114,6 +114,13 @@ inline std::string jni2c(const jstring& val, JNIEnv* env)
 
 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)

src/aria2.cpp

@@ -2,20 +2,24 @@
 
 #include "aria2.h"
 #include "xmlrpc.h"
+#include <iostream>
 #include <sstream>
 #include <thread>
 #include <chrono>
-#include <common/otherTools.h>
-#include <common/pathTools.h>
+#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():
@@ -82,7 +86,7 @@ Aria2::Aria2():
 
   int watchdog = 50;
   while(--watchdog) {
-    std::this_thread::sleep_for(std::chrono::microseconds(10000));
+    sleep(10);
     auto res = curl_easy_perform(mp_curl);
     if (res == CURLE_OK) {
       break;
@@ -171,7 +175,6 @@ std::vector<std::string> Aria2::tellActive()
   MethodCall methodCall("aria2.tellActive", m_secret);
   auto statusArray = methodCall.newParamValue().getArray();
   statusArray.addValue().set(std::string("gid"));
-  statusArray.addValue().set(std::string("following"));
   auto responseContent = doRequest(methodCall);
   MethodResponse response(responseContent);
   std::vector<std::string> activeGID;
@@ -186,6 +189,27 @@ std::vector<std::string> Aria2::tellActive()
   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);
@@ -199,5 +223,25 @@ void Aria2::shutdown()
   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

@@ -37,8 +37,12 @@ class Aria2
     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

src/book.cpp

@@ -20,16 +20,18 @@
 #include "book.h"
 #include "reader.h"
 
-#include "common/base64.h"
-#include "common/regexTools.h"
-#include "common/networkTools.h"
+#include "tools/base64.h"
+#include "tools/regexTools.h"
+#include "tools/networkTools.h"
 
 #include <pugixml.hpp>
 
 namespace kiwix
 {
 /* Constructor */
-Book::Book() : m_readOnly(false)
+Book::Book() :
+  m_pathValid(false),
+  m_readOnly(false)
 {
 }
 /* Destructor */
@@ -46,6 +48,7 @@ bool Book::update(const kiwix::Book& other)
 
   if (m_path.empty()) {
     m_path = other.m_path;
+    m_pathValid = other.m_pathValid;
   }
 
   if (m_url.empty()) {
@@ -60,11 +63,6 @@ bool Book::update(const kiwix::Book& other)
     m_name = other.m_name;
   }
 
-  if (m_indexPath.empty()) {
-    m_indexPath = other.m_indexPath;
-    m_indexType = other.m_indexType;
-  }
-
   if (m_faviconMimeType.empty()) {
     m_favicon = other.m_favicon;
     m_faviconMimeType = other.m_faviconMimeType;
@@ -88,6 +86,7 @@ void Book::update(const kiwix::Reader& reader)
   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);
 }
@@ -101,14 +100,6 @@ void Book::updateFromXml(const pugi::xml_node& node, const std::string& baseDir)
     path = computeAbsolutePath(baseDir, path);
   }
   m_path = path;
-  path = ATTR("indexPath");
-  if (!path.empty()) {
-    if (isRelativePath(path)) {
-      path = computeAbsolutePath(baseDir, path);
-    }
-    m_indexPath = path;
-    m_indexType = XAPIAN;
-  }
   m_title = ATTR("title");
   m_name = ATTR("name");
   m_tags = ATTR("tags");
@@ -151,6 +142,7 @@ void Book::updateFromOpds(const pugi::xml_node& node, const std::string& urlHost
   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();
@@ -168,7 +160,7 @@ void Book::updateFromOpds(const pugi::xml_node& node, const std::string& urlHost
 }
 #undef VALUE
 
-std::string Book::getHumanReadableIdFromPath()
+std::string Book::getHumanReadableIdFromPath() const
 {
   std::string id = m_path;
   if (!id.empty()) {
@@ -194,13 +186,6 @@ void Book::setPath(const std::string& path)
    : path;
 }
 
-void Book::setIndexPath(const std::string& indexPath)
-{
-  m_indexPath = isRelativePath(indexPath)
-    ? computeAbsolutePath(getCurrentDirectory(), indexPath)
-    : indexPath;
-}
-
 const std::string& Book::getFavicon() const {
   if (m_favicon.empty() && !m_faviconUrl.empty()) {
     try {

src/common/networkTools.cpp

@@ -1,209 +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>
-
-#ifdef _WIN32
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <net/if.h>
-#include <netdb.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-
-#include <curl/curl.h>
-
-#include <sstream>
-#include <iostream>
-
-
-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)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";
-}
-
-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 kiwix::download(const std::string& url) {
-  auto curl = curl_easy_init();
-  std::stringstream ss;
-  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
-  curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
-  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &write_callback_to_iss);
-  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ss);
-  auto res = curl_easy_perform(curl);
-  if (res != CURLE_OK) {
-    curl_easy_cleanup(curl);
-    throw std::runtime_error("Cannot perform request");
-  }
-  long response_code;
-  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
-  curl_easy_cleanup(curl);
-  if (response_code != 200) {
-    throw std::runtime_error("Invalid return code from server");
-  }
-  return ss.str();
-}

src/common/otherTools.cpp

@@ -1,326 +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.
- */
-
-#include <common/otherTools.h>
-#include <map>
-
-static std::map<std::string, std::string> codeisomapping {
-//a
-  { "ad", "and" },
-  { "ae", "are" },
-  { "af", "afg" },
-  { "ag", "atg" },
-  { "ai", "aia" },
-  { "al", "alb" },
-  { "am", "arm" },
-  { "an", "ant" },
-  { "ao", "ago" },
-  { "aq", "ata" },
-  { "ar", "arg" },
-  { "as", "asm" },
-  { "at", "aut" },
-  { "au", "aus" },
-  { "aw", "abw" },
-  { "ax", "ala" },
-  { "az", "aze" },
-//b
-  { "ba", "bih" },
-  { "bb", "brb" },
-  { "bd", "bgd" },
-  { "be", "bel" },
-  { "bf", "bfa" },
-  { "bg", "bgr" },
-  { "bh", "bhr" },
-  { "bi", "bdi" },
-  { "bj", "ben" },
-  { "bl", "blm" },
-  { "bn", "brn" },
-  { "bm", "bmu" },
-  { "bo", "bol" },
-  { "br", "bra" },
-  { "bs", "bhs" },
-  { "bt", "btn" },
-  { "bv", "bvt" },
-  { "bw", "bwa" },
-  { "by", "blr" },
-  { "bz", "blz" },
-//c
-  { "ca", "can" },
-  { "cc", "cck" },
-  { "cd", "cod" },
-  { "cf", "caf" },
-  { "cg", "cog" },
-  { "ch", "che" },
-  { "ci", "civ" },
-  { "ck", "cok" },
-  { "cl", "chl" },
-  { "cm", "cmr" },
-  { "cn", "chn" },
-  { "co", "col" },
-  { "cr", "cri" },
-  { "cu", "cub" },
-  { "cv", "cpv" },
-  { "cx", "cxr" },
-  { "cy", "cyp" },
-  { "cz", "cze" },
-//d
-  { "de", "deu" },
-  { "dj", "dji" },
-  { "dk", "dnk" },
-  { "dm", "dma" },
-  { "do", "dom" },
-  { "dz", "dza" },
-//e
-  { "ec", "ecu" },
-  { "ee", "est" },
-  { "eg", "egy" },
-  { "eh", "esh" },
-  { "en", "eng" },
-  { "er", "eri" },
-  { "es", "esp" },
-  { "et", "eth" },
-//f
-  { "fi", "fin" },
-  { "fj", "fji" },
-  { "fk", "flk" },
-  { "fm", "fsm" },
-  { "fo", "fro" },
-  { "fr", "fra" },
-//g
-  { "ga", "gab" },
-  { "gb", "gbr" },
-  { "gd", "grd" },
-  { "ge", "geo" },
-  { "gf", "guf" },
-  { "gg", "ggy" },
-  { "gh", "gha" },
-  { "gi", "gib" },
-  { "gl", "grl" },
-  { "gm", "gmb" },
-  { "gn", "gin" },
-  { "gp", "glp" },
-  { "gq", "gnq" },
-  { "gr", "grc" },
-  { "gs", "sgs" },
-  { "gt", "gtm" },
-  { "gu", "gum" },
-  { "gw", "gnb" },
-  { "gy", "guy" },
-//h
-  { "hk", "hkg" },
-  { "hm", "hmd" },
-  { "hn", "hnd" },
-  { "hr", "hrv" },
-  { "ht", "hti" },
-  { "hu", "hun" },
-//i
-  { "id", "idn" },
-  { "ie", "irl" },
-  { "il", "isr" },
-  { "im", "imn" },
-  { "in", "ind" },
-  { "io", "iot" },
-  { "iq", "irq" },
-  { "ir", "irn" },
-  { "is", "isl" },
-  { "it", "ita" },
-//j
-  { "je", "jey" },
-  { "jm", "jam" },
-  { "jo", "jor" },
-  { "jp", "jpn" },
-//k
-  { "ke", "ken" },
-  { "kg", "kgz" },
-  { "kh", "khm" },
-  { "ki", "kir" },
-  { "km", "com" },
-  { "kn", "kna" },
-  { "kp", "prk" },
-  { "kr", "kor" },
-  { "kw", "kwt" },
-  { "ky", "cym" },
-  { "kz", "kaz" },
-//l
-  { "la", "lao" },
-  { "lb", "lbn" },
-  { "lc", "lca" },
-  { "li", "lie" },
-  { "lk", "lka" },
-  { "lr", "lbr" },
-  { "ls", "lso" },
-  { "lt", "ltu" },
-  { "lu", "lux" },
-  { "lv", "lva" },
-  { "ly", "lby" },
-//m
-  { "ma", "mar" },
-  { "mc", "mco" },
-  { "md", "mda" },
-  { "me", "mne" },
-  { "mf", "maf" },
-  { "mg", "mdg" },
-  { "mh", "mhl" },
-  { "mk", "mkd" },
-  { "ml", "mli" },
-  { "mm", "mmr" },
-  { "mn", "mng" },
-  { "mo", "mac" },
-  { "mp", "mnp" },
-  { "mq", "mtq" },
-  { "mr", "mrt" },
-  { "ms", "msr" },
-  { "mt", "mlt" },
-  { "mu", "mus" },
-  { "mv", "mdv" },
-  { "mw", "mwi" },
-  { "mx", "mex" },
-  { "my", "mys" },
-  { "mz", "moz" },
-//n
-  { "na", "nam" },
-  { "nc", "ncl" },
-  { "ne", "ner" },
-  { "nf", "nfk" },
-  { "ng", "nga" },
-  { "ni", "nic" },
-  { "nl", "nld" },
-  { "no", "nor" },
-  { "np", "npl" },
-  { "nr", "nru" },
-  { "nu", "niu" },
-  { "nz", "nzl" },
-//o
-  { "om", "omn" },
-//p
-  { "pa", "pan" },
-  { "pe", "per" },
-  { "pf", "pyf" },
-  { "pg", "png" },
-  { "ph", "phl" },
-  { "pk", "pak" },
-  { "pl", "pol" },
-  { "pm", "spm" },
-  { "pn", "pcn" },
-  { "pr", "pri" },
-  { "ps", "pse" },
-  { "pt", "prt" },
-  { "pw", "plw" },
-  { "py", "pry" },
-//q
-  { "qa", "qat" },
-//r
-  { "re", "reu" },
-  { "ro", "rou" },
-  { "rs", "srb" },
-  { "ru", "rus" },
-  { "rw", "rwa" },
-//s
-  { "sa", "sau" },
-  { "sb", "slb" },
-  { "sc", "syc" },
-  { "sd", "sdn" },
-  { "se", "swe" },
-  { "sg", "sgp" },
-  { "sh", "shn" },
-  { "si", "svn" },
-  { "sj", "sjm" },
-  { "sk", "svk" },
-  { "sl", "sle" },
-  { "sm", "smr" },
-  { "sn", "sen" },
-  { "so", "som" },
-  { "sr", "sur" },
-  { "ss", "ssd" },
-  { "st", "stp" },
-  { "sv", "slv" },
-  { "sy", "syr" },
-  { "sz", "swz" },
-//t
-  { "tc", "tca" },
-  { "td", "tcd" },
-  { "tf", "atf" },
-  { "tg", "tgo" },
-  { "th", "tha" },
-  { "tj", "tjk" },
-  { "tk", "tkl" },
-  { "tl", "tls" },
-  { "tm", "tkm" },
-  { "tn", "tun" },
-  { "to", "ton" },
-  { "tr", "tur" },
-  { "tt", "tto" },
-  { "tv", "tuv" },
-  { "tw", "twn" },
-  { "tz", "tza" },
-//u
-  { "ua", "ukr" },
-  { "ug", "uga" },
-  { "um", "umi" },
-  { "us", "usa" },
-  { "uy", "ury" },
-  { "uz", "uzb" },
-//v
-  { "va", "vat" },
-  { "vc", "vct" },
-  { "ve", "ven" },
-  { "vg", "vgb" },
-  { "vi", "vir" },
-  { "vn", "vnm" },
-  { "vu", "vut" },
-//w
-  { "wf", "wlf" },
-  { "ws", "wsm" },
-//y
-  { "ye", "yem" },
-  { "yt", "myt" },
-// z
-  { "za", "zaf" },
-  { "zm", "zmb" },
-  { "zw", "zwe" }
-};
-
-void kiwix::sleep(unsigned int milliseconds)
-{
-#ifdef _WIN32
-  Sleep(milliseconds);
-#else
-  usleep(1000 * milliseconds);
-#endif
-}
-
-
-struct XmlStringWriter: pugi::xml_writer
-{
-  std::string result;
-  virtual void write(const void* data, size_t size){
-    result.append(static_cast<const char*>(data), size);
-  }
-};
-
-std::string kiwix::nodeToString(pugi::xml_node node)
-{
-  XmlStringWriter writer;
-  node.print(writer, "  ");
-  return writer.result;
-}
-
-std::string kiwix::converta2toa3(const std::string& a2code){
-  return codeisomapping.at(a2code);
-}

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

@@ -18,7 +18,8 @@
  */
 
 #include "downloader.h"
-#include "common/pathTools.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 
 #include <algorithm>
 #include <thread>
@@ -28,7 +29,7 @@
 
 #include "aria2.h"
 #include "xmlrpc.h"
-#include "common/otherTools.h"
+#include "tools/otherTools.h"
 #include <pugixml.hpp>
 
 namespace kiwix
@@ -36,6 +37,8 @@ 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"};
@@ -93,6 +96,33 @@ void Download::updateStatus(bool follow)
   }
 }
 
+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())
@@ -101,6 +131,10 @@ Downloader::Downloader() :
     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();
+  }
 }
 
 
@@ -139,14 +173,23 @@ Download* Downloader::startDownload(const std::string& uri)
 Download* Downloader::getDownload(const std::string& did)
 {
   try {
+    m_knownDownloads.at(did).get()->updateStatus(true);
     return m_knownDownloads.at(did).get();
-  } catch(exception& e) {
+  } 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

@@ -122,7 +122,6 @@ Entry Entry::getFinalEntry() const
   if (final_article.good()) {
     return final_article;
   }
-
   int loopCounter = 42;
   final_article = article;
   while (final_article.isRedirect() && loopCounter--) {
@@ -131,7 +130,10 @@ Entry Entry::getFinalEntry() const
       throw NoEntry();
     }
   }
-
+  // Prevent infinite loops.
+  if (final_article.isRedirect()) {
+    throw NoEntry();
+  }
   return final_article;
 }
 

src/kiwixserve.cpp

@@ -0,0 +1,70 @@
+#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(int port) : m_port(port)
+{
+}
+
+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, 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 libraryPath = getDataDirectory() + "/library.xml";
+    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(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

@@ -19,17 +19,21 @@
 
 #include "library.h"
 #include "book.h"
+#include "reader.h"
 #include "libxml_dumper.h"
 
-#include "common/base64.h"
-#include "common/regexTools.h"
-#include "common/pathTools.h"
+#include "tools/base64.h"
+#include "tools/regexTools.h"
+#include "tools/pathTools.h"
+#include "tools/stringTools.h"
 
 #include <pugixml.hpp>
 #include <algorithm>
+#include <set>
 
 namespace kiwix
 {
+
 /* Constructor */
 Library::Library()
 {
@@ -81,6 +85,20 @@ 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)
 {
@@ -95,14 +113,16 @@ unsigned int Library::getBookCount(const bool localBooks,
   return result;
 }
 
-bool Library::writeToFile(const std::string& path) {
+bool Library::writeToFile(const std::string& path)
+{
   auto baseDir = removeLastPathElement(path, true, false);
   LibXMLDumper dumper(this);
   dumper.setBaseDir(baseDir);
   return writeTextFile(path, dumper.dumpLibXMLContent(getBooksIds()));
 }
 
-bool Library::writeBookmarksToFile(const std::string& path) {
+bool Library::writeBookmarksToFile(const std::string& path)
+{
   LibXMLDumper dumper(this);
   return writeTextFile(path, dumper.dumpLibXMLBookmark());
 }
@@ -181,67 +201,104 @@ std::vector<std::string> Library::filter(const std::string& search)
     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 (matchRegex(book.getTitle(), "\\Q" + search + "\\E")
-         || matchRegex(book.getDescription(), "\\Q" + search + "\\E")) {
-       bookIds.push_back(pair.first);
-     }
+    auto book = pair.second;
+    if(filter.accept(book)) {
+      bookIds.push_back(pair.first);
+    }
   }
-
   return bookIds;
 }
 
-template<supportedListSortBy sort>
-struct Comparator {
-  Library* lib;
-  Comparator(Library* lib) : lib(lib) {}
-
-  bool operator() (const std::string& id1, const std::string& id2) {
-    return get_keys(id1) < get_keys(id2);
-  }
-
-  std::string get_keys(const std::string& id);
-  unsigned int get_keyi(const std::string& id);
+template<supportedListSortBy SORT>
+struct KEY_TYPE {
+  typedef std::string TYPE;
 };
 
 template<>
-std::string Comparator<TITLE>::get_keys(const std::string& id)
+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<>
-unsigned int Comparator<SIZE>::get_keyi(const std::string& id)
+size_t Comparator<SIZE>::get_key(const std::string& id)
 {
   return lib->getBookById(id).getSize();
 }
 
 template<>
-bool Comparator<SIZE>::operator() (const std::string& id1, const std::string& id2)
-{
-  return get_keyi(id1) < get_keyi(id2);
-}
-
-template<>
-std::string Comparator<DATE>::get_keys(const std::string& id)
+std::string Comparator<DATE>::get_key(const std::string& id)
 {
   return lib->getBookById(id).getDate();
 }
 
 template<>
-std::string Comparator<CREATOR>::get_keys(const std::string& id)
+std::string Comparator<CREATOR>::get_key(const std::string& id)
 {
   return lib->getBookById(id).getCreator();
 }
 
 template<>
-std::string Comparator<PUBLISHER>::get_keys(const std::string& id)
+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,
@@ -250,59 +307,208 @@ std::vector<std::string> Library::listBooksIds(
     const std::string& language,
     const std::string& creator,
     const std::string& publisher,
+    const std::vector<std::string>& tags,
     size_t maxSize) {
 
-  std::vector<std::string> bookIds;
-  for(auto& pair:m_books) {
-    auto& book = pair.second;
-    auto local = !book.getPath().empty();
-    if (mode & LOCAL && !local)
-      continue;
-    if (mode & NOLOCAL && local)
-      continue;
-    auto valid = book.isPathValid();
-    if (mode & VALID && !valid)
-      continue;
-    if (mode & NOVALID && valid)
-      continue;
-    auto remote = !book.getUrl().empty();
-    if (mode & REMOTE && !remote)
-      continue;
-    if (mode & NOREMOTE && remote)
-      continue;
-    if (maxSize != 0 && book.getSize() > maxSize)
-      continue;
-    if (!language.empty() && book.getLanguage() != language)
-      continue;
-    if (!publisher.empty() && book.getPublisher() != publisher)
-      continue;
-    if (!creator.empty() && book.getCreator() != creator)
-      continue;
-    if (!search.empty() && !(matchRegex(book.getTitle(), "\\Q" + search + "\\E")
-                          || matchRegex(book.getDescription(), "\\Q" + search + "\\E")))
-      continue;
-    bookIds.push_back(pair.first);
-  }
+  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);
 
-  switch(sortBy) {
-    case TITLE:
-      std::sort(bookIds.begin(), bookIds.end(), Comparator<TITLE>(this));
-      break;
-    case SIZE:
-      std::sort(bookIds.begin(), bookIds.end(), Comparator<SIZE>(this));
-      break;
-    case DATE:
-      std::sort(bookIds.begin(), bookIds.end(), Comparator<DATE>(this));
-      break;
-    case CREATOR:
-      std::sort(bookIds.begin(), bookIds.end(), Comparator<CREATOR>(this));
-      break;
-    case PUBLISHER:
-      std::sort(bookIds.begin(), bookIds.end(), Comparator<PUBLISHER>(this));
-      break;
-    default:
-      break;
-  }
+  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

@@ -20,9 +20,10 @@
 #include "libxml_dumper.h"
 #include "book.h"
 
-#include <common/base64.h>
-#include <common/stringTools.h>
-#include <common/otherTools.h>
+#include "tools/base64.h"
+#include "tools/stringTools.h"
+#include "tools/otherTools.h"
+#include "tools/pathTools.h"
 
 namespace kiwix
 {
@@ -50,11 +51,6 @@ void LibXMLDumper::handleBook(Book book, pugi::xml_node root_node) {
     ADD_ATTRIBUTE(entry_node, "path", computeRelativePath(baseDir, book.getPath()));
   }
 
-  if (!book.getIndexPath().empty()) {
-    ADD_ATTRIBUTE(entry_node, "indexPath", computeRelativePath(baseDir, book.getIndexPath()));
-    entry_node.append_attribute("indexType") = "xapian";
-  }
-
   if (book.getOrigId().empty()) {
     ADD_ATTR_NOT_EMPTY(entry_node, "title", book.getTitle());
     ADD_ATTR_NOT_EMPTY(entry_node, "name", book.getName());

src/manager.cpp

@@ -208,12 +208,15 @@ bool Manager::addBookFromPath(const std::string& pathToOpen,
 
 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(path);
+    kiwix::Reader reader(tmp_path);
     book->update(reader);
     book->setPathValid(true);
   } catch (const std::exception& e) {
-    std::cerr << "Invalid " << path << " : " << e.what() << std::endl;
     book->setPathValid(false);
     return false;
   }

src/meson.build

@@ -8,17 +8,21 @@ kiwix_sources = [
   'downloader.cpp',
   'reader.cpp',
   'entry.cpp',
+  'server.cpp',
   'searcher.cpp',
+  'search_renderer.cpp',
   'subprocess.cpp',
   'aria2.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'
+  '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
 
@@ -28,10 +32,6 @@ else
   kiwix_sources += 'subprocess_unix.cpp'
 endif
 
-if xapian_dep.found()
-  kiwix_sources += ['xapianSearcher.cpp']
-endif
-
 if get_option('android')
   subdir('android')
   install_dir = 'kiwix-lib/jniLibs/' + meson.get_cross_property('android_abi')
@@ -39,11 +39,6 @@ else
   install_dir = get_option('libdir')
 endif
 
-
-if has_ctpp2_dep
-  kiwix_sources += ['ctpp2/CTPP2VMStringLoader.cpp']
-endif
-
 config_h = configure_file(output : 'kiwix_config.h',
                configuration : conf,
                input : 'config.h.in')
@@ -55,5 +50,4 @@ kiwixlib = library('kiwix',
                    dependencies : all_deps,
                    version: meson.project_version(),
                    install: true,
-                   install_dir: install_dir,
-                   install_rpath: '$ORIGIN')
+                   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

@@ -20,7 +20,8 @@
 #include "opds_dumper.h"
 #include "book.h"
 
-#include <common/otherTools.h>
+#include "tools/otherTools.h"
+#include <iomanip>
 
 namespace kiwix
 {
@@ -74,6 +75,7 @@ pugi::xml_node OPDSDumper::handleBook(Book book, pugi::xml_node root_node) {
   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";

src/reader.cpp

@@ -241,8 +241,6 @@ Entry Reader::getMainPage() const
     throw NoEntry();
   }
 
-  string url = "";
-
   zim::Article article;
   if (this->zimFileHandler->getFileheader().hasMainPage())
   {
@@ -260,7 +258,7 @@ Entry Reader::getMainPage() const
 
 bool Reader::getFavicon(string& content, string& mimeType) const
 {
-  static const char* const paths[] = {"-/favicon.png", "I/favicon.png", "I/favicon", "-/favicon"};
+  static const char* const paths[] = {"-/favicon", "-/favicon.png", "I/favicon.png", "I/favicon"};
 
   for (auto &path: paths) {
     try {
@@ -762,18 +760,21 @@ bool Reader::searchSuggestionsSmart(const string& prefix,
                                     unsigned int suggestionsCount)
 {
   std::vector<std::string> variants = this->getTitleVariants(prefix);
-  bool retVal;
+  bool retVal = false;
 
   this->suggestions.clear();
   this->suggestionsOffset = this->suggestions.begin();
   /* Try to search in the title using fulltext search database */
-  const zim::Search* suggestionSearch
+  const auto suggestionSearch
       = this->getZimFileHandler()->suggestions(prefix, 0, suggestionsCount);
 
   if (suggestionSearch->get_matches_estimated()) {
     for (auto current = suggestionSearch->begin();
          current != suggestionSearch->end();
          current++) {
+      if (!current->good()) {
+          continue;
+      }
       std::vector<std::string> suggestion;
       suggestion.push_back(current->getTitle());
       suggestion.push_back("/A/" + current->getUrl());

src/search_renderer.cpp

@@ -0,0 +1,151 @@
+/*
+ * 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 <cmath>
+
+#include "search_renderer.h"
+#include "searcher.h"
+#include "reader.h"
+#include "library.h"
+#include "name_mapper.h"
+
+#include <zim/search.h>
+
+#include <mustache.hpp>
+#include "kiwixlib-resources.h"
+
+
+namespace kiwix
+{
+
+/* Constructor */
+SearchRenderer::SearchRenderer(Searcher* searcher, NameMapper* mapper)
+    : mp_searcher(searcher),
+      mp_nameMapper(mapper),
+      protocolPrefix("zim://"),
+      searchProtocolPrefix("search://?")
+{}
+
+/* Destructor */
+SearchRenderer::~SearchRenderer() = default;
+
+void SearchRenderer::setSearchPattern(const std::string& pattern)
+{
+  this->searchPattern = pattern;
+}
+
+void SearchRenderer::setSearchContent(const std::string& name)
+{
+  this->searchContent = name;
+}
+
+void SearchRenderer::setProtocolPrefix(const std::string& prefix)
+{
+  this->protocolPrefix = prefix;
+}
+
+void SearchRenderer::setSearchProtocolPrefix(const std::string& prefix)
+{
+  this->searchProtocolPrefix = prefix;
+}
+
+std::string SearchRenderer::getHtml()
+{
+  kainjow::mustache::data results{kainjow::mustache::data::type::list};
+
+  mp_searcher->restart_search();
+  Result* p_result = NULL;
+  while ((p_result = mp_searcher->getNextResult())) {
+    kainjow::mustache::data result;
+    result.set("title", p_result->get_title());
+    result.set("url", p_result->get_url());
+    result.set("snippet", p_result->get_snippet());
+    auto readerIndex = p_result->get_readerIndex();
+    auto reader = mp_searcher->get_reader(readerIndex);
+    result.set("resultContentId", mp_nameMapper->getNameForId(reader->getId()));
+
+    if (p_result->get_wordCount() >= 0) {
+      result.set("wordCount", kiwix::beautifyInteger(p_result->get_wordCount()));
+    }
+
+    results.push_back(result);
+    delete p_result;
+  }
+
+  // pages
+  kainjow::mustache::data pages{kainjow::mustache::data::type::list};
+
+  auto resultStart = mp_searcher->getResultStart();
+  auto resultEnd = mp_searcher->getResultEnd();
+  auto resultCountPerPage = resultEnd - resultStart;
+  auto estimatedResultCount = mp_searcher->getEstimatedResultCount();
+
+  unsigned int pageStart
+      = resultStart / resultCountPerPage >= 5
+            ? resultStart / resultCountPerPage - 4
+            : 0;
+  unsigned int pageCount
+      = estimatedResultCount / resultCountPerPage + 1 - pageStart;
+
+  if (pageCount > 10) {
+    pageCount = 10;
+  } else if (pageCount == 1) {
+    pageCount = 0;
+  }
+
+  for (unsigned int i = pageStart; i < pageStart + pageCount; i++) {
+    kainjow::mustache::data page;
+    page.set("label", to_string(i + 1));
+    page.set("start", to_string(i * resultCountPerPage));
+    page.set("end", to_string((i + 1) * resultCountPerPage));
+
+    if (i * resultCountPerPage == resultStart) {
+      page.set("selected", true);
+    }
+    pages.push_back(page);
+  }
+
+  std::string template_str = RESOURCE::templates::search_result_html;
+  kainjow::mustache::mustache tmpl(template_str);
+
+  kainjow::mustache::data allData;
+  allData.set("results", results);
+  allData.set("pages", pages);
+  allData.set("hasResult", estimatedResultCount != 0);
+  allData.set("count", kiwix::beautifyInteger(estimatedResultCount));
+  allData.set("searchPattern", kiwix::encodeDiples(this->searchPattern));
+  allData.set("searchPatternEncoded", urlEncode(this->searchPattern));
+  allData.set("resultStart", to_string(resultStart + 1));
+  allData.set("resultEnd", to_string(min(resultEnd, estimatedResultCount)));
+  allData.set("resultRange", to_string(resultCountPerPage));
+  allData.set("resultLastPageStart", to_string(estimatedResultCount > resultCountPerPage
+             ? round(estimatedResultCount / resultCountPerPage) * resultCountPerPage
+             : 0));
+  allData.set("lastResult", to_string(estimatedResultCount));
+  allData.set("protocolPrefix", this->protocolPrefix);
+  allData.set("searchProtocolPrefix", this->searchProtocolPrefix);
+  allData.set("contentId", this->searchContent);
+
+  std::stringstream ss;
+  tmpl.render(allData, [&ss](const std::string& str) { ss << str; });
+  return ss.str();
+}
+
+}

src/searcher.cpp

@@ -22,20 +22,12 @@
 
 #include "searcher.h"
 #include "reader.h"
-#include "xapianSearcher.h"
 
 #include <zim/search.h>
 
-#ifdef ENABLE_CTPP2
-#include <ctpp2/CDT.hpp>
-#include <ctpp2/CTPP2FileLogger.hpp>
-#include <ctpp2/CTPP2SimpleVM.hpp>
-#include "ctpp2/CTPP2VMStringLoader.hpp"
+#include <mustache.hpp>
 #include "kiwixlib-resources.h"
 
-using namespace CTPP;
-#endif
-
 #define MAX_SEARCH_LEN 140
 
 namespace kiwix
@@ -61,52 +53,24 @@ class _Result : public Result
 
 struct SearcherInternal {
   const zim::Search* _search;
-  XapianSearcher* _xapianSearcher;
   zim::Search::iterator current_iterator;
 
-  SearcherInternal() : _search(NULL), _xapianSearcher(NULL) {}
+  SearcherInternal() : _search(NULL) {}
   ~SearcherInternal()
   {
     if (_search != NULL) {
       delete _search;
     }
-    if (_xapianSearcher != NULL) {
-      delete _xapianSearcher;
-    }
   }
 };
 
 /* Constructor */
-Searcher::Searcher(const string& xapianDirectoryPath,
-                   Reader* reader,
-                   const string& humanReadableName)
+Searcher::Searcher()
     : internal(new SearcherInternal()),
       searchPattern(""),
-      protocolPrefix("zim://"),
-      searchProtocolPrefix("search://?"),
-      resultCountPerPage(0),
       estimatedResultCount(0),
       resultStart(0),
-      resultEnd(0),
-      contentHumanReadableId(humanReadableName)
-{
-  loadICUExternalTables();
-  if (!reader || !reader->hasFulltextIndex()) {
-    internal->_xapianSearcher = new XapianSearcher(xapianDirectoryPath, reader);
-  }
-  this->humanReaderNames.push_back(humanReadableName);
-}
-
-Searcher::Searcher(const std::string& humanReadableName)
-    : internal(new SearcherInternal()),
-      searchPattern(""),
-      protocolPrefix("zim://"),
-      searchProtocolPrefix("search://?"),
-      resultCountPerPage(0),
-      estimatedResultCount(0),
-      resultStart(0),
-      resultEnd(0),
-      contentHumanReadableId(humanReadableName)
+      resultEnd(0)
 {
   loadICUExternalTables();
 }
@@ -117,16 +81,21 @@ Searcher::~Searcher()
   delete internal;
 }
 
-bool Searcher::add_reader(Reader* reader, const std::string& humanReadableName)
+bool Searcher::add_reader(Reader* reader)
 {
   if (!reader->hasFulltextIndex()) {
       return false;
   }
   this->readers.push_back(reader);
-  this->humanReaderNames.push_back(humanReadableName);
   return true;
 }
 
+
+Reader* Searcher::get_reader(int readerIndex)
+{
+  return readers.at(readerIndex);
+}
+
 /* Search strings in the database */
 void Searcher::search(std::string& search,
                       unsigned int resultStart,
@@ -139,47 +108,27 @@ void Searcher::search(std::string& search,
     cout << "Performing query `" << search << "'" << endl;
   }
 
-  /* If resultEnd & resultStart inverted */
-  if (resultStart > resultEnd) {
-    resultEnd += resultStart;
-    resultStart = resultEnd - resultStart;
-    resultEnd -= resultStart;
-  }
-
   /* Try to find results */
   if (resultStart != resultEnd) {
-    /* Avoid big researches */
-    this->resultCountPerPage = resultEnd - resultStart;
-    if (this->resultCountPerPage > MAX_SEARCH_LEN) {
-      resultEnd = resultStart + MAX_SEARCH_LEN;
-      this->resultCountPerPage = MAX_SEARCH_LEN;
-    }
-
     /* Perform the search */
     this->searchPattern = search;
     this->resultStart = resultStart;
     this->resultEnd = resultEnd;
     string unaccentedSearch = removeAccents(search);
-    if (internal->_xapianSearcher) {
-      internal->_xapianSearcher->searchInIndex(
-          unaccentedSearch, resultStart, resultEnd, verbose);
-      this->estimatedResultCount
-          = internal->_xapianSearcher->results.get_matches_estimated();
-    } else {
-      std::vector<const zim::File*> zims;
-      for (auto current = this->readers.begin(); current != this->readers.end();
-           current++) {
-        if ( (*current)->hasFulltextIndex() ) {
-            zims.push_back((*current)->getZimFileHandler());
-        }
+    std::vector<const zim::File*> zims;
+    for (auto current = this->readers.begin(); current != this->readers.end();
+         current++) {
+      if ( (*current)->hasFulltextIndex() ) {
+          zims.push_back((*current)->getZimFileHandler());
       }
-      zim::Search* search = new zim::Search(zims);
-      search->set_query(unaccentedSearch);
-      search->set_range(resultStart, resultEnd);
-      internal->_search = search;
-      internal->current_iterator = internal->_search->begin();
-      this->estimatedResultCount = internal->_search->get_matches_estimated();
     }
+    zim::Search* search = new zim::Search(zims);
+    search->set_verbose(verbose);
+    search->set_query(unaccentedSearch);
+    search->set_range(resultStart, resultEnd);
+    internal->_search = search;
+    internal->current_iterator = internal->_search->begin();
+    this->estimatedResultCount = internal->_search->get_matches_estimated();
   }
 
   return;
@@ -197,29 +146,11 @@ void Searcher::geo_search(float latitude, float longitude, float distance,
     cout << "Performing geo query `" << distance << "&(" << latitude << ";" << longitude << ")'" << endl;
   }
 
-  /* If resultEnd & resultStart inverted */
-  if (resultStart > resultEnd) {
-    resultEnd += resultStart;
-    resultStart = resultEnd - resultStart;
-    resultEnd -= resultStart;
-  }
-
   /* Try to find results */
   if (resultStart == resultEnd) {
     return;
   }
 
-  if (internal->_xapianSearcher) {
-    return;
-  }
-
-  /* Avoid big researches */
-  this->resultCountPerPage = resultEnd - resultStart;
-  if (this->resultCountPerPage > MAX_SEARCH_LEN) {
-    resultEnd = resultStart + MAX_SEARCH_LEN;
-    this->resultCountPerPage = MAX_SEARCH_LEN;
-  }
-
   /* Perform the search */
   std::ostringstream oss;
   oss << "Articles located less than " << distance << " meters of " << latitude << ";" << longitude;
@@ -233,6 +164,7 @@ void Searcher::geo_search(float latitude, float longitude, float distance,
     zims.push_back((*current)->getZimFileHandler());
   }
   zim::Search* search = new zim::Search(zims);
+  search->set_verbose(verbose);
   search->set_query("");
   search->set_georange(latitude, longitude, distance);
   search->set_range(resultStart, resultEnd);
@@ -244,18 +176,14 @@ void Searcher::geo_search(float latitude, float longitude, float distance,
 
 void Searcher::restart_search()
 {
-  if (internal->_xapianSearcher) {
-    internal->_xapianSearcher->restart_search();
-  } else if (internal->_search) {
+  if (internal->_search) {
     internal->current_iterator = internal->_search->begin();
   }
 }
 
 Result* Searcher::getNextResult()
 {
-  if (internal->_xapianSearcher) {
-    return internal->_xapianSearcher->getNextResult();
-  } else if (internal->_search &&
+  if (internal->_search &&
              internal->current_iterator != internal->_search->end()) {
     Result* result = new _Result(internal->current_iterator);
     internal->current_iterator++;
@@ -272,37 +200,32 @@ void Searcher::reset()
   return;
 }
 
-void Searcher::suggestions(std::string& search, const bool verbose)
+void Searcher::suggestions(std::string& searchPattern, const bool verbose)
 {
   this->reset();
 
   if (verbose == true) {
-    cout << "Performing suggestion query `" << search << "`" << endl;
+    cout << "Performing suggestion query `" << searchPattern << "`" << endl;
   }
 
-  this->searchPattern = search;
+  this->searchPattern = searchPattern;
   this->resultStart = 0;
   this->resultEnd = 10;
-  string unaccentedSearch = removeAccents(search);
+  string unaccentedSearch = removeAccents(searchPattern);
 
-  if (internal->_xapianSearcher) {
-    /* [TODO] Suggestion on a external database ?
-     * We do not support that. */
-    this->estimatedResultCount = 0;
-  } else {
-    std::vector<const zim::File*> zims;
-    for (auto current = this->readers.begin(); current != this->readers.end();
-         current++) {
-      zims.push_back((*current)->getZimFileHandler());
-    }
-    zim::Search* search = new zim::Search(zims);
-    search->set_query(unaccentedSearch);
-    search->set_range(resultStart, resultEnd);
-    search->set_suggestion_mode(true);
-    internal->_search = search;
-    internal->current_iterator = internal->_search->begin();
-    this->estimatedResultCount = internal->_search->get_matches_estimated();
+  std::vector<const zim::File*> zims;
+  for (auto current = this->readers.begin(); current != this->readers.end();
+       current++) {
+    zims.push_back((*current)->getZimFileHandler());
   }
+  zim::Search* search = new zim::Search(zims);
+  search->set_verbose(verbose);
+  search->set_query(unaccentedSearch);
+  search->set_range(resultStart, resultEnd);
+  search->set_suggestion_mode(true);
+  internal->_search = search;
+  internal->current_iterator = internal->_search->begin();
+  this->estimatedResultCount = internal->_search->get_matches_estimated();
 }
 
 /* Return the result count estimation */
@@ -311,18 +234,6 @@ unsigned int Searcher::getEstimatedResultCount()
   return this->estimatedResultCount;
 }
 
-bool Searcher::setProtocolPrefix(const std::string prefix)
-{
-  this->protocolPrefix = prefix;
-  return true;
-}
-
-bool Searcher::setSearchProtocolPrefix(const std::string prefix)
-{
-  this->searchProtocolPrefix = prefix;
-  return true;
-}
-
 _Result::_Result(zim::Search::iterator& iterator)
     : iterator(iterator)
 {
@@ -363,103 +274,6 @@ int _Result::get_readerIndex()
 {
   return iterator.get_fileIndex();
 }
-#ifdef ENABLE_CTPP2
 
-string Searcher::getHtml()
-{
-  SimpleVM oSimpleVM(
-      1024, //iIMaxFunctions (default value)
-      4096, //iIMaxArgStackSize (default value)
-      4096, //iIMaxCodeStackSize (default value)
-      10240 * 2 //iIMaxSteps (default*2)
-  );
 
-  // Fill data
-  CDT oData;
-  CDT resultsCDT(CDT::ARRAY_VAL);
-
-  this->restart_search();
-  Result* p_result = NULL;
-  while ((p_result = this->getNextResult())) {
-    CDT result;
-    result["title"] = p_result->get_title();
-    result["url"] = p_result->get_url();
-    result["snippet"] = p_result->get_snippet();
-    result["contentId"] = humanReaderNames[p_result->get_readerIndex()];
-
-    if (p_result->get_size() >= 0) {
-      result["size"] = kiwix::beautifyInteger(p_result->get_size());
-    }
-
-    if (p_result->get_wordCount() >= 0) {
-      result["wordCount"] = kiwix::beautifyInteger(p_result->get_wordCount());
-    }
-
-    resultsCDT.PushBack(result);
-    delete p_result;
-  }
-  this->restart_search();
-  oData["results"] = resultsCDT;
-
-  // pages
-  CDT pagesCDT(CDT::ARRAY_VAL);
-
-  unsigned int pageStart
-      = this->resultStart / this->resultCountPerPage >= 5
-            ? this->resultStart / this->resultCountPerPage - 4
-            : 0;
-  unsigned int pageCount
-      = this->estimatedResultCount / this->resultCountPerPage + 1 - pageStart;
-
-  if (pageCount > 10) {
-    pageCount = 10;
-  } else if (pageCount == 1) {
-    pageCount = 0;
-  }
-
-  for (unsigned int i = pageStart; i < pageStart + pageCount; i++) {
-    CDT page;
-    page["label"] = i + 1;
-    page["start"] = i * this->resultCountPerPage;
-    page["end"] = (i + 1) * this->resultCountPerPage;
-
-    if (i * this->resultCountPerPage == this->resultStart) {
-      page["selected"] = true;
-    }
-
-    pagesCDT.PushBack(page);
-  }
-  oData["pages"] = pagesCDT;
-
-  oData["count"] = kiwix::beautifyInteger(this->estimatedResultCount);
-  oData["searchPattern"] = kiwix::encodeDiples(this->searchPattern);
-  oData["searchPatternEncoded"] = urlEncode(this->searchPattern);
-  oData["resultStart"] = this->resultStart + 1;
-  oData["resultEnd"] = (this->resultEnd > this->estimatedResultCount
-                            ? this->estimatedResultCount
-                            : this->resultEnd);
-  oData["resultRange"] = this->resultCountPerPage;
-  oData["resultLastPageStart"]
-      = this->estimatedResultCount > this->resultCountPerPage
-            ? std::round(this->estimatedResultCount / this->resultCountPerPage) * this->resultCountPerPage
-            : 0;
-  oData["protocolPrefix"] = this->protocolPrefix;
-  oData["searchProtocolPrefix"] = this->searchProtocolPrefix;
-  oData["contentId"] = this->contentHumanReadableId;
-
-  std::string template_ct2 = RESOURCE::results_ct2;
-  VMStringLoader oLoader(template_ct2.c_str(), template_ct2.size());
-
-  FileLogger oLogger(stderr);
-
-  // DEBUG only (write output to stdout)
-  // oSimpleVM.Run(oData, oLoader, stdout, oLogger);
-
-  std::string sResult;
-  oSimpleVM.Run(oData, oLoader, sResult, oLogger);
-
-  return sResult;
-}
-
-#endif
 }

src/server.cpp

@@ -0,0 +1,911 @@
+/*
+ * 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 "server.h"
+
+#ifdef _WIN32
+# if !defined(__MINGW32__) && (_MSC_VER < 1600)
+#   include "stdint4win.h"
+# endif
+# include <winsock2.h>
+# include <ws2tcpip.h>
+# ifdef __GNUC__
+  // inet_pton is not declared in mingw, even if the function exists.
+  extern "C" {
+    WINSOCK_API_LINKAGE  INT WSAAPI inet_pton( INT Family, PCSTR pszAddrString, PVOID pAddrBuf);
+  }
+# endif
+  typedef UINT64 uint64_t;
+  typedef UINT16 uint16_t;
+#endif
+
+extern "C" {
+#include <microhttpd.h>
+}
+
+#include "tools/otherTools.h"
+#include "tools/pathTools.h"
+#include "tools/regexTools.h"
+#include "tools/stringTools.h"
+#include "library.h"
+#include "name_mapper.h"
+#include "entry.h"
+#include "searcher.h"
+#include "search_renderer.h"
+#include "opds_dumper.h"
+
+#include <zim/uuid.h>
+
+#include <mustache.hpp>
+
+#include <pthread.h>
+#include <atomic>
+#include <string>
+#include <vector>
+#include <chrono>
+#include "kiwixlib-resources.h"
+
+#ifndef _WIN32
+# include <arpa/inet.h>
+#endif
+
+#include "server/request_context.h"
+#include "server/response.h"
+
+#define MAX_SEARCH_LEN 140
+#define KIWIX_MIN_CONTENT_SIZE_TO_DEFLATE 100
+
+namespace kiwix {
+
+static IdNameMapper defaultNameMapper;
+
+static int staticHandlerCallback(void* cls,
+                                 struct MHD_Connection* connection,
+                                 const char* url,
+                                 const char* method,
+                                 const char* version,
+                                 const char* upload_data,
+                                 size_t* upload_data_size,
+                                 void** cont_cls);
+
+
+class InternalServer {
+  public:
+    InternalServer(Library* library,
+                   NameMapper* nameMapper,
+                   std::string addr,
+                   int port,
+                   std::string root,
+                   int nbThreads,
+                   bool verbose,
+                   bool withTaskbar,
+                   bool withLibraryButton);
+    virtual ~InternalServer() = default;
+
+    int handlerCallback(struct MHD_Connection* connection,
+                        const char* url,
+                        const char* method,
+                        const char* version,
+                        const char* upload_data,
+                        size_t* upload_data_size,
+                        void** cont_cls);
+    bool start();
+    void stop();
+
+  private:
+    Response handle_request(const RequestContext& request);
+    Response build_500(const std::string& msg);
+    Response build_404(const RequestContext& request, const std::string& zimName);
+    Response build_homepage(const RequestContext& request);
+    Response handle_skin(const RequestContext& request);
+    Response handle_catalog(const RequestContext& request);
+    Response handle_meta(const RequestContext& request);
+    Response handle_search(const RequestContext& request);
+    Response handle_suggest(const RequestContext& request);
+    Response handle_random(const RequestContext& request);
+    Response handle_content(const RequestContext& request);
+
+    kainjow::mustache::data get_default_data();
+    Response get_default_response();
+
+    std::string m_addr;
+    int m_port;
+    std::string m_root;
+    int m_nbThreads;
+    std::atomic_bool m_verbose;
+    bool m_withTaskbar;
+    bool m_withLibraryButton;
+    struct MHD_Daemon* mp_daemon;
+
+    Library* mp_library;
+    NameMapper* mp_nameMapper;
+};
+
+
+Server::Server(Library* library, NameMapper* nameMapper) :
+  mp_library(library),
+  mp_nameMapper(nameMapper),
+  mp_server(nullptr)
+{
+}
+
+Server::~Server() = default;
+
+bool Server::start() {
+  mp_server.reset(new InternalServer(
+    mp_library,
+    mp_nameMapper,
+    m_addr,
+    m_port,
+    m_root,
+    m_nbThreads,
+    m_verbose,
+    m_withTaskbar,
+    m_withLibraryButton));
+  return mp_server->start();
+}
+
+void Server::stop() {
+  mp_server->stop();
+  mp_server.reset(nullptr);
+}
+
+void Server::setRoot(const std::string& root)
+{
+  m_root = root;
+  if (m_root[0] != '/') {
+    m_root = "/" + m_root;
+  }
+  if (m_root.back() == '/') {
+    m_root.erase(m_root.size() - 1);
+  }
+}
+
+
+InternalServer::InternalServer(Library* library,
+                               NameMapper* nameMapper,
+                               std::string addr,
+                               int port,
+                               std::string root,
+                               int nbThreads,
+                               bool verbose,
+                               bool withTaskbar,
+                               bool withLibraryButton) :
+  m_addr(addr),
+  m_port(port),
+  m_root(root),
+  m_nbThreads(nbThreads),
+  m_verbose(verbose),
+  m_withTaskbar(withTaskbar),
+  m_withLibraryButton(withLibraryButton),
+  mp_daemon(nullptr),
+  mp_library(library),
+  mp_nameMapper(nameMapper ? nameMapper : &defaultNameMapper)
+{}
+
+bool InternalServer::start() {
+#ifdef _WIN32
+  int flags = MHD_USE_SELECT_INTERNALLY;
+#else
+  int flags = MHD_USE_POLL_INTERNALLY;
+#endif
+  if (m_verbose.load())
+    flags |= MHD_USE_DEBUG;
+
+
+  struct sockaddr_in sockAddr;
+  memset(&sockAddr, 0, sizeof(sockAddr));
+  sockAddr.sin_family = AF_INET;
+  sockAddr.sin_port = htons(m_port);
+  if (m_addr.empty()) {
+    if (0 != INADDR_ANY)
+      sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  } else {
+    if (inet_pton(AF_INET, m_addr.c_str(), &(sockAddr.sin_addr.s_addr)) == 0) {
+      std::cerr << "Ip address " << m_addr << "  is not a valid ip address" << std::endl;
+      return false;
+    }
+  }
+
+  mp_daemon = MHD_start_daemon(flags,
+                            m_port,
+                            NULL,
+                            NULL,
+                            &staticHandlerCallback,
+                            this,
+                            MHD_OPTION_SOCK_ADDR, &sockAddr,
+                            MHD_OPTION_THREAD_POOL_SIZE, m_nbThreads,
+                            MHD_OPTION_END);
+  if (mp_daemon == nullptr) {
+    std::cerr << "Unable to instantiate the HTTP daemon. The port " << m_port
+              << " is maybe already occupied or need more permissions to be open. "
+                 "Please try as root or with a port number higher or equal to 1024."
+              << std::endl;
+    return false;
+  }
+  return true;
+}
+
+void InternalServer::stop()
+{
+  MHD_stop_daemon(mp_daemon);
+}
+
+static int staticHandlerCallback(void* cls,
+                                 struct MHD_Connection* connection,
+                                 const char* url,
+                                 const char* method,
+                                 const char* version,
+                                 const char* upload_data,
+                                 size_t* upload_data_size,
+                                 void** cont_cls)
+{
+  InternalServer* _this = static_cast<InternalServer*>(cls);
+
+  return _this->handlerCallback(connection,
+                                url,
+                                method,
+                                version,
+                                upload_data,
+                                upload_data_size,
+                                cont_cls);
+}
+
+int InternalServer::handlerCallback(struct MHD_Connection* connection,
+                                    const char* url,
+                                    const char* method,
+                                    const char* version,
+                                    const char* upload_data,
+                                    size_t* upload_data_size,
+                                    void** cont_cls)
+{
+  auto start_time = std::chrono::steady_clock::now();
+  if (m_verbose.load() ) {
+    printf("======================\n");
+    printf("Requesting : \n");
+    printf("full_url  : %s\n", url);
+  }
+  RequestContext request(connection, m_root, url, method, version);
+
+  if (m_verbose.load() ) {
+    request.print_debug_info();
+  }
+  /* Unexpected method */
+  if (request.get_method() != RequestMethod::GET
+   && request.get_method() != RequestMethod::POST) {
+    printf("Reject request because of unhandled request method.\n");
+    printf("----------------------\n");
+    return MHD_NO;
+  }
+
+  auto response = handle_request(request);
+
+  if (response.getReturnCode() == MHD_HTTP_INTERNAL_SERVER_ERROR) {
+    printf("========== INTERNAL ERROR !! ============\n");
+    if (!m_verbose.load()) {
+      printf("Requesting : \n");
+      printf("full_url : %s\n", url);
+      request.print_debug_info();
+    }
+  }
+
+  auto ret = response.send(request, connection);
+  auto end_time = std::chrono::steady_clock::now();
+  auto time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end_time - start_time);
+  if (m_verbose.load()) {
+    printf("Request time : %fs\n", time_span.count());
+    printf("----------------------\n");
+  }
+  return ret;
+}
+
+
+Response InternalServer::handle_request(const RequestContext& request)
+{
+  try {
+    if (! request.is_valid_url())
+      return build_404(request, "");
+
+    if (kiwix::startsWith(request.get_url(), "/skin/"))
+      return handle_skin(request);
+
+    if (startsWith(request.get_url(), "/catalog"))
+      return handle_catalog(request);
+
+    if (request.get_url() == "/meta")
+      return handle_meta(request);
+
+    if (request.get_url() == "/search")
+      return handle_search(request);
+
+    if (request.get_url() == "/suggest")
+     return handle_suggest(request);
+
+    if (request.get_url() == "/random")
+      return handle_random(request);
+
+    return handle_content(request);
+  } catch (std::exception& e) {
+    fprintf(stderr, "===== Unhandled error : %s\n", e.what());
+    return build_500(e.what());
+  } catch (...) {
+    fprintf(stderr, "===== Unhandled unknown error\n");
+    return build_500("Unknown error");
+  }
+}
+
+kainjow::mustache::data InternalServer::get_default_data()
+{
+  kainjow::mustache::data data;
+  data.set("root", m_root);
+  return data;
+}
+
+Response InternalServer::get_default_response()
+{
+  return Response(m_root, m_verbose.load(), m_withTaskbar, m_withLibraryButton);
+}
+
+
+Response InternalServer::build_404(const RequestContext& request,
+                                   const std::string& bookName)
+{
+  kainjow::mustache::data results;
+  results.set("url", request.get_full_url());
+
+  auto response = get_default_response();
+  response.set_template(RESOURCE::templates::_404_html, results);
+  response.set_mimeType("text/html");
+  response.set_code(MHD_HTTP_NOT_FOUND);
+  response.set_compress(true);
+  response.set_taskbar(bookName, "");
+
+  return response;
+}
+
+Response InternalServer::build_500(const std::string& msg)
+{
+  kainjow::mustache::data data;
+  data.set("error", msg);
+  Response response(m_root, true, false, false);
+  response.set_template(RESOURCE::templates::_500_html, data);
+  response.set_mimeType("text/html");
+  response.set_code(MHD_HTTP_INTERNAL_SERVER_ERROR);
+  return response;
+}
+
+Response InternalServer::build_homepage(const RequestContext& request)
+{
+  auto data = get_default_data();
+
+  kainjow::mustache::data books{kainjow::mustache::data::type::list};
+  for (auto& bookId: mp_library->filter(kiwix::Filter().local(true).valid(true))) {
+    auto& currentBook = mp_library->getBookById(bookId);
+
+    kainjow::mustache::data book;
+    book.set("name", mp_nameMapper->getNameForId(bookId));
+    book.set("title", currentBook.getTitle());
+    book.set("description", currentBook.getDescription());
+    book.set("articleCount", beautifyInteger(currentBook.getArticleCount()));
+    book.set("mediaCount", beautifyInteger(currentBook.getMediaCount()));
+    books.push_back(book);
+  }
+
+  data.set("books", books);
+
+  auto response = get_default_response();
+  response.set_template(RESOURCE::templates::index_html, data);
+  response.set_mimeType("text/html; charset=utf-8");
+  response.set_compress(true);
+  response.set_taskbar("", "");
+  return response;
+}
+
+Response InternalServer::handle_meta(const RequestContext& request)
+{
+  std::string bookName;
+  std::string bookId;
+  std::string meta_name;
+  std::shared_ptr<Reader> reader;
+  try {
+    bookName = request.get_argument("content");
+    bookId = mp_nameMapper->getIdForName(bookName);
+    meta_name = request.get_argument("name");
+    reader = mp_library->getReaderById(bookId);
+  } catch (const std::out_of_range& e) {
+    return build_404(request, bookName);
+  }
+
+  if (reader == nullptr) {
+    return build_404(request, bookName);
+  }
+
+  std::string content;
+  std::string mimeType = "text";
+
+  if (meta_name == "title") {
+    content = reader->getTitle();
+  } else if (meta_name == "description") {
+    content = reader->getDescription();
+  } else if (meta_name == "language") {
+    content = reader->getLanguage();
+  } else if (meta_name == "name") {
+    content = reader->getName();
+  } else if (meta_name == "tags") {
+    content = reader->getTags();
+  } else if (meta_name == "date") {
+    content = reader->getDate();
+  } else if (meta_name == "creator") {
+    content = reader->getCreator();
+  } else if (meta_name == "publisher") {
+    content = reader->getPublisher();
+  } else if (meta_name == "favicon") {
+    reader->getFavicon(content, mimeType);
+  } else {
+    return build_404(request, bookName);
+  }
+
+  auto response = get_default_response();
+  response.set_content(content);
+  response.set_mimeType(mimeType);
+  response.set_compress(false);
+  response.set_cache(true);
+  return response;
+}
+
+Response InternalServer::handle_suggest(const RequestContext& request)
+{
+  if (m_verbose.load()) {
+    printf("** running handle_suggest\n");
+  }
+
+  std::string content;
+  std::string mimeType;
+  unsigned int maxSuggestionCount = 10;
+  unsigned int suggestionCount = 0;
+  std::string suggestion;
+
+  std::string bookName;
+  std::string bookId;
+  std::string term;
+  std::shared_ptr<Reader> reader;
+  try {
+    bookName = request.get_argument("content");
+    bookId = mp_nameMapper->getIdForName(bookName);
+    term = request.get_argument("term");
+    reader = mp_library->getReaderById(bookId);
+  } catch (const std::out_of_range&) {
+    return build_404(request, bookName);
+  }
+
+  if (m_verbose.load()) {
+    printf("Searching suggestions for: \"%s\"\n", term.c_str());
+  }
+
+  kainjow::mustache::data results{kainjow::mustache::data::type::list};
+
+  bool first = true;
+  if (reader != nullptr) {
+    /* Get the suggestions */
+    reader->searchSuggestionsSmart(term, maxSuggestionCount);
+    while (reader->getNextSuggestion(suggestion)) {
+      kainjow::mustache::data result;
+      result.set("label", suggestion);
+      result.set("value", suggestion);
+      result.set("first", first);
+      first = false;
+      results.push_back(result);
+      suggestionCount++;
+    }
+  }
+
+  /* Propose the fulltext search if possible */
+  if (reader->hasFulltextIndex()) {
+    kainjow::mustache::data result;
+    result.set("label", "containing '" + term + "'...");
+    result.set("value", term);
+    result.set("first", first);
+    results.push_back(result);
+  }
+
+  auto data = get_default_data();
+  data.set("suggestions", results);
+
+  auto response = get_default_response();
+  response.set_template(RESOURCE::templates::suggestion_json, data);
+  response.set_mimeType("application/json; charset=utf-8");
+  response.set_compress(true);
+  return response;
+}
+
+Response InternalServer::handle_skin(const RequestContext& request)
+{
+  if (m_verbose.load()) {
+    printf("** running handle_skin\n");
+  }
+
+  auto response = get_default_response();
+  auto resourceName = request.get_url().substr(1);
+  try {
+    response.set_content(getResource(resourceName));
+  } catch (const ResourceNotFound& e) {
+    return build_404(request, "");
+  }
+  response.set_mimeType(getMimeTypeForFile(resourceName));
+  response.set_compress(true);
+  response.set_cache(true);
+  return response;
+}
+
+Response InternalServer::handle_search(const RequestContext& request)
+{
+  if (m_verbose.load()) {
+    printf("** running handle_search\n");
+  }
+
+  std::string bookName;
+  std::string bookId;
+  try {
+    bookName = request.get_argument("content");
+    bookId = mp_nameMapper->getIdForName(bookName);
+  } catch (const std::out_of_range&) {}
+
+  std::string patternString;
+  try {
+    patternString = request.get_argument("pattern");
+  } catch (const std::out_of_range&) {}
+
+  /* Retrive geo search */
+  bool has_geo_query = false;
+  float latitude = 0;
+  float longitude = 0;
+  float distance = 0;
+  try {
+    latitude = request.get_argument<float>("latitude");
+    longitude = request.get_argument<float>("longitude");
+    distance = request.get_argument<float>("distance");
+    has_geo_query = true;
+  } catch(const std::out_of_range&) {}
+    catch(const std::invalid_argument&) {}
+
+  std::shared_ptr<Reader> reader(nullptr);
+  try {
+    reader = mp_library->getReaderById(bookId);
+  } catch (const std::out_of_range&) {}
+
+  /* Try first to load directly the article */
+  if (reader != nullptr && !patternString.empty()) {
+    std::string patternCorrespondingUrl;
+    auto variants = reader->getTitleVariants(patternString);
+    auto variantsItr = variants.begin();
+
+    while (patternCorrespondingUrl.empty() && variantsItr != variants.end()) {
+      try {
+        auto entry = reader->getEntryFromTitle(*variantsItr);
+        entry = entry.getFinalEntry();
+        patternCorrespondingUrl = entry.getPath();
+        break;
+      } catch(kiwix::NoEntry& e) {
+        variantsItr++;
+      }
+    }
+
+    /* If article found then redirect directly to it */
+    if (!patternCorrespondingUrl.empty()) {
+      auto response = get_default_response();
+      response.set_redirection(m_root + "/" + bookName + "/" + patternCorrespondingUrl);
+      return response;
+    }
+  }
+
+  /* Make the search */
+  auto response = get_default_response();
+  response.set_mimeType("text/html; charset=utf-8");
+  response.set_taskbar(bookName, reader ? reader->getTitle() : "");
+  response.set_compress(true);
+
+  if ( (!reader && !bookName.empty())
+    || (patternString.empty() && ! has_geo_query) ) {
+    auto data = get_default_data();
+    data.set("pattern", encodeDiples(patternString));
+    response.set_template(RESOURCE::templates::no_search_result_html, data);
+    response.set_code(MHD_HTTP_NOT_FOUND);
+    return response;
+  }
+
+  Searcher searcher;
+  if (reader) {
+    searcher.add_reader(reader.get());
+  } else {
+    for (auto& bookId: mp_library->filter(kiwix::Filter().local(true).valid(true))) {
+      auto currentReader = mp_library->getReaderById(bookId);
+      if (currentReader) {
+        searcher.add_reader(currentReader.get());
+      }
+    }
+  }
+
+  auto start = 0;
+  try {
+    start = request.get_argument<unsigned int>("start");
+  } catch (const std::exception&) {}
+  auto end = 25;
+  try {
+    end = request.get_argument<unsigned int>("end");
+  } catch (const std::exception&) {}
+  if (start>end) {
+    auto tmp = start;
+    start = end;
+    end = tmp;
+  }
+  if (end > start + MAX_SEARCH_LEN) {
+    end = start + MAX_SEARCH_LEN;
+  }
+
+  /* Get the results */
+  try {
+    if (patternString.empty()) {
+      searcher.geo_search(latitude, longitude, distance,
+                           start, end, m_verbose.load());
+    } else {
+      searcher.search(patternString,
+                       start, end, m_verbose.load());
+    }
+    SearchRenderer renderer(&searcher, mp_nameMapper);
+    renderer.setSearchPattern(patternString);
+    renderer.setSearchContent(bookName);
+    renderer.setProtocolPrefix(m_root + "/");
+    renderer.setSearchProtocolPrefix(m_root + "/search?");
+    response.set_content(renderer.getHtml());
+  } catch (const std::exception& e) {
+    std::cerr << e.what() << std::endl;
+  }
+  return response;
+}
+
+Response InternalServer::handle_random(const RequestContext& request)
+{
+  if (m_verbose.load()) {
+    printf("** running handle_random\n");
+  }
+
+  std::string bookName;
+  std::string bookId;
+  std::shared_ptr<Reader> reader;
+  try {
+    bookName = request.get_argument("content");
+    bookId = mp_nameMapper->getIdForName(bookName);
+    reader = mp_library->getReaderById(bookId);
+  } catch (const std::out_of_range&) {
+    return build_404(request, bookName);
+  }
+
+  if (reader == nullptr) {
+    return build_404(request, bookName);
+  }
+
+  try {
+    auto entry = reader->getRandomPage();
+    entry = entry.getFinalEntry();
+    auto response = get_default_response();
+    response.set_redirection(m_root + "/" + bookName + "/" + kiwix::urlEncode(entry.getPath()));
+    return response;
+  } catch(kiwix::NoEntry& e) {
+    return build_404(request, bookName);
+  }
+}
+
+Response InternalServer::handle_catalog(const RequestContext& request)
+{
+  if (m_verbose.load()) {
+    printf("** running handle_catalog");
+  }
+
+  std::string host;
+  std::string url;
+  try {
+    host = request.get_header("Host");
+    url  = request.get_url_part(1);
+  } catch (const std::out_of_range&) {
+    return build_404(request, "");
+  }
+
+  if (url != "searchdescription.xml" && url != "root.xml" && url != "search") {
+    return build_404(request, "");
+  }
+
+  auto response = get_default_response();
+  response.set_compress(true);
+  if (url == "searchdescription.xml") {
+    response.set_template(RESOURCE::opensearchdescription_xml, get_default_data());
+    response.set_mimeType("application/opensearchdescription+xml");
+    return response;
+  }
+
+  zim::Uuid uuid;
+  kiwix::OPDSDumper opdsDumper;
+  opdsDumper.setRootLocation(m_root);
+  opdsDumper.setSearchDescriptionUrl("catalog/searchdescription.xml");
+  opdsDumper.setId(kiwix::to_string(uuid));
+  opdsDumper.setLibrary(mp_library);
+  response.set_mimeType("application/atom+xml;profile=opds-catalog;kind=acquisition; charset=utf-8");
+  std::vector<std::string> bookIdsToDump;
+  if (url == "root.xml") {
+    opdsDumper.setTitle("All zims");
+    uuid = zim::Uuid::generate(host);
+    bookIdsToDump = mp_library->filter(kiwix::Filter().valid(true).local(true).remote(true));
+  } else if (url == "search") {
+    std::string query;
+    std::string language;
+    std::vector<std::string> tags;
+    std::vector<std::string> noTags;
+    size_t count(10);
+    size_t startIndex(0);
+    try {
+      query = request.get_argument("q");
+    } catch (const std::out_of_range&) {}
+    try {
+      language = request.get_argument("lang");
+    } catch (const std::out_of_range&) {}
+    try {
+      count = extractFromString<unsigned long>(request.get_argument("count"));
+    } catch (...) {}
+    try {
+      startIndex = extractFromString<unsigned long>(request.get_argument("start"));
+    } catch (...) {}
+    try {
+      tags = kiwix::split(request.get_argument("notag"), ";");
+    } catch (...) {}
+    try {
+      noTags = kiwix::split(request.get_argument("notag"), ";");
+    } catch (...) {}
+    opdsDumper.setTitle("Search result for " + query);
+    uuid = zim::Uuid::generate();
+    bookIdsToDump = mp_library->filter(
+      kiwix::Filter().valid(true).local(true).remote(true)
+        .query(query)
+        .lang(language)
+        .acceptTags(tags)
+        .rejectTags(noTags)
+      );
+    auto totalResults = bookIdsToDump.size();
+    bookIdsToDump.erase(bookIdsToDump.begin(), bookIdsToDump.begin()+startIndex);
+    if (count>0 && bookIdsToDump.size() > count) {
+      bookIdsToDump.resize(count);
+    }
+    opdsDumper.setOpenSearchInfo(totalResults, startIndex, bookIdsToDump.size());
+  }
+
+  response.set_content(opdsDumper.dumpOPDSFeed(bookIdsToDump));
+  return response;
+}
+
+Response InternalServer::handle_content(const RequestContext& request)
+{
+  if (m_verbose.load()) {
+    printf("** running handle_content\n");
+  }
+
+  std::string baseUrl;
+  std::string content;
+  std::string mimeType;
+
+  kiwix::Entry entry;
+
+  std::string bookName;
+  try {
+    bookName = request.get_url_part(0);
+  } catch (const std::out_of_range& e) {
+    return build_homepage(request);
+  }
+  if (bookName.empty())
+    return build_homepage(request);
+
+  std::string bookId;
+  std::shared_ptr<Reader> reader;
+  try {
+    bookId = mp_nameMapper->getIdForName(bookName);
+    reader = mp_library->getReaderById(bookId);
+  } catch (const std::out_of_range& e) {
+    return build_404(request, bookName);
+  }
+
+  if (reader == nullptr) {
+    return build_404(request, bookName);
+  }
+
+  auto urlStr = request.get_url().substr(bookName.size()+1);
+  if (urlStr[0] == '/') {
+    urlStr = urlStr.substr(1);
+  }
+
+  try {
+    entry = reader->getEntryFromPath(urlStr);
+    if (entry.isRedirect() || urlStr.empty()) {
+      // If urlStr is empty, we want to mainPage.
+      // We must do a redirection to the real page.
+      entry = entry.getFinalEntry();
+      auto response = get_default_response();
+      response.set_redirection(m_root + "/" + bookName + "/" +
+        kiwix::urlEncode(entry.getPath()));
+      return response;
+    }
+  } catch(kiwix::NoEntry& e) {
+    if (m_verbose.load())
+      printf("Failed to find %s\n", urlStr.c_str());
+
+    return build_404(request, bookName);
+  }
+
+  try {
+    mimeType = entry.getMimetype();
+  } catch (exception& e) {
+    mimeType = "application/octet-stream";
+  }
+
+  if (m_verbose.load()) {
+    printf("Found %s\n", urlStr.c_str());
+    printf("mimeType: %s\n", mimeType.c_str());
+  }
+
+  if (mimeType.find("text/") != string::npos
+      || mimeType.find("application/javascript") != string::npos
+      || mimeType.find("application/json") != string::npos) {
+    zim::Blob raw_content = entry.getBlob();
+    content = string(raw_content.data(), raw_content.size());
+    auto response = get_default_response();
+    response.set_mimeType(mimeType);
+
+    /* Special rewrite URL in case of ZIM file use intern *asbolute* url like
+     * /A/Kiwix */
+    if (mimeType.find("text/html") != string::npos) {
+      content = replaceRegex(content,
+                             "$1$2" + m_root + "/" + bookName + "/$3/",
+                             "(href|src)(=[\"|\']{0,1})/([A-Z|\\-])/");
+      content = replaceRegex(content,
+                             "$1$2" + m_root + "/" + bookName + "/$3/",
+                             "(@import[ ]+)([\"|\']{0,1})/([A-Z|\\-])/");
+      response.set_taskbar(bookName, reader->getTitle());
+    } else if (mimeType.find("text/css") != string::npos) {
+      content = replaceRegex(content,
+                             "$1$2" + m_root + "/" + bookName + "/$3/",
+                             "(url|URL)(\\([\"|\']{0,1})/([A-Z|\\-])/");
+    }
+    response.set_content(content);
+    response.set_compress(true);
+    response.set_cache(true);
+    return response;
+  } else {
+    int range_len;
+    if (request.get_range().second == -1) {
+       range_len = entry.getSize() - request.get_range().first;
+    } else {
+       range_len = request.get_range().second - request.get_range().first;
+    }
+    auto response = get_default_response();
+    response.set_entry(entry);
+    response.set_mimeType(mimeType);
+    response.set_range_first(request.get_range().first);
+    response.set_range_len(range_len);
+    response.set_cache(true);
+    return response;
+  }
+}
+
+}

src/server/request_context.cpp

@@ -0,0 +1,211 @@
+/*
+ * Copyright 2009-2016 Emmanuel Engelhart <kelson@kiwix.org>
+ * 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 "request_context.h"
+#include <string.h>
+#include <stdexcept>
+#include <sstream>
+#include <cstdio>
+#include <atomic>
+
+namespace kiwix {
+
+static std::atomic_ullong s_requestIndex(0);
+
+RequestContext::RequestContext(struct MHD_Connection* connection,
+                               std::string rootLocation,
+                               const std::string& _url,
+                               const std::string& method,
+                               const std::string& version) :
+  full_url(_url),
+  url(_url),
+  valid_url(true),
+  version(version),
+  requestIndex(s_requestIndex++),
+  acceptEncodingDeflate(false),
+  accept_range(false),
+  range_pair(0, -1)
+{
+  if (method == "GET") {
+    this->method = RequestMethod::GET;
+  } else if (method == "HEAD") {
+    this->method = RequestMethod::HEAD;
+  } else if (method == "POST") {
+    this->method = RequestMethod::POST;
+  } else if (method == "PUT") {
+    this->method = RequestMethod::PUT;
+  } else if (method == "DELETE") {
+    this->method = RequestMethod::DELETE_;
+  } else if (method == "CONNECT") {
+    this->method = RequestMethod::CONNECT;
+  } else if (method == "OPTIONS") {
+    this->method = RequestMethod::OPTIONS;
+  } else if (method == "TRACE") {
+    this->method = RequestMethod::TRACE;
+  } else if (method == "PATCH") {
+    this->method = RequestMethod::PATCH;
+  } else {
+    this->method = RequestMethod::OTHER;
+  }
+
+  MHD_get_connection_values(connection, MHD_HEADER_KIND, &RequestContext::fill_header, this);
+  MHD_get_connection_values(connection, MHD_GET_ARGUMENT_KIND, &RequestContext::fill_argument, this);
+
+  valid_url = true;
+  if (rootLocation.empty()) {
+    // nothing special to handle.
+    url = full_url;
+  } else {
+    if (full_url == rootLocation) {
+      url = "/";
+    } else if (full_url.size() > rootLocation.size() &&
+               full_url.substr(0, rootLocation.size()+1) == rootLocation + "/") {
+      url = full_url.substr(rootLocation.size());
+    } else {
+      valid_url = false;
+    }
+  }
+
+  try {
+    acceptEncodingDeflate =
+        (get_header(MHD_HTTP_HEADER_ACCEPT_ENCODING).find("deflate") != std::string::npos);
+  } catch (const std::out_of_range&) {}
+
+  /*Check if range is requested. */
+  try {
+    auto range = get_header(MHD_HTTP_HEADER_RANGE);
+    int start = 0;
+    int end = -1;
+    std::istringstream iss(range);
+    char c;
+
+    iss >> start >> c;
+    if (iss.good() && c=='-') {
+      iss >> end;
+      if (iss.fail()) {
+        // Something went wrong will extracting.
+        end = -1;
+      }
+      if (iss.eof()) {
+        accept_range = true;
+        range_pair = std::pair<int, int>(start, end);
+      }
+    }
+  } catch (const std::out_of_range&) {}
+}
+
+RequestContext::~RequestContext()
+{}
+
+
+int RequestContext::fill_header(void *__this, enum MHD_ValueKind kind,
+                                 const char *key, const char *value)
+{
+  RequestContext *_this = static_cast<RequestContext*>(__this);
+  _this->headers[key] = value;
+  return MHD_YES;
+}
+
+int RequestContext::fill_argument(void *__this, enum MHD_ValueKind kind,
+                                   const char *key, const char* value)
+{
+  RequestContext *_this = static_cast<RequestContext*>(__this);
+  _this->arguments[key] = value == nullptr ? "" : value;
+  return MHD_YES;
+}
+
+void RequestContext::print_debug_info() const {
+  printf("method    : %s (%d)\n", method==RequestMethod::GET ? "GET" :
+                                  method==RequestMethod::POST ? "POST" :
+                                  "OTHER", (int)method);
+  printf("version   : %s\n", version.c_str());
+  printf("request#  : %lld\n", requestIndex);
+  printf("headers   :\n");
+  for (auto it=headers.begin(); it!=headers.end(); it++) {
+    printf(" - %s : '%s'\n", it->first.c_str(), it->second.c_str());
+  }
+  printf("arguments :\n");
+  for (auto it=arguments.begin(); it!=arguments.end(); it++) {
+    printf(" - %s : '%s'\n", it->first.c_str(), it->second.c_str());
+  }
+  printf("Parsed : \n");
+  printf("url   : %s\n", url.c_str());
+  printf("acceptEncodingDeflate : %d\n", acceptEncodingDeflate);
+  printf("has_range : %d\n", accept_range);
+  printf("is_valid_url : %d\n", valid_url);
+  printf(".............\n");
+}
+
+
+RequestMethod RequestContext::get_method() const {
+  return method;
+}
+
+std::string RequestContext::get_url() const {
+  return url;
+}
+
+std::string RequestContext::get_url_part(int number) const {
+  size_t start = 1;
+  while(true) {
+    auto found = url.find('/', start);
+    if (number == 0) {
+      if (found == std::string::npos) {
+        return url.substr(start);
+      } else {
+        return url.substr(start, found-start);
+      }
+    } else {
+      if (found == std::string::npos) {
+        throw std::out_of_range("No parts");
+      }
+      start = found + 1;
+      number -= 1;
+    }
+  }
+}
+
+std::string RequestContext::get_full_url() const {
+  return full_url;
+}
+
+bool RequestContext::is_valid_url() const {
+  return valid_url;
+}
+
+bool RequestContext::has_range() const {
+  return accept_range;
+}
+
+std::pair<int, int> RequestContext::get_range() const {
+  return range_pair;
+}
+
+template<>
+std::string RequestContext::get_argument(const std::string& name) const {
+  return arguments.at(name);
+}
+
+std::string RequestContext::get_header(const std::string& name) const {
+  return headers.at(name);
+}
+
+}

src/server/request_context.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2009-2016 Emmanuel Engelhart <kelson@kiwix.org>
+ * 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 REQUEST_CONTEXT_H
+#define REQUEST_CONTEXT_H
+
+#include <string>
+#include <sstream>
+#include <map>
+#include <stdexcept>
+
+extern "C" {
+#include <microhttpd.h>
+}
+
+namespace kiwix {
+
+enum class RequestMethod {
+    GET,
+    HEAD,
+    POST,
+    PUT,
+    DELETE_,
+    CONNECT,
+    OPTIONS,
+    TRACE,
+    PATCH,
+    OTHER
+};
+
+class KeyError : public std::runtime_error {};
+class IndexError: public std::runtime_error {};
+
+
+class RequestContext {
+  public:
+    RequestContext(struct MHD_Connection* connection,
+                   std::string rootLocation,
+                   const std::string& url,
+                   const std::string& method,
+                   const std::string& version);
+    ~RequestContext();
+
+    void print_debug_info() const;
+
+    bool is_valid_url() const;
+
+    std::string get_header(const std::string& name) const;
+    template<typename T=std::string>
+    T get_argument(const std::string& name) const {
+        std::istringstream stream(arguments.at(name));
+        T v;
+        stream >> v;
+        return v;
+    }
+
+
+    RequestMethod get_method() const;
+    std::string get_url() const;
+    std::string get_url_part(int part) const;
+    std::string get_full_url() const;
+
+    bool has_range() const;
+    std::pair<int, int> get_range() const;
+
+    bool can_compress() const { return acceptEncodingDeflate; }
+
+  private:
+    std::string full_url;
+    std::string url;
+    bool valid_url;
+    RequestMethod method;
+    std::string version;
+    unsigned long long requestIndex;
+
+    bool acceptEncodingDeflate;
+
+    bool accept_range;
+    std::pair<int, int> range_pair;
+    std::map<std::string, std::string> headers;
+    std::map<std::string, std::string> arguments;
+
+    static int fill_header(void *, enum MHD_ValueKind, const char*, const char*);
+    static int fill_argument(void *, enum MHD_ValueKind, const char*, const char*);
+};
+
+template<> std::string RequestContext::get_argument(const std::string& name) const;
+
+}
+
+#endif //REQUEST_CONTEXT_H

src/server/response.cpp

@@ -0,0 +1,250 @@
+
+
+
+#include "response.h"
+#include "request_context.h"
+#include "kiwixlib-resources.h"
+
+#include "tools/regexTools.h"
+#include "tools/stringTools.h"
+
+#include "string.h"
+#include <mustache.hpp>
+#include <zlib.h>
+
+
+#define KIWIX_MIN_CONTENT_SIZE_TO_DEFLATE 100
+
+namespace kiwix {
+
+Response::Response(const std::string& root, bool verbose, bool withTaskbar, bool withLibraryButton)
+  : m_verbose(verbose),
+    m_root(root),
+    m_content(""),
+    m_mimeType(""),
+    m_returnCode(MHD_HTTP_OK),
+    m_withTaskbar(withTaskbar),
+    m_withLibraryButton(withLibraryButton),
+    m_useCache(false),
+    m_addTaskbar(false),
+    m_bookName(""),
+    m_startRange(0),
+    m_lenRange(0)
+{
+}
+
+
+static int print_key_value (void *cls, enum MHD_ValueKind kind,
+                            const char *key, const char *value)
+{
+  printf (" - %s: '%s'\n", key, value);
+  return MHD_YES;
+}
+
+
+struct RunningResponse {
+   kiwix::Entry entry;
+   int range_start;
+
+   RunningResponse(kiwix::Entry entry,
+                   int range_start) :
+     entry(entry),
+     range_start(range_start)
+   {}
+};
+
+static ssize_t callback_reader_from_entry(void* cls,
+                                  uint64_t pos,
+                                  char* buf,
+                                  size_t max)
+{
+  RunningResponse* response = static_cast<RunningResponse*>(cls);
+
+  size_t max_size_to_set = min<size_t>(
+    max,
+    response->entry.getSize() - pos - response->range_start);
+
+  if (max_size_to_set <= 0) {
+    return MHD_CONTENT_READER_END_WITH_ERROR;
+  }
+
+  zim::Blob blob = response->entry.getBlob(response->range_start+pos, max_size_to_set);
+  memcpy(buf, blob.data(), max_size_to_set);
+  return max_size_to_set;
+}
+
+static void callback_free_response(void* cls)
+{
+  RunningResponse* response = static_cast<RunningResponse*>(cls);
+  delete response;
+}
+
+
+
+void print_response_info(int retCode, MHD_Response* response)
+{
+  printf("Response :\n");
+  printf("httpResponseCode : %d\n", retCode);
+  printf("headers :\n");
+  MHD_get_response_headers(response, print_key_value, nullptr);
+}
+
+
+std::string render_template(const std::string& template_str, kainjow::mustache::data data)
+{
+  kainjow::mustache::mustache tmpl(template_str);
+  kainjow::mustache::data urlencode{kainjow::mustache::lambda2{
+                               [](const std::string& str,const kainjow::mustache::renderer& r) { return urlEncode(r(str), true); }}};
+  data.set("urlencoded", urlencode);
+  std::stringstream ss;
+  tmpl.render(data, [&ss](const std::string& str) { ss << str; });
+  return ss.str();
+}
+
+
+void Response::introduce_taskbar()
+{
+  if (! m_withTaskbar)
+    // Taskbar is globally disabled.
+    return;
+  kainjow::mustache::data data;
+  data.set("root", m_root);
+  data.set("content", m_bookName);
+  data.set("hascontent", !m_bookName.empty());
+  data.set("title", m_bookTitle);
+  data.set("withlibrarybutton", m_withLibraryButton);
+  auto head_content = render_template(RESOURCE::templates::head_part_html, data);
+  m_content = appendToFirstOccurence(
+    m_content,
+    "<head>",
+    head_content);
+
+  auto taskbar_part = render_template(RESOURCE::templates::taskbar_part_html, data);
+  m_content = appendToFirstOccurence(
+    m_content,
+    "<body[^>]*>",
+    taskbar_part);
+}
+
+
+
+int Response::send(const RequestContext& request, MHD_Connection* connection)
+{
+  MHD_Response* response = nullptr;
+  switch (m_mode) {
+    case ResponseMode::RAW_CONTENT : {
+      if (m_addTaskbar) {
+        introduce_taskbar();
+      }
+
+      bool shouldCompress = m_compress && request.can_compress();
+      shouldCompress &= m_mimeType.find("text/") != string::npos
+                     || m_mimeType.find("application/javascript") != string::npos
+                     || m_mimeType.find("application/json") != string::npos; 
+
+      shouldCompress &= (m_content.size() > KIWIX_MIN_CONTENT_SIZE_TO_DEFLATE);
+
+      if (shouldCompress) {
+        std::vector<Bytef> compr_buffer(compressBound(m_content.size()));
+        uLongf comprLen = compr_buffer.capacity();
+        int err = compress(&compr_buffer[0],
+                           &comprLen,
+                           (const Bytef*)(m_content.data()),
+                           m_content.size());
+        if (err == Z_OK && comprLen > 2 && comprLen < (m_content.size() + 2)) {
+          /* /!\ Internet Explorer has a bug with deflate compression.
+             It can not handle the first two bytes (compression headers)
+             We need to chunk them off (move the content 2bytes)
+             It has no incidence on other browsers
+             See http://www.subbu.org/blog/2008/03/ie7-deflate-or-not and comments */
+          m_content = string((char*)&compr_buffer[2], comprLen - 2);
+        } else {
+          shouldCompress = false;
+        }
+      }
+
+      response = MHD_create_response_from_buffer(
+        m_content.size(), const_cast<char*>(m_content.data()), MHD_RESPMEM_MUST_COPY);
+
+      if (shouldCompress) {
+        MHD_add_response_header(
+            response, MHD_HTTP_HEADER_VARY, "Accept-Encoding");
+        MHD_add_response_header(
+            response, MHD_HTTP_HEADER_CONTENT_ENCODING, "deflate");
+      }
+      MHD_add_response_header(response, MHD_HTTP_HEADER_CONTENT_TYPE, m_mimeType.c_str());
+      break;
+    }
+
+    case ResponseMode::REDIRECTION : {
+      response = MHD_create_response_from_buffer(0, nullptr, MHD_RESPMEM_MUST_COPY);
+      MHD_add_response_header(response, MHD_HTTP_HEADER_LOCATION, m_content.c_str());
+      break;
+    }
+
+    case ResponseMode::ENTRY : {
+      response = MHD_create_response_from_callback(m_entry.getSize(),
+                                                   16384,
+                                                   callback_reader_from_entry,
+                                                   new RunningResponse(m_entry, m_startRange),
+                                                   callback_free_response);
+      MHD_add_response_header(response,
+        MHD_HTTP_HEADER_CONTENT_TYPE, m_mimeType.c_str());
+      MHD_add_response_header(response, MHD_HTTP_HEADER_ACCEPT_RANGES, "bytes");
+      std::ostringstream oss;
+      oss << "bytes " << m_startRange << "-" << m_startRange + m_lenRange - 1
+          << "/" << m_entry.getSize();
+
+      MHD_add_response_header(response,
+        MHD_HTTP_HEADER_CONTENT_RANGE, oss.str().c_str());
+
+      MHD_add_response_header(response,
+        MHD_HTTP_HEADER_CONTENT_LENGTH, kiwix::to_string(m_lenRange).c_str());
+      break;
+    }
+  }
+
+  MHD_add_response_header(response, "Access-Control-Allow-Origin", "*");
+  MHD_add_response_header(response, MHD_HTTP_HEADER_CACHE_CONTROL,
+    m_useCache ? "max-age=2723040, public" : "no-cache, no-store, must-revalidate");
+
+  if (m_returnCode == MHD_HTTP_OK && request.has_range())
+    m_returnCode = MHD_HTTP_PARTIAL_CONTENT;
+
+  if (m_verbose)
+    print_response_info(m_returnCode, response);
+
+  auto ret = MHD_queue_response(connection, m_returnCode, response);
+  MHD_destroy_response(response);
+  return ret;
+}
+
+void Response::set_template(const std::string& template_str, kainjow::mustache::data data) {
+  set_content(render_template(template_str, data));
+}
+
+void Response::set_content(const std::string& content) {
+  m_content = content;
+  m_mode = ResponseMode::RAW_CONTENT;
+}
+
+void Response::set_redirection(const std::string& url) {
+  m_content = url;
+  m_mode = ResponseMode::REDIRECTION;
+  m_returnCode = MHD_HTTP_FOUND;
+}
+
+void Response::set_entry(const Entry& entry) {
+  m_entry = entry;
+  m_mode = ResponseMode::ENTRY;
+}
+
+void Response::set_taskbar(const std::string& bookName, const std::string& bookTitle)
+{
+  m_addTaskbar = true;
+  m_bookName = bookName;
+  m_bookTitle = bookTitle;
+}
+
+
+}

src/server/response.h

@@ -0,0 +1,89 @@
+/*
+ * 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 KIWIXLIB_SERVER_RESPONSE_H
+#define KIWIXLIB_SERVER_RESPONSE_H
+
+#include <string>
+
+#include <mustache.hpp>
+#include "entry.h"
+
+extern "C" {
+#include <microhttpd.h>
+}
+
+namespace kiwix {
+
+enum class ResponseMode {
+  RAW_CONTENT,
+  REDIRECTION,
+  ENTRY
+};
+
+class RequestContext;
+
+class Response {
+  public:
+    Response(const std::string& root, bool verbose, bool withTaskbar, bool withLibraryButton);
+    ~Response() = default;
+
+    int send(const RequestContext& request, MHD_Connection* connection);
+
+    void set_template(const std::string& template_str, kainjow::mustache::data data);
+    void set_content(const std::string& content);
+    void set_redirection(const std::string& url);
+    void set_entry(const Entry& entry);
+
+
+    void set_mimeType(const std::string& mimeType) { m_mimeType = mimeType; }
+    void set_code(int code) { m_returnCode = code; }
+    void set_cache(bool cache) { m_useCache = cache; }
+    void set_compress(bool compress) { m_compress = compress; }
+    void set_taskbar(const std::string& bookName, const std::string& bookTitle);
+    void set_range_first(uint64_t start) { m_startRange = start; }
+    void set_range_len(uint64_t len) { m_lenRange = len; }
+
+    int getReturnCode() { return m_returnCode; }
+
+    void introduce_taskbar();
+
+  private:
+    bool m_verbose;
+    ResponseMode m_mode;
+    std::string m_root;
+    std::string m_content;
+    Entry m_entry;
+    std::string m_mimeType;
+    int m_returnCode;
+    bool m_withTaskbar;
+    bool m_withLibraryButton;
+    bool m_useCache;
+    bool m_compress;
+    bool m_addTaskbar;
+    std::string m_bookName;
+    std::string m_bookTitle;
+    uint64_t m_startRange;
+    uint64_t m_lenRange;
+};
+
+}
+
+#endif //KIWIXLIB_SERVER_RESPONSE_H

src/subprocess_unix.cpp

@@ -46,7 +46,7 @@ void* UnixImpl::waitForPID(void* _self)
 #endif
 
   UnixImpl* self = static_cast<UnixImpl*>(_self);
-  waitpid(self->m_pid, NULL, WEXITED);
+  waitpid(self->m_pid, NULL, 0);
 
   pthread_mutex_lock(&self->m_mutex);
   self->m_running = false;
@@ -67,7 +67,7 @@ void UnixImpl::run(commandLine_t& commandLine)
       commandLine.push_back(NULL);
       if (execvp(binary, const_cast<char* const*>(commandLine.data()))) {
         perror("Cannot launch\n");
-        exit(-1);
+        _exit(-1);
       }
 
       break;

src/tools/base64.cpp

@@ -24,7 +24,7 @@
    René Nyffenegger rene.nyffenegger@adp-gmbh.ch
 */
 
-#include <common/base64.h>
+#include <tools/base64.h>
 #include <iostream>
 
 static const std::string base64_chars = 

src/tools/networkTools.cpp

@@ -0,0 +1,59 @@
+/*
+ * 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 <tools/networkTools.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <curl/curl.h>
+
+#include <sstream>
+#include <iostream>
+#include <stdexcept>
+
+
+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 kiwix::download(const std::string& url) {
+  auto curl = curl_easy_init();
+  std::stringstream ss;
+  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+  curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &write_callback_to_iss);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ss);
+  auto res = curl_easy_perform(curl);
+  if (res != CURLE_OK) {
+    curl_easy_cleanup(curl);
+    throw std::runtime_error("Cannot perform request");
+  }
+  long response_code;
+  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+  curl_easy_cleanup(curl);
+  if (response_code != 200) {
+    throw std::runtime_error("Invalid return code from server");
+  }
+  return ss.str();
+}

src/tools/otherTools.cpp

@@ -0,0 +1,206 @@
+/*
+ * 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.
+ */
+
+#include "tools/otherTools.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <map>
+#include <pugixml.hpp>
+
+
+static std::map<std::string, std::string> codeisomapping {
+{ "aa", "aar" },
+{ "af", "afr" },
+{ "ak", "aka" },
+{ "am", "amh" },
+{ "ar", "ara" },
+{ "as", "asm" },
+{ "az", "aze" },
+{ "ba", "bak" },
+{ "be", "bel" },
+{ "bg", "bul" },
+{ "bm", "bam" },
+{ "bn", "ben" },
+{ "bo", "bod" },
+{ "br", "bre" },
+{ "bs", "bos" },
+{ "ca", "cat" },
+{ "ce", "che" },
+{ "co", "cos" },
+{ "cs", "ces" },
+{ "cu", "chu" },
+{ "cv", "chv" },
+{ "cy", "cym" },
+{ "da", "dan" },
+{ "de", "deu" },
+{ "dv", "div" },
+{ "dz", "dzo" },
+{ "ee", "ewe" },
+{ "el", "ell" },
+{ "en", "eng" },
+{ "es", "spa" },
+{ "et", "est" },
+{ "eu", "eus" },
+{ "fa", "fas" },
+{ "ff", "ful" },
+{ "fi", "fin" },
+{ "fo", "fao" },
+{ "fr", "fra" },
+{ "fy", "fry" },
+{ "ga", "gle" },
+{ "gd", "gla" },
+{ "gl", "glg" },
+{ "gn", "grn" },
+{ "gu", "guj" },
+{ "gv", "glv" },
+{ "ha", "hau" },
+{ "he", "heb" },
+{ "hi", "hin" },
+{ "hr", "hrv" },
+{ "hu", "hun" },
+{ "hy", "hye" },
+{ "ia", "ina" },
+{ "id", "ind" },
+{ "ig", "ibo" },
+{ "is", "isl" },
+{ "it", "ita" },
+{ "iu", "iku" },
+{ "ja", "jpn" },
+{ "jv", "jav" },
+{ "ka", "kat" },
+{ "ki", "kik" },
+{ "kk", "kaz" },
+{ "kl", "kal" },
+{ "km", "khm" },
+{ "kn", "kan" },
+{ "ko", "kor" },
+{ "ks", "kas" },
+{ "ku", "kur" },
+{ "kw", "cor" },
+{ "ky", "kir" },
+{ "lb", "ltz" },
+{ "lg", "lug" },
+{ "ln", "lin" },
+{ "lo", "lao" },
+{ "lt", "lit" },
+{ "lv", "lav" },
+{ "mg", "mlg" },
+{ "mi", "mri" },
+{ "mi", "mri" },
+{ "mk", "mkd" },
+{ "ml", "mal" },
+{ "mn", "mon" },
+{ "mr", "mar" },
+{ "ms", "msa" },
+{ "mt", "mlt" },
+{ "my", "mya" },
+{ "nb", "nob" },
+{ "ne", "nep" },
+{ "nl", "nld" },
+{ "nn", "nno" },
+{ "no", "nor" },
+{ "ny", "nya" },
+{ "oc", "oci" },
+{ "om", "orm" },
+{ "or", "ori" },
+{ "os", "oss" },
+{ "pa", "pan" },
+{ "pl", "pol" },
+{ "ps", "pus" },
+{ "pt", "por" },
+{ "qu", "que" },
+{ "rm", "roh" },
+{ "rn", "run" },
+{ "ro", "ron" },
+{ "ru", "rus" },
+{ "rw", "kin" },
+{ "sa", "san" },
+{ "sd", "snd" },
+{ "se", "sme" },
+{ "sg", "sag" },
+{ "si", "sin" },
+{ "sk", "slk" },
+{ "sl", "slv" },
+{ "sn", "sna" },
+{ "so", "som" },
+{ "sq", "sqi" },
+{ "sr", "srp" },
+{ "ss", "ssw" },
+{ "st", "sot" },
+{ "sv", "swe" },
+{ "sw", "swa" },
+{ "ta", "tam" },
+{ "te", "tel" },
+{ "tg", "tgk" },
+{ "th", "tha" },
+{ "ti", "tir" },
+{ "tk", "tuk" },
+{ "tl", "tgl" },
+{ "tn", "tsn" },
+{ "to", "ton" },
+{ "tr", "tur" },
+{ "ts", "tso" },
+{ "tt", "tat" },
+{ "ug", "uig" },
+{ "uk", "ukr" },
+{ "ur", "urd" },
+{ "uz", "uzb" },
+{ "ve", "ven" },
+{ "vi", "vie" },
+{ "wa", "wln" },
+{ "wo", "wol" },
+{ "xh", "xho" },
+{ "yo", "yor" },
+{ "zh", "zho" },
+{ "zu", "zul" }
+};
+
+void kiwix::sleep(unsigned int milliseconds)
+{
+#ifdef _WIN32
+  Sleep(milliseconds);
+#else
+  usleep(1000 * milliseconds);
+#endif
+}
+
+
+struct XmlStringWriter: pugi::xml_writer
+{
+  std::string result;
+  virtual void write(const void* data, size_t size){
+    result.append(static_cast<const char*>(data), size);
+  }
+};
+
+std::string kiwix::nodeToString(const pugi::xml_node& node)
+{
+  XmlStringWriter writer;
+  node.print(writer, "  ");
+  return writer.result;
+}
+
+std::string kiwix::converta2toa3(const std::string& a2code){
+  return codeisomapping.at(a2code);
+}

src/tools/pathTools.cpp

@@ -17,7 +17,7 @@
  * MA 02110-1301, USA.
  */
 
-#include <common/pathTools.h>
+#include "tools/pathTools.h"
 
 #ifdef __APPLE__
 #include <limits.h>
@@ -29,10 +29,16 @@
 #define getcwd _getcwd  // stupid MSFT "deprecation" warning
 #endif
 
-#ifdef _WIN32
-#else
-#include <unistd.h>
-#endif
+#include "tools/stringTools.h"
+
+#include <string.h>
+#include <map>
+#include <vector>
+#include <sys/stat.h>
+#include <sstream>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
 
 #ifdef _WIN32
 const std::string SEPARATOR("\\");
@@ -47,7 +53,7 @@ const std::string SEPARATOR("/");
 #define PATH_MAX 1024
 #endif
 
-bool isRelativePath(const string& path)
+bool isRelativePath(const std::string& path)
 {
 #ifdef _WIN32
   return path.empty() || path.substr(1, 2) == ":\\" ? false : true;
@@ -56,7 +62,7 @@ bool isRelativePath(const string& path)
 #endif
 }
 
-string computeRelativePath(const string path, const string absolutePath)
+std::string computeRelativePath(const std::string& path, const std::string& absolutePath)
 {
   std::vector<std::string> pathParts = kiwix::split(path, SEPARATOR);
   std::vector<std::string> absolutePathParts
@@ -69,7 +75,7 @@ string computeRelativePath(const string path, const string absolutePath)
       commonCount++;
   }
 
-  string relativePath;
+  std::string relativePath;
 #ifdef _WIN32
   /* On Windows you have a token more because the root is represented
      by a letter */
@@ -88,10 +94,16 @@ string computeRelativePath(const string path, const string absolutePath)
   return relativePath;
 }
 
+#ifdef _WIN32
+# define STRTOK strtok_s
+#else
+# define STRTOK strtok_r
+#endif
+
 /* Warning: the relative path must be with slashes */
-string computeAbsolutePath(const string path, const string relativePath)
+std::string computeAbsolutePath(const std::string& path, const std::string& relativePath)
 {
-  string absolutePath;
+  std::string absolutePath;
 
   if (path.empty()) {
     char* path = NULL;
@@ -103,7 +115,7 @@ string computeAbsolutePath(const string path, const string relativePath)
     path = getcwd(path, size);
 #endif
 
-    absolutePath = string(path) + SEPARATOR;
+    absolutePath = std::string(path) + SEPARATOR;
   } else {
     absolutePath = path.substr(path.length() - 1, 1) == SEPARATOR
                        ? path
@@ -115,31 +127,33 @@ string computeAbsolutePath(const string path, const string relativePath)
 #else
   char* cRelativePath = strdup(relativePath.c_str());
 #endif
-  char* token = strtok(cRelativePath, "/");
+  char* saveptr = nullptr;
+  char* token = STRTOK(cRelativePath, "/", &saveptr);
 
   while (token != NULL) {
-    if (string(token) == "..") {
+    if (std::string(token) == "..") {
       absolutePath = removeLastPathElement(absolutePath, true, false);
-      token = strtok(NULL, "/");
+      token = STRTOK(NULL, "/", &saveptr);
     } else if (strcmp(token, ".") && strcmp(token, "")) {
-      absolutePath += string(token);
-      token = strtok(NULL, "/");
+      absolutePath += std::string(token);
+      token = STRTOK(NULL, "/", &saveptr);
       if (token != NULL) {
         absolutePath += SEPARATOR;
       }
     } else {
-      token = strtok(NULL, "/");
+      token = STRTOK(NULL, "/", &saveptr);
     }
   }
+  free(cRelativePath);
 
   return absolutePath;
 }
 
-string removeLastPathElement(const string path,
-                             const bool removePreSeparator,
-                             const bool removePostSeparator)
+std::string removeLastPathElement(const std::string& path,
+                                  const bool removePreSeparator,
+                                  const bool removePostSeparator)
 {
-  string newPath = path;
+  std::string newPath = path;
   size_t offset = newPath.find_last_of(SEPARATOR);
   if (removePreSeparator &&
 #ifndef _WIN32
@@ -154,18 +168,18 @@ string removeLastPathElement(const string path,
   return newPath;
 }
 
-string appendToDirectory(const string& directoryPath, const string& filename)
+std::string appendToDirectory(const std::string& directoryPath, const std::string& filename)
 {
-  string newPath = directoryPath + SEPARATOR + filename;
+  std::string newPath = directoryPath + SEPARATOR + filename;
   return newPath;
 }
 
-string getLastPathElement(const string& path)
+std::string getLastPathElement(const std::string& path)
 {
   return path.substr(path.find_last_of(SEPARATOR) + 1);
 }
 
-unsigned int getFileSize(const string& path)
+unsigned int getFileSize(const std::string& path)
 {
 #ifdef _WIN32
   struct _stat filestatus;
@@ -178,14 +192,14 @@ unsigned int getFileSize(const string& path)
   return filestatus.st_size / 1024;
 }
 
-string getFileSizeAsString(const string& path)
+std::string getFileSizeAsString(const std::string& path)
 {
-  ostringstream convert;
+  std::ostringstream convert;
   convert << getFileSize(path);
   return convert.str();
 }
 
-string getFileContent(const string& path)
+std::string getFileContent(const std::string& path)
 {
   std::ifstream f(path, std::ios::in|std::ios::ate);
   std::string content;
@@ -199,14 +213,14 @@ string getFileContent(const string& path)
   return content;
 }
 
-bool fileExists(const string& path)
+bool fileExists(const std::string& path)
 {
 #ifdef _WIN32
   return PathFileExists(path.c_str());
 #else
   bool flag = false;
-  fstream fin;
-  fin.open(path.c_str(), ios::in);
+  std::fstream fin;
+  fin.open(path.c_str(), std::ios::in);
   if (fin.is_open()) {
     flag = true;
   }
@@ -215,7 +229,7 @@ bool fileExists(const string& path)
 #endif
 }
 
-bool makeDirectory(const string& path)
+bool makeDirectory(const std::string& path)
 {
 #ifdef _WIN32
   int status = _mkdir(path.c_str());
@@ -225,32 +239,27 @@ bool makeDirectory(const string& path)
   return status == 0;
 }
 
-string makeTmpDirectory()
+std::string makeTmpDirectory()
 {
 #ifdef _WIN32
-  char cbase[MAX_PATH+1];
-  int base_len = GetTempPath(MAX_PATH+1, cbase);
-  UUID uuid;
-  UuidCreate(&uuid);
-  char* dir_name;
-  UuidToString(&uuid, reinterpret_cast<unsigned char**>(&dir_name));
-  string dir(cbase, base_len);
-  dir += dir_name;
-  _mkdir(dir.c_str());
-  RpcStringFree(reinterpret_cast<unsigned char**>(&dir_name));
+  char cbase[MAX_PATH];
+  char ctmp[MAX_PATH];
+  GetTempPath(MAX_PATH-14, cbase);
+  // This create a file for us, ensure it is unique.
+  // So we need to delete it and create the directory using the same name.
+  GetTempFileName(cbase, "kiwix", 0, ctmp);
+  DeleteFile(ctmp);
+  _mkdir(ctmp);
+  return std::string(ctmp);
 #else
-  string base = "/tmp";
-  auto _template = base + "/kiwix-lib_XXXXXX";
-  char* _template_array = new char[_template.size()+1];
-  memcpy(_template_array, _template.c_str(), _template.size());
-  string dir = mkdtemp(_template_array);
-  delete[] _template_array;
-#endif
+  char _template_array[] = {"/tmp/kiwix-lib_XXXXXX"};
+  std::string dir = mkdtemp(_template_array);
   return dir;
+#endif
 }
 
 /* Try to create a link and if does not work then make a copy */
-bool copyFile(const string& sourcePath, const string& destPath)
+bool copyFile(const std::string& sourcePath, const std::string& destPath)
 {
   try {
 #ifndef _WIN32
@@ -262,15 +271,15 @@ bool copyFile(const string& sourcePath, const string& destPath)
 #ifndef _WIN32
     }
 #endif
-  } catch (exception& e) {
-    cerr << e.what() << endl;
+  } catch (std::exception& e) {
+    std::cerr << e.what() << std::endl;
     return false;
   }
 
   return true;
 }
 
-string getExecutablePath()
+std::string getExecutablePath()
 {
   char binRootPath[PATH_MAX];
 
@@ -291,7 +300,7 @@ string getExecutablePath()
   return "";
 }
 
-bool writeTextFile(const string& path, const string& content)
+bool writeTextFile(const std::string& path, const std::string& content)
 {
   std::ofstream file;
   file.open(path.c_str());
@@ -300,15 +309,15 @@ bool writeTextFile(const string& path, const string& content)
   return true;
 }
 
-string getCurrentDirectory()
+std::string getCurrentDirectory()
 {
   char* a_cwd = getcwd(NULL, 0);
-  string s_cwd(a_cwd);
+  std::string s_cwd(a_cwd);
   free(a_cwd);
   return s_cwd;
 }
 
-string getDataDirectory()
+std::string getDataDirectory()
 {
 #ifdef _WIN32
   char* cDataDir = ::getenv("APPDATA");
@@ -333,3 +342,49 @@ string getDataDirectory()
 #endif
   return appendToDirectory(dataDir, "kiwix");
 }
+
+static std::map<std::string, std::string> extMimeTypes = {
+ { "html", "text/html"},
+ { "htm", "text/html"},
+ { "png", "image/png"},
+ { "tiff", "image/tiff"},
+ { "tif", "image/tiff"},
+ { "jpeg", "image/jpeg"},
+ { "jpg", "image/jpeg"},
+ { "gif", "image/gif"},
+ { "svg", "image/svg+xml"},
+ { "txt", "text/plain"},
+ { "xml", "text/xml"},
+ { "pdf", "application/pdf"},
+ { "ogg", "application/ogg"},
+ { "js", "application/javascript"},
+ { "css", "text/css"},
+ { "otf", "application/vnd.ms-opentype"},
+ { "ttf", "application/font-ttf"},
+ { "woff", "application/font-woff"},
+ { "vtt", "text/vtt"}
+};
+
+/* Try to get the mimeType from the file extension */
+std::string getMimeTypeForFile(const std::string& filename)
+{
+  std::string mimeType = "text/plain";
+  auto pos = filename.find_last_of(".");
+
+  if (pos != std::string::npos) {
+    std::string extension = filename.substr(pos + 1);
+
+    auto it = extMimeTypes.find(extension);
+    if (it != extMimeTypes.end()) {
+      mimeType = it->second;
+    } else {
+      it = extMimeTypes.find(kiwix::lcAll(extension));
+      if (it != extMimeTypes.end()) {
+        mimeType = it->second;
+      }
+    }
+  }
+
+  return mimeType;
+}
+

src/tools/regexTools.cpp

@@ -17,41 +17,47 @@
  * MA 02110-1301, USA.
  */
 
-#include <common/regexTools.h>
+#include <tools/regexTools.h>
+#include <tools/lock.h>
 
-std::map<std::string, icu::RegexMatcher*> regexCache;
+#include <unicode/regex.h>
+#include <unicode/ucnv.h>
 
-icu::RegexMatcher* buildRegex(const std::string& regex)
+#include <memory>
+#include <map>
+#include <pthread.h>
+
+std::map<std::string, std::shared_ptr<icu::RegexPattern>> regexCache;
+static pthread_mutex_t regexLock = PTHREAD_MUTEX_INITIALIZER;
+
+std::unique_ptr<icu::RegexMatcher> buildMatcher(const std::string& regex, icu::UnicodeString& content)
 {
-  icu::RegexMatcher* matcher;
-  auto itr = regexCache.find(regex);
-
+  std::shared_ptr<icu::RegexPattern> pattern;
   /* Regex is in cache */
-  if (itr != regexCache.end()) {
-    matcher = itr->second;
+  try {
+    pattern = regexCache.at(regex);
+  } catch (std::out_of_range&) {
+    // Redo the search with a lock to avoid race condition.
+    kiwix::Lock l(&regexLock);
+    try {
+      pattern = regexCache.at(regex);
+    } catch (std::out_of_range&) {
+      UErrorCode status = U_ZERO_ERROR;
+      UParseError pe;
+      icu::UnicodeString uregex(regex.c_str());
+      pattern.reset(icu::RegexPattern::compile(uregex, UREGEX_CASE_INSENSITIVE, pe, status));
+      regexCache[regex] = pattern;
+    }
   }
-
-  /* Regex needs to be parsed (and cached) */
-  else {
-    UErrorCode status = U_ZERO_ERROR;
-    icu::UnicodeString uregex(regex.c_str());
-    matcher = new icu::RegexMatcher(uregex, UREGEX_CASE_INSENSITIVE, status);
-    regexCache[regex] = matcher;
-  }
-
-  return matcher;
+  UErrorCode status = U_ZERO_ERROR;
+  return std::unique_ptr<icu::RegexMatcher>(pattern->matcher(content, status));
 }
 
-/* todo */
-void freeRegexCache()
-{
-}
 bool matchRegex(const std::string& content, const std::string& regex)
 {
   ucnv_setDefaultName("UTF-8");
   icu::UnicodeString ucontent(content.c_str());
-  auto matcher = buildRegex(regex);
-  matcher->reset(ucontent);
+  auto matcher = buildMatcher(regex, ucontent);
   return matcher->find();
 }
 
@@ -60,10 +66,9 @@ std::string replaceRegex(const std::string& content,
                          const std::string& regex)
 {
   ucnv_setDefaultName("UTF-8");
-  icu::UnicodeString ucontent(content.c_str());
   icu::UnicodeString ureplacement(replacement.c_str());
-  auto matcher = buildRegex(regex);
-  matcher->reset(ucontent);
+  icu::UnicodeString ucontent(content.c_str());
+  auto matcher = buildMatcher(regex, ucontent);
   UErrorCode status = U_ZERO_ERROR;
   auto uresult = matcher->replaceAll(ureplacement, status);
   std::string tmp;
@@ -72,15 +77,13 @@ std::string replaceRegex(const std::string& content,
 }
 
 std::string appendToFirstOccurence(const std::string& content,
-                                   const std::string regex,
+                                   const std::string& regex,
                                    const std::string& replacement)
 {
   ucnv_setDefaultName("UTF-8");
   icu::UnicodeString ucontent(content.c_str());
   icu::UnicodeString ureplacement(replacement.c_str());
-  auto matcher = buildRegex(regex);
-  matcher->reset(ucontent);
-
+  auto matcher = buildMatcher(regex, ucontent);
   if (matcher->find()) {
     UErrorCode status = U_ZERO_ERROR;
     ucontent.insert(matcher->end(status), ureplacement);

src/tools/stringTools.cpp

@@ -17,8 +17,9 @@
  * MA 02110-1301, USA.
  */
 
-#include <common/stringTools.h>
+#include <tools/stringTools.h>
 
+#include <tools/pathTools.h>
 #include <unicode/normlzr.h>
 #include <unicode/rep.h>
 #include <unicode/translit.h>
@@ -26,6 +27,10 @@
 #include <unicode/uniset.h>
 #include <unicode/ustring.h>
 
+
+#include <iostream>
+#include <iomanip>
+
 /* tell ICU where to find its dat file (tables) */
 void kiwix::loadICUExternalTables()
 {
@@ -36,7 +41,7 @@ void kiwix::loadICUExternalTables()
       = computeAbsolutePath(executableDirectory, "icudt58l.dat");
   try {
     u_setDataDirectory(datPath.c_str());
-  } catch (exception& e) {
+  } catch (std::exception& e) {
     std::cerr << e.what() << std::endl;
   }
 #endif
@@ -57,8 +62,6 @@ std::string kiwix::removeAccents(const std::string& text)
   return unaccentedText;
 }
 
-#ifndef __ANDROID__
-
 /* Prepare integer for display */
 std::string kiwix::beautifyInteger(uint64_t number)
 {
@@ -138,8 +141,6 @@ std::string kiwix::encodeDiples(const std::string& str)
   return result;
 }
 
-#endif
-
 /* urlEncode() based on javascript encodeURI() &
    encodeURIComponent(). Mostly code from rstudio/httpuv (GPLv3) */
 
@@ -376,3 +377,11 @@ std::string kiwix::normalize(const std::string& word)
 {
   return kiwix::lcAll(word);
 }
+
+
+bool kiwix::startsWith(const std::string& base, const std::string& start)
+{
+   return start.length() <= base.length()
+        && std::equal(start.begin(), start.end(), base.begin());
+}
+

src/xapian/htmlparse.cc

@@ -1,373 +0,0 @@
-/* htmlparse.cc: simple HTML parser for omega indexer
- *
- * Copyright 1999,2000,2001 BrightStation PLC
- * Copyright 2001 Ananova Ltd
- * Copyright 2002,2006,2007,2008 Olly Betts
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
- * USA
- */
-
-// #include <config.h>
-
-#include "htmlparse.h"
-
-#include <xapian.h>
-
-// #include "utf8convert.h"
-
-#include <algorithm>
-
-#include <ctype.h>
-#include <cstring>
-#include <stdio.h>
-#include <stdlib.h>
-
-using namespace std;
-
-inline void
-lowercase_string(string &str)
-{
-    for (string::iterator i = str.begin(); i != str.end(); ++i) {
-	*i = tolower(static_cast<unsigned char>(*i));
-    }
-}
-
-map<string, unsigned int> HtmlParser::named_ents;
-
-inline static bool
-p_notdigit(char c)
-{
-    return !isdigit(static_cast<unsigned char>(c));
-}
-
-inline static bool
-p_notxdigit(char c)
-{
-    return !isxdigit(static_cast<unsigned char>(c));
-}
-
-inline static bool
-p_notalnum(char c)
-{
-    return !isalnum(static_cast<unsigned char>(c));
-}
-
-inline static bool
-p_notwhitespace(char c)
-{
-    return !isspace(static_cast<unsigned char>(c));
-}
-
-inline static bool
-p_nottag(char c)
-{
-    return !isalnum(static_cast<unsigned char>(c)) &&
-	c != '.' && c != '-' && c != ':'; // ':' for XML namespaces.
-}
-
-inline static bool
-p_whitespacegt(char c)
-{
-    return isspace(static_cast<unsigned char>(c)) || c == '>';
-}
-
-inline static bool
-p_whitespaceeqgt(char c)
-{
-    return isspace(static_cast<unsigned char>(c)) || c == '=' || c == '>';
-}
-
-bool
-HtmlParser::get_parameter(const string & param, string & value)
-{
-    map<string, string>::const_iterator i = parameters.find(param);
-    if (i == parameters.end()) return false;
-    value = i->second;
-    return true;
-}
-
-HtmlParser::HtmlParser()
-{
-    static const struct ent { const char *n; unsigned int v; } ents[] = {
-#include "namedentities.h"
-	{ NULL, 0 }
-    };
-    if (named_ents.empty()) {
-	const struct ent *i = ents;
-	while (i->n) {
-	    named_ents[string(i->n)] = i->v;
-	    ++i;
-	}
-    }
-}
-
-void
-HtmlParser::decode_entities(string &s)
-{
-    // We need a const_iterator version of s.end() - otherwise the
-    // find() and find_if() templates don't work...
-    string::const_iterator amp = s.begin(), s_end = s.end();
-    while ((amp = find(amp, s_end, '&')) != s_end) {
-	unsigned int val = 0;
-	string::const_iterator end, p = amp + 1;
-	if (p != s_end && *p == '#') {
-	    p++;
-	    if (p != s_end && (*p == 'x' || *p == 'X')) {
-		// hex
-		p++;
-		end = find_if(p, s_end, p_notxdigit);
-		sscanf(s.substr(p - s.begin(), end - p).c_str(), "%x", &val);
-	    } else {
-		// number
-		end = find_if(p, s_end, p_notdigit);
-		val = atoi(s.substr(p - s.begin(), end - p).c_str());
-	    }
-	} else {
-	    end = find_if(p, s_end, p_notalnum);
-	    string code = s.substr(p - s.begin(), end - p);
-	    map<string, unsigned int>::const_iterator i;
-	    i = named_ents.find(code);
-	    if (i != named_ents.end()) val = i->second;
-	}
-	if (end < s_end && *end == ';') end++;
-	if (val) {
-	    string::size_type amp_pos = amp - s.begin();
-	    if (val < 0x80) {
-		s.replace(amp_pos, end - amp, 1u, char(val));
-	    } else {
-		// Convert unicode value val to UTF-8.
-		char seq[4];
-		unsigned len = Xapian::Unicode::nonascii_to_utf8(val, seq);
-		s.replace(amp_pos, end - amp, seq, len);
-	    }
-	    s_end = s.end();
-	    // We've modified the string, so the iterators are no longer
-	    // valid...
-	    amp = s.begin() + amp_pos + 1;
-	} else {
-	    amp = end;
-	}
-    }
-}
-
-void
-HtmlParser::parse_html(const string &body)
-{
-    in_script = false;
-
-    parameters.clear();
-    string::const_iterator start = body.begin();
-
-    while (true) {
-	// Skip through until we find an HTML tag, a comment, or the end of
-	// document.  Ignore isolated occurrences of `<' which don't start
-	// a tag or comment.
-	string::const_iterator p = start;
-	while (true) {
-	    p = find(p, body.end(), '<');
-	    if (p == body.end()) break;
-	    unsigned char ch = *(p + 1);
-
-	    // Tag, closing tag, or comment (or SGML declaration).
-	    if ((!in_script && isalpha(ch)) || ch == '/' || ch == '!') break;
-
-	    if (ch == '?') {
-		// PHP code or XML declaration.
-		// XML declaration is only valid at the start of the first line.
-		// FIXME: need to deal with BOMs...
-		if (p != body.begin() || body.size() < 20) break;
-
-		// XML declaration looks something like this:
-		// <?xml version="1.0" encoding="UTF-8"?>
-		if (p[2] != 'x' || p[3] != 'm' || p[4] != 'l') break;
-		if (strchr(" \t\r\n", p[5]) == NULL) break;
-
-		string::const_iterator decl_end = find(p + 6, body.end(), '?');
-		if (decl_end == body.end()) break;
-
-		// Default charset for XML is UTF-8.
-		charset = "UTF-8";
-
-		string decl(p + 6, decl_end);
-		size_t enc = decl.find("encoding");
-		if (enc == string::npos) break;
-
-		enc = decl.find_first_not_of(" \t\r\n", enc + 8);
-		if (enc == string::npos || enc == decl.size()) break;
-
-		if (decl[enc] != '=') break;
-		
-		enc = decl.find_first_not_of(" \t\r\n", enc + 1);
-		if (enc == string::npos || enc == decl.size()) break;
-
-		if (decl[enc] != '"' && decl[enc] != '\'') break;
-
-		char quote = decl[enc++];
-		size_t enc_end = decl.find(quote, enc);
-
-		if (enc != string::npos)
-		    charset = decl.substr(enc, enc_end - enc);
-
-		break;
-	    }
-	    p++;
-	}
-
-	// Process text up to start of tag.
-	if (p > start) {
-	    string text = body.substr(start - body.begin(), p - start);
-	    // convert_to_utf8(text, charset);
-	    decode_entities(text);
-	    process_text(text);
-	}
-
-	if (p == body.end()) break;
-
-	start = p + 1;
-
-	if (start == body.end()) break;
-
-	if (*start == '!') {
-	    if (++start == body.end()) break;
-	    if (++start == body.end()) break;
-	    // comment or SGML declaration
-	    if (*(start - 1) == '-' && *start == '-') {
-		++start;
-		string::const_iterator close = find(start, body.end(), '>');
-		// An unterminated comment swallows rest of document
-		// (like Netscape, but unlike MSIE IIRC)
-		if (close == body.end()) break;
-
-		p = close;
-		// look for -->
-		while (p != body.end() && (*(p - 1) != '-' || *(p - 2) != '-'))
-		    p = find(p + 1, body.end(), '>');
-
-		if (p != body.end()) {
-		    // Check for htdig's "ignore this bit" comments.
-		    if (p - start == 15 && string(start, p - 2) == "htdig_noindex") {
-			string::size_type i;
-			i = body.find("<!--/htdig_noindex-->", p + 1 - body.begin());
-			if (i == string::npos) break;
-			start = body.begin() + i + 21;
-			continue;
-		    }
-		    // If we found --> skip to there.
-		    start = p;
-		} else {
-		    // Otherwise skip to the first > we found (as Netscape does).
-		    start = close;
-		}
-	    } else {
-		// just an SGML declaration, perhaps giving the DTD - ignore it
-		start = find(start - 1, body.end(), '>');
-		if (start == body.end()) break;
-	    }
-	    ++start;
-	} else if (*start == '?') {
-	    if (++start == body.end()) break;
-	    // PHP - swallow until ?> or EOF
-	    start = find(start + 1, body.end(), '>');
-
-	    // look for ?>
-	    while (start != body.end() && *(start - 1) != '?')
-		start = find(start + 1, body.end(), '>');
-
-	    // unterminated PHP swallows rest of document (rather arbitrarily
-	    // but it avoids polluting the database when things go wrong)
-	    if (start != body.end()) ++start;
-	} else {
-	    // opening or closing tag
-	    int closing = 0;
-
-	    if (*start == '/') {
-		closing = 1;
-		start = find_if(start + 1, body.end(), p_notwhitespace);
-	    }
-
-	    p = start;
-	    start = find_if(start, body.end(), p_nottag);
-	    string tag = body.substr(p - body.begin(), start - p);
-	    // convert tagname to lowercase
-	    lowercase_string(tag);
-
-	    if (closing) {
-		closing_tag(tag);
-		if (in_script && tag == "script") in_script = false;
-
-		/* ignore any bogus parameters on closing tags */
-		p = find(start, body.end(), '>');
-		if (p == body.end()) break;
-		start = p + 1;
-	    } else {
-		// FIXME: parse parameters lazily.
-		while (start < body.end() && *start != '>') {
-		    string name, value;
-
-		    p = find_if(start, body.end(), p_whitespaceeqgt);
-
-		    name.assign(body, start - body.begin(), p - start);
-
-		    p = find_if(p, body.end(), p_notwhitespace);
-
-		    start = p;
-		    if (start != body.end() && *start == '=') {
-			start = find_if(start + 1, body.end(), p_notwhitespace);
-
-			p = body.end();
-
-			int quote = *start;
-			if (quote == '"' || quote == '\'') {
-			    start++;
-			    p = find(start, body.end(), quote);
-			}
-
-			if (p == body.end()) {
-			    // unquoted or no closing quote
-			    p = find_if(start, body.end(), p_whitespacegt);
-			}
-			value.assign(body, start - body.begin(), p - start);
-			start = find_if(p, body.end(), p_notwhitespace);
-
-			if (!name.empty()) {
-			    // convert parameter name to lowercase
-			    lowercase_string(name);
-			    // in case of multiple entries, use the first
-			    // (as Netscape does)
-			    parameters.insert(make_pair(name, value));
-			}
-		    }
-		}
-#if 0
-		cout << "<" << tag;
-		map<string, string>::const_iterator x;
-		for (x = parameters.begin(); x != parameters.end(); x++) {
-		    cout << " " << x->first << "=\"" << x->second << "\"";
-		}
-		cout << ">\n";
-#endif
-		opening_tag(tag);
-		parameters.clear();
-
-		// In <script> tags we ignore opening tags to avoid problems
-		// with "a<b".
-		if (tag == "script") in_script = true;
-
-		if (start != body.end() && *start == '>') ++start;
-	    }
-	}
-    }
-}

src/xapian/htmlparse.h

@@ -1,49 +0,0 @@
-/* htmlparse.h: simple HTML parser for omega indexer
- *
- * Copyright 1999,2000,2001 BrightStation PLC
- * Copyright 2002,2006,2008 Olly Betts
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
- * USA
- */
-
-#ifndef OMEGA_INCLUDED_HTMLPARSE_H
-#define OMEGA_INCLUDED_HTMLPARSE_H
-
-#include <string>
-#include <map>
-
-using std::string;
-using std::map;
-
-class HtmlParser {
-	map<string, string> parameters;
-    protected:
-	void decode_entities(string &s);
-	bool in_script;
-	string charset;
-	static map<string, unsigned int> named_ents;
-
-	bool get_parameter(const string & param, string & value);
-    public:
-	virtual void process_text(const string &/*text*/) { }
-	virtual void opening_tag(const string &/*tag*/) { }
-	virtual void closing_tag(const string &/*tag*/) { }
-	virtual void parse_html(const string &text);
-	HtmlParser();
-	virtual ~HtmlParser() { }
-};
-
-#endif // OMEGA_INCLUDED_HTMLPARSE_H

src/xapian/myhtmlparse.cc

@@ -1,302 +0,0 @@
-/* myhtmlparse.cc: subclass of HtmlParser for extracting text.
- *
- * Copyright 1999,2000,2001 BrightStation PLC
- * Copyright 2002,2003,2004,2006,2007,2008 Olly Betts
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
- * USA
- */
-
-// #include <config.h>
-
-#include "myhtmlparse.h"
-
-// #include "utf8convert.h"
-
-#include <ctype.h>
-#include <string.h>
-
-inline void
-lowercase_string(string &str)
-{
-    for (string::iterator i = str.begin(); i != str.end(); ++i) {
-	*i = tolower(static_cast<unsigned char>(*i));
-    }
-}
-
-void
-MyHtmlParser::parse_html(const string &text, const string &charset_,
-			 bool charset_from_meta_)
-{
-    charset = charset_;
-    charset_from_meta = charset_from_meta_;
-    HtmlParser::parse_html(text);
-}
-
-void
-MyHtmlParser::process_text(const string &text)
-{
-    if (!text.empty() && !in_script_tag && !in_style_tag) {
-	string::size_type b = text.find_first_not_of(WHITESPACE);
-	if (b) pending_space = true;
-	while (b != string::npos) {
-	    if (pending_space && !dump.empty()) dump += ' ';
-	    string::size_type e = text.find_first_of(WHITESPACE, b);
-	    pending_space = (e != string::npos);
-	    if (!pending_space) {
-		dump.append(text.data() + b, text.size() - b);
-		return;
-	    }
-	    dump.append(text.data() + b, e - b);
-	    b = text.find_first_not_of(WHITESPACE, e + 1);
-	}
-    }
-}
-
-void
-MyHtmlParser::opening_tag(const string &tag)
-{
-    if (tag.empty()) return;
-    switch (tag[0]) {
-	case 'a':
-	    if (tag == "address") pending_space = true;
-	    break;
-	case 'b':
-	    if (tag == "body") {
-		dump.resize(0);
-		break;
-	    }
-	    if (tag == "blockquote" || tag == "br") pending_space = true;
-	    break;
-	case 'c':
-	    if (tag == "center") pending_space = true;
-	    break;
-	case 'd':
-	    if (tag == "dd" || tag == "dir" || tag == "div" || tag == "dl" ||
-		tag == "dt") pending_space = true;
-	    break;
-	case 'e':
-	    if (tag == "embed") pending_space = true;
-	    break;
-	case 'f':
-	    if (tag == "fieldset" || tag == "form") pending_space = true;
-	    break;
-	case 'h':
-	    // hr, and h1, ..., h6
-	    if (tag.length() == 2 && strchr("r123456", tag[1]))
-		pending_space = true;
-	    break;
-	case 'i':
-	    if (tag == "iframe" || tag == "img" || tag == "isindex" ||
-		tag == "input") pending_space = true;
-	    break;
-	case 'k':
-	    if (tag == "keygen") pending_space = true;
-	    break;
-	case 'l':
-	    if (tag == "legend" || tag == "li" || tag == "listing")
-		pending_space = true;
-	    break;
-	case 'm':
-	    if (tag == "meta") {
-		string content;
-		if (get_parameter("content", content)) {
-		    string name;
-		    if (get_parameter("name", name)) {
-			lowercase_string(name);
-			if (name == "description") {
-			    if (sample.empty()) {
-				swap(sample, content);
-				// convert_to_utf8(sample, charset);
-				decode_entities(sample);
-			    }
-			} else if (name == "keywords") {
-			    if (!keywords.empty()) keywords += ' ';
-			    // convert_to_utf8(content, charset);
-			    decode_entities(content);
-			    keywords += content;
-			} else if (name == "robots") {
-			    decode_entities(content);
-			    lowercase_string(content);
-			    if (content.find("none") != string::npos ||
-				content.find("noindex") != string::npos) {
-				indexing_allowed = false;
-				throw true;
-			    }
-			}
-			break;
-		    }
-		    // If the current charset came from a meta tag, don't
-		    // force reparsing again!
-		    if (charset_from_meta) break;
-		    string hdr;
-		    if (get_parameter("http-equiv", hdr)) {
-			lowercase_string(hdr);
-			if (hdr == "content-type") {
-			    lowercase_string(content);
-			    size_t start = content.find("charset=");
-			    if (start == string::npos) break;
-			    start += 8;
-			    if (start == content.size()) break;
-			    size_t end = start;
-			    if (content[start] != '"') {
-				while (end < content.size()) {
-				    unsigned char ch = content[end];
-				    if (ch <= 32 || ch >= 127 ||
-					strchr(";()<>@,:\\\"/[]?={}", ch))
-					break;
-				    ++end;
-				}
-			    } else {
-				++start;
-				++end;
-				while (end < content.size()) {
-				    unsigned char ch = content[end];
-				    if (ch == '"') break;
-				    if (ch == '\\') content.erase(end, 1);
-				    ++end;
-				}
-			    }
-			    string newcharset(content, start, end - start);
-			    if (charset != newcharset) {
-				throw newcharset;
-			    }
-			}
-		    }
-		    break;
-		}
-		if (charset_from_meta) break;
-		string newcharset;
-		if (get_parameter("charset", newcharset)) {
-		    // HTML5 added: <meta charset="...">
-		    lowercase_string(newcharset);
-		    if (charset != newcharset) {
-			throw newcharset;
-		    }
-		}
-		break;
-	    }
-	    if (tag == "marquee" || tag == "menu" || tag == "multicol")
-		pending_space = true;
-	    break;
-	case 'o':
-	    if (tag == "ol" || tag == "option") pending_space = true;
-	    break;
-	case 'p':
-	    if (tag == "p" || tag == "pre" || tag == "plaintext")
-		pending_space = true;
-	    break;
-	case 'q':
-	    if (tag == "q") pending_space = true;
-	    break;
-	case 's':
-	    if (tag == "style") {
-		in_style_tag = true;
-		break;
-	    }
-	    if (tag == "script") {
-		in_script_tag = true;
-		break;
-	    }
-	    if (tag == "select") pending_space = true;
-	    break;
-	case 't':
-	    if (tag == "table" || tag == "td" || tag == "textarea" ||
-		tag == "th") pending_space = true;
-	    break;
-	case 'u':
-	    if (tag == "ul") pending_space = true;
-	    break;
-	case 'x':
-	    if (tag == "xmp") pending_space = true;
-	    break;
-    }
-}
-
-void
-MyHtmlParser::closing_tag(const string &tag)
-{
-    if (tag.empty()) return;
-    switch (tag[0]) {
-	case 'a':
-	    if (tag == "address") pending_space = true;
-	    break;
-	case 'b':
-	    if (tag == "body") {
-		throw true;
-	    }
-	    if (tag == "blockquote" || tag == "br") pending_space = true;
-	    break;
-	case 'c':
-	    if (tag == "center") pending_space = true;
-	    break;
-	case 'd':
-	    if (tag == "dd" || tag == "dir" || tag == "div" || tag == "dl" ||
-		tag == "dt") pending_space = true;
-	    break;
-	case 'f':
-	    if (tag == "fieldset" || tag == "form") pending_space = true;
-	    break;
-	case 'h':
-	    // hr, and h1, ..., h6
-	    if (tag.length() == 2 && strchr("r123456", tag[1]))
-		pending_space = true;
-	    break;
-	case 'i':
-	    if (tag == "iframe") pending_space = true;
-	    break;
-	case 'l':
-	    if (tag == "legend" || tag == "li" || tag == "listing")
-		pending_space = true;
-	    break;
-	case 'm':
-	    if (tag == "marquee" || tag == "menu") pending_space = true;
-	    break;
-	case 'o':
-	    if (tag == "ol" || tag == "option") pending_space = true;
-	    break;
-	case 'p':
-	    if (tag == "p" || tag == "pre") pending_space = true;
-	    break;
-	case 'q':
-	    if (tag == "q") pending_space = true;
-	    break;
-	case 's':
-	    if (tag == "style") {
-		in_style_tag = false;
-		break;
-	    }
-	    if (tag == "script") {
-		in_script_tag = false;
-		break;
-	    }
-	    if (tag == "select") pending_space = true;
-	    break;
-	case 't':
-	    if (tag == "title") {
-		if (title.empty()) swap(title, dump);
-		break;
-	    }
-	    if (tag == "table" || tag == "td" || tag == "textarea" ||
-		tag == "th") pending_space = true;
-	    break;
-	case 'u':
-	    if (tag == "ul") pending_space = true;
-	    break;
-	case 'x':
-	    if (tag == "xmp") pending_space = true;
-	    break;
-    }
-}

src/xapian/myhtmlparse.h

@@ -1,66 +0,0 @@
-/* myhtmlparse.h: subclass of HtmlParser for extracting text
- *
- * Copyright 1999,2000,2001 BrightStation PLC
- * Copyright 2002,2003,2004,2006,2008 Olly Betts
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
- * USA
- */
-
-#ifndef OMEGA_INCLUDED_MYHTMLPARSE_H
-#define OMEGA_INCLUDED_MYHTMLPARSE_H
-
-#include "htmlparse.h"
-
-// FIXME: Should we include \xa0 which is non-breaking space in iso-8859-1, but
-// not in all charsets and perhaps spans of all \xa0 should become a single
-// \xa0?
-#define WHITESPACE " \t\n\r"
-
-class MyHtmlParser : public HtmlParser {
-    public:
-	bool in_script_tag;
-	bool in_style_tag;
-	bool pending_space;
-	bool indexing_allowed;
-	bool charset_from_meta;
-	string title, sample, keywords, dump;
-	void process_text(const string &text);
-	void opening_tag(const string &tag);
-	void closing_tag(const string &tag);
-        using HtmlParser::parse_html;
-	void parse_html(const string &text, const string &charset_,
-			bool charset_from_meta_);
-	MyHtmlParser() :
-		in_script_tag(false),
-		in_style_tag(false),
-		pending_space(false),
-		indexing_allowed(true),
-		charset_from_meta(false) { }
-
-	void reset() {
-	    in_script_tag = false;
-	    in_style_tag = false;
-	    pending_space = false;
-	    indexing_allowed = true;
-	    charset_from_meta = false;
-	    title.resize(0);
-	    sample.resize(0);
-	    keywords.resize(0);
-	    dump.resize(0);
-	}
-};
-
-#endif // OMEGA_INCLUDED_MYHTMLPARSE_H

src/xapian/namedentities.h

@@ -1,279 +0,0 @@
-/* namedentities.h: named HTML entities.
- *
- * Copyright (C) 2006,2007 Olly Betts
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
- */
-
-#ifndef OMEGA_INCLUDED_NAMEDENTITIES_H
-#define OMEGA_INCLUDED_NAMEDENTITIES_H
-
-// Names and values from: "Character entity references in HTML 4"
-// http://www.w3.org/TR/html4/sgml/entities.html
-{ "quot", 34 },
-{ "amp", 38 },
-{ "apos", 39 }, // Not in HTML 4 list but used in OpenOffice XML.
-{ "lt", 60 },
-{ "gt", 62 },
-{ "nbsp", 160 },
-{ "iexcl", 161 },
-{ "cent", 162 },
-{ "pound", 163 },
-{ "curren", 164 },
-{ "yen", 165 },
-{ "brvbar", 166 },
-{ "sect", 167 },
-{ "uml", 168 },
-{ "copy", 169 },
-{ "ordf", 170 },
-{ "laquo", 171 },
-{ "not", 172 },
-{ "shy", 173 },
-{ "reg", 174 },
-{ "macr", 175 },
-{ "deg", 176 },
-{ "plusmn", 177 },
-{ "sup2", 178 },
-{ "sup3", 179 },
-{ "acute", 180 },
-{ "micro", 181 },
-{ "para", 182 },
-{ "middot", 183 },
-{ "cedil", 184 },
-{ "sup1", 185 },
-{ "ordm", 186 },
-{ "raquo", 187 },
-{ "frac14", 188 },
-{ "frac12", 189 },
-{ "frac34", 190 },
-{ "iquest", 191 },
-{ "Agrave", 192 },
-{ "Aacute", 193 },
-{ "Acirc", 194 },
-{ "Atilde", 195 },
-{ "Auml", 196 },
-{ "Aring", 197 },
-{ "AElig", 198 },
-{ "Ccedil", 199 },
-{ "Egrave", 200 },
-{ "Eacute", 201 },
-{ "Ecirc", 202 },
-{ "Euml", 203 },
-{ "Igrave", 204 },
-{ "Iacute", 205 },
-{ "Icirc", 206 },
-{ "Iuml", 207 },
-{ "ETH", 208 },
-{ "Ntilde", 209 },
-{ "Ograve", 210 },
-{ "Oacute", 211 },
-{ "Ocirc", 212 },
-{ "Otilde", 213 },
-{ "Ouml", 214 },
-{ "times", 215 },
-{ "Oslash", 216 },
-{ "Ugrave", 217 },
-{ "Uacute", 218 },
-{ "Ucirc", 219 },
-{ "Uuml", 220 },
-{ "Yacute", 221 },
-{ "THORN", 222 },
-{ "szlig", 223 },
-{ "agrave", 224 },
-{ "aacute", 225 },
-{ "acirc", 226 },
-{ "atilde", 227 },
-{ "auml", 228 },
-{ "aring", 229 },
-{ "aelig", 230 },
-{ "ccedil", 231 },
-{ "egrave", 232 },
-{ "eacute", 233 },
-{ "ecirc", 234 },
-{ "euml", 235 },
-{ "igrave", 236 },
-{ "iacute", 237 },
-{ "icirc", 238 },
-{ "iuml", 239 },
-{ "eth", 240 },
-{ "ntilde", 241 },
-{ "ograve", 242 },
-{ "oacute", 243 },
-{ "ocirc", 244 },
-{ "otilde", 245 },
-{ "ouml", 246 },
-{ "divide", 247 },
-{ "oslash", 248 },
-{ "ugrave", 249 },
-{ "uacute", 250 },
-{ "ucirc", 251 },
-{ "uuml", 252 },
-{ "yacute", 253 },
-{ "thorn", 254 },
-{ "yuml", 255 },
-{ "OElig", 338 },
-{ "oelig", 339 },
-{ "Scaron", 352 },
-{ "scaron", 353 },
-{ "Yuml", 376 },
-{ "fnof", 402 },
-{ "circ", 710 },
-{ "tilde", 732 },
-{ "Alpha", 913 },
-{ "Beta", 914 },
-{ "Gamma", 915 },
-{ "Delta", 916 },
-{ "Epsilon", 917 },
-{ "Zeta", 918 },
-{ "Eta", 919 },
-{ "Theta", 920 },
-{ "Iota", 921 },
-{ "Kappa", 922 },
-{ "Lambda", 923 },
-{ "Mu", 924 },
-{ "Nu", 925 },
-{ "Xi", 926 },
-{ "Omicron", 927 },
-{ "Pi", 928 },
-{ "Rho", 929 },
-{ "Sigma", 931 },
-{ "Tau", 932 },
-{ "Upsilon", 933 },
-{ "Phi", 934 },
-{ "Chi", 935 },
-{ "Psi", 936 },
-{ "Omega", 937 },
-{ "alpha", 945 },
-{ "beta", 946 },
-{ "gamma", 947 },
-{ "delta", 948 },
-{ "epsilon", 949 },
-{ "zeta", 950 },
-{ "eta", 951 },
-{ "theta", 952 },
-{ "iota", 953 },
-{ "kappa", 954 },
-{ "lambda", 955 },
-{ "mu", 956 },
-{ "nu", 957 },
-{ "xi", 958 },
-{ "omicron", 959 },
-{ "pi", 960 },
-{ "rho", 961 },
-{ "sigmaf", 962 },
-{ "sigma", 963 },
-{ "tau", 964 },
-{ "upsilon", 965 },
-{ "phi", 966 },
-{ "chi", 967 },
-{ "psi", 968 },
-{ "omega", 969 },
-{ "thetasym", 977 },
-{ "upsih", 978 },
-{ "piv", 982 },
-{ "ensp", 8194 },
-{ "emsp", 8195 },
-{ "thinsp", 8201 },
-{ "zwnj", 8204 },
-{ "zwj", 8205 },
-{ "lrm", 8206 },
-{ "rlm", 8207 },
-{ "ndash", 8211 },
-{ "mdash", 8212 },
-{ "lsquo", 8216 },
-{ "rsquo", 8217 },
-{ "sbquo", 8218 },
-{ "ldquo", 8220 },
-{ "rdquo", 8221 },
-{ "bdquo", 8222 },
-{ "dagger", 8224 },
-{ "Dagger", 8225 },
-{ "bull", 8226 },
-{ "hellip", 8230 },
-{ "permil", 8240 },
-{ "prime", 8242 },
-{ "Prime", 8243 },
-{ "lsaquo", 8249 },
-{ "rsaquo", 8250 },
-{ "oline", 8254 },
-{ "frasl", 8260 },
-{ "euro", 8364 },
-{ "image", 8465 },
-{ "weierp", 8472 },
-{ "real", 8476 },
-{ "trade", 8482 },
-{ "alefsym", 8501 },
-{ "larr", 8592 },
-{ "uarr", 8593 },
-{ "rarr", 8594 },
-{ "darr", 8595 },
-{ "harr", 8596 },
-{ "crarr", 8629 },
-{ "lArr", 8656 },
-{ "uArr", 8657 },
-{ "rArr", 8658 },
-{ "dArr", 8659 },
-{ "hArr", 8660 },
-{ "forall", 8704 },
-{ "part", 8706 },
-{ "exist", 8707 },
-{ "empty", 8709 },
-{ "nabla", 8711 },
-{ "isin", 8712 },
-{ "notin", 8713 },
-{ "ni", 8715 },
-{ "prod", 8719 },
-{ "sum", 8721 },
-{ "minus", 8722 },
-{ "lowast", 8727 },
-{ "radic", 8730 },
-{ "prop", 8733 },
-{ "infin", 8734 },
-{ "ang", 8736 },
-{ "and", 8743 },
-{ "or", 8744 },
-{ "cap", 8745 },
-{ "cup", 8746 },
-{ "int", 8747 },
-{ "there4", 8756 },
-{ "sim", 8764 },
-{ "cong", 8773 },
-{ "asymp", 8776 },
-{ "ne", 8800 },
-{ "equiv", 8801 },
-{ "le", 8804 },
-{ "ge", 8805 },
-{ "sub", 8834 },
-{ "sup", 8835 },
-{ "nsub", 8836 },
-{ "sube", 8838 },
-{ "supe", 8839 },
-{ "oplus", 8853 },
-{ "otimes", 8855 },
-{ "perp", 8869 },
-{ "sdot", 8901 },
-{ "lceil", 8968 },
-{ "rceil", 8969 },
-{ "lfloor", 8970 },
-{ "rfloor", 8971 },
-{ "lang", 9001 },
-{ "rang", 9002 },
-{ "loz", 9674 },
-{ "spades", 9824 },
-{ "clubs", 9827 },
-{ "hearts", 9829 },
-{ "diams", 9830 },
-
-#endif // OMEGA_INCLUDED_NAMEDENTITIES_H

src/xapianSearcher.cpp

@@ -1,231 +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 "xapianSearcher.h"
-#include <sys/types.h>
-#include <unicode/locid.h>
-#ifndef _WIN32
-#  include <unistd.h>
-#endif
-#include <zim/article.h>
-#include <zim/error.h>
-#include <zim/file.h>
-#include <zim/zim.h>
-#include "xapian/myhtmlparse.h"
-
-#include <vector>
-
-namespace kiwix
-{
-std::map<std::string, int> read_valuesmap(const std::string& s)
-{
-  std::map<std::string, int> result;
-  std::vector<std::string> elems = split(s, ";");
-  for (std::vector<std::string>::iterator elem = elems.begin();
-       elem != elems.end();
-       elem++) {
-    std::vector<std::string> tmp_elems = split(*elem, ":");
-    result.insert(
-        std::pair<std::string, int>(tmp_elems[0], atoi(tmp_elems[1].c_str())));
-  }
-  return result;
-}
-
-/* Constructor */
-XapianSearcher::XapianSearcher(const string& xapianDirectoryPath,
-                               Reader* reader)
-    : reader(reader)
-{
-  this->openIndex(xapianDirectoryPath);
-}
-
-/* Open Xapian readable database */
-void XapianSearcher::openIndex(const string& directoryPath)
-{
-  this->readableDatabase = Xapian::Database(directoryPath);
-  this->valuesmap
-      = read_valuesmap(this->readableDatabase.get_metadata("valuesmap"));
-  this->language = this->readableDatabase.get_metadata("language");
-  this->stopwords = this->readableDatabase.get_metadata("stopwords");
-  setup_queryParser();
-}
-
-/* Close Xapian writable database */
-void XapianSearcher::closeIndex()
-{
-  return;
-}
-void XapianSearcher::setup_queryParser()
-{
-  queryParser.set_database(readableDatabase);
-  if (!language.empty()) {
-    /* Build ICU Local object to retrieve ISO-639 language code (from
-       ISO-639-3) */
-    icu::Locale languageLocale(language.c_str());
-
-    /* Configuring language base steemming */
-    try {
-      stemmer = Xapian::Stem(languageLocale.getLanguage());
-      queryParser.set_stemmer(stemmer);
-      queryParser.set_stemming_strategy(Xapian::QueryParser::STEM_ALL);
-    } catch (...) {
-      std::cout << "No steemming for language '" << languageLocale.getLanguage()
-                << "'" << std::endl;
-    }
-  }
-
-  if (!stopwords.empty()) {
-    std::string stopWord;
-    std::istringstream file(this->stopwords);
-    while (std::getline(file, stopWord, '\n')) {
-      this->stopper.add(stopWord);
-    }
-    queryParser.set_stopper(&(this->stopper));
-  }
-}
-
-/* Search strings in the database */
-void XapianSearcher::searchInIndex(string& search,
-                                   const unsigned int resultStart,
-                                   const unsigned int resultEnd,
-                                   const bool verbose)
-{
-  /* Create the query */
-  Xapian::Query query = queryParser.parse_query(search);
-
-  /* Create the enquire object */
-  Xapian::Enquire enquire(this->readableDatabase);
-  enquire.set_query(query);
-
-  /* Get the results */
-  this->results = enquire.get_mset(resultStart, resultEnd - resultStart);
-  this->current_result = this->results.begin();
-}
-
-/* Get next result */
-Result* XapianSearcher::getNextResult()
-{
-  if (this->current_result != this->results.end()) {
-    XapianResult* result = new XapianResult(this, this->current_result);
-    this->current_result++;
-    return result;
-  }
-  return NULL;
-}
-
-void XapianSearcher::restart_search()
-{
-  this->current_result = this->results.begin();
-}
-
-XapianResult::XapianResult(XapianSearcher* searcher,
-                           Xapian::MSetIterator& iterator)
-    : searcher(searcher), iterator(iterator), document(iterator.get_document())
-{
-}
-
-std::string XapianResult::get_url()
-{
-  return document.get_data();
-}
-std::string XapianResult::get_title()
-{
-  if (searcher->valuesmap.empty()) {
-    /* This is the old legacy version. Guess and try */
-    return document.get_value(0);
-  } else if (searcher->valuesmap.find("title") != searcher->valuesmap.end()) {
-    return document.get_value(searcher->valuesmap["title"]);
-  }
-  return "";
-}
-
-int XapianResult::get_score()
-{
-  return iterator.get_percent();
-}
-std::string XapianResult::get_snippet()
-{
-  if (searcher->valuesmap.empty()) {
-    /* This is the old legacy version. Guess and try */
-    std::string stored_snippet = document.get_value(1);
-    if (!stored_snippet.empty()) {
-      return stored_snippet;
-    }
-    /* Let's continue here, and see if we can genenate one */
-  } else if (searcher->valuesmap.find("snippet") != searcher->valuesmap.end()) {
-    return document.get_value(searcher->valuesmap["snippet"]);
-  }
-  /* No reader, no snippet */
-  if (!searcher->reader) {
-    return "";
-  }
-  /* Get the content of the article to generate a snippet.
-     We parse it and use the html dump to avoid remove html tags in the
-     content and be able to nicely cut the text at random place. */
-  MyHtmlParser htmlParser;
-  std::string content = get_content();
-  if (content.empty()) {
-    return content;
-  }
-  try {
-    htmlParser.parse_html(content, "UTF-8", true);
-  } catch (...) {
-  }
-  return searcher->results.snippet(htmlParser.dump, 500);
-}
-
-std::string XapianResult::get_content()
-{
-  if (!searcher->reader) {
-    return "";
-  }
-  auto entry = searcher->reader->getEntryFromEncodedPath(get_url());
-  return entry.getContent();
-}
-
-int XapianResult::get_size()
-{
-  if (searcher->valuesmap.empty()) {
-    /* This is the old legacy version. Guess and try */
-    return document.get_value(2).empty() == true
-               ? -1
-               : atoi(document.get_value(2).c_str());
-  } else if (searcher->valuesmap.find("size") != searcher->valuesmap.end()) {
-    return atoi(document.get_value(searcher->valuesmap["size"]).c_str());
-  }
-  /* The size is never used. Do we really want to get the content and
-     calculate the size ? */
-  return -1;
-}
-
-int XapianResult::get_wordCount()
-{
-  if (searcher->valuesmap.empty()) {
-    /* This is the old legacy version. Guess and try */
-    return document.get_value(3).empty() == true
-               ? -1
-               : atoi(document.get_value(3).c_str());
-  } else if (searcher->valuesmap.find("wordcount")
-             != searcher->valuesmap.end()) {
-    return atoi(document.get_value(searcher->valuesmap["wordcount"]).c_str());
-  }
-  return -1;
-}
-
-}  // Kiwix namespace

src/xmlrpc.h

@@ -3,7 +3,8 @@
 #ifndef KIWIX_XMLRPC_H_
 #define KIWIX_XMLRPC_H_
 
-#include <common/otherTools.h>
+#include <tools/otherTools.h>
+#include <pugixml.hpp>
 
 namespace kiwix {
 

static/meson.build

@@ -1,15 +1,5 @@
 
-
-ctpp2c = find_program('ctpp2c', required:false)
-
-if ctpp2c.found()
-  search_result_template = custom_target('result_template',
-    input: 'results.tmpl',
-    output: 'results.ct2',
-    command: [intermediate_ctpp2c, ctpp2c, '@INPUT@', '@OUTPUT@']
-  )
-  resources_list = 'resources_list_ctpp2.txt'
-  lib_resources = custom_target('resources',
+lib_resources = custom_target('resources',
     input: 'resources_list.txt',
     output: ['kiwixlib-resources.cpp', 'kiwixlib-resources.h'],
     command:[res_compiler,
@@ -17,8 +7,5 @@ if ctpp2c.found()
              '--hfile', '@OUTPUT1@',
              '--source_dir', '@OUTDIR@',
              '@INPUT@'],
-    depends: [search_result_template]
-  )
-else
- lib_resources = []
-endif
+    build_always_stale: true
+)

static/navigation_feed.tmpl

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <id>{{id}}</id>
+  <link rel="self"
+        href="{{self_url}}"
+        type="application/atom+xml;profile=opds-catalog;kind=navigation"/>
+  <link rel="start"
+        href="{{start_url}}"
+        type="application/atom+xml;profile=opds-catalog;kind=navigation"/>
+  <title>{{title}}</title>
+  <updated>{{updated}}</updated>
+  <author>
+    <name>{{author_name}}</name>
+    <uri>{{author_uri}}</uri>
+  </author>
+
+ {{#entries}}
+   <entry>
+     <title>{{title}}</title>
+     <link rel="subsection"
+           href="{{href}}"
+           type="application/atom+xml;profile=opds-catalog;kind=acquisition"/>
+     <updated>{{updated}}</updated>
+     <id>{{id}}</id>
+   </entry>
+ {{/entries}}
+</feed>

static/opensearchdescription.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
+  <ShortName>Zim catalog search</ShortName>
+  <Description>Search zim files in the catalog.</Description>
+  <Url type="application/atom+xml;profile=opds-catalog" 
+       xmlns:atom="http://www.w3.org/2005/Atom"
+       indexOffset="0"
+       template="/{{root}}/catalog/search?q={searchTerms}&lang={language}&count={count}&start={startIndex}"/>
+</OpenSearchDescription>

static/resources_list.txt

@@ -1 +1,31 @@
-results.ct2
+skin/jquery-ui/jquery-ui.structure.min.css
+skin/jquery-ui/jquery-ui.min.js
+skin/jquery-ui/external/jquery/jquery.js
+skin/jquery-ui/images/ui-bg_flat_0_aaaaaa_40x100.png
+skin/jquery-ui/images/ui-bg_flat_75_ffffff_40x100.png
+skin/jquery-ui/images/ui-icons_222222_256x240.png
+skin/jquery-ui/images/ui-bg_glass_55_fbf9ee_1x400.png
+skin/jquery-ui/images/ui-bg_highlight-soft_75_cccccc_1x100.png
+skin/jquery-ui/images/ui-bg_glass_65_ffffff_1x400.png
+skin/jquery-ui/images/ui-icons_2e83ff_256x240.png
+skin/jquery-ui/images/ui-icons_cd0a0a_256x240.png
+skin/jquery-ui/images/ui-icons_888888_256x240.png
+skin/jquery-ui/images/ui-bg_glass_75_e6e6e6_1x400.png
+skin/jquery-ui/images/animated-overlay.gif
+skin/jquery-ui/images/ui-bg_glass_75_dadada_1x400.png
+skin/jquery-ui/images/ui-icons_454545_256x240.png
+skin/jquery-ui/images/ui-bg_glass_95_fef1ec_1x400.png
+skin/jquery-ui/jquery-ui.theme.min.css
+skin/jquery-ui/jquery-ui.min.css
+skin/caret.png
+skin/taskbar.js
+skin/taskbar.css
+templates/search_result.html
+templates/no_search_result.html
+templates/404.html
+templates/500.html
+templates/index.html
+templates/suggestion.json
+templates/head_part.html
+templates/taskbar_part.html
+opensearchdescription.xml