Merge branch 'develop'

# Conflicts:
#	lib/libnx

.gitmodules

@@ -1,9 +1,6 @@
-[submodule "libnx"]
-	path = lib/libnx
-	url = https://github.com/ndeadly/libnx.git
 [submodule "Atmosphere-libs"]
 	path = lib/Atmosphere-libs
 	url = https://github.com/Atmosphere-NX/Atmosphere-libs.git
-[submodule "borealis"]
-	path = borealis
-	url = https://github.com/natinusala/borealis.git
+[submodule "libnx"]
+	path = lib/libnx
+	url = https://github.com/switchbrew/libnx.git

Makefile

@@ -36,8 +36,8 @@ dist: all
 
 	cp -r exefs_patches dist/atmosphere/
 
-	mkdir -p dist/atmosphere/config_templates
-	cp mc_mitm/config.ini dist/atmosphere/config_templates/missioncontrol.ini
+	mkdir -p dist/config/MissionControl
+	cp mc_mitm/config.ini dist/config/MissionControl/missioncontrol.ini.template
 
 	cd dist; zip -r $(PROJECT_NAME)-$(BUILD_VERSION).zip ./*; cd ../;
 

mc_mitm/config.ini

@@ -9,3 +9,7 @@
 ;host_name=Nintendo Switch!
 ; Override host mac address of Bluetooth adapter
 ;host_address=04:20:69:04:20:69
+
+[misc]
+; Disable the LED lightbar on Sony Dualshock 4 and Dualsense controllers [default false]
+;disable_sony_leds=false

mc_mitm/source/bluetooth_mitm/bluetooth/bluetooth_circular_buffer.hpp

@@ -40,7 +40,7 @@ namespace ams::bluetooth {
 
     struct CircularBufferPacket{
         CircularBufferPacketHeader header;
-        HidReportData data;
+        HidReportEventInfo data;
     };
 
     class CircularBuffer {

mc_mitm/source/bluetooth_mitm/bluetooth/bluetooth_core.cpp

@@ -69,65 +69,125 @@ namespace ams::bluetooth::core {
         return &g_system_event_user_fwd;
     }
 
+    void SignalFakeEvent(bluetooth::EventType type, const void *data, size_t size) {
+        g_current_event_type = type;
+        std::memcpy(&g_event_info, data, size);
+
+        g_system_event_fwd.Signal();
+    }
+
+    inline void ModifyEventInfov1(bluetooth::EventInfo *event_info, BtdrvEventType event_type) {
+        switch (event_type) {
+            case BtdrvEventTypeOld_InquiryDevice:
+                if (controller::IsAllowedDeviceClass(&event_info->inquiry_device.v1.class_of_device) && !controller::IsOfficialSwitchControllerName(event_info->inquiry_device.v1.name)) {
+                    std::strncpy(event_info->inquiry_device.v1.name, controller::pro_controller_name, sizeof(event_info->inquiry_device.v1.name) - 1);
+                }
+                break;
+            case BtdrvEventTypeOld_PairingPinCodeRequest:
+                if (!controller::IsOfficialSwitchControllerName(event_info->pairing_pin_code_request.name)) {
+                    std::strncpy(event_info->pairing_pin_code_request.name, controller::pro_controller_name, sizeof(event_info->pairing_pin_code_request.name) - 1);
+                }
+                break;
+            case BtdrvEventTypeOld_SspRequest:
+                if (!controller::IsOfficialSwitchControllerName(event_info->ssp_request.v1.name)) {
+                    std::strncpy(event_info->ssp_request.v1.name, controller::pro_controller_name, sizeof(event_info->ssp_request.v1.name) - 1);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    inline void ModifyEventInfov12(bluetooth::EventInfo *event_info, BtdrvEventType event_type) {
+        switch (event_type) {
+            case BtdrvEventType_InquiryDevice:
+                if (controller::IsAllowedDeviceClass(&event_info->inquiry_device.v12.class_of_device) && !controller::IsOfficialSwitchControllerName(event_info->inquiry_device.v12.name)) {
+                    std::strncpy(event_info->inquiry_device.v12.name, controller::pro_controller_name, sizeof(event_info->inquiry_device.v12.name) - 1);
+                }
+                break;
+            case BtdrvEventType_PairingPinCodeRequest:
+                if (!controller::IsOfficialSwitchControllerName(event_info->pairing_pin_code_request.name)) {
+                    std::strncpy(event_info->pairing_pin_code_request.name, controller::pro_controller_name, sizeof(event_info->pairing_pin_code_request.name) - 1);
+                }
+                break;
+            case BtdrvEventType_SspRequest:
+                if (!controller::IsOfficialSwitchControllerName(event_info->ssp_request.v12.name)) {
+                    std::strncpy(event_info->ssp_request.v12.name, controller::pro_controller_name, sizeof(event_info->ssp_request.v12.name) - 1);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
     Result GetEventInfo(ncm::ProgramId program_id, bluetooth::EventType *type, void *buffer, size_t size) {
         std::scoped_lock lk(g_event_info_lock);
 
         *type = g_current_event_type;
         std::memcpy(buffer, &g_event_info, size);
 
-        auto event_info = reinterpret_cast<bluetooth::EventInfo *>(buffer);
-
         if (program_id == ncm::SystemProgramId::Btm) {
-            switch (g_current_event_type) {
-                case BtdrvEventType_DeviceFound:
-                    if (controller::IsAllowedDeviceClass(&event_info->device_found.cod) && !controller::IsOfficialSwitchControllerName(event_info->device_found.name)) {
-                        std::strncpy(event_info->device_found.name, controller::pro_controller_name, sizeof(event_info->device_found.name) - 1);
-                    }
-                    break;
-                case BtdrvEventType_PinRequest:
-                    if (!controller::IsOfficialSwitchControllerName(event_info->pin_reply.name)) {
-                        std::strncpy(event_info->pin_reply.name, controller::pro_controller_name, sizeof(event_info->pin_reply.name) - 1);
-                    }
-                    break;
-                case BtdrvEventType_SspRequest:
-                    if (!controller::IsOfficialSwitchControllerName(event_info->ssp_reply.name)) {
-                        std::strncpy(event_info->ssp_reply.name, controller::pro_controller_name, sizeof(event_info->ssp_reply.name) - 1);
-                    }
-                    break;
-                default:
-                    break;
-            }
+            auto event_info = reinterpret_cast<bluetooth::EventInfo *>(buffer);
+
+            if (hos::GetVersion() < hos::Version_12_0_0)
+                ModifyEventInfov1(event_info, g_current_event_type);
+            else
+                ModifyEventInfov12(event_info, g_current_event_type);
         }
 
         g_data_read_event.Signal();
 
         return ams::ResultSuccess();
     }
 
+    inline void HandlePinCodeRequestEventV1(bluetooth::EventInfo *event_info) {
+        // Default pin used by bluetooth service
+        bluetooth::PinCode pin = {"0000"};
+        uint8_t pin_length = std::strlen(pin.code);
+
+        // Reverse host address as pin code for wii devices
+        if (std::strncmp(g_event_info.pairing_pin_code_request.name, controller::wii_controller_prefix, std::strlen(controller::wii_controller_prefix)) == 0) {
+            // Fetch host adapter address
+            bluetooth::Address host_address;
+            R_ABORT_UNLESS(btdrvLegacyGetAdapterProperty(BtdrvBluetoothPropertyType_Address, &host_address, sizeof(bluetooth::Address)));
+            // Reverse host address
+            *reinterpret_cast<uint64_t *>(&pin) = util::SwapBytes(*reinterpret_cast<uint64_t *>(&host_address)) >> 16;
+            pin_length = sizeof(bluetooth::Address);
+        }
+
+        R_ABORT_UNLESS(btdrvLegacyRespondToPinRequest(g_event_info.pairing_pin_code_request.addr, false, &pin, pin_length));
+    }
+
+    inline void HandlePinCodeRequestEventV12(bluetooth::EventInfo *event_info) {
+        // Default pin used by bluetooth service
+        BtdrvPinCode pin = {"0000", 4};
+
+        // Reverse host address as pin code for wii devices
+        if (std::strncmp(g_event_info.pairing_pin_code_request.name, controller::wii_controller_prefix, std::strlen(controller::wii_controller_prefix)) == 0) {
+            // Fetch host adapter address
+            BtdrvAdapterProperty property;
+            R_ABORT_UNLESS(btdrvGetAdapterProperty(BtdrvAdapterPropertyType_Address, &property));
+            // Reverse host address
+            bluetooth::Address host_address = *reinterpret_cast<bluetooth::Address *>(property.data);
+            *reinterpret_cast<uint64_t *>(&pin.code) = util::SwapBytes(*reinterpret_cast<uint64_t *>(&host_address)) >> 16;
+            pin.length = sizeof(bluetooth::Address);
+        }
+
+        R_ABORT_UNLESS(btdrvRespondToPinRequest(g_event_info.pairing_pin_code_request.addr, &pin));
+    }
+
     void HandleEvent(void) {
         {
             std::scoped_lock lk(g_event_info_lock);
             R_ABORT_UNLESS(btdrvGetEventInfo(&g_event_info, sizeof(bluetooth::EventInfo), &g_current_event_type));
         }
 
         if (!g_redirect_core_events) {
-            if (g_current_event_type == BtdrvEventType_PinRequest) {
-                // Default pin used by bluetooth service
-                bluetooth::PinCode pin = {"0000"};
-                uint8_t pin_length = std::strlen(pin.code);
-
-                // Reverse host address as pin code for wii devices
-                if (std::strncmp(g_event_info.pin_reply.name, controller::wii_controller_prefix, std::strlen(controller::wii_controller_prefix)) == 0) {
-                    // Fetch host adapter address
-                    bluetooth::Address host_address;
-                    R_ABORT_UNLESS(btdrvGetAdapterProperty(BtdrvBluetoothPropertyType_Address, &host_address, sizeof(bluetooth::Address)));
-                    // Reverse host address
-                    *reinterpret_cast<uint64_t *>(&pin) = util::SwapBytes(*reinterpret_cast<uint64_t *>(&host_address)) >> 16;
-                    pin_length = sizeof(bluetooth::Address);
-                }
-
-                // Fuck BTM, we're sending the pin response ourselves if it won't.
-                R_ABORT_UNLESS(btdrvRespondToPinRequest(g_event_info.pin_reply.address, false, &pin, pin_length));
+            if ((hos::GetVersion() < hos::Version_12_0_0) && (g_current_event_type == BtdrvEventTypeOld_PairingPinCodeRequest)) {
+                HandlePinCodeRequestEventV1(&g_event_info);
+            }
+            else if ((hos::GetVersion() >= hos::Version_12_0_0) && (g_current_event_type == BtdrvEventType_PairingPinCodeRequest)) {
+                HandlePinCodeRequestEventV12(&g_event_info);
             }
             else {
                 g_system_event_fwd.Signal();

mc_mitm/source/bluetooth_mitm/bluetooth/bluetooth_core.hpp

@@ -30,6 +30,7 @@ namespace ams::bluetooth::core {
     os::SystemEvent *GetForwardEvent(void);
     os::SystemEvent *GetUserForwardEvent(void);
 
+    void SignalFakeEvent(bluetooth::EventType type, const void *data, size_t size);
     Result GetEventInfo(ncm::ProgramId program_id, bluetooth::EventType *type, void *buffer, size_t size);
     void HandleEvent(void);
 

mc_mitm/source/bluetooth_mitm/bluetooth/bluetooth_hid.cpp

@@ -60,6 +60,13 @@ namespace ams::bluetooth::hid {
         return &g_system_event_user_fwd;
     }
 
+    void SignalFakeEvent(bluetooth::HidEventType type, const void *data, size_t size) {
+        g_current_event_type = type;
+        std::memcpy(&g_event_info, data, size);
+
+        g_system_event_fwd.Signal();
+    }
+
     Result GetEventInfo(bluetooth::HidEventType *type, void *buffer, size_t size) {
         std::scoped_lock lk(g_event_info_lock);
 
@@ -71,42 +78,41 @@ namespace ams::bluetooth::hid {
         return ams::ResultSuccess();
     }
 
-    void SignalFakeEvent(bluetooth::HidEventType type, const void *data, size_t size) {
-        g_current_event_type = type;
-        std::memcpy(&g_event_info, data, size);
-
-        g_system_event_fwd.Signal();
+    inline void HandleConnectionStateEventV1(bluetooth::HidEventInfo *event_info) {
+        switch (event_info->connection.v1.status) {
+            case BtdrvHidConnectionStatusOld_Opened:
+                controller::AttachHandler(&event_info->connection.v1.addr);
+                break;
+            case BtdrvHidConnectionStatusOld_Closed:
+                controller::RemoveHandler(&event_info->connection.v1.addr);
+                break;
+            default:
+                break;
+        }
     }
 
-    void HandleConnectionStateEvent(bluetooth::HidEventInfo *event_info) {
-        switch (event_info->connection_state.state) {
-            case BtdrvHidConnectionState_Connected:
-                controller::AttachHandler(&event_info->connection_state.address);
+    inline void HandleConnectionStateEventV12(bluetooth::HidEventInfo *event_info) {
+        switch (event_info->connection.v12.status) {
+            case BtdrvHidConnectionStatus_Opened:
+                controller::AttachHandler(&event_info->connection.v12.addr);
                 break;
-            case BtdrvHidConnectionState_Disconnected:
-                controller::RemoveHandler(&event_info->connection_state.address);
+            case BtdrvHidConnectionStatus_Closed:
+                controller::RemoveHandler(&event_info->connection.v12.addr);
                 break;
             default:
                 break;
         }
     }
 
-    // void HandleUnknown07Event(bluetooth::HidEventInfo *event_info) {
-    //     ;
-    // }
-
     void HandleEvent(void) {
         {
             std::scoped_lock lk(g_event_info_lock);
             R_ABORT_UNLESS(btdrvGetHidEventInfo(&g_event_info, sizeof(bluetooth::HidEventInfo), &g_current_event_type));
         }
 
         switch (g_current_event_type) {
-            case BtdrvHidEventType_ConnectionState:
-                HandleConnectionStateEvent(&g_event_info);
-                break;
-            case BtdrvHidEventType_Unknown7:
-                //HandleUnknown07Event(&g_event_info);
+            case BtdrvHidEventType_Connection:
+                hos::GetVersion() < hos::Version_12_0_0 ? HandleConnectionStateEventV1(&g_event_info) : HandleConnectionStateEventV12(&g_event_info);
                 break;
             default:
                 break;

mc_mitm/source/bluetooth_mitm/bluetooth/bluetooth_hid.hpp

@@ -28,9 +28,8 @@ namespace ams::bluetooth::hid {
     os::SystemEvent *GetForwardEvent(void);
     os::SystemEvent *GetUserForwardEvent(void);
 
+    void SignalFakeEvent(bluetooth::HidEventType type, const void *data, size_t size);
     Result GetEventInfo(bluetooth::HidEventType *type, void *buffer, size_t size);
     void HandleEvent(void);
 
-    void SignalFakeEvent(bluetooth::HidEventType type, const void *data, size_t size);
-
 }