git subrepo clone https://github.com/Atmosphere-NX/libstratosphere stratosphere/libstratosphere

subrepo:
  subdir:   "stratosphere/libstratosphere"
  merged:   "0c5dab80"
upstream:
  origin:   "https://github.com/Atmosphere-NX/libstratosphere"
  branch:   "master"
  commit:   "0c5dab80"
git-subrepo:
  version:  "0.4.0"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "5d6aba9"

stratosphere/libstratosphere/source/sm/sm_ams.c

@@ -0,0 +1,376 @@
+/*
+ * 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 <switch.h>
+#include <switch/arm/atomics.h>
+#include "sm_ams.h"
+
+static Service g_smMitmSrv;
+static u64 g_mitmRefCnt;
+
+Result smAtmosphereHasService(bool *out, const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = smGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65100;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+            u8 has_service;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc)) {
+            *out = resp->has_service != 0;
+        }
+    }
+
+    return rc;
+}
+
+Result smAtmosphereWaitService(const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = smGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65101;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+Result smAtmosphereHasMitm(bool *out, const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = smGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65004;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+            u8 has_mitm;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc)) {
+            *out = resp->has_mitm != 0;
+        }
+    }
+
+    return rc;
+}
+
+Result smAtmosphereWaitMitm(const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = smGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65005;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+Result smAtmosphereMitmInitialize(void) {
+    atomicIncrement64(&g_mitmRefCnt);
+
+    if (serviceIsActive(&g_smMitmSrv))
+        return 0;
+
+    Handle sm_handle;
+    Result rc = svcConnectToNamedPort(&sm_handle, "sm:");
+    while (R_VALUE(rc) == KERNELRESULT(NotFound)) {
+        svcSleepThread(50000000ul);
+        rc = svcConnectToNamedPort(&sm_handle, "sm:");
+    }
+
+    if (R_SUCCEEDED(rc)) {
+        serviceCreate(&g_smMitmSrv, sm_handle);
+    }
+
+    if (R_SUCCEEDED(rc)) {
+        IpcCommand c;
+        ipcInitialize(&c);
+        ipcSendPid(&c);
+
+        struct {
+            u64 magic;
+            u64 cmd_id;
+            u64 zero;
+            u64 reserved[2];
+        } *raw;
+
+        raw = serviceIpcPrepareHeader(&g_smMitmSrv, &c, sizeof(*raw));
+
+        raw->magic = SFCI_MAGIC;
+        raw->cmd_id = 0;
+        raw->zero = 0;
+
+        rc = serviceIpcDispatch(&g_smMitmSrv);
+
+        if (R_SUCCEEDED(rc)) {
+            IpcParsedCommand r;
+
+            struct {
+                u64 magic;
+                u64 result;
+            } *resp;
+            serviceIpcParse(&g_smMitmSrv, &r, sizeof(*resp));
+
+            resp = r.Raw;
+            rc = resp->result;
+        }
+    }
+
+    if (R_FAILED(rc))
+        smAtmosphereMitmExit();
+
+    return rc;
+}
+
+void smAtmosphereMitmExit(void) {
+    if (atomicDecrement64(&g_mitmRefCnt) == 0) {
+        serviceClose(&g_smMitmSrv);
+    }
+}
+
+Result smAtmosphereMitmInstall(Handle *handle_out, Handle *query_out, const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = &g_smMitmSrv;
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65000;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc)) {
+            *handle_out = r.Handles[0];
+            *query_out = r.Handles[1];
+        }
+    }
+
+    return rc;
+}
+
+Result smAtmosphereMitmUninstall(const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = &g_smMitmSrv;
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65001;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+Result smAtmosphereMitmDeclareFuture(const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = &g_smMitmSrv;
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65006;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+Result smAtmosphereMitmAcknowledgeSession(Service *srv_out, u64 *pid_out, u64 *tid_out, const char *name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = &g_smMitmSrv;
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65003;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+            u64 pid;
+            u64 tid;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+        if (R_SUCCEEDED(rc)) {
+            *pid_out = resp->pid;
+            *tid_out = resp->tid;
+            serviceCreate(srv_out, r.Handles[0]);
+        }
+    }
+
+    return rc;
+}

stratosphere/libstratosphere/source/sm/sm_ams.h

@@ -0,0 +1,29 @@
+/**
+ * @file sm_ams.h
+ * @brief Service manager (sm) IPC wrapper for Atmosphere extensions.
+ * @author SciresM
+ * @copyright libnx Authors
+ */
+#pragma once
+#include <switch.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Result smAtmosphereHasService(bool *out, const char *name);
+Result smAtmosphereWaitService(const char *name);
+Result smAtmosphereHasMitm(bool *out, const char *name);
+Result smAtmosphereWaitMitm(const char *name);
+
+Result smAtmosphereMitmInitialize(void);
+void smAtmosphereMitmExit(void);
+
+Result smAtmosphereMitmInstall(Handle *handle_out, Handle *query_out, const char *name);
+Result smAtmosphereMitmUninstall(const char *name);
+Result smAtmosphereMitmDeclareFuture(const char *name);
+Result smAtmosphereMitmAcknowledgeSession(Service *srv_out, u64 *pid_out, u64 *tid_out, const char *name);
+
+#ifdef __cplusplus
+}
+#endif

stratosphere/libstratosphere/source/sm/sm_api.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <switch.h>
+#include <stratosphere.hpp>
+#include <stratosphere/sm.hpp>
+
+#include "sm_ams.h"
+#include "sm_utils.hpp"
+
+namespace sts::sm {
+
+    /* Ordinary SM API. */
+    Result GetService(Service *out, ServiceName name) {
+        return impl::DoWithUserSession([&]() {
+            return smGetService(out, name.name);
+        });
+    }
+
+    Result RegisterService(Handle *out, ServiceName name, size_t max_sessions, bool is_light) {
+        return impl::DoWithUserSession([&]() {
+            return smRegisterService(out, name.name, is_light, static_cast<int>(max_sessions));
+        });
+    }
+
+    Result UnregisterService(ServiceName name) {
+        return impl::DoWithUserSession([&]() {
+            return smUnregisterService(name.name);
+        });
+    }
+
+    /* Atmosphere extensions. */
+    Result HasService(bool *out, ServiceName name) {
+        return impl::DoWithUserSession([&]() {
+            return smAtmosphereHasService(out, name.name);
+        });
+    }
+
+    Result WaitService(ServiceName name) {
+        return impl::DoWithUserSession([&]() {
+            return smAtmosphereWaitService(name.name);
+        });
+    }
+
+}

stratosphere/libstratosphere/source/sm/sm_manager_api.cpp

@@ -0,0 +1,44 @@
+/*
+ * 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 <switch.h>
+#include <stratosphere.hpp>
+#include <stratosphere/sm.hpp>
+#include <stratosphere/sm/sm_manager_api.hpp>
+
+#include "smm_ams.h"
+
+namespace sts::sm::manager {
+
+    /* Manager API. */
+    Result RegisterProcess(u64 process_id, ncm::TitleId title_id, const void *acid, size_t acid_size, const void *aci, size_t aci_size) {
+        return smManagerAtmosphereRegisterProcess(process_id, static_cast<u64>(title_id), acid, acid_size, aci, aci_size);
+    }
+
+    Result UnregisterProcess(u64 process_id) {
+        return smManagerUnregisterProcess(process_id);
+    }
+
+    /* Atmosphere extensions. */
+    Result EndInitialDefers() {
+        return smManagerAtmosphereEndInitialDefers();
+    }
+
+    Result HasMitm(bool *out, ServiceName name) {
+        return smManagerAtmosphereHasMitm(out, name.name);
+    }
+
+}

stratosphere/libstratosphere/source/sm/sm_mitm_api.cpp

@@ -0,0 +1,63 @@
+/*
+ * 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 <switch.h>
+#include <stratosphere.hpp>
+#include <stratosphere/sm.hpp>
+
+#include "sm_ams.h"
+#include "sm_utils.hpp"
+
+namespace sts::sm::mitm {
+
+    /* Mitm API. */
+    Result InstallMitm(Handle *out_port, Handle *out_query, ServiceName name) {
+        return impl::DoWithMitmSession([&]() {
+            return smAtmosphereMitmInstall(out_port, out_query, name.name);
+        });
+    }
+
+    Result UninstallMitm(ServiceName name) {
+        return impl::DoWithMitmSession([&]() {
+            return smAtmosphereMitmUninstall(name.name);
+        });
+    }
+
+    Result DeclareFutureMitm(ServiceName name) {
+        return impl::DoWithMitmSession([&]() {
+            return smAtmosphereMitmDeclareFuture(name.name);
+        });
+    }
+
+    Result AcknowledgeSession(Service *out_service, u64 *out_pid, ncm::TitleId *out_tid, ServiceName name) {
+        return impl::DoWithMitmSession([&]() {
+            return smAtmosphereMitmAcknowledgeSession(out_service, out_pid, &out_tid->value, name.name);
+        });
+    }
+
+    Result HasMitm(bool *out, ServiceName name) {
+        return impl::DoWithUserSession([&]() {
+            return smAtmosphereHasMitm(out, name.name);
+        });
+    }
+
+    Result WaitMitm(ServiceName name) {
+        return impl::DoWithUserSession([&]() {
+            return smAtmosphereWaitMitm(name.name);
+        });
+    }
+
+}

stratosphere/libstratosphere/source/sm/sm_utils.cpp

@@ -0,0 +1,38 @@
+/*
+ * 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 "sm_utils.hpp"
+
+namespace sts::sm::impl {
+
+    namespace {
+
+        /* Globals. */
+        HosRecursiveMutex g_user_session_mutex;
+        HosRecursiveMutex g_mitm_session_mutex;
+
+    }
+
+    /* Utilities. */
+    HosRecursiveMutex &GetUserSessionMutex() {
+        return g_user_session_mutex;
+    }
+
+    HosRecursiveMutex &GetMitmSessionMutex() {
+        return g_mitm_session_mutex;
+    }
+
+}

stratosphere/libstratosphere/source/sm/sm_utils.hpp

@@ -0,0 +1,53 @@
+/*
+ * 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/>.
+ */
+
+#pragma once
+
+#include <switch.h>
+#include <stratosphere.hpp>
+#include <stratosphere/sm.hpp>
+
+#include "sm_ams.h"
+
+namespace sts::sm::impl {
+
+    /* Utilities. */
+    HosRecursiveMutex &GetUserSessionMutex();
+    HosRecursiveMutex &GetMitmSessionMutex();
+
+    template<typename F>
+    Result DoWithUserSession(F f) {
+        std::scoped_lock<HosRecursiveMutex &> lk(GetUserSessionMutex());
+        {
+            R_ASSERT(smInitialize());
+            ON_SCOPE_EXIT { smExit(); };
+
+            return f();
+        }
+    }
+
+    template<typename F>
+    Result DoWithMitmSession(F f) {
+        std::scoped_lock<HosRecursiveMutex &> lk(GetMitmSessionMutex());
+        {
+            R_ASSERT(smAtmosphereMitmInitialize());
+            ON_SCOPE_EXIT { smAtmosphereMitmExit(); };
+
+            return f();
+        }
+    }
+
+}

stratosphere/libstratosphere/source/sm/smm_ams.c

@@ -0,0 +1,129 @@
+/*
+ * 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 <switch.h>
+#include "smm_ams.h"
+
+Result smManagerAtmosphereEndInitialDefers(void) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = smManagerGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65000;
+
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+    }
+
+    return rc;
+
+}
+
+Result smManagerAtmosphereRegisterProcess(u64 pid, u64 tid, const void *acid_sac, size_t acid_sac_size, const void *aci_sac, size_t aci_sac_size) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    ipcAddSendBuffer(&c, acid_sac, acid_sac_size, BufferType_Normal);
+    ipcAddSendBuffer(&c, aci_sac,  aci_sac_size,  BufferType_Normal);
+    Service *srv = smManagerGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 pid;
+        u64 tid;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65002;
+    raw->pid = pid;
+    raw->tid = tid;
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+Result smManagerAtmosphereHasMitm(bool *out, const char* name) {
+    IpcCommand c;
+    ipcInitialize(&c);
+    Service *srv = smManagerGetServiceSession();
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 service_name;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 65001;
+    raw->service_name = smEncodeName(name);
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+            u8 has_mitm;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc)) {
+            *out = resp->has_mitm != 0;
+        }
+    }
+
+    return rc;
+}

stratosphere/libstratosphere/source/sm/smm_ams.h

@@ -0,0 +1,20 @@
+/**
+ * @file smm_ams.h
+ * @brief Service manager manager (sm:m) IPC wrapper for Atmosphere extensions.
+ * @author SciresM
+ * @copyright libnx Authors
+ */
+#pragma once
+#include <switch.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Result smManagerAtmosphereEndInitialDefers(void);
+Result smManagerAtmosphereRegisterProcess(u64 pid, u64 tid, const void *acid_sac, size_t acid_sac_size, const void *aci_sac, size_t aci_sac_size);
+Result smManagerAtmosphereHasMitm(bool *out, const char* name);
+
+#ifdef __cplusplus
+}
+#endif