react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.21

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

@@ -1,297 +0,0 @@
-# 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

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

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

@@ -1,14 +0,0 @@
-
-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

@@ -1,194 +0,0 @@
-#! /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

@@ -1,5 +0,0 @@
-#!/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

@@ -1,5 +0,0 @@
-#!/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

@@ -1,95 +0,0 @@
-#! /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

@@ -1,5 +0,0 @@
-#!/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

@@ -1,5 +0,0 @@
-#!/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"