andrei/amnezia-client
1
0
Fork 0
mirror of https://github.com/amnezia-vpn/amnezia-client.git synced 2026-06-23 02:00:20 +07:00
Code Issues Packages Projects Releases 10 Wiki Activity

feat: macos full feature conan build, except ss and cloak

Browse Source
This commit is contained in:
Yaroslav Gurov
2026-03-03 01:29:03 +01:00
parent 0bfbd82536
commit 616d58e901
20 changed files with 520 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files
recipes/amnezia-libxray/conanfile.py
+47
View File
@@ -0,0 +1,47 @@
from conan import ConanFile
from conan.tools.files import get, copy
from conan.tools.layout import basic_layout
from conan.errors import ConanInvalidConfiguration
from conan.tools.env import VirtualBuildEnv
import os
import stat
class AmneziaLibxray(ConanFile):
name = "amnezia-libxray"
version = "1.0.0"
settings = "os", "arch"
def layout(self):
basic_layout(self, build_folder=".")
def build_requirements(self):
self.tool_requires("go/1.26.0")
def validate(self):
if self.settings.os != "Android":
raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
def source(self):
get(self, "https://github.com/amnezia-vpn/amnezia-libxray/archive/refs/tags/v1.0.0.zip",
sha256="0c50c5acd5063a9fc3cfbb5b3e11481d30cfa3762b3cb1d72130248ff498e9df", strip_root=True
)
def generate(self):
env = VirtualBuildEnv(self)
def _patch_sources(self):
build_path = os.path.join(self.build_folder, "build.sh")
build_stat = os.stat(build_path)
os.chmod(build_path, build_stat.st_mode | stat.S_IEXEC)
def build(self):
self._patch_sources()
self.run("./build.sh android")
def package(self):
copy(self, "libxray.aar", src=self.build_folder, dst=os.path.join(self.package_folder, "aar"))
def package_info(self):
self.env_info["AMNEZIA_LIBXRAY_PATH"] = os.path.join(self.package_folder, "aar", "libxray.aar")
recipes/amnezia-xray-bindings/conanfile.py
+19 -19
View File
@@ -18,7 +18,6 @@ class AmneziaXrayBindings(ConanFile):
"Macos": "macos",
"Windows": "windows"
}
_arch_map = {
"x86": "386",
"x86_64": "amd64",
@@ -26,24 +25,26 @@ class AmneziaXrayBindings(ConanFile):
}
def validate(self):
os = str(self.settings.os)
if os not in self._os_map:
self._goos = self._os_map.get(str(self.settings.os))
if not self._goos:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {os}"
f"{self.name} v{self.version} does not support {self._goos}"
)
arch = str(self.settings.arch)
if arch not in self._arch_map:
self._goarch = self._arch_map.get(str(self.settings.arch))
if not self._goarch:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {arch}"
f"{self.name} v{self.version} does not support {self._goarch}"
)
def layout(self):
basic_layout(self, build_folder=os.path.join(self.folders.source, "build"))
basic_layout(self, build_folder=".")
def build_requirements(self):
self.tool_requires("go/1.26.0")
if self.settings.os != "Windows":
if self.settings.os == "Windows":
self.tool_requires("mingw-builds/15.1.0")
else:
self.build_requires("make/4.4.1")
def source(self):
@@ -51,17 +52,9 @@ class AmneziaXrayBindings(ConanFile):
sha256="6ea768ec7002cedd422a39aea17704b888acaf794432aa5937cfc92fb6d80eb5", strip_root=True)
def build(self):
os = self._os_map.get(str(self.settings.os))
arch = self._arch_map.get(str(self.settings.arch))
self.run(f"ARCH={arch} OS={os} make -C {self.source_folder}")
def package(self):
copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
copy(self, "*.a", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
copy(self, "*.dll", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
copy(self, "*.lib", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
self.run(f"ARCH={self._goarch} OS={self._goos} make -C {self.source_folder}")
def _rename_libs(self):
# workaround of bad naming strategy in amnezia-xray-bindings
# TODO: change it and kick out the code below
lib_dir = os.path.join(self.package_folder, "lib")
@@ -71,6 +64,13 @@ class AmneziaXrayBindings(ConanFile):
dst = os.path.join(lib_dir, "lib" + fname)
os.rename(src, dst)
def package(self):
copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"), keep_path=False)
copy(self, "*.a", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
copy(self, "*.dll", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
copy(self, "*.lib", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
self._rename_libs()
def package_info(self):
self.cpp_info.set_property("cmake_target_name", "amnezia::xray-bindings")
self.cpp_info.libs = collect_libs(self)
recipes/awg-android/conanfile.py
+72
View File
@@ -0,0 +1,72 @@
from conan import ConanFile
from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
from conan.tools.files import copy, collect_libs, replace_in_file
from conan.errors import ConanInvalidConfiguration
from conan.tools.scm import Git
import os
import platform
class AwgAndroid(ConanFile):
name = "awg-android"
version = "1.1.7"
source_buildenv = True
settings = "os", "arch", "build_type", "compiler"
def layout(self):
cmake_layout(self)
def validate(self):
if self.settings.os != "Android":
raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
def source(self):
git = Git(self)
git.clone(
url="https://github.com/amnezia-vpn/amneziawg-android.git",
target=".",
args=["--recurse-submodules", "--branch", f"v{self.version}"]
)
def generate(self):
tc = CMakeToolchain(self)
tc.variables["GRADLE_USER_HOME"] = os.path.join(self.build_folder, "gradle_user_home")
tc.variables["CMAKE_LIBRARY_OUTPUT_DIRECTORY"] = os.path.join(self.build_folder, "out")
tc.generate()
def _patch_sources(self):
if platform.system() == 'Darwin':
replace_in_file(self,
os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
'flock "$@.lock" -c \' \\\n',
"",
)
replace_in_file(self,
os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
'mv "$@.tmp" "$@"\'',
'mv "$@.tmp" "$@"',
)
replace_in_file(self,
os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
'touch "$@"\'',
'touch "$@"',
)
replace_in_file(self,
os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
'sha256sum -c',
'shasum -a 256 -c'
)
def build(self):
self._patch_sources()
cmake = CMake(self)
cmake.configure(build_script_folder=os.path.join(self.source_folder, "tunnel", "tools"))
cmake.build(target=["libwg-go.so", "libwg.so", "libwg-quick.so"])
def package(self):
copy(self, "libwg-go.h", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "include"))
copy(self, "libwg*.so", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "lib"))
def package_info(self):
self.cpp_info.set_property("cmake_target_name", "amnezia::awg-android")
self.cpp_info.libs = collect_libs(self)
recipes/awg-apple/conanfile.py
+11 -12
View File
@@ -23,20 +23,22 @@ class AwgApple(ConanFile):
def build_requirements(self):
self.tool_requires("go/1.26.0")
if self.settings.os != "Windows":
if self.settings.os == "Windows":
self.tool_requires("mingw-builds/15.1.0")
else:
self.build_requires("make/4.4.1")
def validate(self):
os = str(self.settings.os)
if os not in self._os_map:
def configure(self):
self._goos = self._os_map.get(str(self.settings.os))
if not self._goos:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {os}"
f"{self.name} v{self.version} does not support {self._goos}"
)
arch = str(self.settings.arch)
if arch not in self._arch_map:
self._goarch = self._arch_map.get(str(self.settings.arch))
if not self._goarch:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {arch}"
f"{self.name} v{self.version} does not support {self._goarch}"
)
def layout(self):
@@ -48,10 +50,7 @@ class AwgApple(ConanFile):
)
def build(self):
os = self._os_map.get(str(self.settings.os))
arch = self._arch_map.get(str(self.settings.arch))
self.run(f"ARCHS={arch} PLATFORM_NAME={os} make")
self.run(f"ARCHS={self._goarch} PLATFORM_NAME={self._goos} make")
def package(self):
copy(self, "wireguard.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
recipes/awg-go/conanfile.py
+15 -5
View File
@@ -8,6 +8,7 @@ import os
class AwgGo(ConanFile):
name = "awg-go"
version = "0.2.16"
package_type = "application"
settings = "os", "arch"
@@ -16,26 +17,32 @@ class AwgGo(ConanFile):
"Macos": "darwin",
"Windows": "windows"
}
_arch_map = {
"x86": "386",
"x86_64": "amd64",
"armv8": "arm64",
}
def build_requirements(self):
self.tool_requires("go/1.26.0")
if self.settings.os == "Windows":
self.tool_requires("mingw-builds/15.1.0")
else:
self.build_requires("make/4.4.1")
def validate(self):
os = str(self.settings.os)
if os not in self._os_map:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {os}"
)
arch = str(self.settings.arch)
if arch not in self._arch_map:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {arch}"
)
def source(self):
get(self, f"https://github.com/amnezia-vpn/amneziawg-go/archive/refs/tags/v{self.version}.zip",
sha256="34da7d4189f215f3930de441548bc2a0c89d54d347a4fb85cb9c715fce6413aa", strip_root=True
@@ -49,9 +56,12 @@ class AwgGo(ConanFile):
arch = self._arch_map[str(self.settings.arch)]
self.run(f"GOOS={os} GOARCH={arch} make")
def package(self):
copy(self, "amneziawg-go", src=self.build_folder, dst=os.path.join(self.package_folder, "bin"))
copy(self, "amneziawg-go", src=self.build_folder, dst=self.package_folder)
def package_info(self):
self.cpp_info.exe = True
self.cpp_info.location = os.path.join(self.package_folder, "amneziawg-go")
self.cpp_info.set_property("cmake_target_name", "amnezia::awg-go")
recipes/awg-windows/conanfile.py
View File
recipes/domain-list-community/conanfile.py
+5
View File
@@ -0,0 +1,5 @@
from conan import ConanFile
class PackageConan(ConanFile):
name = "domain-list-community"
version = "20260227093604"
recipes/go/conanfile.py
-5
View File
@@ -1,6 +1,5 @@
from conan import ConanFile
from conan.tools.files import get, copy
from conan.tools.cmake import cmake_layout
import os
@@ -9,10 +8,6 @@ class Golang(ConanFile):
version = "1.26.0"
settings = "os", "arch"
def build_requirements(self):
if self.settings.os == "Windows":
self.tool_requires("mingw-builds/15.1.0")
def build(self):
get(self, **self.conan_data["sources"][str(self.version)][str(self.settings.os)][str(self.settings.arch)])
recipes/hev-socks5-tunnel/conanfile.py
+5
View File
@@ -0,0 +1,5 @@
from conan import ConanFile
class HevSocks5Tunnel(ConanFile):
name = "hev-socks5-tunnel"
version = "1.0.0"
recipes/libssh-local/conanfile.py
+132
View File
@@ -0,0 +1,132 @@
from conan import ConanFile
from conan.errors import ConanInvalidConfiguration
from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
from conan.tools.files import copy, get, rmdir
from conan.tools.microsoft import is_msvc_static_runtime, is_msvc
from conan.tools.scm import Version
import os
required_conan_version = ">=2.21"
class LibsshLocal(ConanFile):
name = "libssh-local"
version = "0.11.3"
license = "LGPL-2.1"
homepage = "https://www.libssh.org/"
description = "multiplatform C library implementing the SSHv2 protocol on client and server side"
topics = ("ssh", "shell", "ssh2", "connection")
package_type = "library"
settings = "os", "compiler", "build_type", "arch"
options = {
"shared": [True, False],
"fPIC": [True, False],
"with_zlib": [True, False],
"crypto_backend": ["openssl", "gcrypt", "mbedtls"],
"with_symbol_versioning": [True, False],
}
default_options = {
"shared": False,
"fPIC": True,
"with_zlib": True,
"crypto_backend": "openssl",
"with_symbol_versioning": True,
}
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
del self.options.with_symbol_versioning
def configure(self):
if self.options.shared:
self.options.rm_safe("fPIC")
self.settings.rm_safe("compiler.libcxx")
self.settings.rm_safe("compiler.cppstd")
def layout(self):
cmake_layout(self, src_folder="src")
def requirements(self):
if self.options.with_zlib:
self.requires("zlib/[>=1.2.11 <2]")
if self.options.crypto_backend =="openssl":
self.requires("openssl/[>=1.1 <4]")
elif self.options.crypto_backend == "gcrypt":
self.requires("libgcrypt/[>=1.8.4 <2]")
elif self.options.crypto_backend == "mbedtls":
self.requires("mbedtls/3.6.0")
def validate(self):
if self.options.crypto_backend == "mbedtls" and not self.dependencies["mbedtls"].options.enable_threading:
raise ConanInvalidConfiguration(f"{self.ref} requires '-o mbedtls/*:enable_threading=True' when using '-o libssh/*:crypto_backend=mbedtls'")
def source(self):
get(self, "https://www.libssh.org/files/0.11/libssh-0.11.3.tar.xz",
sha256="7d8a1361bb094ec3f511964e78a5a4dba689b5986e112afabe4f4d0d6c6125c3", strip_root=True
)
def generate(self):
tc = CMakeToolchain(self)
tc.cache_variables["CLIENT_TESTING"] = False
tc.cache_variables["SERVER_TESTING"] = False
tc.cache_variables["WITH_EXAMPLES"] = False
tc.cache_variables["WITH_GCRYPT"] = self.options.crypto_backend == "gcrypt"
tc.cache_variables["WITH_GSSAPI"] = False
tc.cache_variables["WITH_MBEDTLS"] = self.options.crypto_backend == "mbedtls"
tc.cache_variables["WITH_NACL"] = False
tc.cache_variables["WITH_SYMBOL_VERSIONING"] = self.options.get_safe("with_symbol_versioning", True)
tc.variables["WITH_ZLIB"] = self.options.with_zlib
if is_msvc(self):
tc.cache_variables["USE_MSVC_RUNTIME_LIBRARY_DLL"] = not is_msvc_static_runtime(self)
tc.cache_variables["CMAKE_POLICY_DEFAULT_CMP0077"] = "NEW"
tc.cache_variables["CMAKE_TRY_COMPILE_CONFIGURATION"] = str(self.settings.build_type)
if self.settings.os == "Android":
if Version(self.settings.get_safe("os.api_level")) < 24:
tc.cache_variables["HAVE_IFADDRS_H"] = False
tc.preprocessor_definitions["S_IWRITE"] = "S_IRUSR"
tc.preprocessor_definitions["S_IWRITE"] = "S_IWUSR"
tc.preprocessor_definitions["S_IEXEC"] = "S_IXUSR"
tc.generate()
deps = CMakeDeps(self)
deps.set_property("libgcrypt", "cmake_file_name", "GCrypt")
deps.set_property("libgcrypt", "cmake_additional_variables_prefixes", ["GCRYPT"])
deps.set_property("libgcrypt", "cmake_extra_variables", {"GCRYPT_FOUND": "TRUE"})
deps.set_property("mbedtls", "cmake_additional_variables_prefixes", ["MBEDTLS"])
deps.set_property("mbedtls", "cmake_extra_variables", {"MBEDTLS_FOUND": "TRUE"})
deps.generate()
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
copy(self, pattern="COPYING", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
cmake = CMake(self)
cmake.install()
rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
def package_info(self):
self.cpp_info.libs = ["ssh"]
if not self.options.shared:
self.cpp_info.defines.append("LIBSSH_STATIC=ON")
if self.settings.os == "Windows":
self.cpp_info.system_libs.extend(["ws2_32", "iphlpapi"])
self.cpp_info.set_property("cmake_file_name", "libssh")
# target and alias names defined at:
# ssh https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n351
# ssh::ssh https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n371
# ssh-static https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n413
# ssh::static https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n428
self.cpp_info.set_property("cmake_target_name", "ssh::ssh")
self.cpp_info.set_property(
"cmake_target_aliases",
["ssh"] if self.options.shared else ["ssh", "ssh-static", "ssh::static"],
)
# pkg-config defined at https://git.libssh.org/projects/libssh.git/tree/CMakeLists.txt?h=libssh-0.10.6#n124
self.cpp_info.set_property("pkg_config_name", "libssh")
recipes/openvpn/conanfile.py
+49
View File
@@ -0,0 +1,49 @@
from conan import ConanFile
from conan.tools.files import get, copy
from conan.tools.gnu import Autotools, AutotoolsToolchain, AutotoolsDeps
from conan.tools.layout import basic_layout
import os
class Openvpn(ConanFile):
name = "openvpn"
version = "2.7.0"
package_type = "application"
settings = "os", "build_type", "arch"
def layout(self):
basic_layout(self)
def build_requirements(self):
self.tool_requires("libtool/2.4.7")
self.tool_requires("automake/1.16.5")
def requirements(self):
self.requires("openssl/[>=1.1.0]", visible=False)
self.requires("lz4/[>=1.7.1]", visible=False)
self.requires("lzo/2.10", visible=False)
def source(self):
get(self, f"https://github.com/OpenVPN/openvpn/archive/refs/tags/v{self.version}.zip",
sha256="1a65d8587f932c13d55b1f175ff2e1d61d795d9092788662e888054854d4ee3d", strip_root=True
)
def generate(self):
tc = AutotoolsToolchain(self)
tc.generate()
deps = AutotoolsDeps(self)
deps.generate()
def build(self):
at = Autotools(self)
at.autoreconf()
at.configure()
at.make()
def package(self):
copy(self, "openvpn", src=os.path.join(self.build_folder, "src", "openvpn"), dst=self.package_folder)
def package_info(self):
self.cpp_info.exe = True
self.cpp_info.location = os.path.join(self.package_folder, "openvpn")
recipes/tun2socks/conanfile.py
+74
View File
@@ -0,0 +1,74 @@
from conan import ConanFile
from conan.tools.layout import basic_layout
from conan.tools.files import get, copy
from conan.errors import ConanInvalidConfiguration
import os
class Tun2Socks(ConanFile):
name = "tun2socks"
version = "2.6.0"
settings = "os", "arch"
_os_map = {
"Linux": "linux",
"Macos": "darwin",
"Windows": "windows"
}
_arch_map = {
"x86": "386",
"x86_64": "amd64",
"armv8": "arm64",
}
def build_requirements(self):
self.tool_requires("go/1.26.0")
if self.settings.os == "Windows":
self.tool_requires("mingw-builds/15.1.0")
else:
self.build_requires("make/4.4.1")
def source(self):
#TODO: get tunnel.dll for windows
get(self, f"https://github.com/xjasonlyu/tun2socks/archive/refs/tags/v{self.version}.zip",
sha256="a7ef9cec1c30dfe9971af89a8aac767fd3d2a4df833e92b635642c2f0204c701", strip_root=True
)
def configure(self):
self._goos = self._os_map.get(str(self.settings.os))
if not self._goos:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {self._goos}"
)
self._goarch = self._arch_map.get(str(self.settings.arch))
if not self._goarch:
raise ConanInvalidConfiguration(
f"{self.name} v{self.version} does not support {self._goarch}"
)
self._ext = ".exe" if self.settings.os == "Windows" else ""
def layout(self):
basic_layout(self, build_folder=".")
def build(self):
self.run(f"make {self._goos}-{self._goarch}")
def package(self):
src_name = f"tun2socks-{self._goos}-{self._goarch}{self._ext}"
dst_name = f"tun2socks{self._ext}"
copy(self, src_name, src=os.path.join(self.build_folder, "build"), dst=self.package_folder)
os.rename(
os.path.join(self.package_folder, src_name),
os.path.join(self.package_folder, dst_name)
)
def package_info(self):
self.cpp_info.exe = True
self.cpp_info.location = os.path.join(self.package_folder, f"tun2socks{self._ext}")
self.cpp_info.set_property("cmake_target_name", "xjasonlyu::tun2socks")
recipes/wintun/conanfile.py
+5
View File
@@ -0,0 +1,5 @@
from conan import ConanFile
class PackageConan(ConanFile):
name = "wintun"
version = "1.0.0"