35 files changed, 976 insertions, 983 deletions

diff --git a/.gitmodules b/.gitmodules
index 9d9356151..6931a641d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,6 @@
 [submodule "inih"]
     path = externals/inih/inih
-    url = https://github.com/svn2github/inih
+    url = https://github.com/benhoyt/inih.git
 [submodule "cubeb"]
     path = externals/cubeb
     url = https://github.com/kinetiknz/cubeb.git
diff --git a/externals/CMakeLists.txt b/externals/CMakeLists.txt
index e01ff6930..421b35890 100644
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -73,17 +73,20 @@ if (NOT LIBZIP_FOUND)
 endif()
 
 if (ENABLE_WEB_SERVICE)
-    # LibreSSL
-    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
-    add_subdirectory(libressl EXCLUDE_FROM_ALL)
-    target_include_directories(ssl INTERFACE ./libressl/include)
-    target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-    get_directory_property(OPENSSL_LIBRARIES
-        DIRECTORY libressl
-        DEFINITION OPENSSL_LIBS)
-
-    # lurlparser
-    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
+    find_package(OpenSSL 1.1)
+    if (OPENSSL_FOUND)
+        set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+    else()
+        # LibreSSL
+        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+        set(OPENSSLDIR "/etc/ssl/")
+        add_subdirectory(libressl EXCLUDE_FROM_ALL)
+        target_include_directories(ssl INTERFACE ./libressl/include)
+        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+        get_directory_property(OPENSSL_LIBRARIES
+            DIRECTORY libressl
+            DEFINITION OPENSSL_LIBS)
+    endif()
 
     # httplib
     add_library(httplib INTERFACE)
diff --git a/externals/httplib/README.md b/externals/httplib/README.md
index 73037d297..1940e446c 100644
--- a/externals/httplib/README.md
+++ b/externals/httplib/README.md
@@ -1,4 +1,4 @@
-From https://github.com/yhirose/cpp-httplib/tree/fce8e6fefdab4ad48bc5b25c98e5ebfda4f3cf53
+From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
 
 MIT License
 
diff --git a/externals/httplib/httplib.h b/externals/httplib/httplib.h
index 5139b7f05..8982054e2 100644
--- a/externals/httplib/httplib.h
+++ b/externals/httplib/httplib.h
@@ -173,6 +173,7 @@ using socket_t = int;
 #define INVALID_SOCKET (-1)
 #endif //_WIN32
 
+#include <algorithm>
 #include <array>
 #include <atomic>
 #include <cassert>
@@ -237,6 +238,27 @@ namespace httplib {
 
 namespace detail {
 
+/*
+ * Backport std::make_unique from C++14.
+ *
+ * NOTE: This code came up with the following stackoverflow post:
+ * https://stackoverflow.com/questions/10149840/c-arrays-and-make-unique
+ *
+ */
+
+template <class T, class... Args>
+typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
+make_unique(Args &&... args) {
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+template <class T>
+typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
+make_unique(std::size_t n) {
+  typedef typename std::remove_extent<T>::type RT;
+  return std::unique_ptr<T>(new RT[n]);
+}
+
 struct ci {
   bool operator()(const std::string &s1, const std::string &s2) const {
     return std::lexicographical_compare(
@@ -304,6 +326,10 @@ using ContentProvider =
 using ContentProviderWithoutLength =
     std::function<bool(size_t offset, DataSink &sink)>;
 
+using ContentReceiverWithProgress =
+    std::function<bool(const char *data, size_t data_length, uint64_t offset,
+                       uint64_t total_length)>;
+
 using ContentReceiver =
     std::function<bool(const char *data, size_t data_length)>;
 
@@ -317,14 +343,17 @@ public:
                                              ContentReceiver receiver)>;
 
   ContentReader(Reader reader, MultipartReader multipart_reader)
-      : reader_(reader), multipart_reader_(multipart_reader) {}
+      : reader_(std::move(reader)),
+        multipart_reader_(std::move(multipart_reader)) {}
 
   bool operator()(MultipartContentHeader header,
                   ContentReceiver receiver) const {
-    return multipart_reader_(header, receiver);
+    return multipart_reader_(std::move(header), std::move(receiver));
   }
 
-  bool operator()(ContentReceiver receiver) const { return reader_(receiver); }
+  bool operator()(ContentReceiver receiver) const {
+    return reader_(std::move(receiver));
+  }
 
   Reader reader_;
   MultipartReader multipart_reader_;
@@ -353,7 +382,7 @@ struct Request {
   // for client
   size_t redirect_count = CPPHTTPLIB_REDIRECT_MAX_COUNT;
   ResponseHandler response_handler;
-  ContentReceiver content_receiver;
+  ContentReceiverWithProgress content_receiver;
   size_t content_length = 0;
   ContentProvider content_provider;
   Progress progress;
@@ -475,7 +504,7 @@ public:
 
   void enqueue(std::function<void()> fn) override {
     std::unique_lock<std::mutex> lock(mutex_);
-    jobs_.push_back(fn);
+    jobs_.push_back(std::move(fn));
     cond_.notify_one();
   }
 
@@ -664,8 +693,8 @@ private:
                          ContentReceiver multipart_receiver);
 
   virtual bool process_and_close_socket(socket_t sock);
-  
-  struct MountPointEntry { 
+
+  struct MountPointEntry {
     std::string mount_point;
     std::string base_dir;
     Headers headers;
@@ -704,23 +733,27 @@ enum Error {
   Canceled,
   SSLConnection,
   SSLLoadingCerts,
-  SSLServerVerification
+  SSLServerVerification,
+  UnsupportedMultipartBoundaryChars
 };
 
 class Result {
 public:
-  Result(const std::shared_ptr<Response> &res, Error err)
-      : res_(res), err_(err) {}
+  Result(std::unique_ptr<Response> res, Error err)
+      : res_(std::move(res)), err_(err) {}
   operator bool() const { return res_ != nullptr; }
   bool operator==(std::nullptr_t) const { return res_ == nullptr; }
   bool operator!=(std::nullptr_t) const { return res_ != nullptr; }
   const Response &value() const { return *res_; }
+  Response &value() { return *res_; }
   const Response &operator*() const { return *res_; }
+  Response &operator*() { return *res_; }
   const Response *operator->() const { return res_.get(); }
+  Response *operator->() { return res_.get(); }
   Error error() const { return err_; }
 
 private:
-  std::shared_ptr<Response> res_;
+  std::unique_ptr<Response> res_;
   Error err_;
 };
 
@@ -777,6 +810,8 @@ public:
   Result Post(const char *path, const MultipartFormDataItems &items);
   Result Post(const char *path, const Headers &headers,
               const MultipartFormDataItems &items);
+  Result Post(const char *path, const Headers &headers,
+              const MultipartFormDataItems &items, const std::string &boundary);
 
   Result Put(const char *path);
   Result Put(const char *path, const std::string &body,
@@ -863,7 +898,21 @@ protected:
   };
 
   virtual bool create_and_connect_socket(Socket &socket);
-  virtual void close_socket(Socket &socket, bool process_socket_ret);
+
+  // All of:
+  //   shutdown_ssl
+  //   shutdown_socket
+  //   close_socket
+  // should ONLY be called when socket_mutex_ is locked.
+  // Also, shutdown_ssl and close_socket should also NOT be called concurrently
+  // with a DIFFERENT thread sending requests using that socket.
+  virtual void shutdown_ssl(Socket &socket, bool shutdown_gracefully);
+  void shutdown_socket(Socket &socket);
+  void close_socket(Socket &socket);
+
+  // Similar to shutdown_ssl and close_socket, this should NOT be called
+  // concurrently with a DIFFERENT thread sending requests from the socket
+  void lock_socket_and_shutdown_and_close();
 
   bool process_request(Stream &strm, const Request &req, Response &res,
                        bool close_connection);
@@ -873,7 +922,7 @@ protected:
   void copy_settings(const ClientImpl &rhs);
 
   // Error state
-  mutable Error error_ = Error::Success;
+  mutable std::atomic<Error> error_;
 
   // Socket endoint information
   const std::string host_;
@@ -885,6 +934,11 @@ protected:
   mutable std::mutex socket_mutex_;
   std::recursive_mutex request_mutex_;
 
+  // These are all protected under socket_mutex
+  int socket_requests_in_flight_ = 0;
+  std::thread::id socket_requests_are_from_thread_ = std::thread::id();
+  bool socket_should_be_closed_when_request_is_done_ = false;
+
   // Default headers
   Headers default_headers_;
 
@@ -942,13 +996,13 @@ private:
   bool redirect(const Request &req, Response &res);
   bool handle_request(Stream &strm, const Request &req, Response &res,
                       bool close_connection);
-  void stop_core();
-  std::shared_ptr<Response> send_with_content_provider(
+  std::unique_ptr<Response> send_with_content_provider(
       const char *method, const char *path, const Headers &headers,
       const std::string &body, size_t content_length,
       ContentProvider content_provider, const char *content_type);
 
-  virtual bool process_socket(Socket &socket,
+  // socket is const because this function is called when socket_mutex_ is not locked
+  virtual bool process_socket(const Socket &socket,
                               std::function<bool(Stream &strm)> callback);
   virtual bool is_ssl() const;
 };
@@ -1012,6 +1066,8 @@ public:
   Result Post(const char *path, const MultipartFormDataItems &items);
   Result Post(const char *path, const Headers &headers,
               const MultipartFormDataItems &items);
+  Result Post(const char *path, const Headers &headers,
+              const MultipartFormDataItems &items, const std::string &boundary);
   Result Put(const char *path);
   Result Put(const char *path, const std::string &body,
              const char *content_type);
@@ -1098,7 +1154,7 @@ public:
 #endif
 
 private:
-  std::shared_ptr<ClientImpl> cli_;
+  std::unique_ptr<ClientImpl> cli_;
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
   bool is_ssl_ = false;
@@ -1154,9 +1210,9 @@ public:
 
 private:
   bool create_and_connect_socket(Socket &socket) override;
-  void close_socket(Socket &socket, bool process_socket_ret) override;
+  void shutdown_ssl(Socket &socket, bool shutdown_gracefully) override;
 
-  bool process_socket(Socket &socket,
+  bool process_socket(const Socket &socket,
                       std::function<bool(Stream &strm)> callback) override;
   bool is_ssl() const override;
 
@@ -1942,9 +1998,9 @@ inline socket_t create_client_socket(const char *host, int port,
                                      bool tcp_nodelay,
                                      SocketOptions socket_options,
                                      time_t timeout_sec, time_t timeout_usec,
-                                     const std::string &intf, Error &error) {
+                                     const std::string &intf, std::atomic<Error> &error) {
   auto sock = create_socket(
-      host, port, 0, tcp_nodelay, socket_options,
+      host, port, 0, tcp_nodelay, std::move(socket_options),
       [&](socket_t sock, struct addrinfo &ai) -> bool {
         if (!intf.empty()) {
 #ifdef USE_IF2IP
@@ -2478,7 +2534,8 @@ inline bool read_headers(Stream &strm, Headers &headers) {
 }
 
 inline bool read_content_with_length(Stream &strm, uint64_t len,
-                                     Progress progress, ContentReceiver out) {
+                                     Progress progress,
+                                     ContentReceiverWithProgress out) {
   char buf[CPPHTTPLIB_RECV_BUFSIZ];
 
   uint64_t r = 0;
@@ -2487,8 +2544,7 @@ inline bool read_content_with_length(Stream &strm, uint64_t len,
     auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
     if (n <= 0) { return false; }
 
-    if (!out(buf, static_cast<size_t>(n))) { return false; }
-
+    if (!out(buf, static_cast<size_t>(n), r, len)) { return false; }
     r += static_cast<uint64_t>(n);
 
     if (progress) {
@@ -2510,8 +2566,10 @@ inline void skip_content_with_length(Stream &strm, uint64_t len) {
   }
 }
 
-inline bool read_content_without_length(Stream &strm, ContentReceiver out) {
+inline bool read_content_without_length(Stream &strm,
+                                        ContentReceiverWithProgress out) {
   char buf[CPPHTTPLIB_RECV_BUFSIZ];
+  uint64_t r = 0;
   for (;;) {
     auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ);
     if (n < 0) {
@@ -2519,13 +2577,16 @@ inline bool read_content_without_length(Stream &strm, ContentReceiver out) {
     } else if (n == 0) {
       return true;
     }
-    if (!out(buf, static_cast<size_t>(n))) { return false; }
+
+    if (!out(buf, static_cast<size_t>(n), r, 0)) { return false; }
+    r += static_cast<uint64_t>(n);
   }
 
   return true;
 }
 
-inline bool read_content_chunked(Stream &strm, ContentReceiver out) {
+inline bool read_content_chunked(Stream &strm,
+                                 ContentReceiverWithProgress out) {
   const auto bufsiz = 16;
   char buf[bufsiz];
 
@@ -2570,23 +2631,24 @@ inline bool is_chunked_transfer_encoding(const Headers &headers) {
 }
 
 template <typename T, typename U>
-bool prepare_content_receiver(T &x, int &status, ContentReceiver receiver,
+bool prepare_content_receiver(T &x, int &status,
+                              ContentReceiverWithProgress receiver,
                               bool decompress, U callback) {
   if (decompress) {
     std::string encoding = x.get_header_value("Content-Encoding");
-    std::shared_ptr<decompressor> decompressor;
+    std::unique_ptr<decompressor> decompressor;
 
     if (encoding.find("gzip") != std::string::npos ||
         encoding.find("deflate") != std::string::npos) {
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
-      decompressor = std::make_shared<gzip_decompressor>();
+      decompressor = detail::make_unique<gzip_decompressor>();
 #else
       status = 415;
       return false;
 #endif
     } else if (encoding.find("br") != std::string::npos) {
 #ifdef CPPHTTPLIB_BROTLI_SUPPORT
-      decompressor = std::make_shared<brotli_decompressor>();
+      decompressor = detail::make_unique<brotli_decompressor>();
 #else
       status = 415;
       return false;
@@ -2595,12 +2657,14 @@ bool prepare_content_receiver(T &x, int &status, ContentReceiver receiver,
 
     if (decompressor) {
       if (decompressor->is_valid()) {
-        ContentReceiver out = [&](const char *buf, size_t n) {
-          return decompressor->decompress(
-              buf, n,
-              [&](const char *buf, size_t n) { return receiver(buf, n); });
+        ContentReceiverWithProgress out = [&](const char *buf, size_t n,
+                                              uint64_t off, uint64_t len) {
+          return decompressor->decompress(buf, n,
+                                          [&](const char *buf, size_t n) {
+                                            return receiver(buf, n, off, len);
+                                          });
         };
-        return callback(out);
+        return callback(std::move(out));
       } else {
         status = 500;
         return false;
@@ -2608,18 +2672,20 @@ bool prepare_content_receiver(T &x, int &status, ContentReceiver receiver,
     }
   }
 
-  ContentReceiver out = [&](const char *buf, size_t n) {
-    return receiver(buf, n);
+  ContentReceiverWithProgress out = [&](const char *buf, size_t n, uint64_t off,
+                                        uint64_t len) {
+    return receiver(buf, n, off, len);
   };
-  return callback(out);
+  return callback(std::move(out));
 }
 
 template <typename T>
 bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
-                  Progress progress, ContentReceiver receiver,
+                  Progress progress, ContentReceiverWithProgress receiver,
                   bool decompress) {
   return prepare_content_receiver(
-      x, status, receiver, decompress, [&](const ContentReceiver &out) {
+      x, status, std::move(receiver), decompress,
+      [&](const ContentReceiverWithProgress &out) {
         auto ret = true;
         auto exceed_payload_max_length = false;
 
@@ -2634,7 +2700,7 @@ bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
             skip_content_with_length(strm, len);
             ret = false;
           } else if (len > 0) {
-            ret = read_content_with_length(strm, len, progress, out);
+            ret = read_content_with_length(strm, len, std::move(progress), out);
           }
         }
 
@@ -2875,7 +2941,7 @@ inline bool parse_multipart_boundary(const std::string &content_type,
   return !boundary.empty();
 }
 
-inline bool parse_range_header(const std::string &s, Ranges &ranges) {
+inline bool parse_range_header(const std::string &s, Ranges &ranges) try {
   static auto re_first_range = std::regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))");
   std::smatch m;
   if (std::regex_match(s, m, re_first_range)) {
@@ -2907,7 +2973,7 @@ inline bool parse_range_header(const std::string &s, Ranges &ranges) {
     return all_valid_ranges;
   }
   return false;
-}
+} catch (...) { return false; }
 
 class MultipartFormDataParser {
 public:
@@ -2918,7 +2984,8 @@ public:
   bool is_valid() const { return is_valid_; }
 
   template <typename T, typename U>
-  bool parse(const char *buf, size_t n, T content_callback, U header_callback) {
+  bool parse(const char *buf, size_t n, const T &content_callback,
+             const U &header_callback) {
 
     static const std::regex re_content_disposition(
         "^Content-Disposition:\\s*form-data;\\s*name=\"(.*?)\"(?:;\\s*filename="
@@ -3090,8 +3157,13 @@ inline std::string make_multipart_data_boundary() {
   static const char data[] =
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
+  // std::random_device might actually be deterministic on some
+  // platforms, but due to lack of support in the c++ standard library,
+  // doing better requires either some ugly hacks or breaking portability.
   std::random_device seed_gen;
-  std::mt19937 engine(seed_gen());
+  // Request 128 bits of entropy for initialization
+  std::seed_seq seed_sequence{seed_gen(), seed_gen(), seed_gen(), seed_gen()};
+  std::mt19937 engine(seed_sequence);
 
   std::string result = "--cpp-httplib-multipart-data-";
 
@@ -3114,7 +3186,7 @@ get_range_offset_and_length(const Request &req, size_t content_length,
   auto slen = static_cast<ssize_t>(content_length);
 
   if (r.first == -1) {
-    r.first = slen - r.second;
+    r.first = (std::max)(static_cast<ssize_t>(0), slen - r.second);
     r.second = slen - 1;
   }
 
@@ -3451,7 +3523,7 @@ inline std::pair<std::string, std::string> make_range_header(Ranges ranges) {
     if (r.second != -1) { field += std::to_string(r.second); }
     i++;
   }
-  return std::make_pair("Range", field);
+  return std::make_pair("Range", std::move(field));
 }
 
 inline std::pair<std::string, std::string>
@@ -3460,7 +3532,7 @@ make_basic_authentication_header(const std::string &username,
                                  bool is_proxy = false) {
   auto field = "Basic " + detail::base64_encode(username + ":" + password);
   auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-  return std::make_pair(key, field);
+  return std::make_pair(key, std::move(field));
 }
 
 inline std::pair<std::string, std::string>
@@ -3468,7 +3540,7 @@ make_bearer_token_authentication_header(const std::string &token,
                                         bool is_proxy = false) {
   auto field = "Bearer " + token;
   auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-  return std::make_pair(key, field);
+  return std::make_pair(key, std::move(field));
 }
 
 // Request implementation
@@ -3761,60 +3833,66 @@ inline Server::Server()
 inline Server::~Server() {}
 
 inline Server &Server::Get(const char *pattern, Handler handler) {
-  get_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
+  get_handlers_.push_back(
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Post(const char *pattern, Handler handler) {
-  post_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
+  post_handlers_.push_back(
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Post(const char *pattern,
                             HandlerWithContentReader handler) {
   post_handlers_for_content_reader_.push_back(
-      std::make_pair(std::regex(pattern), handler));
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Put(const char *pattern, Handler handler) {
-  put_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
+  put_handlers_.push_back(
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Put(const char *pattern,
                            HandlerWithContentReader handler) {
   put_handlers_for_content_reader_.push_back(
-      std::make_pair(std::regex(pattern), handler));
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Patch(const char *pattern, Handler handler) {
-  patch_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
+  patch_handlers_.push_back(
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Patch(const char *pattern,
                              HandlerWithContentReader handler) {
   patch_handlers_for_content_reader_.push_back(
-      std::make_pair(std::regex(pattern), handler));
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Delete(const char *pattern, Handler handler) {
-  delete_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
+  delete_handlers_.push_back(
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Delete(const char *pattern,
                               HandlerWithContentReader handler) {
   delete_handlers_for_content_reader_.push_back(
-      std::make_pair(std::regex(pattern), handler));
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
 inline Server &Server::Options(const char *pattern, Handler handler) {
-  options_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
+  options_handlers_.push_back(
+      std::make_pair(std::regex(pattern), std::move(handler)));
   return *this;
 }
 
@@ -3860,7 +3938,7 @@ inline void Server::set_error_handler(Handler handler) {
 inline void Server::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; }
 
 inline void Server::set_socket_options(SocketOptions socket_options) {
-  socket_options_ = socket_options;
+  socket_options_ = std::move(socket_options);
 }
 
 inline void Server::set_logger(Logger logger) { logger_ = std::move(logger); }
@@ -4045,16 +4123,16 @@ inline bool Server::write_response(Stream &strm, bool close_connection,
     }
 
     if (type != detail::EncodingType::None) {
-      std::shared_ptr<detail::compressor> compressor;
+      std::unique_ptr<detail::compressor> compressor;
 
       if (type == detail::EncodingType::Gzip) {
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
-        compressor = std::make_shared<detail::gzip_compressor>();
+        compressor = detail::make_unique<detail::gzip_compressor>();
         res.set_header("Content-Encoding", "gzip");
 #endif
       } else if (type == detail::EncodingType::Brotli) {
 #ifdef CPPHTTPLIB_BROTLI_SUPPORT
-        compressor = std::make_shared<detail::brotli_compressor>();
+        compressor = detail::make_unique<detail::brotli_compressor>();
         res.set_header("Content-Encoding", "brotli");
 #endif
       }
@@ -4136,17 +4214,17 @@ Server::write_content_with_provider(Stream &strm, const Request &req,
     if (res.is_chunked_content_provider) {
       auto type = detail::encoding_type(req, res);
 
-      std::shared_ptr<detail::compressor> compressor;
+      std::unique_ptr<detail::compressor> compressor;
       if (type == detail::EncodingType::Gzip) {
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
-        compressor = std::make_shared<detail::gzip_compressor>();
+        compressor = detail::make_unique<detail::gzip_compressor>();
 #endif
       } else if (type == detail::EncodingType::Brotli) {
 #ifdef CPPHTTPLIB_BROTLI_SUPPORT
-        compressor = std::make_shared<detail::brotli_compressor>();
+        compressor = detail::make_unique<detail::brotli_compressor>();
 #endif
       } else {
-        compressor = std::make_shared<detail::nocompressor>();
+        compressor = detail::make_unique<detail::nocompressor>();
       }
       assert(compressor != nullptr);
 
@@ -4198,8 +4276,9 @@ inline bool Server::read_content_with_content_receiver(
     Stream &strm, Request &req, Response &res, ContentReceiver receiver,
     MultipartContentHeader multipart_header,
     ContentReceiver multipart_receiver) {
-  return read_content_core(strm, req, res, receiver, multipart_header,
-                           multipart_receiver);
+  return read_content_core(strm, req, res, std::move(receiver),
+                           std::move(multipart_header),
+                           std::move(multipart_receiver));
 }
 
 inline bool Server::read_content_core(Stream &strm, Request &req, Response &res,
@@ -4207,7 +4286,7 @@ inline bool Server::read_content_core(Stream &strm, Request &req, Response &res,
                                       MultipartContentHeader mulitpart_header,
                                       ContentReceiver multipart_receiver) {
   detail::MultipartFormDataParser multipart_form_data_parser;
-  ContentReceiver out;
+  ContentReceiverWithProgress out;
 
   if (req.is_multipart_form_data()) {
     const auto &content_type = req.get_header_value("Content-Type");
@@ -4218,7 +4297,7 @@ inline bool Server::read_content_core(Stream &strm, Request &req, Response &res,
     }
 
     multipart_form_data_parser.set_boundary(std::move(boundary));
-    out = [&](const char *buf, size_t n) {
+    out = [&](const char *buf, size_t n, uint64_t /*off*/, uint64_t /*len*/) {
       /* For debug
       size_t pos = 0;
       while (pos < n) {
@@ -4234,7 +4313,8 @@ inline bool Server::read_content_core(Stream &strm, Request &req, Response &res,
                                               mulitpart_header);
     };
   } else {
-    out = receiver;
+    out = [receiver](const char *buf, size_t n, uint64_t /*off*/,
+                     uint64_t /*len*/) { return receiver(buf, n); };
   }
 
   if (req.method == "DELETE" && !req.has_header("Content-Length")) {
@@ -4271,7 +4351,7 @@ inline bool Server::handle_file_request(Request &req, Response &res,
           auto type =
               detail::find_content_type(path, file_extension_and_mimetype_map_);
           if (type) { res.set_header("Content-Type", type); }
-          for (const auto& kv : entry.headers) {
+          for (const auto &kv : entry.headers) {
             res.set_header(kv.first.c_str(), kv.second);
           }
           res.status = 200;
@@ -4290,7 +4370,7 @@ inline socket_t
 Server::create_server_socket(const char *host, int port, int socket_flags,
                              SocketOptions socket_options) const {
   return detail::create_socket(
-      host, port, socket_flags, tcp_nodelay_, socket_options,
+      host, port, socket_flags, tcp_nodelay_, std::move(socket_options),
       [](socket_t sock, struct addrinfo &ai) -> bool {
         if (::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
           return false;
@@ -4392,32 +4472,37 @@ inline bool Server::routing(Request &req, Response &res, Stream &strm) {
     {
       ContentReader reader(
           [&](ContentReceiver receiver) {
-            return read_content_with_content_receiver(strm, req, res, receiver,
-                                                      nullptr, nullptr);
+            return read_content_with_content_receiver(
+                strm, req, res, std::move(receiver), nullptr, nullptr);
           },
           [&](MultipartContentHeader header, ContentReceiver receiver) {
             return read_content_with_content_receiver(strm, req, res, nullptr,
-                                                      header, receiver);
+                                                      std::move(header),
+                                                      std::move(receiver));
           });
 
       if (req.method == "POST") {
         if (dispatch_request_for_content_reader(
-                req, res, reader, post_handlers_for_content_reader_)) {
+                req, res, std::move(reader),
+                post_handlers_for_content_reader_)) {
           return true;
         }
       } else if (req.method == "PUT") {
         if (dispatch_request_for_content_reader(
-                req, res, reader, put_handlers_for_content_reader_)) {
+                req, res, std::move(reader),
+                put_handlers_for_content_reader_)) {
           return true;
         }
       } else if (req.method == "PATCH") {
         if (dispatch_request_for_content_reader(
-                req, res, reader, patch_handlers_for_content_reader_)) {
+                req, res, std::move(reader),
+                patch_handlers_for_content_reader_)) {
           return true;
         }
       } else if (req.method == "DELETE") {
         if (dispatch_request_for_content_reader(
-                req, res, reader, delete_handlers_for_content_reader_)) {
+                req, res, std::move(reader),
+                delete_handlers_for_content_reader_)) {
           return true;
         }
       }
@@ -4448,7 +4533,6 @@ inline bool Server::routing(Request &req, Response &res, Stream &strm) {
 
 inline bool Server::dispatch_request(Request &req, Response &res,
                                      const Handlers &handlers) {
-
   try {
     for (const auto &x : handlers) {
       const auto &pattern = x.first;
@@ -4531,7 +4615,8 @@ Server::process_request(Stream &strm, bool close_connection,
   if (req.has_header("Range")) {
     const auto &range_header_value = req.get_header_value("Range");
     if (!detail::parse_range_header(range_header_value, req.ranges)) {
-      // TODO: error
+      res.status = 416;
+      return write_response(strm, close_connection, req, res);
     }
   }
 
@@ -4588,11 +4673,11 @@ inline ClientImpl::ClientImpl(const std::string &host, int port)
 inline ClientImpl::ClientImpl(const std::string &host, int port,
                               const std::string &client_cert_path,
                               const std::string &client_key_path)
-    : host_(host), port_(port),
+    : error_(Error::Success), host_(host), port_(port),
       host_and_port_(host_ + ":" + std::to_string(port_)),
       client_cert_path_(client_cert_path), client_key_path_(client_key_path) {}
 
-inline ClientImpl::~ClientImpl() { stop_core(); }
+inline ClientImpl::~ClientImpl() { lock_socket_and_shutdown_and_close(); }
 
 inline bool ClientImpl::is_valid() const { return true; }
 
@@ -4653,15 +4738,47 @@ inline bool ClientImpl::create_and_connect_socket(Socket &socket) {
   return true;
 }
 
-inline void ClientImpl::close_socket(Socket &socket,
-                                     bool /*process_socket_ret*/) {
-  detail::close_socket(socket.sock);
-  socket_.sock = INVALID_SOCKET;
+inline void ClientImpl::shutdown_ssl(Socket &socket, bool shutdown_gracefully) {
+  (void)socket;
+  (void)shutdown_gracefully;
+  //If there are any requests in flight from threads other than us, then it's
+  //a thread-unsafe race because individual ssl* objects are not thread-safe. 
+  assert(socket_requests_in_flight_ == 0 ||
+         socket_requests_are_from_thread_ == std::this_thread::get_id());
+}
+
+inline void ClientImpl::shutdown_socket(Socket &socket) {
+  if (socket.sock == INVALID_SOCKET)
+    return;  
+  detail::shutdown_socket(socket.sock);
+}
+ 
+inline void ClientImpl::close_socket(Socket &socket) {
+  // If there are requests in flight in another thread, usually closing
+  // the socket will be fine and they will simply receive an error when
+  // using the closed socket, but it is still a bug since rarely the OS
+  // may reassign the socket id to be used for a new socket, and then
+  // suddenly they will be operating on a live socket that is different
+  // than the one they intended!
+  assert(socket_requests_in_flight_ == 0 ||
+         socket_requests_are_from_thread_ == std::this_thread::get_id());
+  // It is also a bug if this happens while SSL is still active
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  socket_.ssl = nullptr;
+  assert(socket.ssl == nullptr);
 #endif
+  if (socket.sock == INVALID_SOCKET)
+    return;
+  detail::close_socket(socket.sock);
+  socket.sock = INVALID_SOCKET;
 }
 
+inline void ClientImpl::lock_socket_and_shutdown_and_close() {
+  std::lock_guard<std::mutex> guard(socket_mutex_);
+  shutdown_ssl(socket_, true);
+  shutdown_socket(socket_);
+  close_socket(socket_);
+}
+ 
 inline bool ClientImpl::read_response_line(Stream &strm, Response &res) {
   std::array<char, 2048> buf;
 
@@ -4696,11 +4813,23 @@ inline bool ClientImpl::send(const Request &req, Response &res) {
 
   {
     std::lock_guard<std::mutex> guard(socket_mutex_);
+    // Set this to false immediately - if it ever gets set to true by the end of the
+    // request, we know another thread instructed us to close the socket.
+    socket_should_be_closed_when_request_is_done_ = false;
 
     auto is_alive = false;
     if (socket_.is_open()) {
       is_alive = detail::select_write(socket_.sock, 0, 0) > 0;
-      if (!is_alive) { close_socket(socket_, false); }
+      if (!is_alive) {
+        // Attempt to avoid sigpipe by shutting down nongracefully if it seems like
+        // the other side has already closed the connection
+        // Also, there cannot be any requests in flight from other threads since we locked
+        // request_mutex_, so safe to close everything immediately
+        const bool shutdown_gracefully = false;
+        shutdown_ssl(socket_, shutdown_gracefully);
+        shutdown_socket(socket_);
+        close_socket(socket_);
+      }
     }
 
     if (!is_alive) {
@@ -4721,15 +4850,38 @@ inline bool ClientImpl::send(const Request &req, Response &res) {
       }
 #endif
     }
+
+    // Mark the current socket as being in use so that it cannot be closed by anyone
+    // else while this request is ongoing, even though we will be releasing the mutex.
+    if (socket_requests_in_flight_ > 1) {
+      assert(socket_requests_are_from_thread_ == std::this_thread::get_id());
+    }
+    socket_requests_in_flight_ += 1;
+    socket_requests_are_from_thread_ = std::this_thread::get_id();
   }
 
   auto close_connection = !keep_alive_;
-
   auto ret = process_socket(socket_, [&](Stream &strm) {
     return handle_request(strm, req, res, close_connection);
   });
 
-  if (close_connection || !ret) { stop_core(); }
+  //Briefly lock mutex in order to mark that a request is no longer ongoing
+  {
+    std::lock_guard<std::mutex> guard(socket_mutex_);
+    socket_requests_in_flight_ -= 1;
+    if (socket_requests_in_flight_ <= 0) {
+      assert(socket_requests_in_flight_ == 0);
+      socket_requests_are_from_thread_ = std::thread::id();
+    }
+
+    if (socket_should_be_closed_when_request_is_done_ ||
+        close_connection ||
+        !ret ) {
+      shutdown_ssl(socket_, true);
+      shutdown_socket(socket_);
+      close_socket(socket_);
+    }
+  }
 
   if (!ret) {
     if (error_ == Error::Success) { error_ = Error::Unknown; }
@@ -4973,7 +5125,7 @@ inline bool ClientImpl::write_request(Stream &strm, const Request &req,
   return true;
 }
 
-inline std::shared_ptr<Response> ClientImpl::send_with_content_provider(
+inline std::unique_ptr<Response> ClientImpl::send_with_content_provider(
     const char *method, const char *path, const Headers &headers,
     const std::string &body, size_t content_length,
     ContentProvider content_provider, const char *content_type) {
@@ -5036,15 +5188,15 @@ inline std::shared_ptr<Response> ClientImpl::send_with_content_provider(
   {
     if (content_provider) {
       req.content_length = content_length;
-      req.content_provider = content_provider;
+      req.content_provider = std::move(content_provider);
     } else {
       req.body = body;
     }
   }
 
-  auto res = std::make_shared<Response>();
+  auto res = detail::make_unique<Response>();
 
-  return send(req, *res) ? res : nullptr;
+  return send(req, *res) ? std::move(res) : nullptr;
 }
 
 inline bool ClientImpl::process_request(Stream &strm, const Request &req,
@@ -5070,16 +5222,21 @@ inline bool ClientImpl::process_request(Stream &strm, const Request &req,
   if (req.method != "HEAD" && req.method != "CONNECT") {
     auto out =
         req.content_receiver
-            ? static_cast<ContentReceiver>([&](const char *buf, size_t n) {
-                auto ret = req.content_receiver(buf, n);
-                if (!ret) { error_ = Error::Canceled; }
-                return ret;
-              })
-            : static_cast<ContentReceiver>([&](const char *buf, size_t n) {
-                if (res.body.size() + n > res.body.max_size()) { return false; }
-                res.body.append(buf, n);
-                return true;
-              });
+            ? static_cast<ContentReceiverWithProgress>(
+                  [&](const char *buf, size_t n, uint64_t off, uint64_t len) {
+                    auto ret = req.content_receiver(buf, n, off, len);
+                    if (!ret) { error_ = Error::Canceled; }
+                    return ret;
+                  })
+            : static_cast<ContentReceiverWithProgress>(
+                  [&](const char *buf, size_t n, uint64_t /*off*/,
+                      uint64_t /*len*/) {
+                    if (res.body.size() + n > res.body.max_size()) {
+                      return false;
+                    }
+                    res.body.append(buf, n);
+                    return true;
+                  });
 
     auto progress = [&](uint64_t current, uint64_t total) {
       if (!req.progress) { return true; }
@@ -5090,7 +5247,8 @@ inline bool ClientImpl::process_request(Stream &strm, const Request &req,
 
     int dummy_status;
     if (!detail::read_content(strm, res, (std::numeric_limits<size_t>::max)(),
-                              dummy_status, progress, out, decompress_)) {
+                              dummy_status, std::move(progress), std::move(out),
+                              decompress_)) {
       if (error_ != Error::Canceled) { error_ = Error::Read; }
       return false;
     }
@@ -5098,7 +5256,16 @@ inline bool ClientImpl::process_request(Stream &strm, const Request &req,
 
   if (res.get_header_value("Connection") == "close" ||
       (res.version == "HTTP/1.0" && res.reason != "Connection established")) {
-    stop_core();
+    // TODO this requires a not-entirely-obvious chain of calls to be correct
+    // for this to be safe. Maybe a code refactor (such as moving this out to
+    // the send function and getting rid of the recursiveness of the mutex)
+    // could make this more obvious.
+    
+    // This is safe to call because process_request is only called by handle_request
+    // which is only called by send, which locks the request mutex during the process.
+    // It would be a bug to call it from a different thread since it's a thread-safety
+    // issue to do these things to the socket if another thread is using the socket.
+    lock_socket_and_shutdown_and_close();
   }
 
   // Log
@@ -5108,11 +5275,11 @@ inline bool ClientImpl::process_request(Stream &strm, const Request &req,
 }
 
 inline bool
-ClientImpl::process_socket(Socket &socket,
+ClientImpl::process_socket(const Socket &socket,
                            std::function<bool(Stream &strm)> callback) {
-  return detail::process_client_socket(socket.sock, read_timeout_sec_,
-                                       read_timeout_usec_, write_timeout_sec_,
-                                       write_timeout_usec_, callback);
+  return detail::process_client_socket(
+      socket.sock, read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
+      write_timeout_usec_, std::move(callback));
 }
 
 inline bool ClientImpl::is_ssl() const { return false; }
@@ -5138,9 +5305,9 @@ inline Result ClientImpl::Get(const char *path, const Headers &headers,
   req.headers.insert(headers.begin(), headers.end());
   req.progress = std::move(progress);
 
-  auto res = std::make_shared<Response>();
+  auto res = detail::make_unique<Response>();
   auto ret = send(req, *res);
-  return Result{ret ? res : nullptr, get_last_error()};
+  return Result{ret ? std::move(res) : nullptr, get_last_error()};
 }
 
 inline Result ClientImpl::Get(const char *path,
@@ -5170,23 +5337,23 @@ inline Result ClientImpl::Get(const char *path, const Headers &headers,
 inline Result ClientImpl::Get(const char *path,
                               ResponseHandler response_handler,
                               ContentReceiver content_receiver) {
-  return Get(path, Headers(), std::move(response_handler), content_receiver,
-             nullptr);
+  return Get(path, Headers(), std::move(response_handler),
+             std::move(content_receiver), nullptr);
 }
 
 inline Result ClientImpl::Get(const char *path, const Headers &headers,
                               ResponseHandler response_handler,
                               ContentReceiver content_receiver) {
-  return Get(path, headers, std::move(response_handler), content_receiver,
-             nullptr);
+  return Get(path, headers, std::move(response_handler),
+             std::move(content_receiver), nullptr);
 }
 
 inline Result ClientImpl::Get(const char *path,
                               ResponseHandler response_handler,
                               ContentReceiver content_receiver,
                               Progress progress) {
-  return Get(path, Headers(), std::move(response_handler), content_receiver,
-             progress);
+  return Get(path, Headers(), std::move(response_handler),
+             std::move(content_receiver), std::move(progress));
 }
 
 inline Result ClientImpl::Get(const char *path, const Headers &headers,
@@ -5199,12 +5366,16 @@ inline Result ClientImpl::Get(const char *path, const Headers &headers,
   req.headers = default_headers_;
   req.headers.insert(headers.begin(), headers.end());
   req.response_handler = std::move(response_handler);
-  req.content_receiver = std::move(content_receiver);
+  req.content_receiver =
+      [content_receiver](const char *data, size_t data_length,
+                         uint64_t /*offset*/, uint64_t /*total_length*/) {
+        return content_receiver(data, data_length);
+      };
   req.progress = std::move(progress);
 
-  auto res = std::make_shared<Response>();
+  auto res = detail::make_unique<Response>();
   auto ret = send(req, *res);
-  return Result{ret ? res : nullptr, get_last_error()};
+  return Result{ret ? std::move(res) : nullptr, get_last_error()};
 }
 
 inline Result ClientImpl::Head(const char *path) {
@@ -5218,9 +5389,9 @@ inline Result ClientImpl::Head(const char *path, const Headers &headers) {
   req.headers.insert(headers.begin(), headers.end());
   req.path = path;
 
-  auto res = std::make_shared<Response>();
+  auto res = detail::make_unique<Response>();
   auto ret = send(req, *res);
-  return Result{ret ? res : nullptr, get_last_error()};
+  return Result{ret ? std::move(res) : nullptr, get_last_error()};
 }
 
 inline Result ClientImpl::Post(const char *path) {
@@ -5237,7 +5408,7 @@ inline Result ClientImpl::Post(const char *path, const Headers &headers,
                                const char *content_type) {
   auto ret = send_with_content_provider("POST", path, headers, body, 0, nullptr,
                                         content_type);
-  return Result{ret, get_last_error()};
+  return Result{std::move(ret), get_last_error()};
 }
 
 inline Result ClientImpl::Post(const char *path, const Params &params) {
@@ -5247,17 +5418,18 @@ inline Result ClientImpl::Post(const char *path, const Params &params) {
 inline Result ClientImpl::Post(const char *path, size_t content_length,
                                ContentProvider content_provider,
                                const char *content_type) {
-  return Post(path, Headers(), content_length, content_provider, content_type);
+  return Post(path, Headers(), content_length, std::move(content_provider),
+              content_type);
 }
 
 inline Result ClientImpl::Post(const char *path, const Headers &headers,
                                size_t content_length,
                                ContentProvider content_provider,
                                const char *content_type) {
-  auto ret = send_with_content_provider("POST", path, headers, std::string(),
-                                        content_length, content_provider,
-                                        content_type);
-  return Result{ret, get_last_error()};
+  auto ret = send_with_content_provider(
+      "POST", path, headers, std::string(), content_length,
+      std::move(content_provider), content_type);
+  return Result{std::move(ret), get_last_error()};
 }
 
 inline Result ClientImpl::Post(const char *path, const Headers &headers,
@@ -5273,7 +5445,18 @@ inline Result ClientImpl::Post(const char *path,
 
 inline Result ClientImpl::Post(const char *path, const Headers &headers,
                                const MultipartFormDataItems &items) {
-  auto boundary = detail::make_multipart_data_boundary();
+  return Post(path, headers, items, detail::make_multipart_data_boundary());
+}
+inline Result ClientImpl::Post(const char *path, const Headers &headers,
+                               const MultipartFormDataItems &items,
+                               const std::string &boundary) {
+  for (size_t i = 0; i < boundary.size(); i++) {
+    char c = boundary[i];
+    if (!std::isalnum(c) && c != '-' && c != '_') {
+      error_ = Error::UnsupportedMultipartBoundaryChars;
+      return Result{nullptr, error_};
+    }
+  }
 
   std::string body;
 
@@ -5311,23 +5494,24 @@ inline Result ClientImpl::Put(const char *path, const Headers &headers,
                               const char *content_type) {
   auto ret = send_with_content_provider("PUT", path, headers, body, 0, nullptr,
                                         content_type);
-  return Result{ret, get_last_error()};
+  return Result{std::move(ret), get_last_error()};
 }
 
 inline Result ClientImpl::Put(const char *path, size_t content_length,
                               ContentProvider content_provider,
                               const char *content_type) {
-  return Put(path, Headers(), content_length, content_provider, content_type);
+  return Put(path, Headers(), content_length, std::move(content_provider),
+             content_type);
 }
 
 inline Result ClientImpl::Put(const char *path, const Headers &headers,
                               size_t content_length,
                               ContentProvider content_provider,
                               const char *content_type) {
-  auto ret = send_with_content_provider("PUT", path, headers, std::string(),
-                                        content_length, content_provider,
-                                        content_type);
-  return Result{ret, get_last_error()};
+  auto ret = send_with_content_provider(
+      "PUT", path, headers, std::string(), content_length,
+      std::move(content_provider), content_type);
+  return Result{std::move(ret), get_last_error()};
 }
 
 inline Result ClientImpl::Put(const char *path, const Params &params) {
@@ -5350,23 +5534,24 @@ inline Result ClientImpl::Patch(const char *path, const Headers &headers,
                                 const char *content_type) {
   auto ret = send_with_content_provider("PATCH", path, headers, body, 0,
                                         nullptr, content_type);
-  return Result{ret, get_last_error()};
+  return Result{std::move(ret), get_last_error()};
 }
 
 inline Result ClientImpl::Patch(const char *path, size_t content_length,
                                 ContentProvider content_provider,
                                 const char *content_type) {
-  return Patch(path, Headers(), content_length, content_provider, content_type);
+  return Patch(path, Headers(), content_length, std::move(content_provider),
+               content_type);
 }
 
 inline Result ClientImpl::Patch(const char *path, const Headers &headers,
                                 size_t content_length,
                                 ContentProvider content_provider,
                                 const char *content_type) {
-  auto ret = send_with_content_provider("PATCH", path, headers, std::string(),
-                                        content_length, content_provider,
-                                        content_type);
-  return Result{ret, get_last_error()};
+  auto ret = send_with_content_provider(
+      "PATCH", path, headers, std::string(), content_length,
+      std::move(content_provider), content_type);
+  return Result{std::move(ret), get_last_error()};
 }
 
 inline Result ClientImpl::Delete(const char *path) {
@@ -5394,9 +5579,9 @@ inline Result ClientImpl::Delete(const char *path, const Headers &headers,
   if (content_type) { req.headers.emplace("Content-Type", content_type); }
   req.body = body;
 
-  auto res = std::make_shared<Response>();
+  auto res = detail::make_unique<Response>();
   auto ret = send(req, *res);
-  return Result{ret ? res : nullptr, get_last_error()};
+  return Result{ret ? std::move(res) : nullptr, get_last_error()};
 }
 
 inline Result ClientImpl::Options(const char *path) {
@@ -5410,9 +5595,9 @@ inline Result ClientImpl::Options(const char *path, const Headers &headers) {
   req.headers.insert(headers.begin(), headers.end());
   req.path = path;
 
-  auto res = std::make_shared<Response>();
+  auto res = detail::make_unique<Response>();
   auto ret = send(req, *res);
-  return Result{ret ? res : nullptr, get_last_error()};
+  return Result{ret ? std::move(res) : nullptr, get_last_error()};
 }
 
 inline size_t ClientImpl::is_socket_open() const {
@@ -5421,18 +5606,27 @@ inline size_t ClientImpl::is_socket_open() const {
 }
 
 inline void ClientImpl::stop() {
-  stop_core();
-  error_ = Error::Canceled;
-}
-
-inline void ClientImpl::stop_core() {
   std::lock_guard<std::mutex> guard(socket_mutex_);
-  if (socket_.is_open()) {
-    detail::shutdown_socket(socket_.sock);
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    close_socket(socket_, true);
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  // There is no guarantee that this doesn't get overwritten later, but set it so that
+  // there is a good chance that any threads stopping as a result pick up this error.
+  error_ = Error::Canceled;
+  
+  // If there is anything ongoing right now, the ONLY thread-safe thing we can do
+  // is to shutdown_socket, so that threads using this socket suddenly discover
+  // they can't read/write any more and error out.
+  // Everything else (closing the socket, shutting ssl down) is unsafe because these
+  // actions are not thread-safe.
+  if (socket_requests_in_flight_ > 0) {
+    shutdown_socket(socket_);
+    // Aside from that, we set a flag for the socket to be closed when we're done.
+    socket_should_be_closed_when_request_is_done_ = true;
+    return;
   }
+
+  //Otherwise, sitll holding the mutex, we can shut everything down ourselves
+  shutdown_ssl(socket_, true);
+  shutdown_socket(socket_);
+  close_socket(socket_);
 }
 
 inline void ClientImpl::set_connection_timeout(time_t sec, time_t usec) {
@@ -5479,7 +5673,7 @@ inline void ClientImpl::set_default_headers(Headers headers) {
 inline void ClientImpl::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; }
 
 inline void ClientImpl::set_socket_options(SocketOptions socket_options) {
-  socket_options_ = socket_options;
+  socket_options_ = std::move(socket_options);
 }
 
 inline void ClientImpl::set_compress(bool on) { compress_ = on; }
@@ -5554,9 +5748,12 @@ inline SSL *ssl_new(socket_t sock, SSL_CTX *ctx, std::mutex &ctx_mutex,
 }
 
 inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl,
-                       bool process_socket_ret) {
-  if (process_socket_ret) {
-    SSL_shutdown(ssl); // shutdown only if not already closed by remote
+                       bool shutdown_gracefully) {
+  // sometimes we may want to skip this to try to avoid SIGPIPE if we know
+  // the remote has closed the network connection
+  // Note that it is not always possible to avoid SIGPIPE, this is merely a best-efforts.
+  if (shutdown_gracefully) {
+    SSL_shutdown(ssl); 
   }
 
   std::lock_guard<std::mutex> guard(ctx_mutex);
@@ -5650,22 +5847,7 @@ inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl,
       read_timeout_usec_(read_timeout_usec),
       write_timeout_sec_(write_timeout_sec),
       write_timeout_usec_(write_timeout_usec) {
-  {
-    timeval tv;
-    tv.tv_sec = static_cast<long>(read_timeout_sec);
-    tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec);
-
-    setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<char *>(&tv),
-               sizeof(tv));
-  }
-  {
-    timeval tv;
-    tv.tv_sec = static_cast<long>(write_timeout_sec);
-    tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec);
-
-    setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<char *>(&tv),
-               sizeof(tv));
-  }
+  SSL_clear_mode(ssl, SSL_MODE_AUTO_RETRY);
 }
 
 inline SSLSocketStream::~SSLSocketStream() {}
@@ -5680,8 +5862,27 @@ inline bool SSLSocketStream::is_writable() const {
 }
 
 inline ssize_t SSLSocketStream::read(char *ptr, size_t size) {
-  if (SSL_pending(ssl_) > 0 || is_readable()) {
+  if (SSL_pending(ssl_) > 0) {
     return SSL_read(ssl_, ptr, static_cast<int>(size));
+  } else if (is_readable()) {
+    auto ret = SSL_read(ssl_, ptr, static_cast<int>(size));
+    if (ret < 0) {
+      auto err = SSL_get_error(ssl_, ret);
+      while (err == SSL_ERROR_WANT_READ) {
+        if (SSL_pending(ssl_) > 0) {
+          return SSL_read(ssl_, ptr, static_cast<int>(size));
+        } else if (is_readable()) {
+          ret = SSL_read(ssl_, ptr, static_cast<int>(size));
+          if (ret >= 0) {
+            return ret;
+          }
+          err = SSL_get_error(ssl_, ret);
+        } else {
+          return -1;
+        }
+      }
+    }
+    return ret;
   }
   return -1;
 }
@@ -5788,9 +5989,12 @@ inline bool SSLServer::process_and_close_socket(socket_t sock) {
         });
 
     detail::ssl_delete(ctx_mutex_, ssl, ret);
+    detail::shutdown_socket(sock);
+    detail::close_socket(sock);
     return ret;
   }
 
+  detail::shutdown_socket(sock);
   detail::close_socket(sock);
   return false;
 }
@@ -5843,6 +6047,10 @@ inline SSLClient::SSLClient(const std::string &host, int port,
 
 inline SSLClient::~SSLClient() {
   if (ctx_) { SSL_CTX_free(ctx_); }
+  // Make sure to shut down SSL since shutdown_ssl will resolve to the
+  // base function rather than the derived function once we get to the
+  // base class destructor, and won't free the SSL (causing a leak).
+  SSLClient::shutdown_ssl(socket_, true);
 }
 
 inline bool SSLClient::is_valid() const { return ctx_; }
@@ -5876,11 +6084,11 @@ inline bool SSLClient::create_and_connect_socket(Socket &socket) {
   return is_valid() && ClientImpl::create_and_connect_socket(socket);
 }
 
+// Assumes that socket_mutex_ is locked and that there are no requests in flight
 inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res,
                                           bool &success) {
   success = true;
   Response res2;
-
   if (!detail::process_client_socket(
           socket.sock, read_timeout_sec_, read_timeout_usec_,
           write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
@@ -5889,7 +6097,10 @@ inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res,
             req2.path = host_and_port_;
             return process_request(strm, req2, res2, false);
           })) {
-    close_socket(socket, true);
+    // Thread-safe to close everything because we are assuming there are no requests in flight
+    shutdown_ssl(socket, true);
+    shutdown_socket(socket);
+    close_socket(socket);
     success = false;
     return false;
   }
@@ -5912,7 +6123,10 @@ inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res,
                       true));
                   return process_request(strm, req3, res3, false);
                 })) {
-          close_socket(socket, true);
+          // Thread-safe to close everything because we are assuming there are no requests in flight
+          shutdown_ssl(socket, true);
+          shutdown_socket(socket);
+          close_socket(socket);
           success = false;
           return false;
         }
@@ -6005,26 +6219,30 @@ inline bool SSLClient::initialize_ssl(Socket &socket) {
     return true;
   }
 
-  close_socket(socket, false);
+  shutdown_socket(socket);
+  close_socket(socket);
   return false;
 }
 
-inline void SSLClient::close_socket(Socket &socket, bool process_socket_ret) {
-  detail::close_socket(socket.sock);
-  socket_.sock = INVALID_SOCKET;
+inline void SSLClient::shutdown_ssl(Socket &socket, bool shutdown_gracefully) {
+  if (socket.sock == INVALID_SOCKET) {
+    assert(socket.ssl == nullptr);
+    return;
+  }
   if (socket.ssl) {
-    detail::ssl_delete(ctx_mutex_, socket.ssl, process_socket_ret);
-    socket_.ssl = nullptr;
+    detail::ssl_delete(ctx_mutex_, socket.ssl, shutdown_gracefully);
+    socket.ssl = nullptr;
   }
+  assert(socket.ssl == nullptr);
 }
 
 inline bool
-SSLClient::process_socket(Socket &socket,
+SSLClient::process_socket(const Socket &socket,
                           std::function<bool(Stream &strm)> callback) {
   assert(socket.ssl);
   return detail::process_client_socket_ssl(
       socket.ssl, socket.sock, read_timeout_sec_, read_timeout_usec_,
-      write_timeout_sec_, write_timeout_usec_, callback);
+      write_timeout_sec_, write_timeout_usec_, std::move(callback));
 }
 
 inline bool SSLClient::is_ssl() const { return true; }
@@ -6175,6 +6393,8 @@ inline Client::Client(const char *scheme_host_port,
 #else
     if (!scheme.empty() && scheme != "http") {
 #endif
+      std::string msg = "'" + scheme + "' scheme is not supported.";
+      throw std::invalid_argument(msg);
       return;
     }
 
@@ -6187,28 +6407,28 @@ inline Client::Client(const char *scheme_host_port,
 
     if (is_ssl) {
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-      cli_ = std::make_shared<SSLClient>(host.c_str(), port, client_cert_path,
-                                         client_key_path);
+      cli_ = detail::make_unique<SSLClient>(host.c_str(), port,
+                                            client_cert_path, client_key_path);
       is_ssl_ = is_ssl;
 #endif
     } else {
-      cli_ = std::make_shared<ClientImpl>(host.c_str(), port, client_cert_path,
-                                          client_key_path);
+      cli_ = detail::make_unique<ClientImpl>(host.c_str(), port,
+                                             client_cert_path, client_key_path);
     }
   } else {
-    cli_ = std::make_shared<ClientImpl>(scheme_host_port, 80, client_cert_path,
-                                        client_key_path);
+    cli_ = detail::make_unique<ClientImpl>(scheme_host_port, 80,
+                                           client_cert_path, client_key_path);
   }
 }
 
 inline Client::Client(const std::string &host, int port)
-    : cli_(std::make_shared<ClientImpl>(host, port)) {}
+    : cli_(detail::make_unique<ClientImpl>(host, port)) {}
 
 inline Client::Client(const std::string &host, int port,
                       const std::string &client_cert_path,
                       const std::string &client_key_path)
-    : cli_(std::make_shared<ClientImpl>(host, port, client_cert_path,
-                                        client_key_path)) {}
+    : cli_(detail::make_unique<ClientImpl>(host, port, client_cert_path,
+                                           client_key_path)) {}
 
 inline Client::~Client() {}
 
@@ -6221,11 +6441,11 @@ inline Result Client::Get(const char *path, const Headers &headers) {
   return cli_->Get(path, headers);
 }
 inline Result Client::Get(const char *path, Progress progress) {
-  return cli_->Get(path, progress);
+  return cli_->Get(path, std::move(progress));
 }
 inline Result Client::Get(const char *path, const Headers &headers,
                           Progress progress) {
-  return cli_->Get(path, headers, progress);
+  return cli_->Get(path, headers, std::move(progress));
 }
 inline Result Client::Get(const char *path, ContentReceiver content_receiver) {
   return cli_->Get(path, std::move(content_receiver));
@@ -6262,7 +6482,8 @@ inline Result Client::Get(const char *path, ResponseHandler response_handler,
 inline Result Client::Get(const char *path, const Headers &headers,
                           ResponseHandler response_handler,
                           ContentReceiver content_receiver, Progress progress) {
-  return cli_->Get(path, headers, response_handler, content_receiver, progress);
+  return cli_->Get(path, headers, std::move(response_handler),
+                   std::move(content_receiver), std::move(progress));
 }
 
 inline Result Client::Head(const char *path) { return cli_->Head(path); }
@@ -6282,13 +6503,14 @@ inline Result Client::Post(const char *path, const Headers &headers,
 inline Result Client::Post(const char *path, size_t content_length,
                            ContentProvider content_provider,
                            const char *content_type) {
-  return cli_->Post(path, content_length, content_provider, content_type);
+  return cli_->Post(path, content_length, std::move(content_provider),
+                    content_type);
 }
 inline Result Client::Post(const char *path, const Headers &headers,
                            size_t content_length,
                            ContentProvider content_provider,
                            const char *content_type) {
-  return cli_->Post(path, headers, content_length, content_provider,
+  return cli_->Post(path, headers, content_length, std::move(content_provider),
                     content_type);
 }
 inline Result Client::Post(const char *path, const Params &params) {
@@ -6306,6 +6528,11 @@ inline Result Client::Post(const char *path, const Headers &headers,
                            const MultipartFormDataItems &items) {
   return cli_->Post(path, headers, items);
 }
+inline Result Client::Post(const char *path, const Headers &headers,
+                           const MultipartFormDataItems &items,
+                           const std::string &boundary) {
+  return cli_->Post(path, headers, items, boundary);
+}
 inline Result Client::Put(const char *path) { return cli_->Put(path); }
 inline Result Client::Put(const char *path, const std::string &body,
                           const char *content_type) {
@@ -6318,13 +6545,14 @@ inline Result Client::Put(const char *path, const Headers &headers,
 inline Result Client::Put(const char *path, size_t content_length,
                           ContentProvider content_provider,
                           const char *content_type) {
-  return cli_->Put(path, content_length, content_provider, content_type);
+  return cli_->Put(path, content_length, std::move(content_provider),
+                   content_type);
 }
 inline Result Client::Put(const char *path, const Headers &headers,
                           size_t content_length,
                           ContentProvider content_provider,
                           const char *content_type) {
-  return cli_->Put(path, headers, content_length, content_provider,
+  return cli_->Put(path, headers, content_length, std::move(content_provider),
                    content_type);
 }
 inline Result Client::Put(const char *path, const Params &params) {
@@ -6345,13 +6573,14 @@ inline Result Client::Patch(const char *path, const Headers &headers,
 inline Result Client::Patch(const char *path, size_t content_length,
                             ContentProvider content_provider,
                             const char *content_type) {
-  return cli_->Patch(path, content_length, content_provider, content_type);
+  return cli_->Patch(path, content_length, std::move(content_provider),
+                     content_type);
 }
 inline Result Client::Patch(const char *path, const Headers &headers,
                             size_t content_length,
                             ContentProvider content_provider,
                             const char *content_type) {
-  return cli_->Patch(path, headers, content_length, content_provider,
+  return cli_->Patch(path, headers, content_length, std::move(content_provider),
                      content_type);
 }
 inline Result Client::Delete(const char *path) { return cli_->Delete(path); }
@@ -6386,7 +6615,7 @@ inline void Client::set_default_headers(Headers headers) {
 
 inline void Client::set_tcp_nodelay(bool on) { cli_->set_tcp_nodelay(on); }
 inline void Client::set_socket_options(SocketOptions socket_options) {
-  cli_->set_socket_options(socket_options);
+  cli_->set_socket_options(std::move(socket_options));
 }
 
 inline void Client::set_connection_timeout(time_t sec, time_t usec) {
diff --git a/externals/inih/inih b/externals/inih/inih
-Subproject 603729dec89aaca42d7bd08f08bc333165b7d5d
+Subproject 1e80a47dffbda813604f0913e2ad68c7054c14e
diff --git a/externals/libressl b/externals/libressl
-Subproject 7d01cb01cb1a926ecb4c9c98b107ef3c26f59df
+Subproject 8289d0d07de6553bf4b900bf60e808ea3f7f59d
diff --git a/externals/lurlparser/CMakeLists.txt b/externals/lurlparser/CMakeLists.txt
deleted file mode 100644
index 45046ffd3..000000000
--- a/externals/lurlparser/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-add_library(lurlparser
-        LUrlParser.cpp
-        LUrlParser.h
-)
-
-create_target_directory_groups(lurlparser)
-
-target_include_directories(lurlparser INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/externals/lurlparser/LUrlParser.cpp b/externals/lurlparser/LUrlParser.cpp
deleted file mode 100644
index 9c134e330..000000000
--- a/externals/lurlparser/LUrlParser.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- * Lightweight URL & URI parser (RFC 1738, RFC 3986)
- * https://github.com/corporateshark/LUrlParser
- *
- * The MIT License (MIT)
- *
- * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "LUrlParser.h"
-
-#include <algorithm>
-#include <cstring>
-#include <stdlib.h>
-
-// check if the scheme name is valid
-static bool IsSchemeValid( const std::string& SchemeName )
-{
-    for ( auto c : SchemeName  )
-    {
-        if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
-    }
-
-    return true;
-}
-
-bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
-{
-    if ( !IsValid() ) { return false; }
-
-    int Port = atoi( m_Port.c_str() );
-
-    if ( Port <= 0 || Port > 65535 ) { return false; }
-
-    if ( OutPort ) { *OutPort = Port; }
-
-    return true;
-}
-
-// based on RFC 1738 and RFC 3986
-LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
-{
-    LUrlParser::clParseURL Result;
-
-    const char* CurrentString = URL.c_str();
-
-    /*
-     *  <scheme>:<scheme-specific-part>
-     *  <scheme> := [a-z\+\-\.]+
-     *  For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
-     */
-
-    // try to read scheme
-    {
-        const char* LocalString = strchr( CurrentString, ':' );
-
-        if ( !LocalString )
-        {
-            return clParseURL( LUrlParserError_NoUrlCharacter );
-        }
-
-        // save the scheme name
-        Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
-
-        if ( !IsSchemeValid( Result.m_Scheme ) )
-        {
-            return clParseURL( LUrlParserError_InvalidSchemeName );
-        }
-
-        // scheme should be lowercase
-        std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
-
-        // skip ':'
-        CurrentString = LocalString+1;
-    }
-
-    /*
-     *  //<user>:<password>@<host>:<port>/<url-path>
-     *  any ":", "@" and "/" must be normalized
-     */
-
-    // skip "//"
-    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
-    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
-
-    // check if the user name and password are specified
-    bool bHasUserName = false;
-
-    const char* LocalString = CurrentString;
-
-    while ( *LocalString )
-    {
-        if ( *LocalString == '@' )
-        {
-            // user name and password are specified
-            bHasUserName = true;
-            break;
-        }
-        else if ( *LocalString == '/' )
-        {
-            // end of <host>:<port> specification
-            bHasUserName = false;
-            break;
-        }
-
-        LocalString++;
-    }
-
-    // user name and password
-    LocalString = CurrentString;
-
-    if ( bHasUserName )
-    {
-        // read user name
-        while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
-
-        Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
-
-        // proceed with the current pointer
-        CurrentString = LocalString;
-
-        if ( *CurrentString == ':' )
-        {
-            // skip ':'
-            CurrentString++;
-
-            // read password
-            LocalString = CurrentString;
-
-            while ( *LocalString && *LocalString != '@' ) LocalString++;
-
-            Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
-
-            CurrentString = LocalString;
-        }
-
-        // skip '@'
-        if ( *CurrentString != '@' )
-        {
-            return clParseURL( LUrlParserError_NoAtSign );
-        }
-
-        CurrentString++;
-    }
-
-    bool bHasBracket = ( *CurrentString == '[' );
-
-    // go ahead, read the host name
-    LocalString = CurrentString;
-
-    while ( *LocalString )
-    {
-        if ( bHasBracket && *LocalString == ']' )
-        {
-            // end of IPv6 address
-            LocalString++;
-            break;
-        }
-        else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
-        {
-            // port number is specified
-            break;
-        }
-
-        LocalString++;
-    }
-
-    Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
-
-    CurrentString = LocalString;
-
-    // is port number specified?
-    if ( *CurrentString == ':' )
-    {
-        CurrentString++;
-
-        // read port number
-        LocalString = CurrentString;
-
-        while ( *LocalString && *LocalString != '/' ) LocalString++;
-
-        Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
-
-        CurrentString = LocalString;
-    }
-
-    // end of string
-    if ( !*CurrentString )
-    {
-        Result.m_ErrorCode = LUrlParserError_Ok;
-
-        return Result;
-    }
-
-    // skip '/'
-    if ( *CurrentString != '/' )
-    {
-        return clParseURL( LUrlParserError_NoSlash );
-    }
-
-    CurrentString++;
-
-    // parse the path
-    LocalString = CurrentString;
-
-    while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
-
-    Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
-
-    CurrentString = LocalString;
-
-    // check for query
-    if ( *CurrentString == '?' )
-    {
-        // skip '?'
-        CurrentString++;
-
-        // read query
-        LocalString = CurrentString;
-
-        while ( *LocalString && *LocalString != '#' ) LocalString++;
-
-        Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
-
-        CurrentString = LocalString;
-    }
-
-    // check for fragment
-    if ( *CurrentString == '#' )
-    {
-        // skip '#'
-        CurrentString++;
-
-        // read fragment
-        LocalString = CurrentString;
-
-        while ( *LocalString ) LocalString++;
-
-        Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
-
-        CurrentString = LocalString;
-    }
-
-    Result.m_ErrorCode = LUrlParserError_Ok;
-
-    return Result;
-}
diff --git a/externals/lurlparser/LUrlParser.h b/externals/lurlparser/LUrlParser.h
deleted file mode 100644
index 25d210981..000000000
--- a/externals/lurlparser/LUrlParser.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Lightweight URL & URI parser (RFC 1738, RFC 3986)
- * https://github.com/corporateshark/LUrlParser
- *
- * The MIT License (MIT)
- *
- * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#pragma once
-
-#include <string>
-
-namespace LUrlParser
-{
-enum LUrlParserError
-{
-    LUrlParserError_Ok = 0,
-    LUrlParserError_Uninitialized = 1,
-    LUrlParserError_NoUrlCharacter = 2,
-    LUrlParserError_InvalidSchemeName = 3,
-    LUrlParserError_NoDoubleSlash = 4,
-    LUrlParserError_NoAtSign = 5,
-    LUrlParserError_UnexpectedEndOfLine = 6,
-    LUrlParserError_NoSlash = 7,
-};
-
-class clParseURL
-{
-public:
-    LUrlParserError m_ErrorCode;
-    std::string m_Scheme;
-    std::string m_Host;
-    std::string m_Port;
-    std::string m_Path;
-    std::string m_Query;
-    std::string m_Fragment;
-    std::string m_UserName;
-    std::string m_Password;
-
-    clParseURL()
-            : m_ErrorCode( LUrlParserError_Uninitialized )
-    {}
-
-    /// return 'true' if the parsing was successful
-    bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
-
-    /// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
-    bool GetPort( int* OutPort ) const;
-
-    /// parse the URL
-    static clParseURL ParseURL( const std::string& URL );
-
-private:
-    explicit clParseURL( LUrlParserError ErrorCode )
-            : m_ErrorCode( ErrorCode )
-    {}
-};
-
-} // namespace LUrlParser
diff --git a/externals/lurlparser/README.md b/externals/lurlparser/README.md
deleted file mode 100644
index be7f0135a..000000000
--- a/externals/lurlparser/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-From https://github.com/corporateshark/LUrlParser/commit/455d5e2d27e3946f11ad0328fee9ee2628e6a8e2
-
-MIT License
-
-===
-
-Lightweight URL & URI parser (RFC 1738, RFC 3986)
-
-(C) Sergey Kosarevsky, 2015
-
-@corporateshark sk@linderdaum.com
-
-http://www.linderdaum.com
-
-http://blog.linderdaum.com
-
-=============================
-
-A tiny and lightweight URL & URI parser (RFC 1738, RFC 3986) written in C++.
diff --git a/src/common/fiber.cpp b/src/common/fiber.cpp
index 1c1d09ccb..e186ed880 100644
--- a/src/common/fiber.cpp
+++ b/src/common/fiber.cpp
@@ -91,7 +91,7 @@ void Fiber::Rewind() {
     SwitchToFiber(impl->rewind_handle);
 }
 
-void Fiber::YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to) {
+void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
     ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
     ASSERT_MSG(to != nullptr, "Next fiber is null!");
     to->guard.lock();
@@ -199,7 +199,7 @@ void Fiber::Rewind() {
     boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }
 
-void Fiber::YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to) {
+void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
     ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
     ASSERT_MSG(to != nullptr, "Next fiber is null!");
     to->guard.lock();
diff --git a/src/common/fiber.h b/src/common/fiber.h
index 89dde5e36..cefd61df9 100644
--- a/src/common/fiber.h
+++ b/src/common/fiber.h
@@ -46,7 +46,7 @@ public:
 
     /// Yields control from Fiber 'from' to Fiber 'to'
     /// Fiber 'from' must be the currently running fiber.
-    static void YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to);
+    static void YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to);
     [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
 
     void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter);
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index b2b5b8adf..bb3e312a7 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -86,8 +86,6 @@ struct KernelCore::Impl {
         }
         cores.clear();
 
-        registered_core_threads.reset();
-
         process_list.clear();
         current_process = nullptr;
 
@@ -199,9 +197,7 @@ struct KernelCore::Impl {
         const auto it = std::find(register_host_thread_keys.begin(), end, this_id);
         ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
         ASSERT(it == end);
-        ASSERT(!registered_core_threads[core_id]);
         InsertHostThread(static_cast<u32>(core_id));
-        registered_core_threads.set(core_id);
     }
 
     void RegisterHostThread() {
@@ -332,7 +328,6 @@ struct KernelCore::Impl {
 
     // 0-3 IDs represent core threads, >3 represent others
     std::atomic<u32> registered_thread_ids{Core::Hardware::NUM_CPU_CORES};
-    std::bitset<Core::Hardware::NUM_CPU_CORES> registered_core_threads;
 
     // Number of host threads is a relatively high number to avoid overflowing
     static constexpr size_t NUM_REGISTRABLE_HOST_THREADS = 64;
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index ff9d9248b..b17529dee 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <bitset>
+#include <ctime>
 #include <memory>
 #include <random>
 #include "common/alignment.h"
@@ -123,7 +124,7 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,
                                                               : kernel.CreateNewUserProcessID();
     process->capabilities.InitializeForMetadatalessProcess();
 
-    std::mt19937 rng(Settings::values.rng_seed.GetValue().value_or(0));
+    std::mt19937 rng(Settings::values.rng_seed.GetValue().value_or(std::time(nullptr)));
     std::uniform_int_distribution<u64> distribution;
     std::generate(process->random_entropy.begin(), process->random_entropy.end(),
                   [&] { return distribution(rng); });
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index d7a81f64a..2ce742e35 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -1201,6 +1201,8 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
         {151, nullptr, "TryPopFromNotificationStorageChannel"},
         {160, nullptr, "GetHealthWarningDisappearedSystemEvent"},
         {170, nullptr, "SetHdcpAuthenticationActivated"},
+        {180, nullptr, "GetLaunchRequiredVersion"},
+        {181, nullptr, "UpgradeLaunchRequiredVersion"},
         {500, nullptr, "StartContinuousRecordingFlushForDebug"},
         {1000, nullptr, "CreateMovieMaker"},
         {1001, nullptr, "PrepareForJit"},
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 8918946a1..50f709b25 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -260,7 +260,7 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {404, nullptr, "HasLeftRightBattery"},
         {405, nullptr, "GetNpadInterfaceType"},
         {406, nullptr, "GetNpadLeftRightInterfaceType"},
-        {407, nullptr, "GetNpadOfHighestBatteryLevelForJoyLeft"},
+        {407, nullptr, "GetNpadOfHighestBatteryLevel"},
         {408, nullptr, "GetNpadOfHighestBatteryLevelForJoyRight"},
         {500, nullptr, "GetPalmaConnectionHandle"},
         {501, nullptr, "InitializePalma"},
diff --git a/src/core/hle/service/mii/mii.cpp b/src/core/hle/service/mii/mii.cpp
index b81bf6277..d7080b715 100644
--- a/src/core/hle/service/mii/mii.cpp
+++ b/src/core/hle/service/mii/mii.cpp
@@ -47,6 +47,7 @@ public:
             {23, nullptr, "Convert"},
             {24, nullptr, "ConvertCoreDataToCharInfo"},
             {25, nullptr, "ConvertCharInfoToCoreData"},
+            {26, nullptr, "Append"},
         };
         // clang-format on
 
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index e64777668..ffbf90b00 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -202,6 +202,7 @@ SET::SET() : ServiceFramework("set") {
         {8, &SET::GetQuestFlag, "GetQuestFlag"},
         {9, &SET::GetKeyCodeMap2, "GetKeyCodeMap2"},
         {10, nullptr, "GetFirmwareVersionForDebug"},
+        {11, nullptr, "GetDeviceNickName"},
     };
     // clang-format on
 
diff --git a/src/core/hle/service/set/set_sys.cpp b/src/core/hle/service/set/set_sys.cpp
index 8bd4c7e79..080b5743e 100644
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -300,6 +300,8 @@ SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
         {198, nullptr, "SetButtonConfigRegisteredSettingsEmbedded"},
         {199, nullptr, "GetButtonConfigRegisteredSettings"},
         {200, nullptr, "SetButtonConfigRegisteredSettings"},
+        {201, nullptr, "GetFieldTestingFlag"},
+        {202, nullptr, "SetFieldTestingFlag"},
     };
     // clang-format on
 
diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp
index c95feb0d7..b912188b6 100644
--- a/src/input_common/gcadapter/gc_adapter.cpp
+++ b/src/input_common/gcadapter/gc_adapter.cpp
@@ -21,26 +21,6 @@
 
 namespace GCAdapter {
 
-// Used to loop through and assign button in poller
-constexpr std::array<PadButton, 12> PadButtonArray{
-    PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT, PadButton::PAD_BUTTON_DOWN,
-    PadButton::PAD_BUTTON_UP,   PadButton::PAD_TRIGGER_Z,    PadButton::PAD_TRIGGER_R,
-    PadButton::PAD_TRIGGER_L,   PadButton::PAD_BUTTON_A,     PadButton::PAD_BUTTON_B,
-    PadButton::PAD_BUTTON_X,    PadButton::PAD_BUTTON_Y,     PadButton::PAD_BUTTON_START,
-};
-
-static void PadToState(const GCPadStatus& pad, GCState& out_state) {
-    for (const auto& button : PadButtonArray) {
-        const auto button_key = static_cast<u16>(button);
-        const auto button_value = (pad.button & button_key) != 0;
-        out_state.buttons.insert_or_assign(static_cast<s32>(button_key), button_value);
-    }
-
-    for (std::size_t i = 0; i < pad.axis_values.size(); ++i) {
-        out_state.axes.insert_or_assign(static_cast<u32>(i), pad.axis_values[i]);
-    }
-}
-
 Adapter::Adapter() {
     if (usb_adapter_handle != nullptr) {
         return;
@@ -49,168 +29,263 @@ Adapter::Adapter() {
 
     const int init_res = libusb_init(&libusb_ctx);
     if (init_res == LIBUSB_SUCCESS) {
-        Setup();
+        adapter_scan_thread = std::thread(&Adapter::AdapterScanThread, this);
     } else {
         LOG_ERROR(Input, "libusb could not be initialized. failed with error = {}", init_res);
     }
 }
 
-GCPadStatus Adapter::GetPadStatus(std::size_t port, const std::array<u8, 37>& adapter_payload) {
-    GCPadStatus pad = {};
-    const std::size_t offset = 1 + (9 * port);
+Adapter::~Adapter() {
+    Reset();
+}
+
+void Adapter::AdapterInputThread() {
+    LOG_DEBUG(Input, "GC Adapter input thread started");
+    s32 payload_size{};
+    AdapterPayload adapter_payload{};
+
+    if (adapter_scan_thread.joinable()) {
+        adapter_scan_thread.join();
+    }
+
+    while (adapter_input_thread_running) {
+        libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(),
+                                  static_cast<s32>(adapter_payload.size()), &payload_size, 16);
+        if (IsPayloadCorrect(adapter_payload, payload_size)) {
+            UpdateControllers(adapter_payload);
+            UpdateVibrations();
+        }
+        std::this_thread::yield();
+    }
 
-    adapter_controllers_status[port] = static_cast<ControllerTypes>(adapter_payload[offset] >> 4);
+    if (restart_scan_thread) {
+        adapter_scan_thread = std::thread(&Adapter::AdapterScanThread, this);
+        restart_scan_thread = false;
+    }
+}
+
+bool Adapter::IsPayloadCorrect(const AdapterPayload& adapter_payload, s32 payload_size) {
+    if (payload_size != static_cast<s32>(adapter_payload.size()) ||
+        adapter_payload[0] != LIBUSB_DT_HID) {
+        LOG_DEBUG(Input, "Error reading payload (size: {}, type: {:02x})", payload_size,
+                  adapter_payload[0]);
+        if (input_error_counter++ > 20) {
+            LOG_ERROR(Input, "GC adapter timeout, Is the adapter connected?");
+            adapter_input_thread_running = false;
+            restart_scan_thread = true;
+        }
+        return false;
+    }
+
+    input_error_counter = 0;
+    return true;
+}
+
+void Adapter::UpdateControllers(const AdapterPayload& adapter_payload) {
+    for (std::size_t port = 0; port < pads.size(); ++port) {
+        const std::size_t offset = 1 + (9 * port);
+        const auto type = static_cast<ControllerTypes>(adapter_payload[offset] >> 4);
+        UpdatePadType(port, type);
+        if (DeviceConnected(port)) {
+            const u8 b1 = adapter_payload[offset + 1];
+            const u8 b2 = adapter_payload[offset + 2];
+            UpdateStateButtons(port, b1, b2);
+            UpdateStateAxes(port, adapter_payload);
+            if (configuring) {
+                UpdateYuzuSettings(port);
+            }
+        }
+    }
+}
+
+void Adapter::UpdatePadType(std::size_t port, ControllerTypes pad_type) {
+    if (pads[port].type == pad_type) {
+        return;
+    }
+    // Device changed reset device and set new type
+    ResetDevice(port);
+    pads[port].type = pad_type;
+}
+
+void Adapter::UpdateStateButtons(std::size_t port, u8 b1, u8 b2) {
+    if (port >= pads.size()) {
+        return;
+    }
 
     static constexpr std::array<PadButton, 8> b1_buttons{
-        PadButton::PAD_BUTTON_A,    PadButton::PAD_BUTTON_B,    PadButton::PAD_BUTTON_X,
-        PadButton::PAD_BUTTON_Y,    PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT,
-        PadButton::PAD_BUTTON_DOWN, PadButton::PAD_BUTTON_UP,
+        PadButton::ButtonA,    PadButton::ButtonB,     PadButton::ButtonX,    PadButton::ButtonY,
+        PadButton::ButtonLeft, PadButton::ButtonRight, PadButton::ButtonDown, PadButton::ButtonUp,
     };
 
     static constexpr std::array<PadButton, 4> b2_buttons{
-        PadButton::PAD_BUTTON_START,
-        PadButton::PAD_TRIGGER_Z,
-        PadButton::PAD_TRIGGER_R,
-        PadButton::PAD_TRIGGER_L,
+        PadButton::ButtonStart,
+        PadButton::TriggerZ,
+        PadButton::TriggerR,
+        PadButton::TriggerL,
     };
+    pads[port].buttons = 0;
+    for (std::size_t i = 0; i < b1_buttons.size(); ++i) {
+        if ((b1 & (1U << i)) != 0) {
+            pads[port].buttons =
+                static_cast<u16>(pads[port].buttons | static_cast<u16>(b1_buttons[i]));
+            pads[port].last_button = b1_buttons[i];
+        }
+    }
 
+    for (std::size_t j = 0; j < b2_buttons.size(); ++j) {
+        if ((b2 & (1U << j)) != 0) {
+            pads[port].buttons =
+                static_cast<u16>(pads[port].buttons | static_cast<u16>(b2_buttons[j]));
+            pads[port].last_button = b2_buttons[j];
+        }
+    }
+}
+
+void Adapter::UpdateStateAxes(std::size_t port, const AdapterPayload& adapter_payload) {
+    if (port >= pads.size()) {
+        return;
+    }
+
+    const std::size_t offset = 1 + (9 * port);
     static constexpr std::array<PadAxes, 6> axes{
         PadAxes::StickX,    PadAxes::StickY,      PadAxes::SubstickX,
         PadAxes::SubstickY, PadAxes::TriggerLeft, PadAxes::TriggerRight,
     };
 
-    if (adapter_controllers_status[port] == ControllerTypes::None && !get_origin[port]) {
-        // Controller may have been disconnected, recalibrate if reconnected.
-        get_origin[port] = true;
+    for (const PadAxes axis : axes) {
+        const auto index = static_cast<std::size_t>(axis);
+        const u8 axis_value = adapter_payload[offset + 3 + index];
+        if (pads[port].axis_origin[index] == 255) {
+            pads[port].axis_origin[index] = axis_value;
+        }
+        pads[port].axis_values[index] =
+            static_cast<s16>(axis_value - pads[port].axis_origin[index]);
     }
+}
 
-    if (adapter_controllers_status[port] != ControllerTypes::None) {
-        const u8 b1 = adapter_payload[offset + 1];
-        const u8 b2 = adapter_payload[offset + 2];
+void Adapter::UpdateYuzuSettings(std::size_t port) {
+    if (port >= pads.size()) {
+        return;
+    }
 
-        for (std::size_t i = 0; i < b1_buttons.size(); ++i) {
-            if ((b1 & (1U << i)) != 0) {
-                pad.button = static_cast<u16>(pad.button | static_cast<u16>(b1_buttons[i]));
-            }
-        }
+    constexpr u8 axis_threshold = 50;
+    GCPadStatus pad_status = {.port = port};
 
-        for (std::size_t j = 0; j < b2_buttons.size(); ++j) {
-            if ((b2 & (1U << j)) != 0) {
-                pad.button = static_cast<u16>(pad.button | static_cast<u16>(b2_buttons[j]));
-            }
-        }
-        for (PadAxes axis : axes) {
-            const auto index = static_cast<std::size_t>(axis);
-            pad.axis_values[index] = adapter_payload[offset + 3 + index];
-        }
+    if (pads[port].buttons != 0) {
+        pad_status.button = pads[port].last_button;
+        pad_queue.Push(pad_status);
+    }
+
+    // Accounting for a threshold here to ensure an intentional press
+    for (std::size_t i = 0; i < pads[port].axis_values.size(); ++i) {
+        const s16 value = pads[port].axis_values[i];
 
-        if (get_origin[port]) {
-            origin_status[port].axis_values = pad.axis_values;
-            get_origin[port] = false;
+        if (value > axis_threshold || value < -axis_threshold) {
+            pad_status.axis = static_cast<PadAxes>(i);
+            pad_status.axis_value = value;
+            pad_status.axis_threshold = axis_threshold;
+            pad_queue.Push(pad_status);
         }
     }
-    return pad;
 }
 
-void Adapter::Read() {
-    LOG_DEBUG(Input, "GC Adapter Read() thread started");
+void Adapter::UpdateVibrations() {
+    // Use 8 states to keep the switching between on/off fast enough for
+    // a human to not notice the difference between switching from on/off
+    // More states = more rumble strengths = slower update time
+    constexpr u8 vibration_states = 8;
 
-    int payload_size;
-    std::array<u8, 37> adapter_payload;
-    std::array<GCPadStatus, 4> pads;
-
-    while (adapter_thread_running) {
-        libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(),
-                                  sizeof(adapter_payload), &payload_size, 16);
-
-        if (payload_size != sizeof(adapter_payload) || adapter_payload[0] != LIBUSB_DT_HID) {
-            LOG_ERROR(Input,
-                      "Error reading payload (size: {}, type: {:02x}) Is the adapter connected?",
-                      payload_size, adapter_payload[0]);
-            adapter_thread_running = false; // error reading from adapter, stop reading.
-            break;
-        }
-        for (std::size_t port = 0; port < pads.size(); ++port) {
-            pads[port] = GetPadStatus(port, adapter_payload);
-            if (DeviceConnected(port) && configuring) {
-                if (pads[port].button != 0) {
-                    pad_queue[port].Push(pads[port]);
-                }
+    vibration_counter = (vibration_counter + 1) % vibration_states;
 
-                // Accounting for a threshold here to ensure an intentional press
-                for (size_t i = 0; i < pads[port].axis_values.size(); ++i) {
-                    const u8 value = pads[port].axis_values[i];
-                    const u8 origin = origin_status[port].axis_values[i];
-
-                    if (value > origin + pads[port].THRESHOLD ||
-                        value < origin - pads[port].THRESHOLD) {
-                        pads[port].axis = static_cast<PadAxes>(i);
-                        pads[port].axis_value = pads[port].axis_values[i];
-                        pad_queue[port].Push(pads[port]);
-                    }
-                }
-            }
-            PadToState(pads[port], state[port]);
-        }
-        std::this_thread::yield();
+    for (GCController& pad : pads) {
+        const bool vibrate = pad.rumble_amplitude > vibration_counter;
+        vibration_changed |= vibrate != pad.enable_vibration;
+        pad.enable_vibration = vibrate;
     }
+    SendVibrations();
 }
 
-void Adapter::Setup() {
-    // Initialize all controllers as unplugged
-    adapter_controllers_status.fill(ControllerTypes::None);
-    // Initialize all ports to store axis origin values
-    get_origin.fill(true);
-
-    // pointer to list of connected usb devices
-    libusb_device** devices{};
-
-    // populate the list of devices, get the count
-    const ssize_t device_count = libusb_get_device_list(libusb_ctx, &devices);
-    if (device_count < 0) {
-        LOG_ERROR(Input, "libusb_get_device_list failed with error: {}", device_count);
+void Adapter::SendVibrations() {
+    if (!rumble_enabled || !vibration_changed) {
         return;
     }
-
-    if (devices != nullptr) {
-        for (std::size_t index = 0; index < static_cast<std::size_t>(device_count); ++index) {
-            if (CheckDeviceAccess(devices[index])) {
-                // GC Adapter found and accessible, registering it
-                GetGCEndpoint(devices[index]);
-                break;
-            }
+    s32 size{};
+    constexpr u8 rumble_command = 0x11;
+    const u8 p1 = pads[0].enable_vibration;
+    const u8 p2 = pads[1].enable_vibration;
+    const u8 p3 = pads[2].enable_vibration;
+    const u8 p4 = pads[3].enable_vibration;
+    std::array<u8, 5> payload = {rumble_command, p1, p2, p3, p4};
+    const int err = libusb_interrupt_transfer(usb_adapter_handle, output_endpoint, payload.data(),
+                                              static_cast<s32>(payload.size()), &size, 16);
+    if (err) {
+        LOG_DEBUG(Input, "Adapter libusb write failed: {}", libusb_error_name(err));
+        if (output_error_counter++ > 5) {
+            LOG_ERROR(Input, "GC adapter output timeout, Rumble disabled");
+            rumble_enabled = false;
         }
-        libusb_free_device_list(devices, 1);
+        return;
     }
+    output_error_counter = 0;
+    vibration_changed = false;
 }
 
-bool Adapter::CheckDeviceAccess(libusb_device* device) {
-    libusb_device_descriptor desc;
-    const int get_descriptor_error = libusb_get_device_descriptor(device, &desc);
-    if (get_descriptor_error) {
-        // could not acquire the descriptor, no point in trying to use it.
-        LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: {}",
-                  get_descriptor_error);
-        return false;
+bool Adapter::RumblePlay(std::size_t port, f32 amplitude) {
+    amplitude = std::clamp(amplitude, 0.0f, 1.0f);
+    const auto raw_amp = static_cast<u8>(amplitude * 0x8);
+    pads[port].rumble_amplitude = raw_amp;
+
+    return rumble_enabled;
+}
+
+void Adapter::AdapterScanThread() {
+    adapter_scan_thread_running = true;
+    adapter_input_thread_running = false;
+    if (adapter_input_thread.joinable()) {
+        adapter_input_thread.join();
+    }
+    ClearLibusbHandle();
+    ResetDevices();
+    while (adapter_scan_thread_running && !adapter_input_thread_running) {
+        Setup();
+        std::this_thread::sleep_for(std::chrono::seconds(1));
     }
+}
 
-    if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) {
-        // This isn't the device we are looking for.
-        return false;
+void Adapter::Setup() {
+    usb_adapter_handle = libusb_open_device_with_vid_pid(libusb_ctx, 0x057e, 0x0337);
+
+    if (usb_adapter_handle == NULL) {
+        return;
+    }
+    if (!CheckDeviceAccess()) {
+        ClearLibusbHandle();
+        return;
     }
-    const int open_error = libusb_open(device, &usb_adapter_handle);
 
-    if (open_error == LIBUSB_ERROR_ACCESS) {
-        LOG_ERROR(Input, "Yuzu can not gain access to this device: ID {:04X}:{:04X}.",
-                  desc.idVendor, desc.idProduct);
-        return false;
+    libusb_device* device = libusb_get_device(usb_adapter_handle);
+
+    LOG_INFO(Input, "GC adapter is now connected");
+    // GC Adapter found and accessible, registering it
+    if (GetGCEndpoint(device)) {
+        adapter_scan_thread_running = false;
+        adapter_input_thread_running = true;
+        rumble_enabled = true;
+        input_error_counter = 0;
+        output_error_counter = 0;
+        adapter_input_thread = std::thread(&Adapter::AdapterInputThread, this);
     }
-    if (open_error) {
-        LOG_ERROR(Input, "libusb_open failed to open device with error = {}", open_error);
-        return false;
+}
+
+bool Adapter::CheckDeviceAccess() {
+    // This fixes payload problems from offbrand GCAdapters
+    const s32 control_transfer_error =
+        libusb_control_transfer(usb_adapter_handle, 0x21, 11, 0x0001, 0, nullptr, 0, 1000);
+    if (control_transfer_error < 0) {
+        LOG_ERROR(Input, "libusb_control_transfer failed with error= {}", control_transfer_error);
     }
 
-    int kernel_driver_error = libusb_kernel_driver_active(usb_adapter_handle, 0);
+    s32 kernel_driver_error = libusb_kernel_driver_active(usb_adapter_handle, 0);
     if (kernel_driver_error == 1) {
         kernel_driver_error = libusb_detach_kernel_driver(usb_adapter_handle, 0);
         if (kernel_driver_error != 0 && kernel_driver_error != LIBUSB_ERROR_NOT_SUPPORTED) {
@@ -236,13 +311,13 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) {
     return true;
 }
 
-void Adapter::GetGCEndpoint(libusb_device* device) {
+bool Adapter::GetGCEndpoint(libusb_device* device) {
     libusb_config_descriptor* config = nullptr;
     const int config_descriptor_return = libusb_get_config_descriptor(device, 0, &config);
     if (config_descriptor_return != LIBUSB_SUCCESS) {
         LOG_ERROR(Input, "libusb_get_config_descriptor failed with error = {}",
                   config_descriptor_return);
-        return;
+        return false;
     }
 
     for (u8 ic = 0; ic < config->bNumInterfaces; ic++) {
@@ -264,31 +339,51 @@ void Adapter::GetGCEndpoint(libusb_device* device) {
     unsigned char clear_payload = 0x13;
     libusb_interrupt_transfer(usb_adapter_handle, output_endpoint, &clear_payload,
                               sizeof(clear_payload), nullptr, 16);
-
-    adapter_thread_running = true;
-    adapter_input_thread = std::thread(&Adapter::Read, this);
+    return true;
 }
 
-Adapter::~Adapter() {
-    Reset();
-}
+void Adapter::JoinThreads() {
+    restart_scan_thread = false;
+    adapter_input_thread_running = false;
+    adapter_scan_thread_running = false;
 
-void Adapter::Reset() {
-    if (adapter_thread_running) {
-        adapter_thread_running = false;
+    if (adapter_scan_thread.joinable()) {
+        adapter_scan_thread.join();
     }
+
     if (adapter_input_thread.joinable()) {
         adapter_input_thread.join();
     }
+}
 
-    adapter_controllers_status.fill(ControllerTypes::None);
-    get_origin.fill(true);
-
+void Adapter::ClearLibusbHandle() {
     if (usb_adapter_handle) {
         libusb_release_interface(usb_adapter_handle, 1);
         libusb_close(usb_adapter_handle);
         usb_adapter_handle = nullptr;
     }
+}
+
+void Adapter::ResetDevices() {
+    for (std::size_t i = 0; i < pads.size(); ++i) {
+        ResetDevice(i);
+    }
+}
+
+void Adapter::ResetDevice(std::size_t port) {
+    pads[port].type = ControllerTypes::None;
+    pads[port].enable_vibration = false;
+    pads[port].rumble_amplitude = 0;
+    pads[port].buttons = 0;
+    pads[port].last_button = PadButton::Undefined;
+    pads[port].axis_values.fill(0);
+    pads[port].axis_origin.fill(255);
+}
+
+void Adapter::Reset() {
+    JoinThreads();
+    ClearLibusbHandle();
+    ResetDevices();
 
     if (libusb_ctx) {
         libusb_exit(libusb_ctx);
@@ -297,11 +392,11 @@ void Adapter::Reset() {
 
 std::vector<Common::ParamPackage> Adapter::GetInputDevices() const {
     std::vector<Common::ParamPackage> devices;
-    for (std::size_t port = 0; port < state.size(); ++port) {
+    for (std::size_t port = 0; port < pads.size(); ++port) {
         if (!DeviceConnected(port)) {
             continue;
         }
-        std::string name = fmt::format("Gamecube Controller {}", port);
+        std::string name = fmt::format("Gamecube Controller {}", port + 1);
         devices.emplace_back(Common::ParamPackage{
             {"class", "gcpad"},
             {"display", std::move(name)},
@@ -318,18 +413,18 @@ InputCommon::ButtonMapping Adapter::GetButtonMappingForDevice(
     // This list also excludes any button that can't be really mapped
     static constexpr std::array<std::pair<Settings::NativeButton::Values, PadButton>, 12>
         switch_to_gcadapter_button = {
-            std::pair{Settings::NativeButton::A, PadButton::PAD_BUTTON_A},
-            {Settings::NativeButton::B, PadButton::PAD_BUTTON_B},
-            {Settings::NativeButton::X, PadButton::PAD_BUTTON_X},
-            {Settings::NativeButton::Y, PadButton::PAD_BUTTON_Y},
-            {Settings::NativeButton::Plus, PadButton::PAD_BUTTON_START},
-            {Settings::NativeButton::DLeft, PadButton::PAD_BUTTON_LEFT},
-            {Settings::NativeButton::DUp, PadButton::PAD_BUTTON_UP},
-            {Settings::NativeButton::DRight, PadButton::PAD_BUTTON_RIGHT},
-            {Settings::NativeButton::DDown, PadButton::PAD_BUTTON_DOWN},
-            {Settings::NativeButton::SL, PadButton::PAD_TRIGGER_L},
-            {Settings::NativeButton::SR, PadButton::PAD_TRIGGER_R},
-            {Settings::NativeButton::R, PadButton::PAD_TRIGGER_Z},
+            std::pair{Settings::NativeButton::A, PadButton::ButtonA},
+            {Settings::NativeButton::B, PadButton::ButtonB},
+            {Settings::NativeButton::X, PadButton::ButtonX},
+            {Settings::NativeButton::Y, PadButton::ButtonY},
+            {Settings::NativeButton::Plus, PadButton::ButtonStart},
+            {Settings::NativeButton::DLeft, PadButton::ButtonLeft},
+            {Settings::NativeButton::DUp, PadButton::ButtonUp},
+            {Settings::NativeButton::DRight, PadButton::ButtonRight},
+            {Settings::NativeButton::DDown, PadButton::ButtonDown},
+            {Settings::NativeButton::SL, PadButton::TriggerL},
+            {Settings::NativeButton::SR, PadButton::TriggerR},
+            {Settings::NativeButton::R, PadButton::TriggerZ},
         };
     if (!params.Has("port")) {
         return {};
@@ -352,8 +447,10 @@ InputCommon::ButtonMapping Adapter::GetButtonMappingForDevice(
     for (const auto& [switch_button, gcadapter_axis] : switch_to_gcadapter_axis) {
         Common::ParamPackage button_params({{"engine", "gcpad"}});
         button_params.Set("port", params.Get("port", 0));
-        button_params.Set("button", static_cast<int>(PadButton::PAD_STICK));
-        button_params.Set("axis", static_cast<int>(gcadapter_axis));
+        button_params.Set("button", static_cast<s32>(PadButton::Stick));
+        button_params.Set("axis", static_cast<s32>(gcadapter_axis));
+        button_params.Set("threshold", 0.5f);
+        button_params.Set("direction", "+");
         mapping.insert_or_assign(switch_button, std::move(button_params));
     }
     return mapping;
@@ -382,46 +479,33 @@ InputCommon::AnalogMapping Adapter::GetAnalogMappingForDevice(
 }
 
 bool Adapter::DeviceConnected(std::size_t port) const {
-    return adapter_controllers_status[port] != ControllerTypes::None;
-}
-
-void Adapter::ResetDeviceType(std::size_t port) {
-    adapter_controllers_status[port] = ControllerTypes::None;
+    return pads[port].type != ControllerTypes::None;
 }
 
 void Adapter::BeginConfiguration() {
-    get_origin.fill(true);
-    for (auto& pq : pad_queue) {
-        pq.Clear();
-    }
+    pad_queue.Clear();
     configuring = true;
 }
 
 void Adapter::EndConfiguration() {
-    for (auto& pq : pad_queue) {
-        pq.Clear();
-    }
+    pad_queue.Clear();
     configuring = false;
 }
 
-std::array<Common::SPSCQueue<GCPadStatus>, 4>& Adapter::GetPadQueue() {
+Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() {
     return pad_queue;
 }
 
-const std::array<Common::SPSCQueue<GCPadStatus>, 4>& Adapter::GetPadQueue() const {
+const Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
     return pad_queue;
 }
 
-std::array<GCState, 4>& Adapter::GetPadState() {
-    return state;
-}
-
-const std::array<GCState, 4>& Adapter::GetPadState() const {
-    return state;
+GCController& Adapter::GetPadState(std::size_t port) {
+    return pads.at(port);
 }
 
-int Adapter::GetOriginValue(u32 port, u32 axis) const {
-    return origin_status[port].axis_values[axis];
+const GCController& Adapter::GetPadState(std::size_t port) const {
+    return pads.at(port);
 }
 
 } // namespace GCAdapter
diff --git a/src/input_common/gcadapter/gc_adapter.h b/src/input_common/gcadapter/gc_adapter.h
index 4f5f3de8e..d28dcfad3 100644
--- a/src/input_common/gcadapter/gc_adapter.h
+++ b/src/input_common/gcadapter/gc_adapter.h
@@ -19,24 +19,23 @@ struct libusb_device_handle;
 namespace GCAdapter {
 
 enum class PadButton {
-    PAD_BUTTON_LEFT = 0x0001,
-    PAD_BUTTON_RIGHT = 0x0002,
-    PAD_BUTTON_DOWN = 0x0004,
-    PAD_BUTTON_UP = 0x0008,
-    PAD_TRIGGER_Z = 0x0010,
-    PAD_TRIGGER_R = 0x0020,
-    PAD_TRIGGER_L = 0x0040,
-    PAD_BUTTON_A = 0x0100,
-    PAD_BUTTON_B = 0x0200,
-    PAD_BUTTON_X = 0x0400,
-    PAD_BUTTON_Y = 0x0800,
-    PAD_BUTTON_START = 0x1000,
+    Undefined = 0x0000,
+    ButtonLeft = 0x0001,
+    ButtonRight = 0x0002,
+    ButtonDown = 0x0004,
+    ButtonUp = 0x0008,
+    TriggerZ = 0x0010,
+    TriggerR = 0x0020,
+    TriggerL = 0x0040,
+    ButtonA = 0x0100,
+    ButtonB = 0x0200,
+    ButtonX = 0x0400,
+    ButtonY = 0x0800,
+    ButtonStart = 0x1000,
     // Below is for compatibility with "AxisButton" type
-    PAD_STICK = 0x2000,
+    Stick = 0x2000,
 };
 
-extern const std::array<PadButton, 12> PadButtonArray;
-
 enum class PadAxes : u8 {
     StickX,
     StickY,
@@ -47,87 +46,122 @@ enum class PadAxes : u8 {
     Undefined,
 };
 
+enum class ControllerTypes {
+    None,
+    Wired,
+    Wireless,
+};
+
 struct GCPadStatus {
-    u16 button{}; // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
+    std::size_t port{};
 
-    std::array<u8, 6> axis_values{};    // Triggers and sticks, following indices defined in PadAxes
-    static constexpr u8 THRESHOLD = 50; // Threshold for axis press for polling
+    PadButton button{PadButton::Undefined}; // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
 
-    u8 port{};
     PadAxes axis{PadAxes::Undefined};
-    u8 axis_value{255};
+    s16 axis_value{};
+    u8 axis_threshold{50};
 };
 
-struct GCState {
-    std::unordered_map<int, bool> buttons;
-    std::unordered_map<u32, u16> axes;
+struct GCController {
+    ControllerTypes type{};
+    bool enable_vibration{};
+    u8 rumble_amplitude{};
+    u16 buttons{};
+    PadButton last_button{};
+    std::array<s16, 6> axis_values{};
+    std::array<u8, 6> axis_origin{};
 };
 
-enum class ControllerTypes { None, Wired, Wireless };
-
 class Adapter {
 public:
-    /// Initialize the GC Adapter capture and read sequence
     Adapter();
-
-    /// Close the adapter read thread and release the adapter
     ~Adapter();
+
+    /// Request a vibration for a controlelr
+    bool RumblePlay(std::size_t port, f32 amplitude);
+
     /// Used for polling
     void BeginConfiguration();
     void EndConfiguration();
 
+    Common::SPSCQueue<GCPadStatus>& GetPadQueue();
+    const Common::SPSCQueue<GCPadStatus>& GetPadQueue() const;
+
+    GCController& GetPadState(std::size_t port);
+    const GCController& GetPadState(std::size_t port) const;
+
+    /// Returns true if there is a device connected to port
+    bool DeviceConnected(std::size_t port) const;
+
+    /// Used for automapping features
     std::vector<Common::ParamPackage> GetInputDevices() const;
     InputCommon::ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) const;
     InputCommon::AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) const;
 
-    /// Returns true if there is a device connected to port
-    bool DeviceConnected(std::size_t port) const;
+private:
+    using AdapterPayload = std::array<u8, 37>;
 
-    std::array<Common::SPSCQueue<GCPadStatus>, 4>& GetPadQueue();
-    const std::array<Common::SPSCQueue<GCPadStatus>, 4>& GetPadQueue() const;
+    void UpdatePadType(std::size_t port, ControllerTypes pad_type);
+    void UpdateControllers(const AdapterPayload& adapter_payload);
+    void UpdateYuzuSettings(std::size_t port);
+    void UpdateStateButtons(std::size_t port, u8 b1, u8 b2);
+    void UpdateStateAxes(std::size_t port, const AdapterPayload& adapter_payload);
+    void UpdateVibrations();
 
-    std::array<GCState, 4>& GetPadState();
-    const std::array<GCState, 4>& GetPadState() const;
+    void AdapterInputThread();
 
-    int GetOriginValue(u32 port, u32 axis) const;
+    void AdapterScanThread();
 
-private:
-    GCPadStatus GetPadStatus(std::size_t port, const std::array<u8, 37>& adapter_payload);
+    bool IsPayloadCorrect(const AdapterPayload& adapter_payload, s32 payload_size);
+
+    // Updates vibration state of all controllers
+    void SendVibrations();
+
+    /// For use in initialization, querying devices to find the adapter
+    void Setup();
 
-    void Read();
+    /// Resets status of all GC controller devices to a disconected state
+    void ResetDevices();
 
-    /// Resets status of device connected to port
-    void ResetDeviceType(std::size_t port);
+    /// Resets status of device connected to a disconected state
+    void ResetDevice(std::size_t port);
 
     /// Returns true if we successfully gain access to GC Adapter
-    bool CheckDeviceAccess(libusb_device* device);
+    bool CheckDeviceAccess();
 
-    /// Captures GC Adapter endpoint address,
-    void GetGCEndpoint(libusb_device* device);
+    /// Captures GC Adapter endpoint address
+    /// Returns true if the endpoind was set correctly
+    bool GetGCEndpoint(libusb_device* device);
 
     /// For shutting down, clear all data, join all threads, release usb
     void Reset();
 
-    /// For use in initialization, querying devices to find the adapter
-    void Setup();
+    // Join all threads
+    void JoinThreads();
+
+    // Release usb handles
+    void ClearLibusbHandle();
 
     libusb_device_handle* usb_adapter_handle = nullptr;
+    std::array<GCController, 4> pads;
+    Common::SPSCQueue<GCPadStatus> pad_queue;
 
     std::thread adapter_input_thread;
-    bool adapter_thread_running;
+    std::thread adapter_scan_thread;
+    bool adapter_input_thread_running;
+    bool adapter_scan_thread_running;
+    bool restart_scan_thread;
 
     libusb_context* libusb_ctx;
 
-    u8 input_endpoint = 0;
-    u8 output_endpoint = 0;
-
-    bool configuring = false;
+    u8 input_endpoint{0};
+    u8 output_endpoint{0};
+    u8 input_error_counter{0};
+    u8 output_error_counter{0};
+    int vibration_counter{0};
 
-    std::array<GCState, 4> state;
-    std::array<bool, 4> get_origin;
-    std::array<GCPadStatus, 4> origin_status;
-    std::array<Common::SPSCQueue<GCPadStatus>, 4> pad_queue;
-    std::array<ControllerTypes, 4> adapter_controllers_status{};
+    bool configuring{false};
+    bool rumble_enabled{true};
+    bool vibration_changed{true};
 };
-
 } // namespace GCAdapter
diff --git a/src/input_common/gcadapter/gc_poller.cpp b/src/input_common/gcadapter/gc_poller.cpp
index 893556916..6bd6f57fc 100644
--- a/src/input_common/gcadapter/gc_poller.cpp
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -15,22 +15,30 @@ namespace InputCommon {
 
 class GCButton final : public Input::ButtonDevice {
 public:
-    explicit GCButton(u32 port_, int button_, const GCAdapter::Adapter* adapter)
+    explicit GCButton(u32 port_, s32 button_, GCAdapter::Adapter* adapter)
         : port(port_), button(button_), gcadapter(adapter) {}
 
     ~GCButton() override;
 
     bool GetStatus() const override {
         if (gcadapter->DeviceConnected(port)) {
-            return gcadapter->GetPadState()[port].buttons.at(button);
+            return (gcadapter->GetPadState(port).buttons & button) != 0;
         }
         return false;
     }
 
+    bool SetRumblePlay(f32 amp_high, f32 amp_low, f32 freq_high, f32 freq_low) const override {
+        const float amplitude = amp_high + amp_low > 2.0f ? 1.0f : (amp_high + amp_low) * 0.5f;
+        const auto new_amp =
+            static_cast<f32>(pow(amplitude, 0.5f) * (3.0f - 2.0f * pow(amplitude, 0.15f)));
+
+        return gcadapter->RumblePlay(port, new_amp);
+    }
+
 private:
     const u32 port;
-    const int button;
-    const GCAdapter::Adapter* gcadapter;
+    const s32 button;
+    GCAdapter::Adapter* gcadapter;
 };
 
 class GCAxisButton final : public Input::ButtonDevice {
@@ -38,13 +46,12 @@ public:
     explicit GCAxisButton(u32 port_, u32 axis_, float threshold_, bool trigger_if_greater_,
                           const GCAdapter::Adapter* adapter)
         : port(port_), axis(axis_), threshold(threshold_), trigger_if_greater(trigger_if_greater_),
-          gcadapter(adapter),
-          origin_value(static_cast<float>(adapter->GetOriginValue(port_, axis_))) {}
+          gcadapter(adapter) {}
 
     bool GetStatus() const override {
         if (gcadapter->DeviceConnected(port)) {
-            const float current_axis_value = gcadapter->GetPadState()[port].axes.at(axis);
-            const float axis_value = (current_axis_value - origin_value) / 128.0f;
+            const float current_axis_value = gcadapter->GetPadState(port).axis_values.at(axis);
+            const float axis_value = current_axis_value / 128.0f;
             if (trigger_if_greater) {
                 // TODO: Might be worthwile to set a slider for the trigger threshold. It is
                 // currently always set to 0.5 in configure_input_player.cpp ZL/ZR HandleClick
@@ -61,7 +68,6 @@ private:
     float threshold;
     bool trigger_if_greater;
     const GCAdapter::Adapter* gcadapter;
-    const float origin_value;
 };
 
 GCButtonFactory::GCButtonFactory(std::shared_ptr<GCAdapter::Adapter> adapter_)
@@ -73,7 +79,7 @@ std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::Param
     const auto button_id = params.Get("button", 0);
     const auto port = static_cast<u32>(params.Get("port", 0));
 
-    constexpr int PAD_STICK_ID = static_cast<u16>(GCAdapter::PadButton::PAD_STICK);
+    constexpr s32 PAD_STICK_ID = static_cast<s32>(GCAdapter::PadButton::Stick);
 
     // button is not an axis/stick button
     if (button_id != PAD_STICK_ID) {
@@ -106,32 +112,25 @@ Common::ParamPackage GCButtonFactory::GetNextInput() const {
     Common::ParamPackage params;
     GCAdapter::GCPadStatus pad;
     auto& queue = adapter->GetPadQueue();
-    for (std::size_t port = 0; port < queue.size(); ++port) {
-        while (queue[port].Pop(pad)) {
-            // This while loop will break on the earliest detected button
-            params.Set("engine", "gcpad");
-            params.Set("port", static_cast<int>(port));
-            for (const auto& button : GCAdapter::PadButtonArray) {
-                const u16 button_value = static_cast<u16>(button);
-                if (pad.button & button_value) {
-                    params.Set("button", button_value);
-                    break;
-                }
-            }
+    while (queue.Pop(pad)) {
+        // This while loop will break on the earliest detected button
+        params.Set("engine", "gcpad");
+        params.Set("port", static_cast<s32>(pad.port));
+        if (pad.button != GCAdapter::PadButton::Undefined) {
+            params.Set("button", static_cast<u16>(pad.button));
+        }
 
-            // For Axis button implementation
-            if (pad.axis != GCAdapter::PadAxes::Undefined) {
-                params.Set("axis", static_cast<u8>(pad.axis));
-                params.Set("button", static_cast<u16>(GCAdapter::PadButton::PAD_STICK));
-                if (pad.axis_value > 128) {
-                    params.Set("direction", "+");
-                    params.Set("threshold", "0.25");
-                } else {
-                    params.Set("direction", "-");
-                    params.Set("threshold", "-0.25");
-                }
-                break;
+        // For Axis button implementation
+        if (pad.axis != GCAdapter::PadAxes::Undefined) {
+            params.Set("axis", static_cast<u8>(pad.axis));
+            params.Set("button", static_cast<u16>(GCAdapter::PadButton::Stick));
+            params.Set("threshold", "0.25");
+            if (pad.axis_value > 0) {
+                params.Set("direction", "+");
+            } else {
+                params.Set("direction", "-");
             }
+            break;
         }
     }
     return params;
@@ -152,17 +151,14 @@ public:
     explicit GCAnalog(u32 port_, u32 axis_x_, u32 axis_y_, float deadzone_,
                       const GCAdapter::Adapter* adapter, float range_)
         : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter),
-          origin_value_x(static_cast<float>(adapter->GetOriginValue(port_, axis_x_))),
-          origin_value_y(static_cast<float>(adapter->GetOriginValue(port_, axis_y_))),
           range(range_) {}
 
     float GetAxis(u32 axis) const {
         if (gcadapter->DeviceConnected(port)) {
             std::lock_guard lock{mutex};
-            const auto origin_value = axis % 2 == 0 ? origin_value_x : origin_value_y;
             const auto axis_value =
-                static_cast<float>(gcadapter->GetPadState()[port].axes.at(axis));
-            return (axis_value - origin_value) / (100.0f * range);
+                static_cast<float>(gcadapter->GetPadState(port).axis_values.at(axis));
+            return (axis_value) / (100.0f * range);
         }
         return 0.0f;
     }
@@ -215,8 +211,6 @@ private:
     const u32 axis_y;
     const float deadzone;
     const GCAdapter::Adapter* gcadapter;
-    const float origin_value_x;
-    const float origin_value_y;
     const float range;
     mutable std::mutex mutex;
 };
@@ -254,26 +248,44 @@ void GCAnalogFactory::EndConfiguration() {
 
 Common::ParamPackage GCAnalogFactory::GetNextInput() {
     GCAdapter::GCPadStatus pad;
+    Common::ParamPackage params;
     auto& queue = adapter->GetPadQueue();
-    for (std::size_t port = 0; port < queue.size(); ++port) {
-        while (queue[port].Pop(pad)) {
-            if (pad.axis == GCAdapter::PadAxes::Undefined ||
-                std::abs((static_cast<float>(pad.axis_value) - 128.0f) / 128.0f) < 0.1f) {
-                continue;
-            }
-            // An analog device needs two axes, so we need to store the axis for later and wait for
-            // a second input event. The axes also must be from the same joystick.
-            const u8 axis = static_cast<u8>(pad.axis);
-            if (analog_x_axis == -1) {
-                analog_x_axis = axis;
-                controller_number = static_cast<int>(port);
-            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
-                       controller_number == static_cast<int>(port)) {
-                analog_y_axis = axis;
-            }
+    while (queue.Pop(pad)) {
+        if (pad.button != GCAdapter::PadButton::Undefined) {
+            params.Set("engine", "gcpad");
+            params.Set("port", static_cast<s32>(pad.port));
+            params.Set("button", static_cast<u16>(pad.button));
+            return params;
+        }
+        if (pad.axis == GCAdapter::PadAxes::Undefined ||
+            std::abs(static_cast<float>(pad.axis_value) / 128.0f) < 0.1f) {
+            continue;
+        }
+        // An analog device needs two axes, so we need to store the axis for later and wait for
+        // a second input event. The axes also must be from the same joystick.
+        const u8 axis = static_cast<u8>(pad.axis);
+        if (axis == 0 || axis == 1) {
+            analog_x_axis = 0;
+            analog_y_axis = 1;
+            controller_number = static_cast<s32>(pad.port);
+            break;
+        }
+        if (axis == 2 || axis == 3) {
+            analog_x_axis = 2;
+            analog_y_axis = 3;
+            controller_number = static_cast<s32>(pad.port);
+            break;
+        }
+
+        if (analog_x_axis == -1) {
+            analog_x_axis = axis;
+            controller_number = static_cast<s32>(pad.port);
+        } else if (analog_y_axis == -1 && analog_x_axis != axis &&
+                   controller_number == static_cast<s32>(pad.port)) {
+            analog_y_axis = axis;
+            break;
         }
     }
-    Common::ParamPackage params;
     if (analog_x_axis != -1 && analog_y_axis != -1) {
         params.Set("engine", "gcpad");
         params.Set("port", controller_number);
diff --git a/src/tests/common/fibers.cpp b/src/tests/common/fibers.cpp
index 4fd92428f..4757dd2b4 100644
--- a/src/tests/common/fibers.cpp
+++ b/src/tests/common/fibers.cpp
@@ -6,18 +6,40 @@
 #include <cstdlib>
 #include <functional>
 #include <memory>
+#include <mutex>
+#include <stdexcept>
 #include <thread>
 #include <unordered_map>
 #include <vector>
 
 #include <catch2/catch.hpp>
-#include <math.h>
+
 #include "common/common_types.h"
 #include "common/fiber.h"
-#include "common/spin_lock.h"
 
 namespace Common {
 
+class ThreadIds {
+public:
+    void Register(u32 id) {
+        const auto thread_id = std::this_thread::get_id();
+        std::scoped_lock lock{mutex};
+        if (ids.contains(thread_id)) {
+            throw std::logic_error{"Registering the same thread twice"};
+        }
+        ids.emplace(thread_id, id);
+    }
+
+    [[nodiscard]] u32 Get() const {
+        std::scoped_lock lock{mutex};
+        return ids.at(std::this_thread::get_id());
+    }
+
+private:
+    mutable std::mutex mutex;
+    std::unordered_map<std::thread::id, u32> ids;
+};
+
 class TestControl1 {
 public:
     TestControl1() = default;
@@ -26,7 +48,7 @@ public:
 
     void ExecuteThread(u32 id);
 
-    std::unordered_map<std::thread::id, u32> ids;
+    ThreadIds thread_ids;
     std::vector<std::shared_ptr<Common::Fiber>> thread_fibers;
     std::vector<std::shared_ptr<Common::Fiber>> work_fibers;
     std::vector<u32> items;
@@ -39,8 +61,7 @@ static void WorkControl1(void* control) {
 }
 
 void TestControl1::DoWork() {
-    std::thread::id this_id = std::this_thread::get_id();
-    u32 id = ids[this_id];
+    const u32 id = thread_ids.Get();
     u32 value = items[id];
     for (u32 i = 0; i < id; i++) {
         value++;
@@ -50,8 +71,7 @@ void TestControl1::DoWork() {
 }
 
 void TestControl1::ExecuteThread(u32 id) {
-    std::thread::id this_id = std::this_thread::get_id();
-    ids[this_id] = id;
+    thread_ids.Register(id);
     auto thread_fiber = Fiber::ThreadToFiber();
     thread_fibers[id] = thread_fiber;
     work_fibers[id] = std::make_shared<Fiber>(std::function<void(void*)>{WorkControl1}, this);
@@ -98,8 +118,7 @@ public:
             value1 += i;
         }
         Fiber::YieldTo(fiber1, fiber3);
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         assert1 = id == 1;
         value2 += 5000;
         Fiber::YieldTo(fiber1, thread_fibers[id]);
@@ -115,8 +134,7 @@ public:
     }
 
     void DoWork3() {
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         assert2 = id == 0;
         value1 += 1000;
         Fiber::YieldTo(fiber3, thread_fibers[id]);
@@ -125,14 +143,12 @@ public:
     void ExecuteThread(u32 id);
 
     void CallFiber1() {
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         Fiber::YieldTo(thread_fibers[id], fiber1);
     }
 
     void CallFiber2() {
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         Fiber::YieldTo(thread_fibers[id], fiber2);
     }
 
@@ -145,7 +161,7 @@ public:
     u32 value2{};
     std::atomic<bool> trap{true};
     std::atomic<bool> trap2{true};
-    std::unordered_map<std::thread::id, u32> ids;
+    ThreadIds thread_ids;
     std::vector<std::shared_ptr<Common::Fiber>> thread_fibers;
     std::shared_ptr<Common::Fiber> fiber1;
     std::shared_ptr<Common::Fiber> fiber2;
@@ -168,15 +184,13 @@ static void WorkControl2_3(void* control) {
 }
 
 void TestControl2::ExecuteThread(u32 id) {
-    std::thread::id this_id = std::this_thread::get_id();
-    ids[this_id] = id;
+    thread_ids.Register(id);
     auto thread_fiber = Fiber::ThreadToFiber();
     thread_fibers[id] = thread_fiber;
 }
 
 void TestControl2::Exit() {
-    std::thread::id this_id = std::this_thread::get_id();
-    u32 id = ids[this_id];
+    const u32 id = thread_ids.Get();
     thread_fibers[id]->Exit();
 }
 
@@ -228,24 +242,21 @@ public:
     void DoWork1() {
         value1 += 1;
         Fiber::YieldTo(fiber1, fiber2);
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         value3 += 1;
         Fiber::YieldTo(fiber1, thread_fibers[id]);
     }
 
     void DoWork2() {
         value2 += 1;
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         Fiber::YieldTo(fiber2, thread_fibers[id]);
     }
 
     void ExecuteThread(u32 id);
 
     void CallFiber1() {
-        std::thread::id this_id = std::this_thread::get_id();
-        u32 id = ids[this_id];
+        const u32 id = thread_ids.Get();
         Fiber::YieldTo(thread_fibers[id], fiber1);
     }
 
@@ -254,7 +265,7 @@ public:
     u32 value1{};
     u32 value2{};
     u32 value3{};
-    std::unordered_map<std::thread::id, u32> ids;
+    ThreadIds thread_ids;
     std::vector<std::shared_ptr<Common::Fiber>> thread_fibers;
     std::shared_ptr<Common::Fiber> fiber1;
     std::shared_ptr<Common::Fiber> fiber2;
@@ -271,15 +282,13 @@ static void WorkControl3_2(void* control) {
 }
 
 void TestControl3::ExecuteThread(u32 id) {
-    std::thread::id this_id = std::this_thread::get_id();
-    ids[this_id] = id;
+    thread_ids.Register(id);
     auto thread_fiber = Fiber::ThreadToFiber();
     thread_fibers[id] = thread_fiber;
 }
 
 void TestControl3::Exit() {
-    std::thread::id this_id = std::this_thread::get_id();
-    u32 id = ids[this_id];
+    const u32 id = thread_ids.Get();
     thread_fibers[id]->Exit();
 }
 
diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt
index fdfc885fc..abcee2a1c 100644
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -302,7 +302,10 @@ else()
     target_compile_options(video_core PRIVATE
         -Werror=conversion
         -Wno-error=sign-conversion
+        -Werror=pessimizing-move
+        -Werror=redundant-move
         -Werror=switch
+        -Werror=type-limits
         -Werror=unused-variable
 
         $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
diff --git a/src/video_core/cdma_pusher.cpp b/src/video_core/cdma_pusher.cpp
index d774db107..b60f86260 100644
--- a/src/video_core/cdma_pusher.cpp
+++ b/src/video_core/cdma_pusher.cpp
@@ -144,7 +144,7 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
         }
         case ThiMethod::SetMethod1:
             LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
-                      static_cast<u32>(vic_thi_state.method_0));
+                      static_cast<u32>(vic_thi_state.method_0), data);
             vic_processor->ProcessMethod(static_cast<Tegra::Vic::Method>(vic_thi_state.method_0),
                                          {data});
             break;
diff --git a/src/video_core/command_classes/codecs/vp9.cpp b/src/video_core/command_classes/codecs/vp9.cpp
index bcbea9c05..b3e98aa9f 100644
--- a/src/video_core/command_classes/codecs/vp9.cpp
+++ b/src/video_core/command_classes/codecs/vp9.cpp
@@ -917,7 +917,7 @@ void VpxRangeEncoder::Write(bool bit, s32 probability) {
         if (((low_value << (offset - 1)) >> 31) != 0) {
             const s32 current_pos = static_cast<s32>(base_stream.GetPosition());
             base_stream.Seek(-1, Common::SeekOrigin::FromCurrentPos);
-            while (base_stream.GetPosition() >= 0 && PeekByte() == 0xff) {
+            while (PeekByte() == 0xff) {
                 base_stream.WriteByte(0);
 
                 base_stream.Seek(-2, Common::SeekOrigin::FromCurrentPos);
diff --git a/src/video_core/command_classes/sync_manager.cpp b/src/video_core/command_classes/sync_manager.cpp
index a0ab44855..19dc9e0ab 100644
--- a/src/video_core/command_classes/sync_manager.cpp
+++ b/src/video_core/command_classes/sync_manager.cpp
@@ -27,22 +27,22 @@ SyncptIncrManager::SyncptIncrManager(GPU& gpu_) : gpu(gpu_) {}
 SyncptIncrManager::~SyncptIncrManager() = default;
 
 void SyncptIncrManager::Increment(u32 id) {
-    increments.push_back(SyncptIncr{0, id, true});
+    increments.emplace_back(0, 0, id, true);
     IncrementAllDone();
 }
 
 u32 SyncptIncrManager::IncrementWhenDone(u32 class_id, u32 id) {
     const u32 handle = current_id++;
-    increments.push_back(SyncptIncr{handle, class_id, id});
+    increments.emplace_back(handle, class_id, id);
     return handle;
 }
 
 void SyncptIncrManager::SignalDone(u32 handle) {
-    auto done_incr = std::find_if(increments.begin(), increments.end(),
-                                  [handle](SyncptIncr incr) { return incr.id == handle; });
-    if (done_incr != increments.end()) {
-        const SyncptIncr incr = *done_incr;
-        *done_incr = SyncptIncr{incr.id, incr.class_id, incr.syncpt_id, true};
+    const auto done_incr =
+        std::find_if(increments.begin(), increments.end(),
+                     [handle](const SyncptIncr& incr) { return incr.id == handle; });
+    if (done_incr != increments.cend()) {
+        done_incr->complete = true;
     }
     IncrementAllDone();
 }
diff --git a/src/video_core/command_classes/sync_manager.h b/src/video_core/command_classes/sync_manager.h
index 353b67573..2c321ec58 100644
--- a/src/video_core/command_classes/sync_manager.h
+++ b/src/video_core/command_classes/sync_manager.h
@@ -32,8 +32,8 @@ struct SyncptIncr {
     u32 syncpt_id;
     bool complete;
 
-    SyncptIncr(u32 id, u32 syncpt_id_, u32 class_id_, bool done = false)
-        : id(id), class_id(class_id_), syncpt_id(syncpt_id_), complete(done) {}
+    SyncptIncr(u32 id_, u32 class_id_, u32 syncpt_id_, bool done = false)
+        : id(id_), class_id(class_id_), syncpt_id(syncpt_id_), complete(done) {}
 };
 
 class SyncptIncrManager {
diff --git a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
index 166ee34e1..70dd0c3c6 100644
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
@@ -317,8 +317,7 @@ std::optional<std::vector<ShaderDiskCachePrecompiled>> ShaderDiskCacheOpenGL::Lo
             return std::nullopt;
         }
     }
-
-    return std::move(entries);
+    return entries;
 }
 
 void ShaderDiskCacheOpenGL::InvalidateTransferable() {
diff --git a/src/video_core/renderer_vulkan/wrapper.cpp b/src/video_core/renderer_vulkan/wrapper.cpp
index c034558a3..4e83303d8 100644
--- a/src/video_core/renderer_vulkan/wrapper.cpp
+++ b/src/video_core/renderer_vulkan/wrapper.cpp
@@ -844,7 +844,7 @@ std::optional<std::vector<VkExtensionProperties>> EnumerateInstanceExtensionProp
         VK_SUCCESS) {
         return std::nullopt;
     }
-    return std::move(properties);
+    return properties;
 }
 
 std::optional<std::vector<VkLayerProperties>> EnumerateInstanceLayerProperties(
diff --git a/src/web_service/CMakeLists.txt b/src/web_service/CMakeLists.txt
index 7e484b906..ae85a72ea 100644
--- a/src/web_service/CMakeLists.txt
+++ b/src/web_service/CMakeLists.txt
@@ -9,4 +9,4 @@ add_library(web_service STATIC
 )
 
 create_target_directory_groups(web_service)
-target_link_libraries(web_service PRIVATE common nlohmann_json::nlohmann_json httplib lurlparser)
+target_link_libraries(web_service PRIVATE common nlohmann_json::nlohmann_json httplib)
diff --git a/src/web_service/web_backend.cpp b/src/web_service/web_backend.cpp
index 534960d09..67183e64c 100644
--- a/src/web_service/web_backend.cpp
+++ b/src/web_service/web_backend.cpp
@@ -7,7 +7,6 @@
 #include <mutex>
 #include <string>
 
-#include <LUrlParser.h>
 #include <fmt/format.h>
 #include <httplib.h>
 
@@ -19,9 +18,6 @@ namespace WebService {
 
 constexpr std::array<const char, 1> API_VERSION{'1'};
 
-constexpr int HTTP_PORT = 80;
-constexpr int HTTPS_PORT = 443;
-
 constexpr std::size_t TIMEOUT_SECONDS = 30;
 
 struct Client::Impl {
@@ -67,22 +63,14 @@ struct Client::Impl {
                              const std::string& jwt = "", const std::string& username = "",
                              const std::string& token = "") {
         if (cli == nullptr) {
-            const auto parsedUrl = LUrlParser::clParseURL::ParseURL(host);
-            int port{};
-            if (parsedUrl.m_Scheme == "http") {
-                if (!parsedUrl.GetPort(&port)) {
-                    port = HTTP_PORT;
-                }
-            } else if (parsedUrl.m_Scheme == "https") {
-                if (!parsedUrl.GetPort(&port)) {
-                    port = HTTPS_PORT;
-                }
-            } else {
-                LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme);
-                return WebResult{WebResult::Code::InvalidURL, "Bad URL scheme", ""};
-            }
-            cli = std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port);
+            cli = std::make_unique<httplib::Client>(host.c_str());
+        }
+
+        if (!cli->is_valid()) {
+            LOG_ERROR(WebService, "Client is invalid, skipping request!");
+            return {};
         }
+
         cli->set_connection_timeout(TIMEOUT_SECONDS);
         cli->set_read_timeout(TIMEOUT_SECONDS);
         cli->set_write_timeout(TIMEOUT_SECONDS);
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index abbc83929..1ce62e4a6 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -515,7 +515,7 @@ void Config::ReadMotionTouchValues() {
 void Config::ReadCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
-    ReadSettingGlobal(Settings::values.use_multi_core, QStringLiteral("use_multi_core"), false);
+    ReadSettingGlobal(Settings::values.use_multi_core, QStringLiteral("use_multi_core"), true);
 
     qt_config->endGroup();
 }
@@ -716,12 +716,12 @@ void Config::ReadRendererValues() {
                       QStringLiteral("use_disk_shader_cache"), true);
     ReadSettingGlobal(Settings::values.gpu_accuracy, QStringLiteral("gpu_accuracy"), 0);
     ReadSettingGlobal(Settings::values.use_asynchronous_gpu_emulation,
-                      QStringLiteral("use_asynchronous_gpu_emulation"), false);
+                      QStringLiteral("use_asynchronous_gpu_emulation"), true);
     ReadSettingGlobal(Settings::values.use_nvdec_emulation, QStringLiteral("use_nvdec_emulation"),
                       true);
     ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"), true);
     ReadSettingGlobal(Settings::values.use_assembly_shaders, QStringLiteral("use_assembly_shaders"),
-                      false);
+                      true);
     ReadSettingGlobal(Settings::values.use_asynchronous_shaders,
                       QStringLiteral("use_asynchronous_shaders"), false);
     ReadSettingGlobal(Settings::values.use_fast_gpu_time, QStringLiteral("use_fast_gpu_time"),
@@ -1110,7 +1110,7 @@ void Config::SaveControlValues() {
 void Config::SaveCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
-    WriteSettingGlobal(QStringLiteral("use_multi_core"), Settings::values.use_multi_core, false);
+    WriteSettingGlobal(QStringLiteral("use_multi_core"), Settings::values.use_multi_core, true);
 
     qt_config->endGroup();
 }
@@ -1266,12 +1266,12 @@ void Config::SaveRendererValues() {
                        static_cast<int>(Settings::values.gpu_accuracy.GetValue(global)),
                        Settings::values.gpu_accuracy.UsingGlobal(), 0);
     WriteSettingGlobal(QStringLiteral("use_asynchronous_gpu_emulation"),
-                       Settings::values.use_asynchronous_gpu_emulation, false);
+                       Settings::values.use_asynchronous_gpu_emulation, true);
     WriteSettingGlobal(QStringLiteral("use_nvdec_emulation"), Settings::values.use_nvdec_emulation,
                        true);
     WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync, true);
     WriteSettingGlobal(QStringLiteral("use_assembly_shaders"),
-                       Settings::values.use_assembly_shaders, false);
+                       Settings::values.use_assembly_shaders, true);
     WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"),
                        Settings::values.use_asynchronous_shaders, false);
     WriteSettingGlobal(QStringLiteral("use_fast_gpu_time"), Settings::values.use_fast_gpu_time,
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index 23448e747..334038ef9 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -371,7 +371,7 @@ void Config::ReadValues() {
 
     // Core
     Settings::values.use_multi_core.SetValue(
-        sdl2_config->GetBoolean("Core", "use_multi_core", false));
+        sdl2_config->GetBoolean("Core", "use_multi_core", true));
 
     // Renderer
     const int renderer_backend = sdl2_config->GetInteger(
@@ -395,11 +395,11 @@ void Config::ReadValues() {
     const int gpu_accuracy_level = sdl2_config->GetInteger("Renderer", "gpu_accuracy", 0);
     Settings::values.gpu_accuracy.SetValue(static_cast<Settings::GPUAccuracy>(gpu_accuracy_level));
     Settings::values.use_asynchronous_gpu_emulation.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", false));
+        sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true));
     Settings::values.use_vsync.SetValue(
         static_cast<u16>(sdl2_config->GetInteger("Renderer", "use_vsync", 1)));
     Settings::values.use_assembly_shaders.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", false));
+        sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true));
     Settings::values.use_asynchronous_shaders.SetValue(
         sdl2_config->GetBoolean("Renderer", "use_asynchronous_shaders", false));
     Settings::values.use_asynchronous_shaders.SetValue(
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index aa9e40380..796e27df4 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -94,7 +94,7 @@ udp_pad_index=
 
 [Core]
 # Whether to use multi-core for CPU emulation
-# 0 (default): Disabled, 1: Enabled
+# 0: Disabled, 1 (default): Enabled
 use_multi_core=
 
 [Cpu]
@@ -163,7 +163,7 @@ max_anisotropy =
 use_vsync =
 
 # Whether to use OpenGL assembly shaders or not. NV_gpu_program5 is required.
-# 0 (default): Off, 1: On
+# 0: Off, 1 (default): On
 use_assembly_shaders =
 
 # Whether to allow asynchronous shader building.