laag-libsodium 1.0.16.0

data/vendor/github.com/jedisct1/libsodium/m4/ax_valgrind_check.m4

@@ -0,0 +1,241 @@
+# ===========================================================================
+#    https://www.gnu.org/software/autoconf-archive/ax_valgrind_check.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_VALGRIND_DFLT(memcheck|helgrind|drd|sgcheck, on|off)
+#   AX_VALGRIND_CHECK()
+#
+# DESCRIPTION
+#
+#   AX_VALGRIND_CHECK checks whether Valgrind is present and, if so, allows
+#   running `make check` under a variety of Valgrind tools to check for
+#   memory and threading errors.
+#
+#   Defines VALGRIND_CHECK_RULES which should be substituted in your
+#   Makefile; and $enable_valgrind which can be used in subsequent configure
+#   output. VALGRIND_ENABLED is defined and substituted, and corresponds to
+#   the value of the --enable-valgrind option, which defaults to being
+#   enabled if Valgrind is installed and disabled otherwise. Individual
+#   Valgrind tools can be disabled via --disable-valgrind-<tool>, the
+#   default is configurable via the AX_VALGRIND_DFLT command or is to use
+#   all commands not disabled via AX_VALGRIND_DFLT. All AX_VALGRIND_DFLT
+#   calls must be made before the call to AX_VALGRIND_CHECK.
+#
+#   If unit tests are written using a shell script and automake's
+#   LOG_COMPILER system, the $(VALGRIND) variable can be used within the
+#   shell scripts to enable Valgrind, as described here:
+#
+#     https://www.gnu.org/software/gnulib/manual/html_node/Running-self_002dtests-under-valgrind.html
+#
+#   Usage example:
+#
+#   configure.ac:
+#
+#     AX_VALGRIND_DFLT([sgcheck], [off])
+#     AX_VALGRIND_CHECK
+#
+#   Makefile.am:
+#
+#     @VALGRIND_CHECK_RULES@
+#     VALGRIND_SUPPRESSIONS_FILES = my-project.supp
+#     EXTRA_DIST = my-project.supp
+#
+#   This results in a "check-valgrind" rule being added to any Makefile.am
+#   which includes "@VALGRIND_CHECK_RULES@" (assuming the module has been
+#   configured with --enable-valgrind). Running `make check-valgrind` in
+#   that directory will run the module's test suite (`make check`) once for
+#   each of the available Valgrind tools (out of memcheck, helgrind and drd)
+#   while the sgcheck will be skipped unless enabled again on the
+#   commandline with --enable-valgrind-sgcheck. The results for each check
+#   will be output to test-suite-$toolname.log. The target will succeed if
+#   there are zero errors and fail otherwise.
+#
+#   Alternatively, a "check-valgrind-$TOOL" rule will be added, for $TOOL in
+#   memcheck, helgrind, drd and sgcheck. These are useful because often only
+#   some of those tools can be ran cleanly on a codebase.
+#
+#   The macro supports running with and without libtool.
+#
+# LICENSE
+#
+#   Copyright (c) 2014, 2015, 2016 Philip Withnall <philip.withnall@collabora.co.uk>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 15
+
+dnl Configured tools
+m4_define([valgrind_tool_list], [[memcheck], [helgrind], [drd], [sgcheck]])
+m4_set_add_all([valgrind_exp_tool_set], [sgcheck])
+m4_foreach([vgtool], [valgrind_tool_list],
+           [m4_define([en_dflt_valgrind_]vgtool, [on])])
+
+AC_DEFUN([AX_VALGRIND_DFLT],[
+	m4_define([en_dflt_valgrind_$1], [$2])
+])dnl
+
+AC_DEFUN([AX_VALGRIND_CHECK],[
+	dnl Check for --enable-valgrind
+	AC_ARG_ENABLE([valgrind],
+				  [AS_HELP_STRING([--enable-valgrind], [Whether to enable Valgrind on the unit tests (requires GNU make)])],
+				  [enable_valgrind=$enableval],[enable_valgrind=no])
+
+	AS_IF([test "$enable_valgrind" != "no"],[
+		# Check for Valgrind.
+		AC_CHECK_PROG([VALGRIND],[valgrind],[valgrind])
+		AS_IF([test "$VALGRIND" = ""],[
+			AS_IF([test "$enable_valgrind" = "yes"],[
+				AC_MSG_ERROR([Could not find valgrind; either install it or reconfigure with --disable-valgrind])
+			],[
+				enable_valgrind=no
+			])
+		],[
+			enable_valgrind=yes
+		])
+	])
+
+	AM_CONDITIONAL([VALGRIND_ENABLED],[test "$enable_valgrind" = "yes"])
+	AC_SUBST([VALGRIND_ENABLED],[$enable_valgrind])
+
+	# Check for Valgrind tools we care about.
+	[valgrind_enabled_tools=]
+	m4_foreach([vgtool],[valgrind_tool_list],[
+		AC_ARG_ENABLE([valgrind-]vgtool,
+		    m4_if(m4_defn([en_dflt_valgrind_]vgtool),[off],dnl
+[AS_HELP_STRING([--enable-valgrind-]vgtool, [Whether to use ]vgtool[ during the Valgrind tests])],dnl
+[AS_HELP_STRING([--disable-valgrind-]vgtool, [Whether to skip ]vgtool[ during the Valgrind tests])]),
+		              [enable_valgrind_]vgtool[=$enableval],
+		              [enable_valgrind_]vgtool[=])
+		AS_IF([test "$enable_valgrind" = "no"],[
+			enable_valgrind_]vgtool[=no],
+		      [test "$enable_valgrind_]vgtool[" ]dnl
+m4_if(m4_defn([en_dflt_valgrind_]vgtool), [off], [= "yes"], [!= "no"]),[
+			AC_CACHE_CHECK([for Valgrind tool ]vgtool,
+			               [ax_cv_valgrind_tool_]vgtool,[
+				ax_cv_valgrind_tool_]vgtool[=no
+				m4_set_contains([valgrind_exp_tool_set],vgtool,
+				    [m4_define([vgtoolx],[exp-]vgtool)],
+				    [m4_define([vgtoolx],vgtool)])
+				AS_IF([`$VALGRIND --tool=]vgtoolx[ --help >/dev/null 2>&1`],[
+					ax_cv_valgrind_tool_]vgtool[=yes
+				])
+			])
+			AS_IF([test "$ax_cv_valgrind_tool_]vgtool[" = "no"],[
+				AS_IF([test "$enable_valgrind_]vgtool[" = "yes"],[
+					AC_MSG_ERROR([Valgrind does not support ]vgtool[; reconfigure with --disable-valgrind-]vgtool)
+				],[
+					enable_valgrind_]vgtool[=no
+				])
+			],[
+				enable_valgrind_]vgtool[=yes
+			])
+		])
+		AS_IF([test "$enable_valgrind_]vgtool[" = "yes"],[
+			valgrind_enabled_tools="$valgrind_enabled_tools ]m4_bpatsubst(vgtool,[^exp-])["
+		])
+		AC_SUBST([ENABLE_VALGRIND_]vgtool,[$enable_valgrind_]vgtool)
+	])
+	AC_SUBST([valgrind_tools],["]m4_join([ ], valgrind_tool_list)["])
+	AC_SUBST([valgrind_enabled_tools],[$valgrind_enabled_tools])
+
+[VALGRIND_CHECK_RULES='
+# Valgrind check
+#
+# Optional:
+#  - VALGRIND_SUPPRESSIONS_FILES: Space-separated list of Valgrind suppressions
+#    files to load. (Default: empty)
+#  - VALGRIND_FLAGS: General flags to pass to all Valgrind tools.
+#    (Default: --num-callers=30)
+#  - VALGRIND_$toolname_FLAGS: Flags to pass to Valgrind $toolname (one of:
+#    memcheck, helgrind, drd, sgcheck). (Default: various)
+
+# Optional variables
+VALGRIND_SUPPRESSIONS ?= $(addprefix --suppressions=,$(VALGRIND_SUPPRESSIONS_FILES))
+VALGRIND_FLAGS ?= --num-callers=30
+VALGRIND_memcheck_FLAGS ?= --leak-check=full --show-reachable=no
+VALGRIND_helgrind_FLAGS ?= --history-level=approx
+VALGRIND_drd_FLAGS ?=
+VALGRIND_sgcheck_FLAGS ?=
+
+# Internal use
+valgrind_log_files = $(addprefix test-suite-,$(addsuffix .log,$(valgrind_tools)))
+
+valgrind_memcheck_flags = --tool=memcheck $(VALGRIND_memcheck_FLAGS)
+valgrind_helgrind_flags = --tool=helgrind $(VALGRIND_helgrind_FLAGS)
+valgrind_drd_flags = --tool=drd $(VALGRIND_drd_FLAGS)
+valgrind_sgcheck_flags = --tool=exp-sgcheck $(VALGRIND_sgcheck_FLAGS)
+
+valgrind_quiet = $(valgrind_quiet_$(V))
+valgrind_quiet_ = $(valgrind_quiet_$(AM_DEFAULT_VERBOSITY))
+valgrind_quiet_0 = --quiet
+valgrind_v_use   = $(valgrind_v_use_$(V))
+valgrind_v_use_  = $(valgrind_v_use_$(AM_DEFAULT_VERBOSITY))
+valgrind_v_use_0 = @echo "  USE   " $(patsubst check-valgrind-%,%,$''@):;
+
+# Support running with and without libtool.
+ifneq ($(LIBTOOL),)
+valgrind_lt = $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=execute
+else
+valgrind_lt =
+endif
+
+# Use recursive makes in order to ignore errors during check
+check-valgrind:
+ifeq ($(VALGRIND_ENABLED),yes)
+	$(A''M_V_at)$(MAKE) $(AM_MAKEFLAGS) -k \
+		$(foreach tool, $(valgrind_enabled_tools), check-valgrind-$(tool))
+else
+	@echo "Need to use GNU make and reconfigure with --enable-valgrind"
+endif
+
+# Valgrind running
+VALGRIND_TESTS_ENVIRONMENT = \
+	$(TESTS_ENVIRONMENT) \
+	env VALGRIND=$(VALGRIND) \
+	G_SLICE=always-malloc,debug-blocks \
+	G_DEBUG=fatal-warnings,fatal-criticals,gc-friendly
+
+VALGRIND_LOG_COMPILER = \
+	$(valgrind_lt) \
+	$(VALGRIND) $(VALGRIND_SUPPRESSIONS) --error-exitcode=1 $(VALGRIND_FLAGS)
+
+define valgrind_tool_rule =
+check-valgrind-$(1):
+ifeq ($$(VALGRIND_ENABLED)-$$(ENABLE_VALGRIND_$(1)),yes-yes)
+	$$(valgrind_v_use)$$(MAKE) check-TESTS \
+		TESTS_ENVIRONMENT="$$(VALGRIND_TESTS_ENVIRONMENT)" \
+		LOG_COMPILER="$$(VALGRIND_LOG_COMPILER)" \
+		LOG_FLAGS="$$(valgrind_$(1)_flags)" \
+		TEST_SUITE_LOG=test-suite-$(1).log
+else ifeq ($$(VALGRIND_ENABLED),yes)
+	@echo "Need to reconfigure with --enable-valgrind-$(1)"
+else
+	@echo "Need to reconfigure with --enable-valgrind"
+endif
+endef
+
+$(foreach tool,$(valgrind_tools),$(eval $(call valgrind_tool_rule,$(tool))))
+
+A''M_DISTCHECK_CONFIGURE_FLAGS ?=
+A''M_DISTCHECK_CONFIGURE_FLAGS += --disable-valgrind
+
+MOSTLYCLEANFILES ?=
+MOSTLYCLEANFILES += $(valgrind_log_files)
+
+.PHONY: check-valgrind $(add-prefix check-valgrind-,$(valgrind_tools))
+']
+
+	AS_IF([test "$enable_valgrind" != "yes"], [
+		VALGRIND_CHECK_RULES='
+check-valgrind:
+	@echo "Need to use GNU make and reconfigure with --enable-valgrind"'
+	])
+
+	AC_SUBST([VALGRIND_CHECK_RULES])
+	m4_ifdef([_AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE([VALGRIND_CHECK_RULES])])
+])

data/vendor/github.com/jedisct1/libsodium/m4/ld-output-def.m4

@@ -0,0 +1,29 @@
+# ld-output-def.m4 serial 2
+dnl Copyright (C) 2008-2013 Free Software Foundation, Inc.
+dnl This file is free software; the Free Software Foundation
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl From Simon Josefsson
+
+# gl_LD_OUTPUT_DEF()
+# -------------
+# Check if linker supports -Wl,--output-def and define automake
+# conditional HAVE_LD_OUTPUT_DEF if it is.
+AC_DEFUN([gl_LD_OUTPUT_DEF],
+[
+  AC_CACHE_CHECK([if gcc/ld supports -Wl,--output-def],
+    [gl_cv_ld_output_def],
+    [if test "$enable_shared" = no; then
+       gl_cv_ld_output_def="not needed, shared libraries are disabled"
+     else
+       gl_ldflags_save=$LDFLAGS
+       LDFLAGS="-Wl,--output-def,conftest.def"
+       AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
+                   [gl_cv_ld_output_def=yes],
+                   [gl_cv_ld_output_def=no])
+       rm -f conftest.def
+       LDFLAGS="$gl_ldflags_save"
+     fi])
+  AM_CONDITIONAL([HAVE_LD_OUTPUT_DEF], test "x$gl_cv_ld_output_def" = "xyes")
+])

data/vendor/github.com/jedisct1/libsodium/msvc-scripts/Makefile.am

@@ -0,0 +1,4 @@
+EXTRA_DIST = \
+	process.bat \
+	rep.vbs \
+	sodium.props

data/vendor/github.com/jedisct1/libsodium/msvc-scripts/process.bat

@@ -0,0 +1,5 @@
+cscript msvc-scripts/rep.vbs //Nologo s/@VERSION@/1.0.16/ < src\libsodium\include\sodium\version.h.in > tmp
+cscript msvc-scripts/rep.vbs //Nologo s/@SODIUM_LIBRARY_VERSION_MAJOR@/10/ < tmp > tmp2
+cscript msvc-scripts/rep.vbs //Nologo s/@SODIUM_LIBRARY_VERSION_MINOR@/1/ < tmp2 > tmp3
+cscript msvc-scripts/rep.vbs //Nologo s/@SODIUM_LIBRARY_MINIMAL_DEF@// < tmp3 > src\libsodium\include\sodium\version.h
+del tmp tmp2 tmp3

data/vendor/github.com/jedisct1/libsodium/msvc-scripts/rep.vbs

@@ -0,0 +1,12 @@
+Dim pat, patparts, rxp, inp
+pat = WScript.Arguments(0)
+patparts = Split(pat, "/")
+Set rxp = new RegExp
+rxp.Global = True
+rxp.Multiline = False
+rxp.Pattern = patparts(1)
+Do While Not WScript.StdIn.AtEndOfStream
+  inp = WScript.StdIn.ReadLine()
+  WScript.Echo rxp.Replace(inp, patparts(2))
+Loop
+

data/vendor/github.com/jedisct1/libsodium/msvc-scripts/sodium.props

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir);$(SolutionDir)src\libsodium\include\sodium;$(SolutionDir)src\libsodium\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>UNICODE;_UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NATIVE_LITTLE_ENDIAN=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>inline=__inline;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <PreBuildEvent>
+      <Command>"$(SolutionDir)/msvc-scripts/process.bat"</Command>
+    </PreBuildEvent>
+    <PreBuildEvent>
+      <Message>Process .in files</Message>
+    </PreBuildEvent>
+    <PostBuildEvent>
+      <Command>"$(SolutionDir)/test/default/wintest.bat" $(Configuration) $(Platform)</Command>
+    </PostBuildEvent>
+    <PostBuildEvent>
+      <Message>Run the test suite</Message>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup />
+</Project>

data/vendor/github.com/jedisct1/libsodium/packaging/dotnet-core/.gitignore

@@ -0,0 +1,5 @@
+build
+cache
+temp
+Makefile
+!recipes/*

data/vendor/github.com/jedisct1/libsodium/packaging/dotnet-core/README.md

@@ -0,0 +1,59 @@
+This directory contains scripts and files to package libsodium for .NET Core.
+
+*Note:* The NuGet package is intended for the implementation of language
+bindings such as [NSec](https://github.com/ektrah/nsec). It does not provide a
+.NET API itself.
+
+In .NET Core, it is customary to provide pre-compiled binaries for all platforms
+as NuGet packages. The purpose of the `prepare.py` script in this directory is
+to generate a `Makefile` that downloads and builds libsodium binaries for a
+number of platforms and assembles them in a NuGet package that can be uploaded
+to [nuget.org](https://nuget.org/).
+
+* For Windows, binaries are obtained from
+  [download.libsodium.org](https://download.libsodium.org/libsodium/releases/).
+* For macOS, binaries are extracted from the
+  [Homebrew libsodium bottle](https://bintray.com/homebrew/bottles/libsodium).
+* For Linux, libsodium is compiled in Docker containers.
+
+See `prepare.py` for the complete list of supported platforms.
+
+The metadata for the NuGet package is located in `libsodium.props`.
+
+
+**Versioning**
+
+Version numbers for the packages for .NET Core consist of three components:
+
+* *libsodium version*  
+  The libsodium version is in the format `X.Y.Z`.
+* *package revision*  
+  It may be necessary to release more than one package for a libsodium version,
+  e.g., when adding support for a new platform or if a release contains a broken
+  binary. In this case, a package revision number is added as a fourth part to
+  the libsodium version, starting at `1`. For example, `1.0.16` is the initial
+  release of the package for libsodium 1.0.16 and `1.0.16.5` is the fifth
+  revision (sixth release) of that package.
+* *pre-release label*  
+  If a package is a pre-release, a label is appended to the version number in
+  `-preview-##` format where `##` is the number of the pre-release, starting at
+  `01`. For example, `1.0.16-preview-01` is the first pre-release of the package
+  for libsodium 1.0.16 and `1.0.16.5-preview-02` the second pre-release of the
+  fifth revision of the package for libsodium 1.0.16.
+
+
+**Making a release**
+
+1. Update any existing Docker images.
+2. Run `python3 prepare.py <version>` to generate the `Makefile`, where
+   `<version>` is the package version number in the format described above.
+3. Take a look at the generated `Makefile`. It uses `sudo` a few times.
+4. Run `make` to download and build the binaries and create the NuGet package.
+   You may need to install `docker`, `make`, `curl`, `tar` and `unzip` first.
+5. Grab a cup of coffee. Downloading the Docker images and compiling the Linux
+   binaries takes a while. When done, the NuGet package is output as a `.nupkg`
+   file in the `build` directory.
+6. Run `make test` to perform a quick test of the NuGet package. Verify that
+   everything else in the `.nupkg` file is in place.
+7. Publish the release by uploading the `.nupkg` file to
+   [nuget.org](https://nuget.org/).

data/vendor/github.com/jedisct1/libsodium/packaging/dotnet-core/libsodium.props

@@ -0,0 +1,36 @@
+<?xml version="1.0"?>
+<Project>
+
+  <PropertyGroup>
+    <TargetFramework>netstandard1.1</TargetFramework>
+    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
+    <NoBuild>true</NoBuild>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <PackageOutputPath>$(MSBuildProjectDirectory)</PackageOutputPath>
+    <ProjectFileToPack>$(MSBuildProjectFullPath)</ProjectFileToPack>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <PackageId>libsodium</PackageId>
+    <Version><!-- set by prepare.py --></Version>
+    <Authors>Frank Denis</Authors>
+    <Description>Internal implementation package not meant for direct consumption. Please do not reference directly.</Description>
+    <Copyright>&#169; 2013-2017 Frank Denis</Copyright>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <PackageLicenseUrl>https://raw.githubusercontent.com/jedisct1/libsodium/master/LICENSE</PackageLicenseUrl>
+    <PackageProjectUrl>https://libsodium.org/</PackageProjectUrl>
+    <MinClientVersion>4.0</MinClientVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETCore.Platforms" Version="1.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="LICENSE" PackagePath="" />
+    <Content Include="AUTHORS" PackagePath="" />
+    <Content Include="ChangeLog" PackagePath="" />
+    <Content Include="runtimes\**\*.*" PackagePath="runtimes\" />
+  </ItemGroup>
+
+</Project>

data/vendor/github.com/jedisct1/libsodium/packaging/dotnet-core/prepare.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+
+import os.path
+import re
+import sys
+
+WINDOWS = [
+  # --------------------- ----------------- #
+  # Runtime ID            Platform          #
+  # --------------------- ----------------- #
+  ( 'win-x64',            'x64'             ),
+  ( 'win-x86',            'Win32'           ),
+  # --------------------- ----------------- #
+]
+
+MACOS = [
+  # --------------------- ----------------- #
+  # Runtime ID            Codename          #
+  # --------------------- ----------------- #
+  ( 'osx-x64',            'sierra'          ),
+  # --------------------- ----------------- #
+]
+
+LINUX = [
+  # --------------------- ----------------- #
+  # Runtime ID            Docker Image      #
+  # --------------------- ----------------- #
+  ( 'linux-x64',          'debian:stretch'  ),
+  # --------------------- ----------------- #
+]
+
+EXTRAS = [ 'LICENSE', 'AUTHORS', 'ChangeLog' ]
+
+PROPSFILE = 'libsodium.props'
+MAKEFILE = 'Makefile'
+BUILDDIR = 'build'
+CACHEDIR = 'cache'
+TEMPDIR = 'temp'
+
+PACKAGE = 'libsodium'
+LIBRARY = 'libsodium'
+
+DOCKER = 'sudo docker'
+
+class Version:
+
+  def __init__(self, libsodium_version, package_version):
+    self.libsodium_version = libsodium_version
+    self.package_version = package_version
+
+    self.builddir = os.path.join(BUILDDIR, libsodium_version)
+    self.tempdir = os.path.join(TEMPDIR, libsodium_version)
+    self.projfile = os.path.join(self.builddir, '{0}.{1}.pkgproj'.format(PACKAGE, package_version))
+    self.propsfile = os.path.join(self.builddir, '{0}.props'.format(PACKAGE))
+    self.pkgfile = os.path.join(BUILDDIR, '{0}.{1}.nupkg'.format(PACKAGE, package_version))
+
+class WindowsItem:
+
+  def __init__(self, version, rid, platform):
+    self.url = 'https://download.libsodium.org/libsodium/releases/libsodium-{0}-msvc.zip'.format(version.libsodium_version)
+    self.cachefile = os.path.join(CACHEDIR, re.sub(r'[^A-Za-z0-9.]', '-', self.url))
+    self.packfile = os.path.join(version.builddir, 'runtimes', rid, 'native', LIBRARY + '.dll')
+    self.itemfile = '{0}/Release/v140/dynamic/libsodium.dll'.format(platform)
+    self.tempdir = os.path.join(version.tempdir, rid)
+    self.tempfile = os.path.join(self.tempdir, os.path.normpath(self.itemfile))
+
+  def make(self, f):
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.packfile, self.tempfile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcp -f $< $@\n')
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.tempfile, self.cachefile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcd {0} && unzip -q -DD -o {1} \'{2}\'\n'.format(
+      self.tempdir,
+      os.path.relpath(self.cachefile, self.tempdir),
+      self.itemfile
+    ))
+
+class MacOSItem:
+
+  def __init__(self, version, rid, codename):
+    self.url = 'https://bintray.com/homebrew/bottles/download_file?file_path=libsodium-{0}.{1}.bottle.tar.gz'.format(version.libsodium_version, codename)
+    self.cachefile = os.path.join(CACHEDIR, re.sub(r'[^A-Za-z0-9.]', '-', self.url))
+    self.packfile = os.path.join(version.builddir, 'runtimes', rid, 'native', LIBRARY + '.dylib')
+    self.itemfile = 'libsodium/{0}/lib/libsodium.dylib'.format(version.libsodium_version)
+    self.tempdir = os.path.join(version.tempdir, rid)
+    self.tempfile = os.path.join(self.tempdir, os.path.normpath(self.itemfile))
+
+  def make(self, f):
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.packfile, self.tempfile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcp -f $< $@\n')
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.tempfile, self.cachefile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcd {0} && tar xzmf {1} \'{2}\'\n'.format(
+      self.tempdir,
+      os.path.relpath(self.cachefile, self.tempdir),
+      os.path.dirname(self.itemfile)
+    ))
+
+class LinuxItem:
+
+  def __init__(self, version, rid, docker_image):
+    self.url = 'https://download.libsodium.org/libsodium/releases/libsodium-{0}.tar.gz'.format(version.libsodium_version)
+    self.cachefile = os.path.join(CACHEDIR, re.sub(r'[^A-Za-z0-9.]', '-', self.url))
+    self.packfile = os.path.join(version.builddir, 'runtimes', rid, 'native', LIBRARY + '.so')
+    self.tempdir = os.path.join(version.tempdir, rid)
+    self.tempfile = os.path.join(self.tempdir, 'libsodium.so')
+    self.docker_image = docker_image
+    self.recipe = rid
+
+  def make(self, f):
+    recipe = self.recipe
+    while not os.path.exists(os.path.join('recipes', recipe)):
+      m = re.fullmatch(r'([^.-]+)((([.][^.-]+)*)[.][^.-]+)?([-].*)?', recipe)
+      if m.group(5) is None:
+        recipe = 'build'
+        break
+      elif m.group(2) is None:
+        recipe = m.group(1)
+      else:
+        recipe = m.group(1) + m.group(3) + m.group(5)
+
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.packfile, self.tempfile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcp -f $< $@\n')
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.tempfile, self.cachefile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\t{0} run --rm '.format(DOCKER) +
+            '-v $(abspath recipes):/io/recipes ' +
+            '-v $(abspath $<):/io/libsodium.tar.gz ' +
+            '-v $(abspath $(dir $@)):/io/output ' +
+            '{0} sh -x -e /io/recipes/{1}\n'.format(self.docker_image, recipe))
+
+class ExtraItem:
+
+  def __init__(self, version, filename):
+    self.url = 'https://download.libsodium.org/libsodium/releases/libsodium-{0}.tar.gz'.format(version.libsodium_version)
+    self.cachefile = os.path.join(CACHEDIR, re.sub(r'[^A-Za-z0-9.]', '-', self.url))
+    self.packfile = os.path.join(version.builddir, filename)
+    self.itemfile = 'libsodium-{0}/{1}'.format(version.libsodium_version, filename)
+    self.tempdir = os.path.join(version.tempdir, 'extras')
+    self.tempfile = os.path.join(self.tempdir, os.path.normpath(self.itemfile))
+
+  def make(self, f):
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.packfile, self.tempfile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcp -f $< $@\n')
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(self.tempfile, self.cachefile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcd {0} && tar xzmf {1} \'{2}\'\n'.format(
+      self.tempdir,
+      os.path.relpath(self.cachefile, self.tempdir),
+      self.itemfile
+    ))
+
+def main(args):
+  m = re.fullmatch(r'((\d+\.\d+\.\d+)(\.\d+)?)(?:-(\w+(?:[_.-]\w+)*))?', args[1]) if len(args) == 2 else None
+
+  if m is None:
+    print('Usage:')
+    print('       python3 prepare.py <version>')
+    print()
+    print('Examples:')
+    print('       python3 prepare.py 1.0.16-preview-01')
+    print('       python3 prepare.py 1.0.16-preview-02')
+    print('       python3 prepare.py 1.0.16-preview-03')
+    print('       python3 prepare.py 1.0.16')
+    print('       python3 prepare.py 1.0.16.1-preview-01')
+    print('       python3 prepare.py 1.0.16.1')
+    print('       python3 prepare.py 1.0.16.2')
+    return 1
+
+  version = Version(m.group(2), m.group(0))
+
+  items = [ WindowsItem(version, rid, platform)   for (rid, platform) in WINDOWS   ] + \
+          [ MacOSItem(version, rid, codename)     for (rid, codename) in MACOS     ] + \
+          [ LinuxItem(version, rid, docker_image) for (rid, docker_image) in LINUX ] + \
+          [ ExtraItem(version, filename)          for filename in EXTRAS           ]
+
+  downloads = {item.cachefile: item.url for item in items}
+
+  with open(MAKEFILE, 'w') as f:
+    f.write('all: {0}\n'.format(version.pkgfile))
+
+    for download in sorted(downloads):
+      f.write('\n')
+      f.write('{0}:\n'.format(download))
+      f.write('\t@mkdir -p $(dir $@)\n')
+      f.write('\tcurl -f#Lo $@ \'{0}\'\n'.format(downloads[download]))
+
+    for item in items:
+      item.make(f)
+
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(version.propsfile, PROPSFILE))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\tcp -f $< $@\n')
+
+    f.write('\n')
+    f.write('{0}: {1}\n'.format(version.projfile, version.propsfile))
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\techo \'' +
+            '<Project Sdk="Microsoft.NET.Sdk">' +
+            '<Import Project="{0}" />'.format(os.path.relpath(version.propsfile, os.path.dirname(version.projfile))) +
+            '<PropertyGroup>' +
+            '<Version>{0}</Version>'.format(version.package_version) +
+            '</PropertyGroup>' +
+            '</Project>\' > $@\n')
+
+    f.write('\n')
+    f.write('{0}:'.format(version.pkgfile))
+    f.write(' \\\n\t\t{0}'.format(version.projfile))
+    f.write(' \\\n\t\t{0}'.format(version.propsfile))
+    for item in items:
+      f.write(' \\\n\t\t{0}'.format(item.packfile))
+    f.write('\n')
+    f.write('\t@mkdir -p $(dir $@)\n')
+    f.write('\t{0} run --rm '.format(DOCKER) +
+            '-v $(abspath recipes):/io/recipes ' +
+            '-v $(abspath $(dir $<)):/io/input ' +
+            '-v $(abspath $(dir $@)):/io/output ' +
+            '{0} sh -x -e /io/recipes/{1} {2}\n'.format('microsoft/dotnet:2.0-sdk', 'pack', os.path.relpath(version.projfile, version.builddir)))
+
+    f.write('\n')
+    f.write('test: {0}\n'.format(version.pkgfile))
+    f.write('\t{0} run --rm '.format(DOCKER) +
+            '-v $(abspath recipes):/io/recipes ' +
+            '-v $(abspath $(dir $<)):/io/packages ' +
+            '{0} sh -x -e /io/recipes/{1} "{2}"\n'.format('microsoft/dotnet:2.0-sdk', 'test', version.package_version))
+
+  print('prepared', MAKEFILE, 'to make', version.pkgfile, 'for libsodium', version.libsodium_version)
+  return 0
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv))

data/vendor/github.com/jedisct1/libsodium/packaging/dotnet-core/recipes/alpine-x64

@@ -0,0 +1,3 @@
+apk add --update alpine-sdk
+
+. $(dirname $0)/build