2025-01-14 06:33:24 +01:00
|
|
|
# SPDX-FileCopyrightText: 2025 Citron Homebrew Emulator Project
|
chore: make yuzu REUSE compliant
[REUSE] is a specification that aims at making file copyright
information consistent, so that it can be both human and machine
readable. It basically requires that all files have a header containing
copyright and licensing information. When this isn't possible, like
when dealing with binary assets, generated files or embedded third-party
dependencies, it is permitted to insert copyright information in the
`.reuse/dep5` file.
Oh, and it also requires that all the licenses used in the project are
present in the `LICENSES` folder, that's why the diff is so huge.
This can be done automatically with `reuse download --all`.
The `reuse` tool also contains a handy subcommand that analyzes the
project and tells whether or not the project is (still) compliant,
`reuse lint`.
Following REUSE has a few advantages over the current approach:
- Copyright information is easy to access for users / downstream
- Files like `dist/license.md` do not need to exist anymore, as
`.reuse/dep5` is used instead
- `reuse lint` makes it easy to ensure that copyright information of
files like binary assets / images is always accurate and up to date
To add copyright information of files that didn't have it I looked up
who committed what and when, for each file. As yuzu contributors do not
have to sign a CLA or similar I couldn't assume that copyright ownership
was of the "yuzu Emulator Project", so I used the name and/or email of
the commit author instead.
[REUSE]: https://reuse.software
Follow-up to 01cf05bc75b1e47beb08937439f3ed9339e7b254
2022-05-15 02:06:02 +02:00
|
|
|
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
|
|
2022-11-29 04:48:49 +01:00
|
|
|
cmake_minimum_required(VERSION 3.22)
|
2018-08-12 01:36:19 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
project(citron)
|
2023-01-05 05:00:44 +01:00
|
|
|
|
2017-05-28 08:45:55 +02:00
|
|
|
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
|
|
|
|
|
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
|
2023-01-05 05:00:44 +01:00
|
|
|
|
2017-09-09 19:24:13 +02:00
|
|
|
include(DownloadExternals)
|
2018-01-20 08:46:04 +01:00
|
|
|
include(CMakeDependentOption)
|
2023-01-05 05:00:44 +01:00
|
|
|
include(CTest)
|
2017-05-28 08:45:55 +02:00
|
|
|
|
2025-01-12 04:26:22 +01:00
|
|
|
# Disable Warnings as Errors for MSVC
|
|
|
|
|
if (MSVC)
|
|
|
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX-")
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
# Check if SDL2::SDL2 target exists; if not, create an alias
|
|
|
|
|
if (TARGET SDL2::SDL2-static)
|
|
|
|
|
add_library(SDL2::SDL2 ALIAS SDL2::SDL2-static)
|
|
|
|
|
elseif (TARGET SDL2::SDL2-shared)
|
|
|
|
|
add_library(SDL2::SDL2 ALIAS SDL2::SDL2-shared)
|
|
|
|
|
endif()
|
|
|
|
|
|
2018-01-20 08:46:04 +01:00
|
|
|
# Set bundled sdl2/qt as dependent options.
|
2017-05-28 08:45:55 +02:00
|
|
|
option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
|
2024-12-31 08:07:49 +01:00
|
|
|
CMAKE_DEPENDENT_OPTION(CITRON_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
|
|
|
|
|
CMAKE_DEPENDENT_OPTION(CITRON_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
|
2017-05-28 08:45:55 +02:00
|
|
|
|
2023-06-03 09:14:33 +02:00
|
|
|
cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "NOT ANDROID" OFF)
|
2022-12-28 23:26:46 +01:00
|
|
|
|
2022-12-10 21:12:27 +01:00
|
|
|
option(ENABLE_OPENGL "Enable OpenGL" ON)
|
|
|
|
|
mark_as_advanced(FORCE ENABLE_OPENGL)
|
2017-05-28 08:45:55 +02:00
|
|
|
option(ENABLE_QT "Enable the Qt frontend" ON)
|
2022-10-18 01:55:40 +02:00
|
|
|
|
2020-01-26 00:26:07 +01:00
|
|
|
option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
|
2024-12-31 08:07:49 +01:00
|
|
|
CMAKE_DEPENDENT_OPTION(CITRON_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)
|
2017-05-28 08:45:55 +02:00
|
|
|
|
2018-09-16 20:05:51 +02:00
|
|
|
option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
|
2021-02-05 19:45:10 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
|
2022-12-29 02:55:32 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" ON)
|
2023-12-28 12:35:28 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
|
2022-10-18 01:55:40 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
|
2018-12-24 22:24:01 +01:00
|
|
|
|
2018-07-28 19:44:50 +02:00
|
|
|
option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
|
|
|
|
|
|
2018-09-16 20:05:51 +02:00
|
|
|
option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_TESTS "Compile tests" "${BUILD_TESTING}")
|
2022-01-12 00:36:20 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
|
2022-11-23 00:38:23 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)
|
2023-09-08 21:43:54 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
CMAKE_DEPENDENT_OPTION(CITRON_ROOM "Compile LDN room server" ON "NOT ANDROID" OFF)
|
2022-12-28 23:18:27 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
CMAKE_DEPENDENT_OPTION(CITRON_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
|
2022-07-25 22:45:38 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_USE_BUNDLED_VCPKG "Use vcpkg for citron dependencies" "${MSVC}")
|
2022-07-22 20:49:43 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_CHECK_SUBMODULES "Check if submodules are present" ON)
|
2022-07-30 05:01:09 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_ENABLE_LTO "Enable link-time optimization" OFF)
|
2023-02-27 05:01:44 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_DOWNLOAD_TIME_ZONE_DATA "Always download time zone binaries" OFF)
|
2023-06-16 10:32:31 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
option(CITRON_ENABLE_PORTABLE "Allow citron to enable portable mode if a user folder is found in the CWD" ON)
|
2023-09-07 00:53:39 +02:00
|
|
|
|
2025-01-09 08:24:53 +01:00
|
|
|
option(CITRON_USE_LLVM_DEMANGLE "Use LLVM Demangle" ON)
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
CMAKE_DEPENDENT_OPTION(CITRON_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
|
2022-12-10 18:50:00 +01:00
|
|
|
|
2023-08-17 03:17:56 +02:00
|
|
|
CMAKE_DEPENDENT_OPTION(USE_SYSTEM_MOLTENVK "Use the system MoltenVK lib (instead of the bundled one)" OFF "APPLE" OFF)
|
|
|
|
|
|
2023-06-26 02:36:51 +02:00
|
|
|
set(DEFAULT_ENABLE_OPENSSL ON)
|
2025-01-12 04:26:22 +01:00
|
|
|
if (ANDROID OR WIN32 OR APPLE)
|
|
|
|
|
set(DEFAULT_ENABLE_OPENSSL OFF)
|
|
|
|
|
endif()
|
|
|
|
|
option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
|
|
|
|
|
|
2023-07-02 00:02:25 +02:00
|
|
|
if (ANDROID OR WIN32 OR APPLE)
|
2023-06-26 02:36:51 +02:00
|
|
|
# - Windows defaults to the Schannel backend.
|
2023-07-02 00:02:25 +02:00
|
|
|
# - macOS defaults to the SecureTransport backend.
|
2023-06-26 02:36:51 +02:00
|
|
|
# - Android currently has no SSL backend as the NDK doesn't include any SSL
|
|
|
|
|
# library; a proper 'native' backend would have to go through Java.
|
|
|
|
|
# But you can force builds for those platforms to use OpenSSL if you have
|
|
|
|
|
# your own copy of it.
|
|
|
|
|
set(DEFAULT_ENABLE_OPENSSL OFF)
|
|
|
|
|
endif()
|
|
|
|
|
option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
|
Implement SSL service
This implements some missing network APIs including a large chunk of the SSL
service, enough for Mario Maker (with an appropriate mod applied) to connect to
the fan server [Open Course World](https://opencourse.world/).
Connecting to first-party servers is out of scope of this PR and is a
minefield I'd rather not step into.
## TLS
TLS is implemented with multiple backends depending on the system's 'native'
TLS library. Currently there are two backends: Schannel for Windows, and
OpenSSL for Linux. (In reality Linux is a bit of a free-for-all where there's
no one 'native' library, but OpenSSL is the closest it gets.) On macOS the
'native' library is SecureTransport but that isn't implemented in this PR.
(Instead, all non-Windows OSes will use OpenSSL unless disabled with
`-DENABLE_OPENSSL=OFF`.)
Why have multiple backends instead of just using a single library, especially
given that Yuzu already embeds mbedtls for cryptographic algorithms? Well, I
tried implementing this on mbedtls first, but the problem is TLS policies -
mainly trusted certificate policies, and to a lesser extent trusted algorithms,
SSL versions, etc.
...In practice, the chance that someone is going to conduct a man-in-the-middle
attack on a third-party game server is pretty low, but I'm a security nerd so I
like to do the right security things.
My base assumption is that we want to use the host system's TLS policies. An
alternative would be to more closely emulate the Switch's TLS implementation
(which is based on NSS). But for one thing, I don't feel like reverse
engineering it. And I'd argue that for third-party servers such as Open Course
World, it's theoretically preferable to use the system's policies rather than
the Switch's, for two reasons
1. Someday the Switch will stop being updated, and the trusted cert list,
algorithms, etc. will start to go stale, but users will still want to
connect to third-party servers, and there's no reason they shouldn't have
up-to-date security when doing so. At that point, homebrew users on actual
hardware may patch the TLS implementation, but for emulators it's simpler to
just use the host's stack.
2. Also, it's good to respect any custom certificate policies the user may have
added systemwide. For example, they may have added custom trusted CAs in
order to use TLS debugging tools or pass through corporate MitM middleboxes.
Or they may have removed some CAs that are normally trusted out of paranoia.
Note that this policy wouldn't work as-is for connecting to first-party
servers, because some of them serve certificates based on Nintendo's own CA
rather than a publicly trusted one. However, this could probably be solved
easily by using appropriate APIs to adding Nintendo's CA as an alternate
trusted cert for Yuzu's connections. That is not implemented in this PR
because, again, first-party servers are out of scope.
(If anything I'd rather have an option to _block_ connections to Nintendo
servers, but that's not implemented here.)
To use the host's TLS policies, there are three theoretical options:
a) Import the host's trusted certificate list into a cross-platform TLS
library (presumably mbedtls).
b) Use the native TLS library to verify certificates but use a cross-platform
TLS library for everything else.
c) Use the native TLS library for everything.
Two problems with option a). First, importing the trusted certificate list at
minimum requires a bunch of platform-specific code, which mbedtls does not have
built in. Interestingly, OpenSSL recently gained the ability to import the
Windows certificate trust store... but that leads to the second problem, which
is that a list of trusted certificates is [not expressive
enough](https://bugs.archlinux.org/task/41909) to express a modern certificate
trust policy. For example, Windows has the concept of [explicitly distrusted
certificates](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/dn265983(v=ws.11)),
and macOS requires Certificate Transparency validation for some certificates
with complex rules for when it's required.
Option b) (using native library just to verify certs) is probably feasible, but
it would miss aspects of TLS policy other than trusted certs (like allowed
algorithms), and in any case it might well require writing more code, not less,
compared to using the native library for everything.
So I ended up at option c), using the native library for everything.
What I'd *really* prefer would be to use a third-party library that does option
c) for me. Rust has a good library for this,
[native-tls](https://docs.rs/native-tls/latest/native_tls/). I did search, but
I couldn't find a good option in the C or C++ ecosystem, at least not any that
wasn't part of some much larger framework. I was surprised - isn't this a
pretty common use case? Well, many applications only need TLS for HTTPS, and they can
use libcurl, which has a TLS abstraction layer internally but doesn't expose
it. Other applications only support a single TLS library, or use one of the
aforementioned larger frameworks, or are platform-specific to begin with, or of
course are written in a non-C/C++ language, most of which have some canonical
choice for TLS. But there are also many applications that have a set of TLS
backends just like this; it's just that nobody has gone ahead and abstracted
the pattern into a library, at least not a widespread one.
Amusingly, there is one TLS abstraction layer that Yuzu already bundles: the
one in ffmpeg. But it is missing some features that would be needed to use it
here (like reusing an existing socket rather than managing the socket itself).
Though, that does mean that the wiki's build instructions for Linux (and macOS
for some reason?) already recommend installing OpenSSL, so no need to update
those.
## Other APIs implemented
- Sockets:
- GetSockOpt(`SO_ERROR`)
- SetSockOpt(`SO_NOSIGPIPE`) (stub, I have no idea what this does on Switch)
- `DuplicateSocket` (because the SSL sysmodule calls it internally)
- More `PollEvents` values
- NSD:
- `Resolve` and `ResolveEx` (stub, good enough for Open Course World and
probably most third-party servers, but not first-party)
- SFDNSRES:
- `GetHostByNameRequest` and `GetHostByNameRequestWithOptions`
- `ResolverSetOptionRequest` (stub)
## Fixes
- Parts of the socket code were previously allocating a `sockaddr` object on
the stack when calling functions that take a `sockaddr*` (e.g. `accept`).
This might seem like the right thing to do to avoid illegal aliasing, but in
fact `sockaddr` is not guaranteed to be large enough to hold any particular
type of address, only the header. This worked in practice because in
practice `sockaddr` is the same size as `sockaddr_in`, but it's not how the
API is meant to be used. I changed this to allocate an `sockaddr_in` on the
stack and `reinterpret_cast` it. I could try to do something cleverer with
`aligned_storage`, but casting is the idiomatic way to use these particular
APIs, so it's really the system's responsibility to avoid any aliasing
issues.
- I rewrote most of the `GetAddrInfoRequest[WithOptions]` implementation. The
old implementation invoked the host's getaddrinfo directly from sfdnsres.cpp,
and directly passed through the host's socket type, protocol, etc. values
rather than looking up the corresponding constants on the Switch. To be
fair, these constants don't tend to actually vary across systems, but
still... I added a wrapper for `getaddrinfo` in
`internal_network/network.cpp` similar to the ones for other socket APIs, and
changed the `GetAddrInfoRequest` implementation to use it. While I was at
it, I rewrote the serialization to use the same approach I used to implement
`GetHostByNameRequest`, because it reduces the number of size calculations.
While doing so I removed `AF_INET6` support because the Switch doesn't
support IPv6; it might be nice to support IPv6 anyway, but that would have to
apply to all of the socket APIs.
I also corrected the IPC wrappers for `GetAddrInfoRequest` and
`GetAddrInfoRequestWithOptions` based on reverse engineering and hardware
testing. Every call to `GetAddrInfoRequestWithOptions` returns *four*
different error codes (IPC status, getaddrinfo error code, netdb error code,
and errno), and `GetAddrInfoRequest` returns three of those but in a
different order, and it doesn't really matter but the existing implementation
was a bit off, as I discovered while testing `GetHostByNameRequest`.
- The new serialization code is based on two simple helper functions:
```cpp
template <typename T> static void Append(std::vector<u8>& vec, T t);
void AppendNulTerminated(std::vector<u8>& vec, std::string_view str);
```
I was thinking there must be existing functions somewhere that assist with
serialization/deserialization of binary data, but all I could find was the
helper methods in `IOFile` and `HLERequestContext`, not anything that could
be used with a generic byte buffer. If I'm not missing something, then
maybe I should move the above functions to a new header in `common`...
right now they're just sitting in `sfdnsres.cpp` where they're used.
- Not a fix, but `SocketBase::Recv`/`Send` is changed to use `std::span<u8>`
rather than `std::vector<u8>&` to avoid needing to copy the data to/from a
vector when those methods are called from the TLS implementation.
2023-06-20 03:17:43 +02:00
|
|
|
|
2025-01-15 07:44:07 +01:00
|
|
|
if (ANDROID AND CITRON_DOWNLOAD_ANDROID_VVL)
|
|
|
|
|
set(vvl_version "sdk-1.3.261.1")
|
|
|
|
|
set(vvl_zip_file "${CMAKE_BINARY_DIR}/externals/vvl-android.zip")
|
|
|
|
|
if (NOT EXISTS "${vvl_zip_file}")
|
|
|
|
|
# Download and extract validation layer release to externals directory
|
|
|
|
|
set(vvl_base_url "https://github.com/KhronosGroup/Vulkan-ValidationLayers/releases/download")
|
|
|
|
|
file(DOWNLOAD "${vvl_base_url}/${vvl_version}/android-binaries-${vvl_version}-android.zip"
|
|
|
|
|
"${vvl_zip_file}" SHOW_PROGRESS)
|
|
|
|
|
execute_process(COMMAND ${CMAKE_COMMAND} -E tar xf "${vvl_zip_file}"
|
|
|
|
|
WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/externals")
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
# Copy the arm64 binary to src/android/app/main/jniLibs only if it doesn't exist
|
|
|
|
|
set(vvl_lib_path "${CMAKE_CURRENT_SOURCE_DIR}/src/android/app/src/main/jniLibs/arm64-v8a/")
|
|
|
|
|
set(vvl_lib_file "${vvl_lib_path}/libVkLayer_khronos_validation.so")
|
|
|
|
|
if (NOT EXISTS "${vvl_lib_file}")
|
|
|
|
|
file(COPY "${CMAKE_BINARY_DIR}/externals/android-binaries-${vvl_version}/arm64-v8a/libVkLayer_khronos_validation.so"
|
|
|
|
|
DESTINATION "${vvl_lib_path}")
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
2023-09-08 21:43:54 +02:00
|
|
|
|
2022-12-30 08:25:03 +01:00
|
|
|
if (ANDROID)
|
|
|
|
|
set(CMAKE_SKIP_INSTALL_RULES ON)
|
|
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_USE_BUNDLED_VCPKG)
|
2022-12-30 08:25:03 +01:00
|
|
|
if (ANDROID)
|
|
|
|
|
set(ENV{ANDROID_NDK_HOME} "${ANDROID_NDK}")
|
|
|
|
|
list(APPEND VCPKG_MANIFEST_FEATURES "android")
|
2023-03-16 16:56:51 +01:00
|
|
|
|
|
|
|
|
if (CMAKE_ANDROID_ARCH_ABI STREQUAL "arm64-v8a")
|
|
|
|
|
set(VCPKG_TARGET_TRIPLET "arm64-android")
|
|
|
|
|
# this is to avoid CMake using the host pkg-config to find the host
|
|
|
|
|
# libraries when building for Android targets
|
|
|
|
|
set(PKG_CONFIG_EXECUTABLE "aarch64-none-linux-android-pkg-config" CACHE FILEPATH "" FORCE)
|
|
|
|
|
elseif (CMAKE_ANDROID_ARCH_ABI STREQUAL "x86_64")
|
|
|
|
|
set(VCPKG_TARGET_TRIPLET "x64-android")
|
|
|
|
|
set(PKG_CONFIG_EXECUTABLE "x86_64-none-linux-android-pkg-config" CACHE FILEPATH "" FORCE)
|
|
|
|
|
else()
|
|
|
|
|
message(FATAL_ERROR "Unsupported Android architecture ${CMAKE_ANDROID_ARCH_ABI}")
|
|
|
|
|
endif()
|
2022-12-30 08:25:03 +01:00
|
|
|
endif()
|
|
|
|
|
|
2023-07-25 21:47:44 +02:00
|
|
|
if (MSVC)
|
|
|
|
|
set(VCPKG_DOWNLOADS_PATH ${PROJECT_SOURCE_DIR}/externals/vcpkg/downloads)
|
|
|
|
|
set(NASM_VERSION "2.16.01")
|
|
|
|
|
set(NASM_DESTINATION_PATH ${VCPKG_DOWNLOADS_PATH}/nasm-${NASM_VERSION}-win64.zip)
|
2024-12-31 08:07:49 +01:00
|
|
|
set(NASM_DOWNLOAD_URL "https://github.com/yuzu-mirror/ext-windows-bin/raw/master/nasm/nasm-${NASM_VERSION}-win64.zip")
|
2023-07-25 21:47:44 +02:00
|
|
|
|
|
|
|
|
if (NOT EXISTS ${NASM_DESTINATION_PATH})
|
|
|
|
|
file(DOWNLOAD ${NASM_DOWNLOAD_URL} ${NASM_DESTINATION_PATH} SHOW_PROGRESS STATUS NASM_STATUS)
|
|
|
|
|
|
|
|
|
|
if (NOT NASM_STATUS EQUAL 0)
|
|
|
|
|
# Warn and not fail since vcpkg is supposed to download this package for us in the first place
|
|
|
|
|
message(WARNING "External nasm vcpkg package download from ${NASM_DOWNLOAD_URL} failed with status ${NASM_STATUS}")
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_TESTS)
|
|
|
|
|
list(APPEND VCPKG_MANIFEST_FEATURES "citron-tests")
|
2022-07-25 19:02:09 +02:00
|
|
|
endif()
|
2023-02-22 20:27:05 +01:00
|
|
|
if (ENABLE_WEB_SERVICE)
|
|
|
|
|
list(APPEND VCPKG_MANIFEST_FEATURES "web-service")
|
|
|
|
|
endif()
|
2023-12-17 06:11:20 +01:00
|
|
|
if (ANDROID)
|
|
|
|
|
list(APPEND VCPKG_MANIFEST_FEATURES "android")
|
|
|
|
|
endif()
|
2022-07-25 19:02:09 +02:00
|
|
|
|
2022-07-22 20:49:43 +02:00
|
|
|
include(${CMAKE_SOURCE_DIR}/externals/vcpkg/scripts/buildsystems/vcpkg.cmake)
|
|
|
|
|
elseif(NOT "$ENV{VCPKG_TOOLCHAIN_FILE}" STREQUAL "")
|
|
|
|
|
# Disable manifest mode (use vcpkg classic mode) when using a custom vcpkg installation
|
|
|
|
|
option(VCPKG_MANIFEST_MODE "")
|
|
|
|
|
include("$ENV{VCPKG_TOOLCHAIN_FILE}")
|
|
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_USE_PRECOMPILED_HEADERS)
|
2022-11-30 05:01:32 +01:00
|
|
|
if (MSVC AND CCACHE)
|
|
|
|
|
# buildcache does not properly cache PCH files, leading to compilation errors.
|
|
|
|
|
# See https://github.com/mbitsnbites/buildcache/discussions/230
|
|
|
|
|
message(WARNING "buildcache does not properly support Precompiled Headers. Disabling PCH")
|
2022-12-03 19:32:24 +01:00
|
|
|
set(DYNARMIC_USE_PRECOMPILED_HEADERS OFF CACHE BOOL "" FORCE)
|
2024-12-31 08:07:49 +01:00
|
|
|
set(CITRON_USE_PRECOMPILED_HEADERS OFF CACHE BOOL "" FORCE)
|
2022-11-30 05:01:32 +01:00
|
|
|
endif()
|
|
|
|
|
endif()
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_USE_PRECOMPILED_HEADERS)
|
2022-11-30 05:01:32 +01:00
|
|
|
message(STATUS "Using Precompiled Headers.")
|
|
|
|
|
set(CMAKE_PCH_INSTANTIATE_TEMPLATES ON)
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
|
2020-05-08 23:09:29 +02:00
|
|
|
# Default to a Release build
|
|
|
|
|
get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
|
|
|
|
|
if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
|
|
|
|
|
set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
|
|
|
|
|
message(STATUS "Defaulting to a Release build")
|
|
|
|
|
endif()
|
|
|
|
|
|
2019-12-06 04:48:20 +01:00
|
|
|
if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
|
2021-07-09 03:27:12 +02:00
|
|
|
if (EXISTS ${PROJECT_SOURCE_DIR}/.git/)
|
|
|
|
|
message(STATUS "Copying pre-commit hook")
|
|
|
|
|
file(COPY hooks/pre-commit DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
|
|
|
|
|
endif()
|
2017-05-28 08:45:55 +02:00
|
|
|
endif()
|
|
|
|
|
|
2019-06-29 22:19:47 +02:00
|
|
|
# Sanity check : Check that all submodules are present
|
|
|
|
|
# =======================================================================
|
|
|
|
|
|
|
|
|
|
function(check_submodules_present)
|
|
|
|
|
file(READ "${PROJECT_SOURCE_DIR}/.gitmodules" gitmodules)
|
|
|
|
|
string(REGEX MATCHALL "path *= *[^ \t\r\n]*" gitmodules ${gitmodules})
|
|
|
|
|
foreach(module ${gitmodules})
|
|
|
|
|
string(REGEX REPLACE "path *= *" "" module ${module})
|
|
|
|
|
if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
|
|
|
|
|
message(FATAL_ERROR "Git submodule ${module} not found. "
|
2021-11-02 07:51:11 +01:00
|
|
|
"Please run: \ngit submodule update --init --recursive")
|
2019-06-29 22:19:47 +02:00
|
|
|
endif()
|
|
|
|
|
endforeach()
|
|
|
|
|
endfunction()
|
2019-12-06 04:48:20 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if(EXISTS ${PROJECT_SOURCE_DIR}/.gitmodules AND CITRON_CHECK_SUBMODULES)
|
2019-12-06 04:48:20 +01:00
|
|
|
check_submodules_present()
|
|
|
|
|
endif()
|
2018-10-20 23:08:26 +02:00
|
|
|
configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
|
|
|
|
|
${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
|
2018-08-29 15:42:53 +02:00
|
|
|
COPYONLY)
|
2022-07-03 17:41:31 +02:00
|
|
|
if (EXISTS ${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json)
|
|
|
|
|
configure_file("${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json"
|
|
|
|
|
"${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json"
|
|
|
|
|
COPYONLY)
|
|
|
|
|
endif()
|
2018-10-20 23:08:26 +02:00
|
|
|
if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
|
2024-12-31 08:07:49 +01:00
|
|
|
message(STATUS "Downloading compatibility list for citron...")
|
2018-08-29 15:42:53 +02:00
|
|
|
file(DOWNLOAD
|
2024-12-31 08:07:49 +01:00
|
|
|
https://api.yuzu-mirror.org/gamedb/
|
2018-10-20 23:08:26 +02:00
|
|
|
"${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
|
2018-08-29 15:42:53 +02:00
|
|
|
endif()
|
2018-10-20 23:08:26 +02:00
|
|
|
if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
|
|
|
|
|
file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
|
2018-08-29 15:42:53 +02:00
|
|
|
endif()
|
|
|
|
|
|
2017-05-28 08:45:55 +02:00
|
|
|
# Detect current compilation architecture and create standard definitions
|
|
|
|
|
# =======================================================================
|
2015-08-28 21:57:08 +02:00
|
|
|
|
2015-08-28 21:55:22 +02:00
|
|
|
include(CheckSymbolExists)
|
|
|
|
|
function(detect_architecture symbol arch)
|
|
|
|
|
if (NOT DEFINED ARCHITECTURE)
|
|
|
|
|
set(CMAKE_REQUIRED_QUIET 1)
|
|
|
|
|
check_symbol_exists("${symbol}" "" ARCHITECTURE_${arch})
|
|
|
|
|
unset(CMAKE_REQUIRED_QUIET)
|
|
|
|
|
|
|
|
|
|
# The output variable needs to be unique across invocations otherwise
|
|
|
|
|
# CMake's crazy scope rules will keep it defined
|
|
|
|
|
if (ARCHITECTURE_${arch})
|
|
|
|
|
set(ARCHITECTURE "${arch}" PARENT_SCOPE)
|
|
|
|
|
set(ARCHITECTURE_${arch} 1 PARENT_SCOPE)
|
|
|
|
|
add_definitions(-DARCHITECTURE_${arch}=1)
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
|
|
|
|
endfunction()
|
|
|
|
|
|
2018-01-20 01:36:09 +01:00
|
|
|
if (NOT ENABLE_GENERIC)
|
|
|
|
|
if (MSVC)
|
|
|
|
|
detect_architecture("_M_AMD64" x86_64)
|
|
|
|
|
detect_architecture("_M_IX86" x86)
|
2022-11-06 22:45:36 +01:00
|
|
|
detect_architecture("_M_ARM" arm)
|
|
|
|
|
detect_architecture("_M_ARM64" arm64)
|
2018-01-20 01:36:09 +01:00
|
|
|
else()
|
|
|
|
|
detect_architecture("__x86_64__" x86_64)
|
|
|
|
|
detect_architecture("__i386__" x86)
|
2022-11-06 22:45:36 +01:00
|
|
|
detect_architecture("__arm__" arm)
|
|
|
|
|
detect_architecture("__aarch64__" arm64)
|
2018-01-20 01:36:09 +01:00
|
|
|
endif()
|
2015-08-28 21:55:22 +02:00
|
|
|
endif()
|
2018-01-20 01:36:09 +01:00
|
|
|
|
2015-08-28 21:55:22 +02:00
|
|
|
if (NOT DEFINED ARCHITECTURE)
|
|
|
|
|
set(ARCHITECTURE "GENERIC")
|
|
|
|
|
set(ARCHITECTURE_GENERIC 1)
|
|
|
|
|
add_definitions(-DARCHITECTURE_GENERIC=1)
|
2015-08-15 04:29:08 +02:00
|
|
|
endif()
|
2015-08-28 21:55:22 +02:00
|
|
|
message(STATUS "Target architecture: ${ARCHITECTURE}")
|
2015-08-15 04:29:08 +02:00
|
|
|
|
2020-08-31 16:09:06 +02:00
|
|
|
if (UNIX)
|
2024-12-31 08:07:49 +01:00
|
|
|
add_definitions(-DCITRON_UNIX=1)
|
2020-08-31 16:09:06 +02:00
|
|
|
endif()
|
2017-05-28 08:45:55 +02:00
|
|
|
|
2023-11-27 02:25:18 +01:00
|
|
|
if (ARCHITECTURE_arm64 AND (ANDROID OR ${CMAKE_SYSTEM_NAME} STREQUAL "Linux"))
|
|
|
|
|
set(HAS_NCE 1)
|
|
|
|
|
add_definitions(-DHAS_NCE=1)
|
|
|
|
|
endif()
|
|
|
|
|
|
2019-03-16 06:45:08 +01:00
|
|
|
# Configure C++ standard
|
2017-05-28 08:45:55 +02:00
|
|
|
# ===========================
|
|
|
|
|
|
2020-07-13 00:15:27 +02:00
|
|
|
# boost asio's concept usage doesn't play nicely with some compilers yet.
|
|
|
|
|
add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
|
2020-07-11 01:24:23 +02:00
|
|
|
if (MSVC)
|
2023-06-07 02:19:44 +02:00
|
|
|
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++20>)
|
2020-07-11 01:24:23 +02:00
|
|
|
|
2021-12-06 18:56:43 +01:00
|
|
|
# boost still makes use of deprecated result_of.
|
2020-07-11 01:24:23 +02:00
|
|
|
add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
|
|
|
|
|
else()
|
2020-07-13 00:15:27 +02:00
|
|
|
set(CMAKE_CXX_STANDARD 20)
|
2020-07-11 01:24:23 +02:00
|
|
|
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
|
|
|
|
endif()
|
2016-06-30 19:59:32 +02:00
|
|
|
|
2018-01-15 10:42:40 +01:00
|
|
|
# Output binaries to bin/
|
2018-10-20 23:08:26 +02:00
|
|
|
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
|
2018-01-15 10:42:40 +01:00
|
|
|
|
2020-05-08 23:09:29 +02:00
|
|
|
# System imported libraries
|
|
|
|
|
# =======================================================================
|
2016-03-27 05:59:50 +02:00
|
|
|
|
2022-12-31 12:48:08 +01:00
|
|
|
# Enforce the search mode of non-required packages for better and shorter failure messages
|
2025-01-15 10:20:37 +01:00
|
|
|
find_package(Boost REQUIRED context)
|
|
|
|
|
find_package(enet MODULE)
|
2022-11-25 19:35:46 +01:00
|
|
|
find_package(fmt 9 REQUIRED)
|
2025-01-09 08:24:53 +01:00
|
|
|
if (CITRON_USE_LLVM_DEMANGLE)
|
2025-01-15 10:20:37 +01:00
|
|
|
find_package(LLVM MODULE COMPONENTS Demangle)
|
2025-01-09 08:24:53 +01:00
|
|
|
endif()
|
2022-12-05 22:56:42 +01:00
|
|
|
find_package(lz4 REQUIRED)
|
2025-01-15 10:20:37 +01:00
|
|
|
find_package(nlohmann_json REQUIRED)
|
|
|
|
|
find_package(Opus MODULE)
|
2023-09-16 18:59:53 +02:00
|
|
|
find_package(RenderDoc MODULE)
|
2023-11-02 18:53:40 +01:00
|
|
|
find_package(SimpleIni MODULE)
|
2023-10-12 16:36:26 +02:00
|
|
|
find_package(stb MODULE)
|
2023-06-27 22:54:33 +02:00
|
|
|
find_package(VulkanMemoryAllocator CONFIG)
|
2025-01-15 10:20:37 +01:00
|
|
|
find_package(ZLIB REQUIRED)
|
|
|
|
|
find_package(zstd REQUIRED)
|
2022-11-25 19:35:46 +01:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (NOT CITRON_USE_EXTERNAL_VULKAN_HEADERS)
|
2024-02-02 01:16:45 +01:00
|
|
|
find_package(VulkanHeaders 1.3.274 REQUIRED)
|
2022-12-29 02:55:32 +01:00
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (NOT CITRON_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES)
|
2023-12-28 12:35:28 +01:00
|
|
|
find_package(VulkanUtilityLibraries REQUIRED)
|
|
|
|
|
endif()
|
|
|
|
|
|
2022-12-28 23:26:46 +01:00
|
|
|
if (ENABLE_LIBUSB)
|
2022-12-31 12:48:08 +01:00
|
|
|
find_package(libusb 1.0.24 MODULE)
|
2022-12-28 23:26:46 +01:00
|
|
|
endif()
|
|
|
|
|
|
2022-11-25 19:35:46 +01:00
|
|
|
if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
|
2022-12-31 12:48:08 +01:00
|
|
|
find_package(xbyak 6 CONFIG)
|
2022-11-25 19:35:46 +01:00
|
|
|
endif()
|
|
|
|
|
|
2024-01-29 22:17:00 +01:00
|
|
|
if (ARCHITECTURE_arm64)
|
|
|
|
|
find_package(oaknut 2.0.1 CONFIG)
|
|
|
|
|
endif()
|
|
|
|
|
|
2022-11-25 19:35:46 +01:00
|
|
|
if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
|
2022-12-31 12:48:08 +01:00
|
|
|
find_package(dynarmic 6.4.0 CONFIG)
|
2022-11-25 19:35:46 +01:00
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
if (ENABLE_CUBEB)
|
2022-12-31 12:48:08 +01:00
|
|
|
find_package(cubeb CONFIG)
|
2022-11-25 19:35:46 +01:00
|
|
|
endif()
|
2020-05-08 23:09:29 +02:00
|
|
|
|
2022-11-25 19:35:46 +01:00
|
|
|
if (USE_DISCORD_PRESENCE)
|
2022-12-31 12:48:08 +01:00
|
|
|
find_package(DiscordRPC MODULE)
|
2022-07-22 06:51:01 +02:00
|
|
|
endif()
|
|
|
|
|
|
2022-11-25 19:35:46 +01:00
|
|
|
if (ENABLE_WEB_SERVICE)
|
2022-12-31 12:48:08 +01:00
|
|
|
find_package(cpp-jwt 1.4 CONFIG)
|
2023-02-24 23:45:38 +01:00
|
|
|
find_package(httplib 0.12 MODULE COMPONENTS OpenSSL)
|
2022-07-25 19:02:09 +02:00
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_TESTS)
|
2023-01-05 03:38:38 +01:00
|
|
|
find_package(Catch2 3.0.1 REQUIRED)
|
2022-07-22 06:51:01 +02:00
|
|
|
endif()
|
2020-05-08 23:09:29 +02:00
|
|
|
|
2022-05-31 20:37:37 +02:00
|
|
|
# boost:asio has functions that require AcceptEx et al
|
|
|
|
|
if (MINGW)
|
|
|
|
|
find_library(MSWSOCK_LIBRARY mswsock REQUIRED)
|
|
|
|
|
endif()
|
|
|
|
|
|
Implement SSL service
This implements some missing network APIs including a large chunk of the SSL
service, enough for Mario Maker (with an appropriate mod applied) to connect to
the fan server [Open Course World](https://opencourse.world/).
Connecting to first-party servers is out of scope of this PR and is a
minefield I'd rather not step into.
## TLS
TLS is implemented with multiple backends depending on the system's 'native'
TLS library. Currently there are two backends: Schannel for Windows, and
OpenSSL for Linux. (In reality Linux is a bit of a free-for-all where there's
no one 'native' library, but OpenSSL is the closest it gets.) On macOS the
'native' library is SecureTransport but that isn't implemented in this PR.
(Instead, all non-Windows OSes will use OpenSSL unless disabled with
`-DENABLE_OPENSSL=OFF`.)
Why have multiple backends instead of just using a single library, especially
given that Yuzu already embeds mbedtls for cryptographic algorithms? Well, I
tried implementing this on mbedtls first, but the problem is TLS policies -
mainly trusted certificate policies, and to a lesser extent trusted algorithms,
SSL versions, etc.
...In practice, the chance that someone is going to conduct a man-in-the-middle
attack on a third-party game server is pretty low, but I'm a security nerd so I
like to do the right security things.
My base assumption is that we want to use the host system's TLS policies. An
alternative would be to more closely emulate the Switch's TLS implementation
(which is based on NSS). But for one thing, I don't feel like reverse
engineering it. And I'd argue that for third-party servers such as Open Course
World, it's theoretically preferable to use the system's policies rather than
the Switch's, for two reasons
1. Someday the Switch will stop being updated, and the trusted cert list,
algorithms, etc. will start to go stale, but users will still want to
connect to third-party servers, and there's no reason they shouldn't have
up-to-date security when doing so. At that point, homebrew users on actual
hardware may patch the TLS implementation, but for emulators it's simpler to
just use the host's stack.
2. Also, it's good to respect any custom certificate policies the user may have
added systemwide. For example, they may have added custom trusted CAs in
order to use TLS debugging tools or pass through corporate MitM middleboxes.
Or they may have removed some CAs that are normally trusted out of paranoia.
Note that this policy wouldn't work as-is for connecting to first-party
servers, because some of them serve certificates based on Nintendo's own CA
rather than a publicly trusted one. However, this could probably be solved
easily by using appropriate APIs to adding Nintendo's CA as an alternate
trusted cert for Yuzu's connections. That is not implemented in this PR
because, again, first-party servers are out of scope.
(If anything I'd rather have an option to _block_ connections to Nintendo
servers, but that's not implemented here.)
To use the host's TLS policies, there are three theoretical options:
a) Import the host's trusted certificate list into a cross-platform TLS
library (presumably mbedtls).
b) Use the native TLS library to verify certificates but use a cross-platform
TLS library for everything else.
c) Use the native TLS library for everything.
Two problems with option a). First, importing the trusted certificate list at
minimum requires a bunch of platform-specific code, which mbedtls does not have
built in. Interestingly, OpenSSL recently gained the ability to import the
Windows certificate trust store... but that leads to the second problem, which
is that a list of trusted certificates is [not expressive
enough](https://bugs.archlinux.org/task/41909) to express a modern certificate
trust policy. For example, Windows has the concept of [explicitly distrusted
certificates](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/dn265983(v=ws.11)),
and macOS requires Certificate Transparency validation for some certificates
with complex rules for when it's required.
Option b) (using native library just to verify certs) is probably feasible, but
it would miss aspects of TLS policy other than trusted certs (like allowed
algorithms), and in any case it might well require writing more code, not less,
compared to using the native library for everything.
So I ended up at option c), using the native library for everything.
What I'd *really* prefer would be to use a third-party library that does option
c) for me. Rust has a good library for this,
[native-tls](https://docs.rs/native-tls/latest/native_tls/). I did search, but
I couldn't find a good option in the C or C++ ecosystem, at least not any that
wasn't part of some much larger framework. I was surprised - isn't this a
pretty common use case? Well, many applications only need TLS for HTTPS, and they can
use libcurl, which has a TLS abstraction layer internally but doesn't expose
it. Other applications only support a single TLS library, or use one of the
aforementioned larger frameworks, or are platform-specific to begin with, or of
course are written in a non-C/C++ language, most of which have some canonical
choice for TLS. But there are also many applications that have a set of TLS
backends just like this; it's just that nobody has gone ahead and abstracted
the pattern into a library, at least not a widespread one.
Amusingly, there is one TLS abstraction layer that Yuzu already bundles: the
one in ffmpeg. But it is missing some features that would be needed to use it
here (like reusing an existing socket rather than managing the socket itself).
Though, that does mean that the wiki's build instructions for Linux (and macOS
for some reason?) already recommend installing OpenSSL, so no need to update
those.
## Other APIs implemented
- Sockets:
- GetSockOpt(`SO_ERROR`)
- SetSockOpt(`SO_NOSIGPIPE`) (stub, I have no idea what this does on Switch)
- `DuplicateSocket` (because the SSL sysmodule calls it internally)
- More `PollEvents` values
- NSD:
- `Resolve` and `ResolveEx` (stub, good enough for Open Course World and
probably most third-party servers, but not first-party)
- SFDNSRES:
- `GetHostByNameRequest` and `GetHostByNameRequestWithOptions`
- `ResolverSetOptionRequest` (stub)
## Fixes
- Parts of the socket code were previously allocating a `sockaddr` object on
the stack when calling functions that take a `sockaddr*` (e.g. `accept`).
This might seem like the right thing to do to avoid illegal aliasing, but in
fact `sockaddr` is not guaranteed to be large enough to hold any particular
type of address, only the header. This worked in practice because in
practice `sockaddr` is the same size as `sockaddr_in`, but it's not how the
API is meant to be used. I changed this to allocate an `sockaddr_in` on the
stack and `reinterpret_cast` it. I could try to do something cleverer with
`aligned_storage`, but casting is the idiomatic way to use these particular
APIs, so it's really the system's responsibility to avoid any aliasing
issues.
- I rewrote most of the `GetAddrInfoRequest[WithOptions]` implementation. The
old implementation invoked the host's getaddrinfo directly from sfdnsres.cpp,
and directly passed through the host's socket type, protocol, etc. values
rather than looking up the corresponding constants on the Switch. To be
fair, these constants don't tend to actually vary across systems, but
still... I added a wrapper for `getaddrinfo` in
`internal_network/network.cpp` similar to the ones for other socket APIs, and
changed the `GetAddrInfoRequest` implementation to use it. While I was at
it, I rewrote the serialization to use the same approach I used to implement
`GetHostByNameRequest`, because it reduces the number of size calculations.
While doing so I removed `AF_INET6` support because the Switch doesn't
support IPv6; it might be nice to support IPv6 anyway, but that would have to
apply to all of the socket APIs.
I also corrected the IPC wrappers for `GetAddrInfoRequest` and
`GetAddrInfoRequestWithOptions` based on reverse engineering and hardware
testing. Every call to `GetAddrInfoRequestWithOptions` returns *four*
different error codes (IPC status, getaddrinfo error code, netdb error code,
and errno), and `GetAddrInfoRequest` returns three of those but in a
different order, and it doesn't really matter but the existing implementation
was a bit off, as I discovered while testing `GetHostByNameRequest`.
- The new serialization code is based on two simple helper functions:
```cpp
template <typename T> static void Append(std::vector<u8>& vec, T t);
void AppendNulTerminated(std::vector<u8>& vec, std::string_view str);
```
I was thinking there must be existing functions somewhere that assist with
serialization/deserialization of binary data, but all I could find was the
helper methods in `IOFile` and `HLERequestContext`, not anything that could
be used with a generic byte buffer. If I'm not missing something, then
maybe I should move the above functions to a new header in `common`...
right now they're just sitting in `sfdnsres.cpp` where they're used.
- Not a fix, but `SocketBase::Recv`/`Send` is changed to use `std::span<u8>`
rather than `std::vector<u8>&` to avoid needing to copy the data to/from a
vector when those methods are called from the TLS implementation.
2023-06-20 03:17:43 +02:00
|
|
|
if(ENABLE_OPENSSL)
|
2023-06-25 23:57:34 +02:00
|
|
|
find_package(OpenSSL 1.1.1 REQUIRED)
|
Implement SSL service
This implements some missing network APIs including a large chunk of the SSL
service, enough for Mario Maker (with an appropriate mod applied) to connect to
the fan server [Open Course World](https://opencourse.world/).
Connecting to first-party servers is out of scope of this PR and is a
minefield I'd rather not step into.
## TLS
TLS is implemented with multiple backends depending on the system's 'native'
TLS library. Currently there are two backends: Schannel for Windows, and
OpenSSL for Linux. (In reality Linux is a bit of a free-for-all where there's
no one 'native' library, but OpenSSL is the closest it gets.) On macOS the
'native' library is SecureTransport but that isn't implemented in this PR.
(Instead, all non-Windows OSes will use OpenSSL unless disabled with
`-DENABLE_OPENSSL=OFF`.)
Why have multiple backends instead of just using a single library, especially
given that Yuzu already embeds mbedtls for cryptographic algorithms? Well, I
tried implementing this on mbedtls first, but the problem is TLS policies -
mainly trusted certificate policies, and to a lesser extent trusted algorithms,
SSL versions, etc.
...In practice, the chance that someone is going to conduct a man-in-the-middle
attack on a third-party game server is pretty low, but I'm a security nerd so I
like to do the right security things.
My base assumption is that we want to use the host system's TLS policies. An
alternative would be to more closely emulate the Switch's TLS implementation
(which is based on NSS). But for one thing, I don't feel like reverse
engineering it. And I'd argue that for third-party servers such as Open Course
World, it's theoretically preferable to use the system's policies rather than
the Switch's, for two reasons
1. Someday the Switch will stop being updated, and the trusted cert list,
algorithms, etc. will start to go stale, but users will still want to
connect to third-party servers, and there's no reason they shouldn't have
up-to-date security when doing so. At that point, homebrew users on actual
hardware may patch the TLS implementation, but for emulators it's simpler to
just use the host's stack.
2. Also, it's good to respect any custom certificate policies the user may have
added systemwide. For example, they may have added custom trusted CAs in
order to use TLS debugging tools or pass through corporate MitM middleboxes.
Or they may have removed some CAs that are normally trusted out of paranoia.
Note that this policy wouldn't work as-is for connecting to first-party
servers, because some of them serve certificates based on Nintendo's own CA
rather than a publicly trusted one. However, this could probably be solved
easily by using appropriate APIs to adding Nintendo's CA as an alternate
trusted cert for Yuzu's connections. That is not implemented in this PR
because, again, first-party servers are out of scope.
(If anything I'd rather have an option to _block_ connections to Nintendo
servers, but that's not implemented here.)
To use the host's TLS policies, there are three theoretical options:
a) Import the host's trusted certificate list into a cross-platform TLS
library (presumably mbedtls).
b) Use the native TLS library to verify certificates but use a cross-platform
TLS library for everything else.
c) Use the native TLS library for everything.
Two problems with option a). First, importing the trusted certificate list at
minimum requires a bunch of platform-specific code, which mbedtls does not have
built in. Interestingly, OpenSSL recently gained the ability to import the
Windows certificate trust store... but that leads to the second problem, which
is that a list of trusted certificates is [not expressive
enough](https://bugs.archlinux.org/task/41909) to express a modern certificate
trust policy. For example, Windows has the concept of [explicitly distrusted
certificates](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/dn265983(v=ws.11)),
and macOS requires Certificate Transparency validation for some certificates
with complex rules for when it's required.
Option b) (using native library just to verify certs) is probably feasible, but
it would miss aspects of TLS policy other than trusted certs (like allowed
algorithms), and in any case it might well require writing more code, not less,
compared to using the native library for everything.
So I ended up at option c), using the native library for everything.
What I'd *really* prefer would be to use a third-party library that does option
c) for me. Rust has a good library for this,
[native-tls](https://docs.rs/native-tls/latest/native_tls/). I did search, but
I couldn't find a good option in the C or C++ ecosystem, at least not any that
wasn't part of some much larger framework. I was surprised - isn't this a
pretty common use case? Well, many applications only need TLS for HTTPS, and they can
use libcurl, which has a TLS abstraction layer internally but doesn't expose
it. Other applications only support a single TLS library, or use one of the
aforementioned larger frameworks, or are platform-specific to begin with, or of
course are written in a non-C/C++ language, most of which have some canonical
choice for TLS. But there are also many applications that have a set of TLS
backends just like this; it's just that nobody has gone ahead and abstracted
the pattern into a library, at least not a widespread one.
Amusingly, there is one TLS abstraction layer that Yuzu already bundles: the
one in ffmpeg. But it is missing some features that would be needed to use it
here (like reusing an existing socket rather than managing the socket itself).
Though, that does mean that the wiki's build instructions for Linux (and macOS
for some reason?) already recommend installing OpenSSL, so no need to update
those.
## Other APIs implemented
- Sockets:
- GetSockOpt(`SO_ERROR`)
- SetSockOpt(`SO_NOSIGPIPE`) (stub, I have no idea what this does on Switch)
- `DuplicateSocket` (because the SSL sysmodule calls it internally)
- More `PollEvents` values
- NSD:
- `Resolve` and `ResolveEx` (stub, good enough for Open Course World and
probably most third-party servers, but not first-party)
- SFDNSRES:
- `GetHostByNameRequest` and `GetHostByNameRequestWithOptions`
- `ResolverSetOptionRequest` (stub)
## Fixes
- Parts of the socket code were previously allocating a `sockaddr` object on
the stack when calling functions that take a `sockaddr*` (e.g. `accept`).
This might seem like the right thing to do to avoid illegal aliasing, but in
fact `sockaddr` is not guaranteed to be large enough to hold any particular
type of address, only the header. This worked in practice because in
practice `sockaddr` is the same size as `sockaddr_in`, but it's not how the
API is meant to be used. I changed this to allocate an `sockaddr_in` on the
stack and `reinterpret_cast` it. I could try to do something cleverer with
`aligned_storage`, but casting is the idiomatic way to use these particular
APIs, so it's really the system's responsibility to avoid any aliasing
issues.
- I rewrote most of the `GetAddrInfoRequest[WithOptions]` implementation. The
old implementation invoked the host's getaddrinfo directly from sfdnsres.cpp,
and directly passed through the host's socket type, protocol, etc. values
rather than looking up the corresponding constants on the Switch. To be
fair, these constants don't tend to actually vary across systems, but
still... I added a wrapper for `getaddrinfo` in
`internal_network/network.cpp` similar to the ones for other socket APIs, and
changed the `GetAddrInfoRequest` implementation to use it. While I was at
it, I rewrote the serialization to use the same approach I used to implement
`GetHostByNameRequest`, because it reduces the number of size calculations.
While doing so I removed `AF_INET6` support because the Switch doesn't
support IPv6; it might be nice to support IPv6 anyway, but that would have to
apply to all of the socket APIs.
I also corrected the IPC wrappers for `GetAddrInfoRequest` and
`GetAddrInfoRequestWithOptions` based on reverse engineering and hardware
testing. Every call to `GetAddrInfoRequestWithOptions` returns *four*
different error codes (IPC status, getaddrinfo error code, netdb error code,
and errno), and `GetAddrInfoRequest` returns three of those but in a
different order, and it doesn't really matter but the existing implementation
was a bit off, as I discovered while testing `GetHostByNameRequest`.
- The new serialization code is based on two simple helper functions:
```cpp
template <typename T> static void Append(std::vector<u8>& vec, T t);
void AppendNulTerminated(std::vector<u8>& vec, std::string_view str);
```
I was thinking there must be existing functions somewhere that assist with
serialization/deserialization of binary data, but all I could find was the
helper methods in `IOFile` and `HLERequestContext`, not anything that could
be used with a generic byte buffer. If I'm not missing something, then
maybe I should move the above functions to a new header in `common`...
right now they're just sitting in `sfdnsres.cpp` where they're used.
- Not a fix, but `SocketBase::Recv`/`Send` is changed to use `std::span<u8>`
rather than `std::vector<u8>&` to avoid needing to copy the data to/from a
vector when those methods are called from the TLS implementation.
2023-06-20 03:17:43 +02:00
|
|
|
endif()
|
|
|
|
|
|
2023-11-03 19:27:08 +01:00
|
|
|
if (UNIX AND NOT APPLE)
|
|
|
|
|
find_package(gamemode 1.7 MODULE)
|
|
|
|
|
endif()
|
|
|
|
|
|
2022-10-18 01:55:40 +02:00
|
|
|
# Please consider this as a stub
|
|
|
|
|
if(ENABLE_QT6 AND Qt6_LOCATION)
|
|
|
|
|
list(APPEND CMAKE_PREFIX_PATH "${Qt6_LOCATION}")
|
|
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
# find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the citron_find_package
|
2021-04-16 08:12:23 +02:00
|
|
|
if (ENABLE_SDL2)
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_USE_BUNDLED_SDL2)
|
2021-04-16 08:12:23 +02:00
|
|
|
# Detect toolchain and platform
|
2025-01-03 05:27:12 +01:00
|
|
|
if ((MSVC_VERSION GREATER_EQUAL 1920) AND ARCHITECTURE_x86_64)
|
2023-08-28 05:08:28 +02:00
|
|
|
set(SDL2_VER "SDL2-2.28.2")
|
2021-04-16 08:12:23 +02:00
|
|
|
else()
|
2024-12-31 08:07:49 +01:00
|
|
|
message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable CITRON_USE_BUNDLED_SDL2 and provide your own.")
|
2021-04-16 08:12:23 +02:00
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
if (DEFINED SDL2_VER)
|
|
|
|
|
download_bundled_external("sdl2/" ${SDL2_VER} SDL2_PREFIX)
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
set(SDL2_FOUND YES)
|
|
|
|
|
set(SDL2_INCLUDE_DIR "${SDL2_PREFIX}/include" CACHE PATH "Path to SDL2 headers")
|
|
|
|
|
set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
|
|
|
|
|
set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
|
|
|
|
|
|
2022-12-06 00:44:52 +01:00
|
|
|
add_library(SDL2::SDL2 INTERFACE IMPORTED)
|
|
|
|
|
target_link_libraries(SDL2::SDL2 INTERFACE "${SDL2_LIBRARY}")
|
|
|
|
|
target_include_directories(SDL2::SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
|
2024-12-31 08:07:49 +01:00
|
|
|
elseif (CITRON_USE_EXTERNAL_SDL2)
|
2021-07-16 03:02:00 +02:00
|
|
|
message(STATUS "Using SDL2 from externals.")
|
2021-04-16 08:12:23 +02:00
|
|
|
else()
|
2023-05-20 20:42:37 +02:00
|
|
|
find_package(SDL2 2.26.4 REQUIRED)
|
2020-05-08 23:09:29 +02:00
|
|
|
endif()
|
|
|
|
|
endif()
|
2017-05-28 06:38:49 +02:00
|
|
|
|
2025-01-12 04:26:22 +01:00
|
|
|
add_subdirectory(externals)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (ENABLE_QT)
|
|
|
|
|
if (NOT USE_SYSTEM_QT)
|
|
|
|
|
download_qt(6.7.3)
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
find_package(Qt6 REQUIRED COMPONENTS Widgets Multimedia Concurrent)
|
|
|
|
|
|
|
|
|
|
if (UNIX AND NOT APPLE)
|
|
|
|
|
find_package(Qt6 REQUIRED COMPONENTS DBus)
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
if (ENABLE_QT_TRANSLATION)
|
|
|
|
|
find_package(Qt6 REQUIRED COMPONENTS LinguistTools)
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
if (NOT DEFINED QT_TARGET_PATH)
|
|
|
|
|
get_target_property(qtcore_path Qt6::Core LOCATION_Release)
|
|
|
|
|
string(FIND "${qtcore_path}" "/bin/" qtcore_path_bin_pos REVERSE)
|
|
|
|
|
string(FIND "${qtcore_path}" "/lib/" qtcore_path_lib_pos REVERSE)
|
|
|
|
|
if (qtcore_path_bin_pos GREATER qtcore_path_lib_pos)
|
|
|
|
|
string(SUBSTRING "${qtcore_path}" 0 ${qtcore_path_bin_pos} QT_TARGET_PATH)
|
|
|
|
|
else()
|
|
|
|
|
string(SUBSTRING "${qtcore_path}" 0 ${qtcore_path_lib_pos} QT_TARGET_PATH)
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
if (NOT DEFINED QT_HOST_PATH)
|
|
|
|
|
set(QT_HOST_PATH "${QT_TARGET_PATH}")
|
|
|
|
|
endif()
|
|
|
|
|
message(STATUS "Using target Qt at ${QT_TARGET_PATH}")
|
|
|
|
|
message(STATUS "Using host Qt at ${QT_HOST_PATH}")
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
function(set_citron_qt_components)
|
|
|
|
|
# Best practice is to ask for all components at once, so they are from the same version
|
|
|
|
|
set(CITRON_QT_COMPONENTS2 Core Widgets Concurrent)
|
|
|
|
|
if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
|
|
|
|
|
list(APPEND CITRON_QT_COMPONENTS2 DBus)
|
|
|
|
|
endif()
|
|
|
|
|
if (CITRON_USE_QT_MULTIMEDIA)
|
|
|
|
|
list(APPEND CITRON_QT_COMPONENTS2 Multimedia)
|
|
|
|
|
endif()
|
|
|
|
|
if (CITRON_USE_QT_WEB_ENGINE)
|
|
|
|
|
list(APPEND CITRON_QT_COMPONENTS2 WebEngineCore WebEngineWidgets)
|
|
|
|
|
endif()
|
|
|
|
|
if (ENABLE_QT_TRANSLATION)
|
|
|
|
|
list(APPEND CITRON_QT_COMPONENTS2 LinguistTools)
|
|
|
|
|
endif()
|
|
|
|
|
if (USE_DISCORD_PRESENCE)
|
|
|
|
|
list(APPEND CITRON_QT_COMPONENTS2 Network)
|
|
|
|
|
endif()
|
|
|
|
|
set(CITRON_QT_COMPONENTS ${CITRON_QT_COMPONENTS2} PARENT_SCOPE)
|
|
|
|
|
endfunction(set_citron_qt_components)
|
|
|
|
|
|
|
|
|
|
# List of all FFmpeg components required
|
|
|
|
|
set(FFmpeg_COMPONENTS
|
2021-02-06 09:14:11 +01:00
|
|
|
avcodec
|
2023-05-13 23:35:01 +02:00
|
|
|
avfilter
|
2021-02-06 09:14:11 +01:00
|
|
|
avutil
|
|
|
|
|
swscale)
|
|
|
|
|
|
2025-01-12 04:26:22 +01:00
|
|
|
if (UNIX AND NOT APPLE AND NOT ANDROID)
|
2022-09-20 22:21:52 +02:00
|
|
|
find_package(PkgConfig REQUIRED)
|
2021-08-07 21:19:20 +02:00
|
|
|
pkg_check_modules(LIBVA libva)
|
|
|
|
|
endif()
|
2024-12-31 08:07:49 +01:00
|
|
|
if (NOT CITRON_USE_BUNDLED_FFMPEG)
|
2021-02-06 09:14:11 +01:00
|
|
|
# Use system installed FFmpeg
|
2022-12-01 06:49:58 +01:00
|
|
|
find_package(FFmpeg 4.3 REQUIRED QUIET COMPONENTS ${FFmpeg_COMPONENTS})
|
2021-02-06 09:14:11 +01:00
|
|
|
endif()
|
|
|
|
|
|
2025-01-12 04:26:22 +01:00
|
|
|
if(ENABLE_QT)
|
|
|
|
|
set_citron_qt_components()
|
|
|
|
|
find_package(Qt6 REQUIRED COMPONENTS ${CITRON_QT_COMPONENTS})
|
|
|
|
|
set(QT_MAJOR_VERSION 6)
|
|
|
|
|
# Qt6 sets cxx_std_17 and we need to undo that
|
|
|
|
|
set_target_properties(Qt6::Platform PROPERTIES INTERFACE_COMPILE_FEATURES "")
|
|
|
|
|
endif()
|
|
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (WIN32 AND CITRON_CRASH_DUMPS)
|
2023-10-04 19:11:05 +02:00
|
|
|
set(BREAKPAD_VER "breakpad-c89f9dd")
|
|
|
|
|
download_bundled_external("breakpad/" ${BREAKPAD_VER} BREAKPAD_PREFIX)
|
|
|
|
|
|
|
|
|
|
set(BREAKPAD_CLIENT_INCLUDE_DIR "${BREAKPAD_PREFIX}/include")
|
|
|
|
|
set(BREAKPAD_CLIENT_LIBRARY "${BREAKPAD_PREFIX}/lib/libbreakpad_client.lib")
|
|
|
|
|
|
|
|
|
|
add_library(libbreakpad_client INTERFACE IMPORTED)
|
|
|
|
|
target_link_libraries(libbreakpad_client INTERFACE "${BREAKPAD_CLIENT_LIBRARY}")
|
|
|
|
|
target_include_directories(libbreakpad_client INTERFACE "${BREAKPAD_CLIENT_INCLUDE_DIR}")
|
|
|
|
|
endif()
|
|
|
|
|
|
2020-05-08 23:09:29 +02:00
|
|
|
# Prefer the -pthread flag on Linux.
|
|
|
|
|
set(THREADS_PREFER_PTHREAD_FLAG ON)
|
|
|
|
|
find_package(Threads REQUIRED)
|
2018-01-04 06:13:23 +01:00
|
|
|
|
2017-05-28 08:45:55 +02:00
|
|
|
# Platform-specific library requirements
|
|
|
|
|
# ======================================
|
|
|
|
|
|
2019-03-16 06:45:08 +01:00
|
|
|
if (APPLE)
|
|
|
|
|
# Umbrella framework for everything GUI-related
|
|
|
|
|
find_library(COCOA_LIBRARY Cocoa)
|
2016-10-10 19:35:23 +02:00
|
|
|
set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY})
|
2019-03-16 06:45:08 +01:00
|
|
|
elseif (WIN32)
|
2023-03-04 02:48:15 +01:00
|
|
|
# Target Windows 10
|
|
|
|
|
add_definitions(-D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00)
|
2021-08-12 21:32:53 +02:00
|
|
|
set(PLATFORM_LIBRARIES winmm ws2_32 iphlpapi)
|
2019-03-16 06:45:08 +01:00
|
|
|
if (MINGW)
|
2016-11-28 19:38:47 +01:00
|
|
|
# PSAPI is the Process Status API
|
2016-11-30 15:59:26 +01:00
|
|
|
set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version)
|
2019-03-16 06:45:08 +01:00
|
|
|
endif()
|
|
|
|
|
elseif (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
|
2014-12-24 10:34:25 +01:00
|
|
|
set(PLATFORM_LIBRARIES rt)
|
2019-03-16 06:45:08 +01:00
|
|
|
endif()
|
2014-04-29 04:40:39 +02:00
|
|
|
|
2018-01-20 08:31:44 +01:00
|
|
|
# Setup a custom clang-format target (if clang-format can be found) that will run
|
|
|
|
|
# against all the src files. This should be used before making a pull request.
|
|
|
|
|
# =======================================================================
|
|
|
|
|
|
2023-01-30 02:56:12 +01:00
|
|
|
set(CLANG_FORMAT_POSTFIX "-15")
|
2018-01-20 08:31:44 +01:00
|
|
|
find_program(CLANG_FORMAT
|
|
|
|
|
NAMES clang-format${CLANG_FORMAT_POSTFIX}
|
|
|
|
|
clang-format
|
2018-10-20 23:08:26 +02:00
|
|
|
PATHS ${PROJECT_BINARY_DIR}/externals)
|
2018-01-20 08:31:44 +01:00
|
|
|
# if find_program doesn't find it, try to download from externals
|
|
|
|
|
if (NOT CLANG_FORMAT)
|
2020-05-08 23:09:29 +02:00
|
|
|
if (WIN32 AND NOT CMAKE_CROSSCOMPILING)
|
2018-01-20 08:31:44 +01:00
|
|
|
message(STATUS "Clang format not found! Downloading...")
|
2018-10-20 23:08:26 +02:00
|
|
|
set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
|
2018-01-20 08:31:44 +01:00
|
|
|
file(DOWNLOAD
|
2024-12-31 08:07:49 +01:00
|
|
|
https://github.com/yuzu-mirror/ext-windows-bin/raw/master/clang-format${CLANG_FORMAT_POSTFIX}.exe
|
2018-01-20 08:31:44 +01:00
|
|
|
"${CLANG_FORMAT}" SHOW_PROGRESS
|
|
|
|
|
STATUS DOWNLOAD_SUCCESS)
|
|
|
|
|
if (NOT DOWNLOAD_SUCCESS EQUAL 0)
|
|
|
|
|
message(WARNING "Could not download clang format! Disabling the clang format target")
|
|
|
|
|
file(REMOVE ${CLANG_FORMAT})
|
|
|
|
|
unset(CLANG_FORMAT)
|
|
|
|
|
endif()
|
|
|
|
|
else()
|
|
|
|
|
message(WARNING "Clang format not found! Disabling the clang format target")
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
|
|
|
|
|
|
|
|
|
if (CLANG_FORMAT)
|
2018-10-20 23:08:26 +02:00
|
|
|
set(SRCS ${PROJECT_SOURCE_DIR}/src)
|
2018-01-20 08:31:44 +01:00
|
|
|
set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
|
|
|
|
|
if (WIN32)
|
|
|
|
|
add_custom_target(clang-format
|
2019-04-03 03:02:43 +02:00
|
|
|
COMMAND powershell.exe -Command "Get-ChildItem '${SRCS}/*' -Include *.cpp,*.h -Recurse | Foreach {&'${CLANG_FORMAT}' -i $_.fullname}"
|
2018-01-20 08:31:44 +01:00
|
|
|
COMMENT ${CCOMMENT})
|
|
|
|
|
elseif(MINGW)
|
|
|
|
|
add_custom_target(clang-format
|
|
|
|
|
COMMAND find `cygpath -u ${SRCS}` -iname *.h -o -iname *.cpp | xargs `cygpath -u ${CLANG_FORMAT}` -i
|
|
|
|
|
COMMENT ${CCOMMENT})
|
|
|
|
|
else()
|
|
|
|
|
add_custom_target(clang-format
|
|
|
|
|
COMMAND find ${SRCS} -iname *.h -o -iname *.cpp | xargs ${CLANG_FORMAT} -i
|
|
|
|
|
COMMENT ${CCOMMENT})
|
|
|
|
|
endif()
|
|
|
|
|
unset(SRCS)
|
|
|
|
|
unset(CCOMMENT)
|
|
|
|
|
endif()
|
2015-08-28 21:57:08 +02:00
|
|
|
|
2017-05-28 08:45:55 +02:00
|
|
|
# Include source code
|
|
|
|
|
# ===================
|
2013-08-30 05:35:09 +02:00
|
|
|
|
2014-08-24 03:22:05 +02:00
|
|
|
# This function should be passed a list of all files in a target. It will automatically generate
|
|
|
|
|
# file groups following the directory hierarchy, so that the layout of the files in IDEs matches the
|
|
|
|
|
# one in the filesystem.
|
2018-01-18 01:37:34 +01:00
|
|
|
function(create_target_directory_groups target_name)
|
2014-08-24 03:22:05 +02:00
|
|
|
# Place any files that aren't in the source list in a separate group so that they don't get in
|
|
|
|
|
# the way.
|
|
|
|
|
source_group("Other Files" REGULAR_EXPRESSION ".")
|
|
|
|
|
|
2018-01-18 01:37:34 +01:00
|
|
|
get_target_property(target_sources "${target_name}" SOURCES)
|
|
|
|
|
|
|
|
|
|
foreach(file_name IN LISTS target_sources)
|
2014-08-24 03:22:05 +02:00
|
|
|
get_filename_component(dir_name "${file_name}" PATH)
|
|
|
|
|
# Group names use '\' as a separator even though the entire rest of CMake uses '/'...
|
|
|
|
|
string(REPLACE "/" "\\" group_name "${dir_name}")
|
|
|
|
|
source_group("${group_name}" FILES "${file_name}")
|
|
|
|
|
endforeach()
|
|
|
|
|
endfunction()
|
|
|
|
|
|
2019-08-24 15:57:49 +02:00
|
|
|
# Prevent boost from linking against libs when building
|
2022-12-06 21:01:26 +01:00
|
|
|
target_link_libraries(Boost::headers INTERFACE Boost::disable_autolinking)
|
2021-12-24 02:23:02 +01:00
|
|
|
# Adjustments for MSVC + Ninja
|
|
|
|
|
if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
|
|
|
|
|
add_compile_options(
|
|
|
|
|
/wd4464 # relative include path contains '..'
|
2022-10-21 08:34:07 +02:00
|
|
|
/wd4711 # function 'function' selected for automatic inline expansion
|
|
|
|
|
/wd4820 # 'bytes' bytes padding added after construct 'member_name'
|
2021-12-24 02:23:02 +01:00
|
|
|
)
|
|
|
|
|
endif()
|
2019-08-24 15:57:49 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
if (CITRON_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
|
2022-12-10 18:50:00 +01:00
|
|
|
# We will assume that if the compiler is GCC, it will attempt to use ld.bfd by default.
|
|
|
|
|
# Try to pick a faster linker.
|
|
|
|
|
find_program(LLD lld)
|
|
|
|
|
find_program(MOLD mold)
|
|
|
|
|
|
|
|
|
|
if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
|
|
|
|
|
message(NOTICE "Selecting mold as linker")
|
|
|
|
|
add_link_options("-fuse-ld=mold")
|
|
|
|
|
elseif (LLD)
|
|
|
|
|
message(NOTICE "Selecting lld as linker")
|
|
|
|
|
add_link_options("-fuse-ld=lld")
|
|
|
|
|
endif()
|
|
|
|
|
endif()
|
|
|
|
|
|
2025-01-12 04:26:22 +01:00
|
|
|
# Set runtime library to MD/MDd for all configurations
|
|
|
|
|
if(MSVC)
|
|
|
|
|
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
|
|
|
|
|
|
|
|
|
|
# Force all projects (including external dependencies) to use the same runtime
|
|
|
|
|
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
|
|
|
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
|
|
|
|
|
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MD")
|
|
|
|
|
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MDd")
|
|
|
|
|
|
|
|
|
|
# Add this to ensure Cubeb uses the same runtime
|
|
|
|
|
add_compile_options(
|
|
|
|
|
$<$<CONFIG:Debug>:/MDd>
|
|
|
|
|
$<$<CONFIG:Release>:/MD>
|
|
|
|
|
$<$<CONFIG:RelWithDebInfo>:/MD>
|
|
|
|
|
$<$<CONFIG:MinSizeRel>:/MD>
|
|
|
|
|
)
|
|
|
|
|
endif()
|
|
|
|
|
|
2013-08-30 05:35:09 +02:00
|
|
|
add_subdirectory(src)
|
2015-04-22 13:34:42 +02:00
|
|
|
|
2024-12-31 08:07:49 +01:00
|
|
|
# Set citron project or citron-cmd project as default StartUp Project in Visual Studio depending on whether QT is enabled or not
|
2018-09-22 12:24:02 +02:00
|
|
|
if(ENABLE_QT)
|
2024-12-31 08:07:49 +01:00
|
|
|
set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT citron)
|
2018-09-22 12:24:02 +02:00
|
|
|
else()
|
2024-12-31 08:07:49 +01:00
|
|
|
set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT citron-cmd)
|
2018-09-22 12:24:02 +02:00
|
|
|
endif()
|
2018-09-12 17:36:10 +02:00
|
|
|
|
2017-05-28 08:45:55 +02:00
|
|
|
|
|
|
|
|
# Installation instructions
|
|
|
|
|
# =========================
|
|
|
|
|
|
2015-04-22 13:34:42 +02:00
|
|
|
# Install freedesktop.org metadata files, following those specifications:
|
2022-04-28 23:24:19 +02:00
|
|
|
# https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html
|
|
|
|
|
# https://specifications.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
|
|
|
|
|
# https://specifications.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html
|
|
|
|
|
# https://www.freedesktop.org/software/appstream/docs/
|
2016-10-10 07:58:05 +02:00
|
|
|
if(ENABLE_QT AND UNIX AND NOT APPLE)
|
2024-12-31 08:07:49 +01:00
|
|
|
install(FILES "dist/org.citron_emu.citron.desktop"
|
2022-04-28 23:24:19 +02:00
|
|
|
DESTINATION "share/applications")
|
2024-12-31 08:07:49 +01:00
|
|
|
install(FILES "dist/citron.svg"
|
2022-04-28 23:24:19 +02:00
|
|
|
DESTINATION "share/icons/hicolor/scalable/apps"
|
2024-12-31 08:07:49 +01:00
|
|
|
RENAME "org.citron_emu.citron.svg")
|
|
|
|
|
install(FILES "dist/org.citron_emu.citron.xml"
|
2022-04-28 23:24:19 +02:00
|
|
|
DESTINATION "share/mime/packages")
|
2024-12-31 08:07:49 +01:00
|
|
|
install(FILES "dist/org.citron_emu.citron.metainfo.xml"
|
2022-04-28 23:24:19 +02:00
|
|
|
DESTINATION "share/metainfo")
|
2015-04-22 13:34:42 +02:00
|
|
|
endif()
|
2025-01-13 08:57:17 +01:00
|
|
|
|
2025-01-14 06:33:24 +01:00
|
|
|
# Set CPU architecture compatibility flags
|
2025-01-13 08:57:17 +01:00
|
|
|
if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64")
|
2025-01-14 06:33:24 +01:00
|
|
|
# Default to x86-64 baseline for maximum compatibility
|
|
|
|
|
set(ISA_FLAGS "-march=x86-64")
|
|
|
|
|
|
|
|
|
|
# Allow override via CMake option
|
|
|
|
|
option(CITRON_USE_X86_64_V2 "Enable x86-64-v2 instruction set" OFF)
|
|
|
|
|
|
|
|
|
|
if(CITRON_USE_X86_64_V2)
|
|
|
|
|
set(ISA_FLAGS "-march=x86-64-v2")
|
|
|
|
|
endif()
|
2025-01-13 09:26:44 +01:00
|
|
|
|
|
|
|
|
# Set for main project
|
|
|
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ISA_FLAGS}")
|
|
|
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ISA_FLAGS}")
|
|
|
|
|
|
|
|
|
|
# Set for vcpkg dependencies
|
|
|
|
|
set(VCPKG_CXX_FLAGS "${ISA_FLAGS}")
|
|
|
|
|
set(VCPKG_C_FLAGS "${ISA_FLAGS}")
|
|
|
|
|
|
2025-01-14 06:33:24 +01:00
|
|
|
# Set toolchain options for vcpkg
|
|
|
|
|
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/cmake/x86-64-toolchain.cmake")
|
2025-01-13 08:57:17 +01:00
|
|
|
|
|
|
|
|
# Ensure we're not getting overridden by system defaults
|
2025-01-13 09:26:44 +01:00
|
|
|
add_compile_options(${ISA_FLAGS})
|
2025-01-13 08:57:17 +01:00
|
|
|
|
|
|
|
|
# Force disable higher ISA levels
|
|
|
|
|
add_compile_definitions(
|
|
|
|
|
__x86_64_v3__=0
|
|
|
|
|
__x86_64_v4__=0
|
|
|
|
|
)
|
|
|
|
|
endif()
|
