react-native-quick-crypto 1.0.0-beta.17 → 1.0.0-beta.19

package/ios/libsodium-stable/contrib/Findsodium.cmake

@@ -0,0 +1,297 @@
+# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
+#
+# To the extent possible under law, the author(s) have dedicated all copyright
+# and related and neighboring rights to this software to the public domain
+# worldwide. This software is distributed without any warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication along with
+# this software. If not, see
+#
+# http://creativecommons.org/publicdomain/zero/1.0/
+#
+# ##############################################################################
+# Tries to find the local libsodium installation.
+#
+# On Windows the sodium_DIR environment variable is used as a default hint which
+# can be overridden by setting the corresponding cmake variable.
+#
+# Once done the following variables will be defined:
+#
+# sodium_FOUND sodium_INCLUDE_DIR sodium_LIBRARY_DEBUG sodium_LIBRARY_RELEASE
+# sodium_VERSION_STRING
+#
+# Furthermore an imported "sodium" target is created.
+#
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  set(_GCC_COMPATIBLE 1)
+endif()
+
+# static library option
+if(NOT DEFINED sodium_USE_STATIC_LIBS)
+  option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
+endif()
+if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
+  unset(sodium_LIBRARY CACHE)
+  unset(sodium_LIBRARY_DEBUG CACHE)
+  unset(sodium_LIBRARY_RELEASE CACHE)
+  unset(sodium_DLL_DEBUG CACHE)
+  unset(sodium_DLL_RELEASE CACHE)
+  set(sodium_USE_STATIC_LIBS_LAST
+      ${sodium_USE_STATIC_LIBS}
+      CACHE INTERNAL "internal change tracking variable")
+endif()
+
+# ##############################################################################
+# UNIX
+if(UNIX)
+  # import pkg-config
+  find_package(PkgConfig QUIET)
+  if(PKG_CONFIG_FOUND)
+    pkg_check_modules(sodium_PKG QUIET libsodium)
+  endif()
+
+  if(sodium_USE_STATIC_LIBS)
+    if(sodium_PKG_STATIC_LIBRARIES)
+      foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
+        if(NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending
+                                               # with .a
+          list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
+        endif()
+      endforeach()
+      list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
+    else()
+      # if pkgconfig for libsodium doesn't provide static lib info, then
+      # override PKG_STATIC here..
+      set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
+    endif()
+
+    set(XPREFIX sodium_PKG_STATIC)
+  else()
+    if(sodium_PKG_LIBRARIES STREQUAL "")
+      set(sodium_PKG_LIBRARIES sodium)
+    endif()
+
+    set(XPREFIX sodium_PKG)
+  endif()
+
+  find_path(sodium_INCLUDE_DIR sodium.h HINTS ${${XPREFIX}_INCLUDE_DIRS})
+  find_library(sodium_LIBRARY_DEBUG
+               NAMES ${${XPREFIX}_LIBRARIES}
+               HINTS ${${XPREFIX}_LIBRARY_DIRS})
+  find_library(sodium_LIBRARY_RELEASE
+               NAMES ${${XPREFIX}_LIBRARIES}
+               HINTS ${${XPREFIX}_LIBRARY_DIRS})
+
+  # ############################################################################
+  # Windows
+elseif(WIN32)
+  set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
+  mark_as_advanced(sodium_DIR)
+
+  find_path(sodium_INCLUDE_DIR sodium.h
+            HINTS ${sodium_DIR}
+            PATH_SUFFIXES include)
+
+  if(MSVC)
+    # detect target architecture
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.c" [=[
+            #if defined _M_IX86
+            #error ARCH_VALUE x86_32
+            #elif defined _M_X64
+            #error ARCH_VALUE x86_64
+            #endif
+            #error ARCH_VALUE unknown
+        ]=])
+    try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}"
+                "${CMAKE_CURRENT_BINARY_DIR}/arch.c"
+                OUTPUT_VARIABLE _COMPILATION_LOG)
+    string(REGEX
+           REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*"
+                   "\\1"
+                   _TARGET_ARCH
+                   "${_COMPILATION_LOG}")
+
+    # construct library path
+    if(_TARGET_ARCH STREQUAL "x86_32")
+      string(APPEND _PLATFORM_PATH "Win32")
+    elseif(_TARGET_ARCH STREQUAL "x86_64")
+      string(APPEND _PLATFORM_PATH "x64")
+    else()
+      message(
+        FATAL_ERROR
+          "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake."
+        )
+    endif()
+    string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
+
+    if(MSVC_VERSION LESS 1900)
+      math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
+    else()
+      math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
+    endif()
+    string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
+
+    if(sodium_USE_STATIC_LIBS)
+      string(APPEND _PLATFORM_PATH "/static")
+    else()
+      string(APPEND _PLATFORM_PATH "/dynamic")
+    endif()
+
+    string(REPLACE "$$CONFIG$$"
+                   "Debug"
+                   _DEBUG_PATH_SUFFIX
+                   "${_PLATFORM_PATH}")
+    string(REPLACE "$$CONFIG$$"
+                   "Release"
+                   _RELEASE_PATH_SUFFIX
+                   "${_PLATFORM_PATH}")
+
+    find_library(sodium_LIBRARY_DEBUG libsodium.lib
+                 HINTS ${sodium_DIR}
+                 PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
+    find_library(sodium_LIBRARY_RELEASE libsodium.lib
+                 HINTS ${sodium_DIR}
+                 PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
+    if(NOT sodium_USE_STATIC_LIBS)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
+      find_library(sodium_DLL_DEBUG libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
+      find_library(sodium_DLL_RELEASE libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
+    endif()
+
+  elseif(_GCC_COMPATIBLE)
+    if(sodium_USE_STATIC_LIBS)
+      find_library(sodium_LIBRARY_DEBUG libsodium.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+      find_library(sodium_LIBRARY_RELEASE libsodium.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+    else()
+      find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+      find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+
+      file(GLOB _DLL
+           LIST_DIRECTORIES false
+           RELATIVE "${sodium_DIR}/bin"
+           "${sodium_DIR}/bin/libsodium*.dll")
+      find_library(sodium_DLL_DEBUG ${_DLL} libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES bin)
+      find_library(sodium_DLL_RELEASE ${_DLL} libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES bin)
+    endif()
+  else()
+    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+  endif()
+
+  # ############################################################################
+  # unsupported
+else()
+  message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+endif()
+
+# ##############################################################################
+# common stuff
+
+# extract sodium version
+if(sodium_INCLUDE_DIR)
+  set(_VERSION_HEADER "${sodium_INCLUDE_DIR}/sodium/version.h")
+  if(EXISTS "${_VERSION_HEADER}")
+    file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
+    string(
+      REGEX
+      REPLACE
+        ".*define[ \t]+SODIUM_VERSION_STRING[^\"]+\"([^\"]+)\".*"
+        "\\1"
+        sodium_VERSION_STRING
+        "${_VERSION_HEADER_CONTENT}")
+    set(sodium_VERSION_STRING "${sodium_VERSION_STRING}")
+  endif()
+endif()
+
+# communicate results
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(sodium
+                                  REQUIRED_VARS
+                                  sodium_LIBRARY_RELEASE
+                                  sodium_LIBRARY_DEBUG
+                                  sodium_INCLUDE_DIR
+                                  VERSION_VAR
+                                  sodium_VERSION_STRING)
+
+if (NOT sodium_FOUND)
+  return()
+endif()
+
+# mark file paths as advanced
+mark_as_advanced(sodium_INCLUDE_DIR)
+mark_as_advanced(sodium_LIBRARY_DEBUG)
+mark_as_advanced(sodium_LIBRARY_RELEASE)
+if(WIN32)
+  mark_as_advanced(sodium_DLL_DEBUG)
+  mark_as_advanced(sodium_DLL_RELEASE)
+endif()
+
+# create imported target
+if(sodium_USE_STATIC_LIBS)
+  set(_LIB_TYPE STATIC)
+else()
+  set(_LIB_TYPE SHARED)
+endif()
+add_library(sodium ${_LIB_TYPE} IMPORTED)
+
+set_target_properties(sodium
+                      PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                 "${sodium_INCLUDE_DIR}"
+                                 IMPORTED_LINK_INTERFACE_LANGUAGES
+                                 "C")
+
+if(sodium_USE_STATIC_LIBS)
+  set_target_properties(sodium
+                        PROPERTIES INTERFACE_COMPILE_DEFINITIONS
+                                   "SODIUM_STATIC"
+                                   IMPORTED_LOCATION
+                                   "${sodium_LIBRARY_RELEASE}"
+                                   IMPORTED_LOCATION_DEBUG
+                                   "${sodium_LIBRARY_DEBUG}")
+else()
+  if(UNIX)
+    set_target_properties(sodium
+                          PROPERTIES IMPORTED_LOCATION
+                                     "${sodium_LIBRARY_RELEASE}"
+                                     IMPORTED_LOCATION_DEBUG
+                                     "${sodium_LIBRARY_DEBUG}")
+  elseif(WIN32)
+    set_target_properties(sodium
+                          PROPERTIES IMPORTED_IMPLIB
+                                     "${sodium_LIBRARY_RELEASE}"
+                                     IMPORTED_IMPLIB_DEBUG
+                                     "${sodium_LIBRARY_DEBUG}")
+    if(NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
+      set_target_properties(sodium
+                            PROPERTIES IMPORTED_LOCATION_DEBUG
+                                       "${sodium_DLL_DEBUG}")
+    endif()
+    if(NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
+      set_target_properties(sodium
+                            PROPERTIES IMPORTED_LOCATION_RELWITHDEBINFO
+                                       "${sodium_DLL_RELEASE}"
+                                       IMPORTED_LOCATION_MINSIZEREL
+                                       "${sodium_DLL_RELEASE}"
+                                       IMPORTED_LOCATION_RELEASE
+                                       "${sodium_DLL_RELEASE}")
+    endif()
+  endif()
+endif()

package/ios/libsodium-stable/contrib/Makefile.am

@@ -0,0 +1,3 @@
+
+EXTRA_DIST = \
+	Findsodium.cmake

package/ios/libsodium-stable/dist-build/Makefile.am

@@ -0,0 +1,14 @@
+
+EXTRA_DIST = \
+	android-build.sh \
+	android-aar.sh \
+	android-armv7-a.sh \
+	android-armv8-a.sh \
+	android-x86.sh \
+	android-x86_64.sh \
+	emscripten.sh \
+	apple-xcframework.sh \
+	macos.sh \
+	msys2-win32.sh \
+	msys2-win64.sh \
+	wasm32-wasi.sh

package/ios/libsodium-stable/dist-build/android-aar.sh

@@ -0,0 +1,194 @@
+#! /bin/sh
+
+# Create an AAR with libsodium in all combinations of static | shared | minimal | full.
+#
+# To simplify linking, library variants have distinct names: sodium, sodium-static, sodium-minimal and sodium-minimal-static.
+
+SODIUM_VERSION="1.0.20.0"
+
+if [ -z "$ANDROID_NDK_HOME" ]; then
+  echo "ANDROID_NDK_HOME must be set to the directory containing the Android NDK."
+  exit 1
+fi
+
+if [ ! -f "${ANDROID_NDK_HOME}/ndk-build" ]; then
+  echo "The ANDROID_NDK_HOME directory does not contain an 'ndk-build' file."
+  exit 1
+fi
+
+if [ ! -d "${ANDROID_NDK_HOME}/toolchains" ]; then
+  echo "The ANDROID_NDK_HOME directory does not contain a 'toolchains' directory."
+  exit 1
+fi
+
+if [ ! -f "${ANDROID_NDK_HOME}/source.properties" ]; then
+  echo "The ANDROID_NDK_HOME directory does not contain a 'source.properties' file."
+  exit 1
+fi
+
+NDK_VERSION=$(grep "Pkg.Revision = " <"${ANDROID_NDK_HOME}/source.properties" | cut -f 2 -d '=' | cut -f 2 -d' ' | cut -f 1 -d'.')
+DEST_PATH=$(mktemp -d)
+
+if [ -z "$NDK_PLATFORM" ]; then
+  export NDK_PLATFORM="android-21"
+  echo "Compiling for default platform: [${NDK_PLATFORM}]"
+  echo "That can be changed by setting an NDK_PLATFORM environment variable."
+fi
+
+SDK_VERSION=$(echo "$NDK_PLATFORM" | cut -f2 -d"-")
+if [ -z "$NDK_VERSION" ]; then
+  echo "Failed to determine the NDK version."
+  exit 1
+fi
+if [ -z "$SDK_VERSION" ]; then
+  echo "Failed to determine the SDK version."
+  exit 1
+fi
+echo "NDK version: [$NDK_VERSION]"
+echo "SDK version: [$SDK_VERSION]"
+
+echo
+
+if which zip >/dev/null; then
+  echo "The 'zip' command is installed."
+else
+  echo "The 'zip' command is not installed. Please install it before running this script."
+  exit 1
+fi
+
+cd "$(dirname "$0")/../" || exit
+
+trap 'kill -TERM -$$' INT
+
+make_abi_json() {
+  echo "{\"abi\":\"${NDK_ARCH}\",\"api\":${SDK_VERSION},\"ndk\":${NDK_VERSION},\"stl\":\"none\"}" >"$1/abi.json"
+}
+
+make_prefab_json() {
+  echo "{\"name\":\"sodium\",\"schema_version\":1,\"dependencies\":[],\"version\":\"$SODIUM_VERSION\"}" >"$1/prefab.json"
+}
+
+make_manifest() {
+  echo "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\" package=\"com.android.ndk.thirdparty.sodium\" android:versionCode=\"1\" android:versionName=\"1.0\">
+        <uses-sdk android:minSdkVersion=\"$SDK_VERSION\" android:targetSdkVersion=\"$SDK_VERSION\"/>
+</manifest>" >"${1}/AndroidManifest.xml"
+}
+
+make_prefab_structure() {
+  for variant_dirs in "prefab" "prefab/modules" "META-INF"; do
+    mkdir "${DEST_PATH}/${variant_dirs}"
+  done
+
+  make_prefab_json "${DEST_PATH}/prefab"
+  make_manifest "${DEST_PATH}"
+  cp "LICENSE" "${DEST_PATH}/META-INF"
+
+  for variant in \
+    "prefab/modules/sodium" "prefab/modules/sodium-static" \
+    "prefab/modules/sodium-minimal" "prefab/modules/sodium-minimal-static"; do
+    mkdir "${DEST_PATH}/${variant}"
+
+    if [ "$variant" = "prefab/modules/sodium-minimal" ]; then
+      echo "{\"library_name\":\"libsodium\"}" >"${DEST_PATH}/${variant}/module.json"
+    else
+      echo "{}" >"${DEST_PATH}/${variant}/module.json"
+    fi
+
+    mkdir "${DEST_PATH}/${variant}/libs"
+
+    for arch in "arm64-v8a" "armeabi-v7a" "x86" "x86_64"; do
+      mkdir "$DEST_PATH/${variant}/libs/android.${arch}"
+      mkdir "$DEST_PATH/${variant}/libs/android.${arch}/include"
+      NDK_ARCH="$arch"
+
+      make_abi_json "$DEST_PATH/${variant}/libs/android.${arch}"
+    done
+  done
+}
+
+copy_libs() {
+  SRC_DIR="libsodium-android-${1}"
+
+  SHARED_DEST_DIR="${DEST_PATH}/prefab/modules/sodium${3}/libs/android.${2}"
+  STATIC_DEST_DIR="${DEST_PATH}/prefab/modules/sodium${3}-static/libs/android.${2}"
+
+  cp -r "${SRC_DIR}/include" "$SHARED_DEST_DIR"
+  cp -r "${SRC_DIR}/include" "$STATIC_DEST_DIR"
+  cp "${SRC_DIR}/lib/libsodium.so" "${SHARED_DEST_DIR}/libsodium.so"
+  cp "${SRC_DIR}/lib/libsodium.a" "${STATIC_DEST_DIR}/libsodium${3}-static.a"
+
+  rm -r "$SRC_DIR"
+}
+
+build_all() {
+  dist-build/android-armv7-a.sh
+  dist-build/android-armv8-a.sh
+  dist-build/android-x86_64.sh
+  dist-build/android-x86.sh
+}
+
+make_prefab_structure
+
+build_all
+
+copy_libs "armv7-a" "armeabi-v7a" "-minimal"
+copy_libs "armv8-a+crypto" "arm64-v8a" "-minimal"
+copy_libs "i686" "x86" "-minimal"
+copy_libs "westmere" "x86_64" "-minimal"
+
+LIBSODIUM_FULL_BUILD="Y"
+export LIBSODIUM_FULL_BUILD
+
+build_all
+
+copy_libs "armv7-a" "armeabi-v7a"
+copy_libs "armv8-a+crypto" "arm64-v8a"
+copy_libs "i686" "x86"
+copy_libs "westmere" "x86_64"
+
+AAR_PATH="$(pwd)/libsodium-${SODIUM_VERSION}.aar"
+cd "$DEST_PATH" || exit
+rm "$AAR_PATH"
+zip -9 -r "$AAR_PATH" META-INF prefab AndroidManifest.xml
+cd .. || exit
+rm -r "$DEST_PATH"
+
+echo "
+
+Congrats you have built an AAR containing libsodium!
+The build used a min Android SDK of version $SDK_VERSION
+You can build for a different SDK version by specifying NDK_PLATFORM=\"android-{SDK_VERSION}\"
+as an environment variable before running this script but the defaults should be fine.
+
+To use the aar with
+gradle or cmake (as set by default for Android Studio projects):
+
+- Edit the app/build.gradle file to add:
+
+    android {
+        buildFeatures {
+            prefab true
+        }
+    }
+
+  and
+
+    dependencies {
+        implementation fileTree(dir:'path/to/aar/',include:['libsodium-$SODIUM_VERSION.aar'])
+    }
+
+  Optionally, store multiple AAR files in the same folder and include '*.aar'
+
+- Edit your module's CMakeLists.txt file to add:
+
+    find_package(sodium REQUIRED CONFIG)
+
+- Then, specify 'sodium::x' as an item in the relevant 'target_link_libraries' statement.
+    The first part is the AAR name and should be 'sodium'.
+    The second part ('x', to be replaced) should be set to:
+      - 'sodium' for the full shared library,
+      - 'sodium-static' for the full static library
+      - 'sodium-minimal' for the minimal shared library, or
+      - 'sodium-minimal-static' for the minimal static library.
+
+  "

package/ios/libsodium-stable/dist-build/android-armv7-a.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+export TARGET_ARCH=armv7-a
+export CFLAGS="-Os -mfloat-abi=softfp -mfpu=vfpv3-d16 -mthumb -marm -march=${TARGET_ARCH}"
+export LDFLAGS="-Wl,-z,max-page-size=16384"
+ARCH=arm HOST_COMPILER=armv7a-linux-androideabi "$(dirname "$0")/android-build.sh"

package/ios/libsodium-stable/dist-build/android-armv8-a.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+export TARGET_ARCH=armv8-a+crypto
+export CFLAGS="-Os -march=${TARGET_ARCH}"
+export LDFLAGS="-Wl,-z,max-page-size=16384"
+ARCH=arm64 HOST_COMPILER=aarch64-linux-android "$(dirname "$0")/android-build.sh"

package/ios/libsodium-stable/dist-build/android-build.sh

@@ -0,0 +1,95 @@
+#! /bin/sh
+
+if [ -z "$NDK_PLATFORM" ]; then
+  echo "No NDK_PLATFORM specified, set to value such as \"android-{Min_SDK_VERSION}\" or just use android-aar.sh"
+  exit
+fi
+SDK_VERSION=$(echo "$NDK_PLATFORM" | cut -f2 -d"-")
+export NDK_PLATFORM_COMPAT="${NDK_PLATFORM_COMPAT:-${NDK_PLATFORM}}"
+export NDK_API_VERSION="$(echo "$NDK_PLATFORM" | sed 's/^android-//')"
+export NDK_API_VERSION_COMPAT="$(echo "$NDK_PLATFORM_COMPAT" | sed 's/^android-//')"
+
+if [ -z "$ANDROID_NDK_HOME" ]; then
+  echo "ANDROID_NDK_HOME must be set to the directory containing the Android NDK."
+  exit 1
+fi
+
+if [ ! -f ./configure ]; then
+  echo "Can't find ./configure. Wrong directory or haven't run autogen.sh?" >&2
+  exit 1
+fi
+
+if [ -z "$TARGET_ARCH" ] || [ -z "$ARCH" ] || [ -z "$HOST_COMPILER" ]; then
+  echo "You shouldn't use android-build.sh directly, use android-[arch].sh instead" >&2
+  exit 1
+fi
+
+export PREFIX="$(pwd)/libsodium-android-${TARGET_ARCH}"
+export TOOLCHAIN_OS_DIR="$(uname | tr '[:upper:]' '[:lower:]')-x86_64/"
+export TOOLCHAIN_DIR="$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/${TOOLCHAIN_OS_DIR}"
+
+export PATH="${PATH}:${TOOLCHAIN_DIR}/bin"
+
+export CC=${CC:-"${HOST_COMPILER}${SDK_VERSION}-clang"}
+
+echo
+echo "Warnings related to headers being present but not usable are due to functions"
+echo "that didn't exist in the specified minimum API version level."
+echo "They can be safely ignored."
+echo
+
+echo
+if [ "$NDK_PLATFORM" != "$NDK_PLATFORM_COMPAT" ]; then
+  echo "Building for platform [${NDK_PLATFORM}], retaining compatibility with platform [${NDK_PLATFORM_COMPAT}]"
+else
+  echo "Building for platform [${NDK_PLATFORM}]"
+fi
+echo
+
+if [ -z "$LIBSODIUM_FULL_BUILD" ]; then
+  export LIBSODIUM_ENABLE_MINIMAL_FLAG="--enable-minimal"
+else
+  export LIBSODIUM_ENABLE_MINIMAL_FLAG=""
+fi
+
+./configure \
+  --disable-soname-versions \
+  --disable-pie \
+  ${LIBSODIUM_ENABLE_MINIMAL_FLAG} \
+  --host="${HOST_COMPILER}" \
+  --prefix="${PREFIX}" \
+  --with-sysroot="${TOOLCHAIN_DIR}/sysroot" || exit 1
+
+if [ -z "$NDK_PLATFORM" ]; then
+  echo "Aborting"
+  exit 1
+fi
+if [ "$NDK_PLATFORM" != "$NDK_PLATFORM_COMPAT" ]; then
+  grep -E '^#define ' config.log | sort -u >config-def-compat.log
+  echo
+  echo "Configuring again for platform [${NDK_PLATFORM}]"
+  echo
+
+  ./configure \
+    --disable-soname-versions \
+    --disable-pie \
+    ${LIBSODIUM_ENABLE_MINIMAL_FLAG} \
+    --host="${HOST_COMPILER}" \
+    --prefix="${PREFIX}" \
+    --with-sysroot="${TOOLCHAIN_DIR}/sysroot" || exit 1
+
+  grep -E '^#define ' config.log | sort -u >config-def.log
+  if ! cmp config-def.log config-def-compat.log; then
+    echo "Platform [${NDK_PLATFORM}] is not backwards-compatible with [${NDK_PLATFORM_COMPAT}]" >&2
+    diff -u config-def.log config-def-compat.log >&2
+    exit 1
+  fi
+  rm -f config-def.log config-def-compat.log
+fi
+
+NPROCESSORS=$(getconf NPROCESSORS_ONLN 2>/dev/null || getconf _NPROCESSORS_ONLN 2>/dev/null)
+PROCESSORS=${NPROCESSORS:-3}
+
+make clean &&
+  make -j"${PROCESSORS}" install &&
+  echo "libsodium has been installed into ${PREFIX}"

package/ios/libsodium-stable/dist-build/android-x86.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+export TARGET_ARCH=i686
+export CFLAGS="-Os -march=${TARGET_ARCH}"
+export LDFLAGS="-Wl,-z,max-page-size=16384"
+ARCH=x86 HOST_COMPILER=i686-linux-android "$(dirname "$0")/android-build.sh"

package/ios/libsodium-stable/dist-build/android-x86_64.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+export TARGET_ARCH=westmere
+export CFLAGS="-Os -march=${TARGET_ARCH}"
+export LDFLAGS="-Wl,-z,max-page-size=16384"
+ARCH=x86_64 HOST_COMPILER=x86_64-linux-android "$(dirname "$0")/android-build.sh"