sf: implement mitm forwarding + domains.

stratosphere/libstratosphere/source/sf/cmif/sf_cmif_domain_manager.cpp

@@ -41,9 +41,8 @@ namespace sts::sf::cmif {
         return ResultSuccess;
     }
 
-    Result ServerDomainManager::Domain::AlterReservedIds(const DomainObjectId *old_reserved_ids, const DomainObjectId *new_reserved_ids, size_t count) {
-        this->manager->entry_manager.ReallocateEntries(old_reserved_ids, new_reserved_ids, count);
-        return ResultSuccess;
+    void ServerDomainManager::Domain::ReserveSpecificIds(const DomainObjectId *ids, size_t count) {
+        this->manager->entry_manager.AllocateSpecificEntries(ids, count);
     }
 
     void ServerDomainManager::Domain::UnreserveIds(const DomainObjectId *ids, size_t count) {
@@ -132,27 +131,16 @@ namespace sts::sf::cmif {
         this->free_list.push_front(*entry);
     }
 
-    void ServerDomainManager::EntryManager::ReallocateEntries(const DomainObjectId *old_reserved_ids, const DomainObjectId *new_reserved_ids, size_t count) {
+    void ServerDomainManager::EntryManager::AllocateSpecificEntries(const DomainObjectId *ids, size_t count) {
         std::scoped_lock lk(this->lock);
 
-        /* Free old ids. */
+        /* Allocate new IDs. */
         for (size_t i = 0; i < count; i++) {
-            const auto id = old_reserved_ids[i];
+            const auto id = ids[i];
             Entry *entry = this->GetEntry(id);
             if (id != InvalidDomainObjectId) {
                 STS_ASSERT(entry != nullptr);
                 STS_ASSERT(entry->owner == nullptr);
-                STS_ASSERT(!entry->object);
-                this->free_list.push_front(*entry);
-            }
-        }
-
-        /* Allocate new IDs. */
-        for (size_t i = 0; i < count; i++) {
-            const auto id = old_reserved_ids[i];
-            Entry *entry = this->GetEntry(id);
-            if (id != InvalidDomainObjectId) {
-                STS_ASSERT(entry != nullptr);
                 this->free_list.erase(this->free_list.iterator_to(*entry));
             }
         }

stratosphere/libstratosphere/source/sf/cmif/sf_cmif_domain_service_object.cpp

@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <functional>
+#include <stratosphere.hpp>
+
+namespace sts::sf::cmif {
+
+    Result DomainServiceObjectDispatchTable::ProcessMessage(ServiceDispatchContext &ctx, const cmif::PointerAndSize &in_raw_data) const  {
+        return this->ProcessMessageImpl(ctx, static_cast<DomainServiceObject *>(ctx.srv_obj)->GetServerDomain(), in_raw_data);
+    }
+
+    Result DomainServiceObjectDispatchTable::ProcessMessageForMitm(ServiceDispatchContext &ctx, const cmif::PointerAndSize &in_raw_data) const {
+        return this->ProcessMessageForMitmImpl(ctx, static_cast<DomainServiceObject *>(ctx.srv_obj)->GetServerDomain(), in_raw_data);
+    }
+
+    Result DomainServiceObjectDispatchTable::ProcessMessageImpl(ServiceDispatchContext &ctx, ServerDomainBase *domain, const cmif::PointerAndSize &in_raw_data) const {
+        const CmifDomainInHeader *in_header = reinterpret_cast<const CmifDomainInHeader *>(in_raw_data.GetPointer());
+        R_UNLESS(in_raw_data.GetSize() >= sizeof(*in_header), ResultServiceFrameworkInvalidCmifHeaderSize);
+        const cmif::PointerAndSize in_domain_raw_data = cmif::PointerAndSize(in_raw_data.GetAddress() + sizeof(*in_header), in_raw_data.GetSize() - sizeof(*in_header));
+
+        const DomainObjectId target_object_id = DomainObjectId{in_header->object_id};
+        switch (in_header->type) {
+            case CmifDomainRequestType_SendMessage:
+            {
+                auto target_object = domain->GetObject(target_object_id);
+                R_UNLESS(static_cast<bool>(target_object), ResultServiceFrameworkTargetNotFound);
+                R_UNLESS(in_header->data_size + in_header->num_in_objects * sizeof(DomainObjectId) <= in_domain_raw_data.GetSize(), ResultServiceFrameworkInvalidCmifHeaderSize);
+                const cmif::PointerAndSize in_message_raw_data = cmif::PointerAndSize(in_domain_raw_data.GetAddress(), in_header->data_size);
+                DomainObjectId in_object_ids[8];
+                R_UNLESS(in_header->num_in_objects <= util::size(in_object_ids), ResultServiceFrameworkInvalidCmifNumInObjects);
+                std::memcpy(in_object_ids, reinterpret_cast<DomainObjectId *>(in_message_raw_data.GetAddress() + in_message_raw_data.GetSize()), sizeof(DomainObjectId) * in_header->num_in_objects);
+                DomainServiceObjectProcessor domain_processor(domain, in_object_ids, in_header->num_in_objects);
+                if (ctx.processor == nullptr) {
+                    ctx.processor = &domain_processor;
+                } else {
+                    ctx.processor->SetImplementationProcessor(&domain_processor);
+                }
+                return target_object.ProcessMessage(ctx, in_message_raw_data);
+            }
+            case CmifDomainRequestType_Close:
+                /* TODO: N doesn't error check here. Should we? */
+                domain->UnregisterObject(target_object_id);
+                return ResultSuccess;
+            default:
+                return ResultServiceFrameworkInvalidCmifInHeader;
+        }
+    }
+
+    Result DomainServiceObjectDispatchTable::ProcessMessageForMitmImpl(ServiceDispatchContext &ctx, ServerDomainBase *domain, const cmif::PointerAndSize &in_raw_data) const {
+        const CmifDomainInHeader *in_header = reinterpret_cast<const CmifDomainInHeader *>(in_raw_data.GetPointer());
+        R_UNLESS(in_raw_data.GetSize() >= sizeof(*in_header), ResultServiceFrameworkInvalidCmifHeaderSize);
+        const cmif::PointerAndSize in_domain_raw_data = cmif::PointerAndSize(in_raw_data.GetAddress() + sizeof(*in_header), in_raw_data.GetSize() - sizeof(*in_header));
+
+        const DomainObjectId target_object_id = DomainObjectId{in_header->object_id};
+        switch (in_header->type) {
+            case CmifDomainRequestType_SendMessage:
+            {
+                auto target_object = domain->GetObject(target_object_id);
+
+                /* Mitm. If we don't have a target object, we should forward to let the server handle. */
+                if (!target_object) {
+                    return ctx.session->ForwardRequest(ctx);
+                }
+
+                R_UNLESS(in_header->data_size + in_header->num_in_objects * sizeof(DomainObjectId) <= in_domain_raw_data.GetSize(), ResultServiceFrameworkInvalidCmifHeaderSize);
+                const cmif::PointerAndSize in_message_raw_data = cmif::PointerAndSize(in_domain_raw_data.GetAddress(), in_header->data_size);
+                DomainObjectId in_object_ids[8];
+                R_UNLESS(in_header->num_in_objects <= util::size(in_object_ids), ResultServiceFrameworkInvalidCmifNumInObjects);
+                std::memcpy(in_object_ids, reinterpret_cast<DomainObjectId *>(in_message_raw_data.GetAddress() + in_message_raw_data.GetSize()), sizeof(DomainObjectId) * in_header->num_in_objects);
+                DomainServiceObjectProcessor domain_processor(domain, in_object_ids, in_header->num_in_objects);
+                if (ctx.processor == nullptr) {
+                    ctx.processor = &domain_processor;
+                } else {
+                    ctx.processor->SetImplementationProcessor(&domain_processor);
+                }
+                return target_object.ProcessMessage(ctx, in_message_raw_data);
+            }
+            case CmifDomainRequestType_Close:
+            {
+                auto target_object = domain->GetObject(target_object_id);
+
+                /* If the object is not in the domain, tell the server to close it. */
+                if (!target_object) {
+                    return ctx.session->ForwardRequest(ctx);
+                }
+
+                /* If the object is in the domain, close our copy of it. Mitm objects are required to close their associated domain id, so this shouldn't cause desynch. */
+                domain->UnregisterObject(target_object_id);
+                return ResultSuccess;
+            }
+            default:
+                return ResultServiceFrameworkInvalidCmifInHeader;
+        }
+    }
+
+    Result DomainServiceObjectProcessor::PrepareForProcess(const ServiceDispatchContext &ctx, const ServerMessageRuntimeMetadata runtime_metadata) const {
+        /* Validate in object count. */
+        R_UNLESS(this->impl_metadata.GetInObjectCount() == this->GetInObjectCount(), ResultServiceFrameworkInvalidCmifNumInObjects);
+
+        /* Nintendo reserves domain object IDs here. We do this later, to support mitm semantics. */
+
+        /* Pass onwards. */
+        return this->impl_processor->PrepareForProcess(ctx, runtime_metadata);
+    }
+
+    Result DomainServiceObjectProcessor::GetInObjects(ServiceObjectHolder *in_objects) const {
+        for (size_t i = 0; i < this->GetInObjectCount(); i++) {
+            in_objects[i] = this->domain->GetObject(this->in_object_ids[i]);
+        }
+        return ResultSuccess;
+    }
+
+    HipcRequest DomainServiceObjectProcessor::PrepareForReply(const cmif::ServiceDispatchContext &ctx, PointerAndSize &out_raw_data, const ServerMessageRuntimeMetadata runtime_metadata) {
+        /* Call into impl processor, get request. */
+        PointerAndSize raw_data;
+        HipcRequest request = this->impl_processor->PrepareForReply(ctx, raw_data, runtime_metadata);
+
+        /* Write out header. */
+        constexpr size_t out_header_size = sizeof(CmifDomainOutHeader);
+        const size_t impl_out_data_total_size = this->GetImplOutDataTotalSize();
+        STS_ASSERT(out_header_size + impl_out_data_total_size + sizeof(DomainObjectId) * this->GetOutObjectCount() <= raw_data.GetSize());
+        *reinterpret_cast<CmifDomainOutHeader *>(raw_data.GetPointer()) = CmifDomainOutHeader{ .num_out_objects = static_cast<u32>(this->GetOutObjectCount()), };
+
+        /* Set output raw data. */
+        out_raw_data = cmif::PointerAndSize(raw_data.GetAddress() + out_header_size, raw_data.GetSize() - out_header_size);
+        this->out_object_ids = reinterpret_cast<DomainObjectId *>(out_raw_data.GetAddress() + out_raw_data.GetSize());
+
+        return request;
+    }
+
+    void DomainServiceObjectProcessor::PrepareForErrorReply(const cmif::ServiceDispatchContext &ctx, PointerAndSize &out_raw_data, const ServerMessageRuntimeMetadata runtime_metadata) {
+        /* Call into impl processor, get request. */
+        PointerAndSize raw_data;
+        this->impl_processor->PrepareForErrorReply(ctx, raw_data, runtime_metadata);
+
+        /* Write out header. */
+        constexpr size_t out_header_size = sizeof(CmifDomainOutHeader);
+        const size_t impl_out_data_total_size = this->GetImplOutDataTotalSize();
+        STS_ASSERT(out_header_size + impl_out_data_total_size <= raw_data.GetSize());
+        *reinterpret_cast<CmifDomainOutHeader *>(raw_data.GetPointer()) = CmifDomainOutHeader{ .num_out_objects = 0, };
+
+        /* Set output raw data. */
+        out_raw_data = cmif::PointerAndSize(raw_data.GetAddress() + out_header_size, raw_data.GetSize() - out_header_size);
+
+        /* Nintendo unreserves domain entries here, but we haven't reserved them yet. */
+    }
+
+    void DomainServiceObjectProcessor::SetOutObjects(const cmif::ServiceDispatchContext &ctx, const HipcRequest &response, ServiceObjectHolder *out_objects, DomainObjectId *selected_ids) {
+        const size_t num_out_objects = this->GetOutObjectCount();
+
+        /* Copy input object IDs from command impl (normally these are Invalid, in mitm they should be set). */
+        DomainObjectId object_ids[8];
+        bool is_reserved[8];
+        for (size_t i = 0; i < num_out_objects; i++) {
+            object_ids[i] = selected_ids[i];
+            is_reserved[i] = false;
+        }
+
+        /* Reserve object IDs as necessary. */
+        {
+            DomainObjectId reservations[8];
+            {
+                size_t num_unreserved_ids = 0;
+                DomainObjectId specific_ids[8];
+                size_t num_specific_ids = 0;
+                for (size_t i = 0; i < num_out_objects; i++) {
+                    /* In the mitm case, we must not reserve IDs in use by other objects, so mitm objects will set this. */
+                    if (object_ids[i] == InvalidDomainObjectId) {
+                        num_unreserved_ids++;
+                    } else {
+                        specific_ids[num_specific_ids++] = object_ids[i];
+                    }
+                }
+                /* TODO: Can we make this error non-fatal? It isn't for N, since they can reserve IDs earlier due to not having to worry about mitm. */
+                R_ASSERT(this->domain->ReserveIds(reservations, num_unreserved_ids));
+                this->domain->ReserveSpecificIds(specific_ids, num_specific_ids);
+            }
+
+            size_t reservation_index = 0;
+            for (size_t i = 0; i < num_out_objects; i++) {
+                if (object_ids[i] == InvalidDomainObjectId) {
+                    object_ids[i] = reservations[reservation_index++];
+                    is_reserved[i] = true;
+                }
+            }
+        }
+
+        /* Actually set out objects. */
+        for (size_t i = 0; i < num_out_objects; i++) {
+            if (!out_objects[i]) {
+                if (is_reserved[i]) {
+                    this->domain->UnreserveIds(object_ids + i, 1);
+                }
+                object_ids[i] = InvalidDomainObjectId;
+                continue;
+            }
+            this->domain->RegisterObject(object_ids[i], std::move(out_objects[i]));
+        }
+
+        /* Set out object IDs in message. */
+        for (size_t i = 0; i < num_out_objects; i++) {
+            this->out_object_ids[i] = object_ids[i];
+        }
+    }
+
+}

stratosphere/libstratosphere/source/sf/cmif/sf_cmif_service_dispatch.cpp

@@ -26,6 +26,7 @@ namespace sts::sf::cmif {
         const CmifInHeader *in_header = reinterpret_cast<const CmifInHeader *>(in_raw_data.GetPointer());
         R_UNLESS(in_raw_data.GetSize() >= sizeof(*in_header), ResultServiceFrameworkInvalidCmifHeaderSize);
         R_UNLESS(in_header->magic == CMIF_IN_HEADER_MAGIC && in_header->version <= max_cmif_version, ResultServiceFrameworkInvalidCmifInHeader);
+        const cmif::PointerAndSize in_message_raw_data = cmif::PointerAndSize(in_raw_data.GetAddress() + sizeof(*in_header), in_raw_data.GetSize() - sizeof(*in_header));
         const u32 cmd_id = in_header->command_id;
 
         /* Find a handler. */
@@ -40,7 +41,7 @@ namespace sts::sf::cmif {
 
         /* Invoke handler. */
         CmifOutHeader *out_header = nullptr;
-        Result command_result = cmd_handler(&out_header, ctx, cmif::PointerAndSize(in_raw_data.GetAddress() + sizeof(*in_header), in_raw_data.GetSize() - sizeof(*in_header)));
+        Result command_result = cmd_handler(&out_header, ctx, in_message_raw_data);
 
         /* Forward forwardable results, otherwise ensure we can send result to user. */
         R_TRY_CATCH(command_result) {
@@ -65,6 +66,7 @@ namespace sts::sf::cmif {
         const CmifInHeader *in_header = reinterpret_cast<const CmifInHeader *>(in_raw_data.GetPointer());
         R_UNLESS(in_raw_data.GetSize() >= sizeof(*in_header), ResultServiceFrameworkInvalidCmifHeaderSize);
         R_UNLESS(in_header->magic == CMIF_IN_HEADER_MAGIC && in_header->version <= max_cmif_version, ResultServiceFrameworkInvalidCmifInHeader);
+        const cmif::PointerAndSize in_message_raw_data = cmif::PointerAndSize(in_raw_data.GetAddress() + sizeof(*in_header), in_raw_data.GetSize() - sizeof(*in_header));
         const u32 cmd_id = in_header->command_id;
 
         /* Find a handler. */
@@ -78,21 +80,18 @@ namespace sts::sf::cmif {
 
         /* If we didn't find a handler, forward the request. */
         if (cmd_handler == nullptr) {
-            /* TODO: FORWARD REQUEST */
-            STS_ASSERT(false);
+            return ctx.session->ForwardRequest(ctx);
         }
 
         /* Invoke handler. */
         CmifOutHeader *out_header = nullptr;
-        Result command_result = cmd_handler(&out_header, ctx, cmif::PointerAndSize(in_raw_data.GetAddress() + sizeof(*in_header), in_raw_data.GetSize() - sizeof(*in_header)));
+        Result command_result = cmd_handler(&out_header, ctx, in_message_raw_data);
 
         /* Forward forwardable results, otherwise ensure we can send result to user. */
         R_TRY_CATCH(command_result) {
             R_CATCH(ResultServiceFrameworkRequestDeferredByUser) { return ResultServiceFrameworkRequestDeferredByUser; }
             R_CATCH(ResultAtmosphereMitmShouldForwardToSession) {
-                /* TODO: Restore TLS. */
-                /* TODO: FORWARD REQUEST */
-                STS_ASSERT(false);
+                return ctx.session->ForwardRequest(ctx);
             }
             R_CATCH_ALL() { STS_ASSERT(out_header != nullptr); }
         } R_END_TRY_CATCH;

stratosphere/libstratosphere/source/sf/hipc/sf_hipc_server_domain_session_manager.cpp

@@ -63,8 +63,50 @@ namespace sts::sf::hipc {
                 }
 
                 Result ConvertCurrentObjectToDomain(sf::Out<cmif::DomainObjectId> out) {
-                    /* TODO */
-                    return ResultHipcOutOfDomains;
+                    /* Allocate a domain. */
+                    auto domain = this->manager->AllocateDomainServiceObject();
+                    R_UNLESS(domain, ResultHipcOutOfDomains);
+
+                    cmif::DomainObjectId object_id = cmif::InvalidDomainObjectId;
+
+                    cmif::ServiceObjectHolder new_holder;
+
+                    if (this->is_mitm_session) {
+                        /* If we're a mitm session, we need to convert the remote session to domain. */
+                        STS_ASSERT(session->forward_service->own_handle);
+                        R_TRY_CLEANUP(serviceConvertToDomain(session->forward_service.get()), {
+                            this->manager->FreeDomainServiceObject(domain);
+                        });
+
+                        /* The object ID reservation cannot fail here, as that would cause desynchronization from target domain. */
+                        object_id = cmif::DomainObjectId{session->forward_service->object_id};
+                        domain->ReserveSpecificIds(&object_id, 1);
+
+                        /* Create new object. */
+                        cmif::MitmDomainServiceObject *domain_ptr = static_cast<cmif::MitmDomainServiceObject *>(domain);
+                        new_holder = cmif::ServiceObjectHolder(std::move(std::shared_ptr<cmif::MitmDomainServiceObject>(domain_ptr, [&](cmif::MitmDomainServiceObject *obj) {
+                            this->manager->FreeDomainServiceObject(domain);
+                        })));
+                    } else {
+                        /* We're not a mitm session. Reserve a new object in the domain. */
+                        R_TRY(domain->ReserveIds(&object_id, 1));
+
+                        /* Create new object. */
+                        cmif::DomainServiceObject *domain_ptr = static_cast<cmif::DomainServiceObject *>(domain);
+                        new_holder = cmif::ServiceObjectHolder(std::move(std::shared_ptr<cmif::DomainServiceObject>(domain_ptr, [&](cmif::DomainServiceObject *obj) {
+                            this->manager->FreeDomainServiceObject(domain);
+                        })));
+                    }
+
+                    STS_ASSERT(object_id != cmif::InvalidDomainObjectId);
+                    STS_ASSERT(static_cast<bool>(new_holder));
+
+                    /* We succeeded! */
+                    domain->RegisterObject(object_id, std::move(session->srv_obj_holder));
+                    session->srv_obj_holder = std::move(new_holder);
+                    out.SetValue(object_id);
+
+                    return ResultSuccess;
                 }
 
                 Result CopyFromCurrentDomain(sf::OutMoveHandle out, cmif::DomainObjectId object_id) {

stratosphere/libstratosphere/source/sf/hipc/sf_hipc_server_session_manager.cpp

@@ -17,6 +17,57 @@
 
 namespace sts::sf::hipc {
 
+    namespace {
+
+        constexpr inline void PreProcessCommandBufferForMitm(const cmif::ServiceDispatchContext &ctx, const cmif::PointerAndSize &pointer_buffer, uintptr_t cmd_buffer) {
+            /* TODO: Less gross method of editing command buffer? */
+            if (ctx.request.meta.send_pid) {
+                constexpr u64 MitmProcessIdTag = 0xFFFE000000000000ul;
+                constexpr u64 OldProcessIdMask = 0x0000FFFFFFFFFFFFul;
+                u64 *process_id = reinterpret_cast<u64 *>(cmd_buffer + sizeof(HipcHeader) + sizeof(HipcSpecialHeader));
+                *process_id = (MitmProcessIdTag) | (*process_id & OldProcessIdMask);
+            }
+
+            if (ctx.request.meta.num_recv_statics) {
+                /* TODO: Can we do this without gross bit-hackery? */
+                reinterpret_cast<HipcHeader *>(cmd_buffer)->recv_static_mode = 2;
+                const uintptr_t old_recv_list_entry = reinterpret_cast<uintptr_t>(ctx.request.data.recv_list);
+                const size_t old_recv_list_offset = old_recv_list_entry - util::AlignDown(old_recv_list_entry, TlsMessageBufferSize);
+                *reinterpret_cast<HipcRecvListEntry *>(cmd_buffer + old_recv_list_offset) = hipcMakeRecvStatic(pointer_buffer.GetPointer(), pointer_buffer.GetSize());
+            }
+        }
+
+    }
+
+    Result ServerSession::ForwardRequest(const cmif::ServiceDispatchContext &ctx) const {
+        STS_ASSERT(this->IsMitmSession());
+        /* TODO: Support non-TLS messages? */
+        STS_ASSERT(this->saved_message.GetPointer() != nullptr);
+        STS_ASSERT(this->saved_message.GetSize() == TlsMessageBufferSize);
+
+        /* Copy saved TLS in. */
+        std::memcpy(armGetTls(), this->saved_message.GetPointer(), this->saved_message.GetSize());
+
+        /* Prepare buffer. */
+        PreProcessCommandBufferForMitm(ctx, this->pointer_buffer, reinterpret_cast<uintptr_t>(armGetTls()));
+
+        /* Dispatch forwards. */
+        R_TRY(svcSendSyncRequest(this->forward_service->session));
+
+        /* Parse, to ensure we catch any copy handles and close them. */
+        {
+            const auto response = hipcParseResponse(armGetTls());
+            if (response.num_copy_handles) {
+                ctx.handles_to_close->num_handles = response.num_copy_handles;
+                for (size_t i = 0; i < response.num_copy_handles; i++) {
+                    ctx.handles_to_close->handles[i] = response.copy_handles[i];
+                }
+            }
+        }
+
+        return ResultSuccess;
+    }
+
     void ServerSessionManager::DestroySession(ServerSession *session) {
         /* Destroy object. */
         session->~ServerSession();
@@ -63,6 +114,9 @@ namespace sts::sf::hipc {
         /* Assign session resources. */
         session_memory->pointer_buffer = this->GetSessionPointerBuffer(session_memory);
         session_memory->saved_message  = this->GetSessionSavedMessageBuffer(session_memory);
+        /* Validate session pointer buffer. */
+        STS_ASSERT(session_memory->pointer_buffer.GetSize() >= session_memory->forward_service->pointer_buffer_size);
+        session_memory->pointer_buffer = cmif::PointerAndSize(session_memory->pointer_buffer.GetAddress(), session_memory->forward_service->pointer_buffer_size);
         /* Register to wait list. */
         this->RegisterSessionToWaitList(session_memory);
         return ResultSuccess;
@@ -205,6 +259,7 @@ namespace sts::sf::hipc {
         cmif::ServiceDispatchContext dispatch_ctx = {
             .srv_obj = obj_holder.GetServiceObjectUnsafe(),
             .manager = this,
+            .session = session,
             .processor = nullptr, /* Filled in by template implementations. */
             .handles_to_close = &handles_to_close,
             .pointer_buffer = session->pointer_buffer,