Include external libraries as system headers to remove warnings

Add libtorrent library to the Launcher application

apps/Launcher/CMakeLists.txt

@@ -25,24 +25,28 @@
 set(APPLICATION_NAME Launcher)
 set(APPLICATION_LINK_TO_OPENSPACE ON)
 
+include (${OPENSPACE_CMAKE_EXT_DIR}/handle_external_library.cmake)
+
+set(application_path ${OPENSPACE_APPS_DIR}/Launcher)
+
 set(SOURCE_FILES
-    ${OPENSPACE_APPS_DIR}/Launcher/main.cpp
-    ${OPENSPACE_APPS_DIR}/Launcher/mainwindow.cpp
-    ${OPENSPACE_APPS_DIR}/Launcher/shortcutwidget.cpp
-    ${OPENSPACE_APPS_DIR}/Launcher/syncwidget.cpp
+    ${application_path}/main.cpp
+    ${application_path}/mainwindow.cpp
+    ${application_path}/shortcutwidget.cpp
+    ${application_path}/syncwidget.cpp
 )
 
 set(HEADER_FILES
-    ${OPENSPACE_APPS_DIR}/Launcher/mainwindow.h
-    ${OPENSPACE_APPS_DIR}/Launcher/shortcutwidget.h
-    ${OPENSPACE_APPS_DIR}/Launcher/syncwidget.h
+    ${application_path}/mainwindow.h
+    ${application_path}/shortcutwidget.h
+    ${application_path}/syncwidget.h
 ) 
 
 find_package(Qt5Widgets)
 find_package(Qt5Network)
 
 qt5_wrap_cpp(MOC_FILES ${HEADER_FILES})
-qt5_add_resources(RESOURCE_FILES ${OPENSPACE_APPS_DIR}/Launcher/files.qrc)
+qt5_add_resources(RESOURCE_FILES ${application_path}/files.qrc)
 
 add_executable(${APPLICATION_NAME} MACOSX_BUNDLE
     ${SOURCE_FILES}
@@ -57,8 +61,15 @@ target_link_libraries(${APPLICATION_NAME}
 )
 
 if (APPLE)
-INSTALL(CODE "
-   include(BundleUtilities)
-   fixup_bundle(\"/Users/alex/Development/OpenSpace/bin/openspace/Debug/Launcher.app/Contents/MacOS/Launcher\"   \"/Users/alex/Development/OpenSpace/bin/openspace/Debug/TimelineView.app/Contents/plugins/platforms/libqcocoa.dylib\"   \"\")
-   " COMPONENT Runtime)
+    INSTALL(CODE "
+       include(BundleUtilities)
+       fixup_bundle(\"/Users/alex/Development/OpenSpace/bin/openspace/Debug/Launcher.app/Contents/MacOS/Launcher\"   \"/Users/alex/Development/OpenSpace/bin/openspace/Debug/TimelineView.app/Contents/plugins/platforms/libqcocoa.dylib\"   \"\")
+       " COMPONENT Runtime)
 endif ()
+
+# Libtorrent
+set(encryption OFF CACHE BOOL "")
+set(shared OFF CACHE BOOL "")
+include_external_library(${APPLICATION_NAME} torrent-rasterbar ${application_path}/ext/libtorrent)
+
+copy_files(${APPLICATION_NAME} "${CURL_ROOT_DIR}/lib/libcurl.dll")

apps/Launcher/ext/libtorrent/AUTHORS

+Written by Arvid Norberg. Copyright (c) 2003-2014
+
+Contributions by:
+Andrei Kurushin
+Steven Siloti
+Thomas Fischer
+Massaroddel
+Tianhao Qiu.
+Shyam
+Magnus Jonsson
+Daniel Wallin
+Cory Nelson
+Stas Khirman
+Ryan Norton
+Andrew Resch
+
+Building and maintainance of the autotools scripts:
+Michael Wojciechowski
+Peter Koeleman
+
+Thanks to Reimond Retz for bugfixes, suggestions and testing
+
+Thanks to University of UmeΠfor providing development and test hardware.
+
+Project is hosted by sourceforge.
+

apps/Launcher/ext/libtorrent/CMakeLists.txt

+cmake_minimum_required(VERSION 2.6)
+project(libtorrent)
+set (SOVERSION "8")
+set (VERSION "1.0.5")
+
+set(sources
+	web_connection_base
+	alert
+	alert_manager
+	allocator
+	asio
+	assert
+	bandwidth_limit
+	bandwidth_manager
+	bandwidth_queue_entry
+	bloom_filter
+	chained_buffer
+	connection_queue
+	create_torrent
+	disk_buffer_holder
+	entry
+	error_code
+	file_storage
+	lazy_bdecode
+	escape_string
+	string_util
+	file
+	gzip
+	hasher
+	http_connection
+	http_stream
+	http_parser
+	i2p_stream
+	identify_client
+	ip_filter
+	ip_voter
+	peer_connection
+	bt_peer_connection
+	web_peer_connection
+	http_seed_connection
+	instantiate_connection
+	natpmp
+	packet_buffer
+	piece_picker
+	policy
+	puff
+	random
+	rss
+	session
+	session_impl
+	settings
+	socket_io
+	socket_type  
+	socks5_stream
+	stat
+	storage
+	time
+	timestamp_history
+	torrent
+	torrent_handle
+	torrent_info
+	tracker_manager
+	http_tracker_connection
+	utf8
+	udp_tracker_connection
+	udp_socket
+	upnp
+	utp_socket_manager
+	utp_stream
+	logger
+	file_pool
+	lsd
+	disk_buffer_pool
+	disk_io_thread
+	enum_net
+	broadcast_socket
+	magnet_uri
+	parse_url
+	ConvertUTF
+	thread
+	xml_parse
+
+# -- extensions --
+	metadata_transfer
+	ut_pex
+	ut_metadata
+	smart_ban
+	lt_trackers
+)
+
+# -- kademlia --
+set(kademlia_sources
+	dht_tracker
+	node
+	refresh
+	rpc_manager
+	find_data
+	node_id
+	routing_table
+	traversal_algorithm
+	logging
+	item
+	get_peers
+	get_item
+)
+
+# -- ed25519 --
+set(ed25519_sources
+	add_scalar
+	fe
+	ge
+	key_exchange
+	keypair
+	sc
+	seed
+	sha512
+	sign
+	verify
+)
+
+set(includes include ed25519/src)
+
+option(shared "build libtorrent as a shared library" ON)
+option(static_runtime "build libtorrent with static runtime" OFF)
+option(tcmalloc "link against google performance tools tcmalloc" OFF)
+option(pool-allocators "Uses a pool allocator for disk and piece buffers" ON)
+option(encryption "link against openssl and enable encryption" ON)
+option(geoip "link against LGPL GeoIP code from Maxmind, to enable geoip database support" OFF)
+option(dht "enable support for Mainline DHT" ON)
+option(resolve-countries "enable support for resolving countries from peer IPs" ON)
+option(unicode "enable unicode support" ON)
+option(deprecated-functions "enable deprecated functions for backwards compatibility" ON)
+option(exceptions "build with exception support" ON)
+option(logging "build with logging" OFF)
+option(verbose-logging "build with verbose logging" OFF)
+option(build_tests "build tests" OFF)
+
+set(CMAKE_CONFIGURATION_TYPES Debug Release RelWithDebInfo)
+
+if (NOT CMAKE_BUILD_TYPE)
+	set(CMAKE_BUILD_TYPE Release FORCE)
+endif()
+
+# add_definitions() doesn't seem to let you say wich build type to apply it to
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DTORRENT_DEBUG")
+if(UNIX)
+	set(CMAKE_C_FLAGS_RELWITHDEBINFO "-Os -g")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
+endif()
+
+if (build_tests)
+	# this will make some internal functions available in the
+	# DLL interface, for the tests to access
+	add_definitions(-DTORRENT_EXPORT_EXTRA)
+endif (build_tests)
+
+include_directories(${includes})
+
+if (encryption)
+	list(APPEND sources pe_crypto asio_ssl)
+	if(NOT DEFINED OPENSSL_INCLUDE_DIR OR NOT DEFINED OPENSSL_LIBRARIES)
+		FIND_PACKAGE(OpenSSL REQUIRED)
+	endif()
+	add_definitions(-DTORRENT_USE_OPENSSL)
+	include_directories(${OPENSSL_INCLUDE_DIR})
+else()
+	add_definitions(-DTORRENT_DISABLE_ENCRYPTION)
+	list(APPEND sources sha1)
+endif (encryption)
+
+if (logging)
+	add_definitions(-DTORRENT_LOGGING)
+endif()
+if (verbose-logging)
+	add_definitions(-DTORRENT_VERBOSE_LOGGING)
+endif()
+
+foreach(s ${sources})
+	list(APPEND sources2 src/${s})
+endforeach(s)
+
+if (dht)
+	foreach(s ${kademlia_sources})
+		list(APPEND sources2 src/kademlia/${s})
+	endforeach(s)
+	foreach(s ${ed25519_sources})
+		list(APPEND sources2 ed25519/src/${s})
+	endforeach(s)
+else()
+	add_definitions(-DTORRENT_DISABLE_DHT)
+endif()
+
+if(NOT MSVC)
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+	set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -fvisibility-inlines-hidden")
+endif()
+
+if (shared)
+	add_definitions(-DTORRENT_BUILDING_SHARED)
+	add_library(torrent-rasterbar SHARED ${sources2})
+else (shared)
+	if(static_runtime)
+		# fix /MT flag:
+		set(CompilerFlags
+				CMAKE_CXX_FLAGS
+				CMAKE_CXX_FLAGS_DEBUG
+				CMAKE_CXX_FLAGS_RELWITHDEBINFO
+				CMAKE_CXX_FLAGS_RELEASE
+				CMAKE_C_FLAGS
+				CMAKE_C_FLAGS_DEBUG
+				CMAKE_CXX_FLAGS_RELWITHDEBINFO
+				CMAKE_C_FLAGS_RELEASE
+				)
+		foreach(CompilerFlag ${CompilerFlags})
+			string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+		endforeach()
+	endif()
+	add_library(torrent-rasterbar STATIC ${sources2})
+endif()
+
+# Boost
+if(NOT DEFINED Boost_INCLUDE_DIR OR NOT DEFINED Boost_LIBRARIES)
+	FIND_PACKAGE( Boost COMPONENTS system thread date_time chrono)
+endif()
+include_directories(${Boost_INCLUDE_DIR})
+target_link_libraries(torrent-rasterbar ${Boost_LIBRARIES})
+
+# this works around a bug in asio in boost-1.39
+#add_definitions(-DBOOST_ASIO_HASH_MAP_BUCKETS=1021  -D__USE_W32_SOCKETS -DWIN32_LEAN_AND_MEAN )
+
+if(NOT static_runtime)
+	add_definitions(-DBOOST_ASIO_DYN_LINK -DBOOST_DATE_TIME_DYN_LINK -DBOOST_THREAD_DYN_LINK -DBOOST_SYSTEM_DYN_LINK -DBOOST_CHRONO_DYN_LINK)
+else()
+	add_definitions(-DBOOST_ASIO_SEPARATE_COMPILATION)
+endif()
+
+if (WIN32)
+	target_link_libraries(torrent-rasterbar wsock32 ws2_32)
+	add_definitions(-D_WIN32_WINNT=0x0600)
+	if (MSVC)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP") # multicore compilation
+	endif()
+endif()
+
+if (encryption)
+	target_link_libraries(torrent-rasterbar ${OPENSSL_LIBRARIES})
+endif()
+
+if (NOT pool-allocators)
+	add_definitions(-DTORRENT_DISABLE_POOL_ALLOCATOR)
+endif()
+
+if (NOT geoip)
+	add_definitions(-DTORRENT_DISABLE_GEO_IP)
+endif()
+
+if (NOT resolve-countries)
+	add_definitions(-DTORRENT_DISABLE_RESOLVE_COUNTRIES)
+endif()
+
+if (unicode)
+	add_definitions(-DUNICODE -D_UNICODE)
+endif()
+
+if (NOT deprecated-functions)
+	add_definitions(-DTORRENT_NO_DEPRECATE)
+endif()
+
+if (exceptions)
+	if (MSVC)
+		add_definitions(/EHsc)
+	else (MSVC)
+		add_definitions(-fexceptions)
+	endif (MSVC)
+else()
+	if (MSVC)
+		add_definitions(-D_HAS_EXCEPTIONS=0)
+	else (MSVC)
+		add_definitions(-fno-exceptions)
+	endif (MSVC)
+endif()
+
+if (MSVC)
+# disable bogus deprecation warnings on msvc8
+	add_definitions(-D_SCL_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_DEPRECATE)
+# these compiler settings just makes the compiler standard conforming
+	add_definitions(/Zc:wchar_t /Zc:forScope)
+# for multi-core compilation
+	add_definitions(/MP)
+
+#$(SolutionDir)<toolset>msvc,<variant>release:<linkflags>/OPT:ICF=5
+#$(SolutionDir)<toolset>msvc,<variant>release:<linkflags>/OPT:REF
+else()
+	add_definitions(-Wno-c++11-extensions)
+endif()
+
+add_definitions(-D_FILE_OFFSET_BITS=64)
+add_definitions(-DBOOST_EXCEPTION_DISABLE)
+add_definitions(-DBOOST_ASIO_ENABLE_CANCELIO)
+
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	add_definitions(-fcolor-diagnostics)
+endif()
+
+if (tcmalloc)
+	target_link_libraries(torrent-rasterbar tcmalloc)
+endif()
+
+set_target_properties(torrent-rasterbar PROPERTIES
+	SOVERSION ${SOVERSION})
+
+get_property (COMPILETIME_OPTIONS_LIST
+	DIRECTORY ${CMAKE_CURRENT_SOURCE_DIRECTORY}
+	PROPERTY COMPILE_DEFINITIONS
+	)
+foreach (s ${COMPILETIME_OPTIONS_LIST})
+	set (COMPILETIME_OPTIONS "${COMPILETIME_OPTIONS} -D${s}")
+endforeach (s)
+
+configure_file(libtorrent-rasterbar-cmake.pc.in libtorrent-rasterbar.pc)
+
+string (COMPARE EQUAL "${CMAKE_SIZEOF_VOID_P}" "8" IS64BITS)
+
+if (IS64BITS AND RESPECTLIB64)
+	set (LIBDIR "lib64")
+else()
+	set (LIBDIR "lib")
+endif()
+
+install(TARGETS torrent-rasterbar DESTINATION ${LIBDIR})
+install(DIRECTORY include/libtorrent
+	DESTINATION include
+	PATTERN ".svn" EXCLUDE)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libtorrent-rasterbar.pc DESTINATION ${LIBDIR}/pkgconfig)
+
+# === set up examples directory as an independent project ===
+#file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/examples)
+#configure_file(examples/run_cmake.sh.in examples/run_cmake.sh)
+# to build the examples, run examples/run_cmake.sh after building libtorrent
+
+# === build tests ===
+if(build_tests)
+	FILE(GLOB tests RELATIVE "${PROJECT_SOURCE_DIR}" "test/test_*.cpp")
+	add_library(test_common STATIC test/main.cpp test/setup_transfer.cpp
+		test/dht_server.cpp test/udp_tracker.cpp test/peer_server.cpp
+		test/web_seed_suite.cpp)
+	enable_testing()
+
+	foreach(s ${tests})
+		get_filename_component (sn ${s} NAME_WE)
+		add_executable(${sn} ${s})
+		target_link_libraries(${sn} torrent-rasterbar test_common)
+		add_test(${sn} ${s})
+	endforeach(s)
+
+#	add_executable(test_upnp test/test_upnp.cpp)
+#	target_link_libraries(test_upnp torrent-rasterbar)
+
+#	add_executable(test_natpmp test/test_natpmp.cpp)
+#	target_link_libraries(test_natpmp torrent-rasterbar)
+endif()

apps/Launcher/ext/libtorrent/COPYING

+Copyright (c) 2003-2014, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution.
+    * Neither the name of Rasterbar Software nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+

apps/Launcher/ext/libtorrent/LICENSE

+Copyright (c) 2003-2014, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+------------------------------------------------------------------------------
+
+puff.c
+Copyright (C) 2002, 2003 Mark Adler
+For conditions of distribution and use, see copyright notice in puff.h
+version 1.7, 3 Mar 2003
+
+puff.c is a simple inflate written to be an unambiguous way to specify the
+deflate format.  It is not written for speed but rather simplicity.  As a
+side benefit, this code might actually be useful when small code is more
+important than speed, such as bootstrap applications.  For typical deflate
+data, zlib's inflate() is about four times as fast as puff().  zlib's
+inflate compiles to around 20K on my machine, whereas puff.c compiles to
+around 4K on my machine (a PowerPC using GNU cc).  If the faster decode()
+function here is used, then puff() is only twice as slow as zlib's
+inflate().
+
+All dynamically allocated memory comes from the stack.  The stack required
+is less than 2K bytes.  This code is compatible with 16-bit int's and
+assumes that long's are at least 32 bits.  puff.c uses the short data type,
+assumed to be 16 bits, for arrays in order to to conserve memory.  The code
+works whether integers are stored big endian or little endian.
+
+In the comments below are "Format notes" that describe the inflate process
+and document some of the less obvious aspects of the format.  This source
+code is meant to supplement RFC 1951, which formally describes the deflate
+format:
+
+   http://www.zlib.org/rfc-deflate.html
+
+------------------------------------------------------------------------------
+
+GeoIP.c
+
+Copyright (C) 2006 MaxMind LLC
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+------------------------------------------------------------------------------
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

apps/Launcher/ext/libtorrent/NEWS

+See ChangeLog

apps/Launcher/ext/libtorrent/README

+libtorrent is an open source C++ library implementing the BitTorrent protocol,
+along with most popular extensions, making it suitable for real world
+deployment. It is configurable to be able to fit both servers and embedded
+devices.
+
+The main goals of libtorrent are to be efficient and easy to use.
+
+See docs/index.html for more detailed build and usage instructions.
+
+To build with boost-build, run:
+
+   b2
+
+See docs/building.html for more details on how to build and which configuration
+options are available.
+

apps/Launcher/ext/libtorrent/ed25519/readme.md

+Ed25519
+=======
+
+This is a portable implementation of [Ed25519](http://ed25519.cr.yp.to/) based
+on the SUPERCOP "ref10" implementation. Additionally there is key exchanging
+and scalar addition included to further aid building a PKI using Ed25519. All
+code is in the public domain.
+
+All code is pure ANSI C without any dependencies, except for the random seed
+generation which uses standard OS cryptography APIs (`CryptGenRandom` on
+Windows, `/dev/urandom` on nix). If you wish to be entirely portable define
+`ED25519_NO_SEED`. This disables the `ed25519_create_seed` function, so if your
+application requires key generation you must supply your own seeding function
+(which is simply a 256 bit (32 byte) cryptographic random number generator).
+
+
+Performance
+-----------
+
+On a Windows machine with an Intel Pentium B970 @ 2.3GHz I got the following
+speeds (running on only one a single core):
+
+    Seed generation: 64us (15625 per second)
+    Key generation: 88us (11364 per second)
+    Message signing (short message): 87us (11494 per second)
+    Message verifying (short message): 228us (4386 per second)
+    Scalar addition: 100us (10000 per second)
+    Key exchange: 220us (4545 per second)
+
+The speeds on other machines may vary. Sign/verify times will be higher with
+longer messages. The implementation significantly benefits from 64 bit
+architectures, if possible compile as 64 bit.
+
+
+Usage
+-----
+
+Simply add all .c and .h files in the `src/` folder to your project and include
+`ed25519.h` in any file you want to use the API. If you prefer to use a shared
+library, only copy `ed25519.h` and define `ED25519_DLL` before importing. A
+windows DLL is pre-built.
+
+There are no defined types for seeds, private keys, public keys, shared secrets
+or signatures. Instead simple `unsigned char` buffers are used with the
+following sizes:
+
+```c
+unsigned char seed[32];
+unsigned char signature[64];
+unsigned char public_key[32];
+unsigned char private_key[64];
+unsigned char scalar[32];
+unsigned char shared_secret[32];
+```
+
+API
+---
+
+```c
+int ed25519_create_seed(unsigned char *seed);
+```
+
+Creates a 32 byte random seed in `seed` for key generation. `seed` must be a
+writable 32 byte buffer. Returns 0 on success, and nonzero on failure.
+
+```c
+void ed25519_create_keypair(unsigned char *public_key, unsigned char *private_key, const unsigned char *seed);
+```
+
+Creates a new key pair from the given seed. `public_key` must be a writable 32
+byte buffer, `private_key` must be a writable 64 byte buffer and `seed` must be
+a 32 byte buffer.
+
+```c
+void ed25519_sign(unsigned char *signature,
+                  const unsigned char *message, size_t message_len,
+                  const unsigned char *public_key, const unsigned char *private_key);
+```
+
+Creates a signature of the given message with the given key pair. `signature`
+must be a writable 64 byte buffer. `message` must have at least `message_len`
+bytes to be read. 
+
+```c
+int ed25519_verify(const unsigned char *signature,
+                   const unsigned char *message, size_t message_len,
+                   const unsigned char *public_key);
+```
+
+Verifies the signature on the given message using `public_key`. `signature`
+must be a readable 64 byte buffer. `message` must have at least `message_len`
+bytes to be read. Returns 1 if the signature matches, 0 otherwise.
+
+```c
+void ed25519_add_scalar(unsigned char *public_key, unsigned char *private_key,
+                        const unsigned char *scalar);
+```
+
+Adds `scalar` to the given key pair where scalar is a 32 byte buffer (possibly
+generated with `ed25519_create_seed`), generating a new key pair. You can
+calculate the public key sum without knowing the private key and vice versa by
+passing in `NULL` for the key you don't know. This is useful for enforcing
+randomness on a key pair by a third party while only knowing the public key,
+among other things.  Warning: the last bit of the scalar is ignored - if
+comparing scalars make sure to clear it with `scalar[31] &= 127`.
+
+
+```c
+void ed25519_key_exchange(unsigned char *shared_secret,
+                          const unsigned char *public_key, const unsigned char *private_key);
+```
+
+Performs a key exchange on the given public key and private key, producing a
+shared secret. It is recommended to hash the shared secret before using it.
+`shared_secret` must be a 32 byte writable buffer where the shared secret will
+be stored.
+
+Example
+-------
+
+```c
+unsigned char seed[32], public_key[32], private_key[64], signature[64];
+unsigned char other_public_key[32], other_private_key[64], shared_secret[32];
+const unsigned char message[] = "TEST MESSAGE";
+
+/* create a random seed, and a key pair out of that seed */
+if (ed25519_create_seed(seed)) {
+    printf("error while generating seed\n");
+    exit(1);
+}
+
+ed25519_create_keypair(public_key, private_key, seed);
+
+/* create signature on the message with the key pair */
+ed25519_sign(signature, message, strlen(message), public_key, private_key);
+
+/* verify the signature */
+if (ed25519_verify(signature, message, strlen(message), public_key)) {
+    printf("valid signature\n");
+} else {
+    printf("invalid signature\n");
+}
+
+/* create a dummy keypair to use for a key exchange, normally you'd only have
+the public key and receive it through some communication channel */
+if (ed25519_create_seed(seed)) {
+    printf("error while generating seed\n");
+    exit(1);
+}
+
+ed25519_create_keypair(other_public_key, other_private_key, seed);
+
+/* do a key exchange with other_public_key */
+ed25519_key_exchange(shared_secret, other_public_key, private_key);
+
+/* 
+    the magic here is that ed25519_key_exchange(shared_secret, public_key,
+    other_private_key); would result in the same shared_secret
+*/
+
+```
+
+License
+-------
+All code is in the public domain.

apps/Launcher/ext/libtorrent/ed25519/src/add_scalar.cpp

+#include "libtorrent/ed25519.hpp"
+#include "ge.h"
+#include "sc.h"
+
+
+/* see http://crypto.stackexchange.com/a/6215/4697 */
+void ed25519_add_scalar(unsigned char *public_key, unsigned char *private_key, const unsigned char *scalar) {
+    const unsigned char SC_1[32] = {1}; /* scalar with value 1 */
+    
+    unsigned char n[32]; 
+    ge_p3 nB;
+    ge_p1p1 A_p1p1;
+    ge_p3 A;
+    ge_p3 public_key_unpacked;
+    ge_cached T;
+
+    int i;
+
+    /* copy the scalar and clear highest bit */
+    for (i = 0; i < 31; ++i) {
+        n[i] = scalar[i];
+    }
+    n[31] = scalar[31] & 127;
+
+    /* private key: a = n + t */
+    if (private_key) {
+        sc_muladd(private_key, SC_1, n, private_key);
+    }
+
+    /* public key: A = nB + T */
+    if (public_key) {
+        /* if we know the private key we don't need a point addition, which is faster */
+        /* using a "timing attack" you could find out wether or not we know the private
+           key, but this information seems rather useless - if this is important pass
+           public_key and private_key seperately in 2 function calls */
+        if (private_key) {
+            ge_scalarmult_base(&A, private_key);
+        } else {
+            /* unpack public key into T */
+            ge_frombytes_negate_vartime(&public_key_unpacked, public_key);
+            fe_neg(public_key_unpacked.X, public_key_unpacked.X); // undo negate
+            fe_neg(public_key_unpacked.T, public_key_unpacked.T); // undo negate
+            ge_p3_to_cached(&T, &public_key_unpacked);
+
+            /* calculate n*B */
+            ge_scalarmult_base(&nB, n);
+
+            /* A = n*B + T */
+            ge_add(&A_p1p1, &nB, &T);
+            ge_p1p1_to_p3(&A, &A_p1p1);
+        }
+            
+        /* pack public key */
+        ge_p3_tobytes(public_key, &A);
+    }
+}

apps/Launcher/ext/libtorrent/ed25519/src/fe.h

+#ifndef FE_H
+#define FE_H
+
+#include "fixedint.h"
+
+
+/*
+    fe means field element.
+    Here the field is \Z/(2^255-19).
+    An element t, entries t[0]...t[9], represents the integer
+    t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9].
+    Bounds on each t[i] vary depending on context.
+*/
+
+
+typedef int32_t fe[10];
+
+
+void fe_0(fe h);
+void fe_1(fe h);
+
+void fe_frombytes(fe h, const unsigned char *s);
+void fe_tobytes(unsigned char *s, const fe h);
+
+void fe_copy(fe h, const fe f);
+int fe_isnegative(const fe f);
+int fe_isnonzero(const fe f);
+void fe_cmov(fe f, const fe g, unsigned int b);
+void fe_cswap(fe f, fe g, unsigned int b);
+
+void fe_neg(fe h, const fe f);
+void fe_add(fe h, const fe f, const fe g);
+void fe_invert(fe out, const fe z);
+void fe_sq(fe h, const fe f);
+void fe_sq2(fe h, const fe f);
+void fe_mul(fe h, const fe f, const fe g);
+void fe_mul121666(fe h, fe f);
+void fe_pow22523(fe out, const fe z);
+void fe_sub(fe h, const fe f, const fe g);
+
+#endif

apps/Launcher/ext/libtorrent/ed25519/src/fixedint.h

+#include <boost/cstdint.hpp>
+
+using boost::uint64_t;
+using boost::int64_t;
+using boost::int32_t;
+

apps/Launcher/ext/libtorrent/ed25519/src/ge.cpp

+#include "ge.h"
+#include "precomp_data.h"
+
+
+/*
+r = p + q
+*/
+
+void ge_add(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q) {
+    fe t0;
+    fe_add(r->X, p->Y, p->X);
+    fe_sub(r->Y, p->Y, p->X);
+    fe_mul(r->Z, r->X, q->YplusX);
+    fe_mul(r->Y, r->Y, q->YminusX);
+    fe_mul(r->T, q->T2d, p->T);
+    fe_mul(r->X, p->Z, q->Z);
+    fe_add(t0, r->X, r->X);
+    fe_sub(r->X, r->Z, r->Y);
+    fe_add(r->Y, r->Z, r->Y);
+    fe_add(r->Z, t0, r->T);
+    fe_sub(r->T, t0, r->T);
+}
+
+
+static void slide(signed char *r, const unsigned char *a) {
+    int i;
+    int b;
+    int k;
+
+    for (i = 0; i < 256; ++i) {
+        r[i] = 1 & (a[i >> 3] >> (i & 7));
+    }
+
+    for (i = 0; i < 256; ++i)
+        if (r[i]) {
+            for (b = 1; b <= 6 && i + b < 256; ++b) {
+                if (r[i + b]) {
+                    if (r[i] + (r[i + b] << b) <= 15) {
+                        r[i] += r[i + b] << b;
+                        r[i + b] = 0;
+                    } else if (r[i] - (r[i + b] << b) >= -15) {
+                        r[i] -= r[i + b] << b;
+
+                        for (k = i + b; k < 256; ++k) {
+                            if (!r[k]) {
+                                r[k] = 1;
+                                break;
+                            }
+
+                            r[k] = 0;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+}
+
+/*
+r = a * A + b * B
+where a = a[0]+256*a[1]+...+256^31 a[31].
+and b = b[0]+256*b[1]+...+256^31 b[31].
+B is the Ed25519 base point (x,4/5) with x positive.
+*/
+
+void ge_double_scalarmult_vartime(ge_p2 *r, const unsigned char *a, const ge_p3 *A, const unsigned char *b) {
+    signed char aslide[256];
+    signed char bslide[256];
+    ge_cached Ai[8]; /* A,3A,5A,7A,9A,11A,13A,15A */
+    ge_p1p1 t;
+    ge_p3 u;
+    ge_p3 A2;
+    int i;
+    slide(aslide, a);
+    slide(bslide, b);
+    ge_p3_to_cached(&Ai[0], A);
+    ge_p3_dbl(&t, A);
+    ge_p1p1_to_p3(&A2, &t);
+    ge_add(&t, &A2, &Ai[0]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[1], &u);
+    ge_add(&t, &A2, &Ai[1]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[2], &u);
+    ge_add(&t, &A2, &Ai[2]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[3], &u);
+    ge_add(&t, &A2, &Ai[3]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[4], &u);
+    ge_add(&t, &A2, &Ai[4]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[5], &u);
+    ge_add(&t, &A2, &Ai[5]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[6], &u);
+    ge_add(&t, &A2, &Ai[6]);
+    ge_p1p1_to_p3(&u, &t);
+    ge_p3_to_cached(&Ai[7], &u);
+    ge_p2_0(r);
+
+    for (i = 255; i >= 0; --i) {
+        if (aslide[i] || bslide[i]) {
+            break;
+        }
+    }
+
+    for (; i >= 0; --i) {
+        ge_p2_dbl(&t, r);
+
+        if (aslide[i] > 0) {
+            ge_p1p1_to_p3(&u, &t);
+            ge_add(&t, &u, &Ai[aslide[i] / 2]);
+        } else if (aslide[i] < 0) {
+            ge_p1p1_to_p3(&u, &t);
+            ge_sub(&t, &u, &Ai[(-aslide[i]) / 2]);
+        }
+
+        if (bslide[i] > 0) {
+            ge_p1p1_to_p3(&u, &t);
+            ge_madd(&t, &u, &Bi[bslide[i] / 2]);
+        } else if (bslide[i] < 0) {
+            ge_p1p1_to_p3(&u, &t);
+            ge_msub(&t, &u, &Bi[(-bslide[i]) / 2]);
+        }
+
+        ge_p1p1_to_p2(r, &t);
+    }
+}
+
+
+static const fe d = {
+    -10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116
+};
+
+static const fe sqrtm1 = {
+    -32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482
+};
+
+int ge_frombytes_negate_vartime(ge_p3 *h, const unsigned char *s) {
+    fe u;
+    fe v;
+    fe v3;
+    fe vxx;
+    fe check;
+    fe_frombytes(h->Y, s);
+    fe_1(h->Z);
+    fe_sq(u, h->Y);
+    fe_mul(v, u, d);
+    fe_sub(u, u, h->Z);     /* u = y^2-1 */
+    fe_add(v, v, h->Z);     /* v = dy^2+1 */
+    fe_sq(v3, v);
+    fe_mul(v3, v3, v);      /* v3 = v^3 */
+    fe_sq(h->X, v3);
+    fe_mul(h->X, h->X, v);
+    fe_mul(h->X, h->X, u);  /* x = uv^7 */
+    fe_pow22523(h->X, h->X); /* x = (uv^7)^((q-5)/8) */
+    fe_mul(h->X, h->X, v3);
+    fe_mul(h->X, h->X, u);  /* x = uv^3(uv^7)^((q-5)/8) */
+    fe_sq(vxx, h->X);
+    fe_mul(vxx, vxx, v);
+    fe_sub(check, vxx, u);  /* vx^2-u */
+
+    if (fe_isnonzero(check)) {
+        fe_add(check, vxx, u); /* vx^2+u */
+
+        if (fe_isnonzero(check)) {
+            return -1;
+        }
+
+        fe_mul(h->X, h->X, sqrtm1);
+    }
+
+    if (fe_isnegative(h->X) == (s[31] >> 7)) {
+        fe_neg(h->X, h->X);
+    }
+
+    fe_mul(h->T, h->X, h->Y);
+    return 0;
+}
+
+
+/*
+r = p + q
+*/
+
+void ge_madd(ge_p1p1 *r, const ge_p3 *p, const ge_precomp *q) {
+    fe t0;
+    fe_add(r->X, p->Y, p->X);
+    fe_sub(r->Y, p->Y, p->X);
+    fe_mul(r->Z, r->X, q->yplusx);
+    fe_mul(r->Y, r->Y, q->yminusx);
+    fe_mul(r->T, q->xy2d, p->T);
+    fe_add(t0, p->Z, p->Z);
+    fe_sub(r->X, r->Z, r->Y);
+    fe_add(r->Y, r->Z, r->Y);
+    fe_add(r->Z, t0, r->T);
+    fe_sub(r->T, t0, r->T);
+}
+
+
+/*
+r = p - q
+*/
+
+void ge_msub(ge_p1p1 *r, const ge_p3 *p, const ge_precomp *q) {
+    fe t0;
+
+    fe_add(r->X, p->Y, p->X);
+    fe_sub(r->Y, p->Y, p->X);
+    fe_mul(r->Z, r->X, q->yminusx);
+    fe_mul(r->Y, r->Y, q->yplusx);
+    fe_mul(r->T, q->xy2d, p->T);
+    fe_add(t0, p->Z, p->Z);
+    fe_sub(r->X, r->Z, r->Y);
+    fe_add(r->Y, r->Z, r->Y);
+    fe_sub(r->Z, t0, r->T);
+    fe_add(r->T, t0, r->T);
+}
+
+
+/*
+r = p
+*/
+
+void ge_p1p1_to_p2(ge_p2 *r, const ge_p1p1 *p) {
+    fe_mul(r->X, p->X, p->T);
+    fe_mul(r->Y, p->Y, p->Z);
+    fe_mul(r->Z, p->Z, p->T);
+}
+
+
+
+/*
+r = p
+*/
+
+void ge_p1p1_to_p3(ge_p3 *r, const ge_p1p1 *p) {
+    fe_mul(r->X, p->X, p->T);
+    fe_mul(r->Y, p->Y, p->Z);
+    fe_mul(r->Z, p->Z, p->T);
+    fe_mul(r->T, p->X, p->Y);
+}
+
+
+void ge_p2_0(ge_p2 *h) {
+    fe_0(h->X);
+    fe_1(h->Y);
+    fe_1(h->Z);
+}
+
+
+
+/*
+r = 2 * p
+*/
+
+void ge_p2_dbl(ge_p1p1 *r, const ge_p2 *p) {
+    fe t0;
+
+    fe_sq(r->X, p->X);
+    fe_sq(r->Z, p->Y);
+    fe_sq2(r->T, p->Z);
+    fe_add(r->Y, p->X, p->Y);
+    fe_sq(t0, r->Y);
+    fe_add(r->Y, r->Z, r->X);
+    fe_sub(r->Z, r->Z, r->X);
+    fe_sub(r->X, t0, r->Y);
+    fe_sub(r->T, r->T, r->Z);
+}
+
+
+void ge_p3_0(ge_p3 *h) {
+    fe_0(h->X);
+    fe_1(h->Y);
+    fe_1(h->Z);
+    fe_0(h->T);
+}
+
+
+/*
+r = 2 * p
+*/
+
+void ge_p3_dbl(ge_p1p1 *r, const ge_p3 *p) {
+    ge_p2 q;
+    ge_p3_to_p2(&q, p);
+    ge_p2_dbl(r, &q);
+}
+
+
+
+/*
+r = p
+*/
+
+static const fe d2 = {
+    -21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199
+};
+
+void ge_p3_to_cached(ge_cached *r, const ge_p3 *p) {
+    fe_add(r->YplusX, p->Y, p->X);
+    fe_sub(r->YminusX, p->Y, p->X);
+    fe_copy(r->Z, p->Z);
+    fe_mul(r->T2d, p->T, d2);
+}
+
+
+/*
+r = p
+*/
+
+void ge_p3_to_p2(ge_p2 *r, const ge_p3 *p) {
+    fe_copy(r->X, p->X);
+    fe_copy(r->Y, p->Y);
+    fe_copy(r->Z, p->Z);
+}
+
+
+void ge_p3_tobytes(unsigned char *s, const ge_p3 *h) {
+    fe recip;
+    fe x;
+    fe y;
+    fe_invert(recip, h->Z);
+    fe_mul(x, h->X, recip);
+    fe_mul(y, h->Y, recip);
+    fe_tobytes(s, y);
+    s[31] ^= fe_isnegative(x) << 7;
+}
+
+
+static unsigned char equal(signed char b, signed char c) {
+    unsigned char ub = b;
+    unsigned char uc = c;
+    unsigned char x = ub ^ uc; /* 0: yes; 1..255: no */
+    uint64_t y = x; /* 0: yes; 1..255: no */
+    y -= 1; /* large: yes; 0..254: no */
+    y >>= 63; /* 1: yes; 0: no */
+    return (unsigned char) y;
+}
+
+static unsigned char negative(signed char b) {
+    uint64_t x = b; /* 18446744073709551361..18446744073709551615: yes; 0..255: no */
+    x >>= 63; /* 1: yes; 0: no */
+    return (unsigned char) x;
+}
+
+static void cmov(ge_precomp *t, ge_precomp *u, unsigned char b) {
+    fe_cmov(t->yplusx, u->yplusx, b);
+    fe_cmov(t->yminusx, u->yminusx, b);
+    fe_cmov(t->xy2d, u->xy2d, b);
+}
+
+
+static void select(ge_precomp *t, int pos, signed char b) {
+    ge_precomp minust;
+    unsigned char bnegative = negative(b);
+    unsigned char babs = b - (((-bnegative) & b) << 1);
+    fe_1(t->yplusx);
+    fe_1(t->yminusx);
+    fe_0(t->xy2d);
+    cmov(t, &base[pos][0], equal(babs, 1));
+    cmov(t, &base[pos][1], equal(babs, 2));
+    cmov(t, &base[pos][2], equal(babs, 3));
+    cmov(t, &base[pos][3], equal(babs, 4));
+    cmov(t, &base[pos][4], equal(babs, 5));
+    cmov(t, &base[pos][5], equal(babs, 6));
+    cmov(t, &base[pos][6], equal(babs, 7));
+    cmov(t, &base[pos][7], equal(babs, 8));
+    fe_copy(minust.yplusx, t->yminusx);
+    fe_copy(minust.yminusx, t->yplusx);
+    fe_neg(minust.xy2d, t->xy2d);
+    cmov(t, &minust, bnegative);
+}
+
+/*
+h = a * B
+where a = a[0]+256*a[1]+...+256^31 a[31]
+B is the Ed25519 base point (x,4/5) with x positive.
+
+Preconditions:
+  a[31] <= 127
+*/
+
+void ge_scalarmult_base(ge_p3 *h, const unsigned char *a) {
+    signed char e[64];
+    signed char carry;
+    ge_p1p1 r;
+    ge_p2 s;
+    ge_precomp t;
+    int i;
+
+    for (i = 0; i < 32; ++i) {
+        e[2 * i + 0] = (a[i] >> 0) & 15;
+        e[2 * i + 1] = (a[i] >> 4) & 15;
+    }
+
+    /* each e[i] is between 0 and 15 */
+    /* e[63] is between 0 and 7 */
+    carry = 0;
+
+    for (i = 0; i < 63; ++i) {
+        e[i] += carry;
+        carry = e[i] + 8;
+        carry >>= 4;
+        e[i] -= carry << 4;
+    }
+
+    e[63] += carry;
+    /* each e[i] is between -8 and 8 */
+    ge_p3_0(h);
+
+    for (i = 1; i < 64; i += 2) {
+        select(&t, i / 2, e[i]);
+        ge_madd(&r, h, &t);
+        ge_p1p1_to_p3(h, &r);
+    }
+
+    ge_p3_dbl(&r, h);
+    ge_p1p1_to_p2(&s, &r);
+    ge_p2_dbl(&r, &s);
+    ge_p1p1_to_p2(&s, &r);
+    ge_p2_dbl(&r, &s);
+    ge_p1p1_to_p2(&s, &r);
+    ge_p2_dbl(&r, &s);
+    ge_p1p1_to_p3(h, &r);
+
+    for (i = 0; i < 64; i += 2) {
+        select(&t, i / 2, e[i]);
+        ge_madd(&r, h, &t);
+        ge_p1p1_to_p3(h, &r);
+    }
+}
+
+
+/*
+r = p - q
+*/
+
+void ge_sub(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q) {
+    fe t0;
+    
+    fe_add(r->X, p->Y, p->X);
+    fe_sub(r->Y, p->Y, p->X);
+    fe_mul(r->Z, r->X, q->YminusX);
+    fe_mul(r->Y, r->Y, q->YplusX);
+    fe_mul(r->T, q->T2d, p->T);
+    fe_mul(r->X, p->Z, q->Z);
+    fe_add(t0, r->X, r->X);
+    fe_sub(r->X, r->Z, r->Y);
+    fe_add(r->Y, r->Z, r->Y);
+    fe_sub(r->Z, t0, r->T);
+    fe_add(r->T, t0, r->T);
+}
+
+
+void ge_tobytes(unsigned char *s, const ge_p2 *h) {
+    fe recip;
+    fe x;
+    fe y;
+    fe_invert(recip, h->Z);
+    fe_mul(x, h->X, recip);
+    fe_mul(y, h->Y, recip);
+    fe_tobytes(s, y);
+    s[31] ^= fe_isnegative(x) << 7;
+}

apps/Launcher/ext/libtorrent/ed25519/src/ge.h

+#ifndef GE_H
+#define GE_H
+
+#include "fe.h"
+
+
+/*
+ge means group element.
+
+Here the group is the set of pairs (x,y) of field elements (see fe.h)
+satisfying -x^2 + y^2 = 1 + d x^2y^2
+where d = -121665/121666.
+
+Representations:
+  ge_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z
+  ge_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+  ge_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+  ge_precomp (Duif): (y+x,y-x,2dxy)
+*/
+
+typedef struct {
+  fe X;
+  fe Y;
+  fe Z;
+} ge_p2;
+
+typedef struct {
+  fe X;
+  fe Y;
+  fe Z;
+  fe T;
+} ge_p3;
+
+typedef struct {
+  fe X;
+  fe Y;
+  fe Z;
+  fe T;
+} ge_p1p1;
+
+typedef struct {
+  fe yplusx;
+  fe yminusx;
+  fe xy2d;
+} ge_precomp;
+
+typedef struct {
+  fe YplusX;
+  fe YminusX;
+  fe Z;
+  fe T2d;
+} ge_cached;
+
+void ge_p3_tobytes(unsigned char *s, const ge_p3 *h);
+void ge_tobytes(unsigned char *s, const ge_p2 *h);
+int ge_frombytes_negate_vartime(ge_p3 *h, const unsigned char *s);
+
+void ge_add(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q);
+void ge_sub(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q);
+void ge_double_scalarmult_vartime(ge_p2 *r, const unsigned char *a, const ge_p3 *A, const unsigned char *b);
+void ge_madd(ge_p1p1 *r, const ge_p3 *p, const ge_precomp *q);
+void ge_msub(ge_p1p1 *r, const ge_p3 *p, const ge_precomp *q);
+void ge_scalarmult_base(ge_p3 *h, const unsigned char *a);
+
+void ge_p1p1_to_p2(ge_p2 *r, const ge_p1p1 *p);
+void ge_p1p1_to_p3(ge_p3 *r, const ge_p1p1 *p);
+void ge_p2_0(ge_p2 *h);
+void ge_p2_dbl(ge_p1p1 *r, const ge_p2 *p);
+void ge_p3_0(ge_p3 *h);
+void ge_p3_dbl(ge_p1p1 *r, const ge_p3 *p);
+void ge_p3_to_cached(ge_cached *r, const ge_p3 *p);
+void ge_p3_to_p2(ge_p2 *r, const ge_p3 *p);
+
+#endif

apps/Launcher/ext/libtorrent/ed25519/src/key_exchange.cpp

+#include "libtorrent/ed25519.hpp"
+#include "fe.h"
+
+void ed25519_key_exchange(unsigned char *shared_secret
+	, const unsigned char *public_key, const unsigned char *private_key) {
+    unsigned char e[32];
+    unsigned int i;
+    
+    fe x1;
+    fe x2;
+    fe z2;
+    fe x3;
+    fe z3;
+    fe tmp0;
+    fe tmp1;
+
+    int pos;
+    unsigned int swap;
+    unsigned int b;
+
+    /* copy the private key and make sure it's valid */
+    for (i = 0; i < 32; ++i) {
+        e[i] = private_key[i];
+    }
+
+    e[0] &= 248;
+    e[31] &= 63;
+    e[31] |= 64;
+
+    /* unpack the public key and convert edwards to montgomery */
+    /* due to CodesInChaos: montgomeryX = (edwardsY + 1)*inverse(1 - edwardsY) mod p */
+    fe_frombytes(x1, public_key);
+    fe_1(tmp1);
+    fe_add(tmp0, x1, tmp1);
+    fe_sub(tmp1, tmp1, x1);
+    fe_invert(tmp1, tmp1);
+    fe_mul(x1, tmp0, tmp1);
+
+    fe_1(x2);
+    fe_0(z2);
+    fe_copy(x3, x1);
+    fe_1(z3);
+
+    swap = 0;
+    for (pos = 254; pos >= 0; --pos) {
+        b = e[pos / 8] >> (pos & 7);
+        b &= 1;
+        swap ^= b;
+        fe_cswap(x2, x3, swap);
+        fe_cswap(z2, z3, swap);
+        swap = b;
+
+        /* from montgomery.h */
+        fe_sub(tmp0, x3, z3);
+        fe_sub(tmp1, x2, z2);
+        fe_add(x2, x2, z2);
+        fe_add(z2, x3, z3);
+        fe_mul(z3, tmp0, x2);
+        fe_mul(z2, z2, tmp1);
+        fe_sq(tmp0, tmp1);
+        fe_sq(tmp1, x2);
+        fe_add(x3, z3, z2);
+        fe_sub(z2, z3, z2);
+        fe_mul(x2, tmp1, tmp0);
+        fe_sub(tmp1, tmp1, tmp0);
+        fe_sq(z2, z2);
+        fe_mul121666(z3, tmp1);
+        fe_sq(x3, x3);
+        fe_add(tmp0, tmp0, z3);
+        fe_mul(z3, x1, z2);
+        fe_mul(z2, tmp1, tmp0);
+    }
+
+    fe_cswap(x2, x3, swap);
+    fe_cswap(z2, z3, swap);
+
+    fe_invert(z2, z2);
+    fe_mul(x2, x2, z2);
+    fe_tobytes(shared_secret, x2);
+}

apps/Launcher/ext/libtorrent/ed25519/src/keypair.cpp

+#include "libtorrent/ed25519.hpp"
+#include "sha512.h"
+#include "ge.h"
+
+
+void ed25519_create_keypair(unsigned char *public_key, unsigned char *private_key, const unsigned char *seed) {
+    ge_p3 A;
+
+    sha512(seed, 32, private_key);
+    private_key[0] &= 248;
+    private_key[31] &= 63;
+    private_key[31] |= 64;
+
+    ge_scalarmult_base(&A, private_key);
+    ge_p3_tobytes(public_key, &A);
+}

apps/Launcher/ext/libtorrent/ed25519/src/sc.h

+#ifndef SC_H
+#define SC_H
+
+/*
+The set of scalars is \Z/l
+where l = 2^252 + 27742317777372353535851937790883648493.
+*/
+
+void sc_reduce(unsigned char *s);
+void sc_muladd(unsigned char *s, const unsigned char *a, const unsigned char *b, const unsigned char *c);
+
+#endif
+