thermosphere: copy paste lots of gdb luma files (but don't build them yet)

thermosphere/src/gdb/xfer.c

@@ -0,0 +1,257 @@
+/*
+*   This file is part of Luma3DS.
+*   Copyright (C) 2016-2019 Aurora Wright, TuxSH
+*
+*   SPDX-License-Identifier: (MIT OR GPL-2.0-or-later)
+*/
+
+#include <3ds/os.h>
+
+#include "gdb/xfer.h"
+#include "gdb/net.h"
+#include "fmt.h"
+
+#include "osdata_cfw_version_template_xml.h"
+#include "osdata_memory_template_xml.h"
+#include "osdata_xml.h"
+#include "target_xml.h"
+
+struct
+{
+    const char *name;
+    int (*handler)(GDBContext *ctx, bool write, const char *annex, u32 offset, u32 length);
+} xferCommandHandlers[] =
+{
+    { "features", GDB_XFER_HANDLER(Features) },
+    { "osdata",   GDB_XFER_HANDLER(OsData) },
+};
+
+GDB_DECLARE_XFER_HANDLER(Features)
+{
+    if(strcmp(annex, "target.xml") != 0 || write)
+        return GDB_ReplyEmpty(ctx);
+    else
+        return GDB_SendStreamData(ctx, (const char *)target_xml, offset, length, target_xml_size, false);
+}
+
+struct
+{
+    const char *name;
+    int (*handler)(GDBContext *ctx, bool write, u32 offset, u32 length);
+} xferOsDataCommandHandlers[] =
+{
+    { "cfwversion", GDB_XFER_OSDATA_HANDLER(CfwVersion) },
+    { "memory",     GDB_XFER_OSDATA_HANDLER(Memory) },
+    { "processes",  GDB_XFER_OSDATA_HANDLER(Processes) },
+};
+
+GDB_DECLARE_XFER_OSDATA_HANDLER(CfwVersion)
+{
+    if(write)
+        return GDB_HandleUnsupported(ctx);
+    else
+    {
+        char buf[512]; // Make sure this doesn't overflow
+        char versionString[16];
+        s64 out;
+        u32 version, commitHash;
+        bool isRelease;
+        u32 sz;
+
+        svcGetSystemInfo(&out, 0x10000, 0);
+        version = (u32)out;
+
+        svcGetSystemInfo(&out, 0x10000, 1);
+        commitHash = (u32)out;
+
+        svcGetSystemInfo(&out, 0x10000, 0x200);
+        isRelease = (bool)out;
+
+        if(GET_VERSION_REVISION(version) == 0)
+            sprintf(versionString, "v%lu.%lu", GET_VERSION_MAJOR(version), GET_VERSION_MINOR(version));
+        else
+            sprintf(versionString, "v%lu.%lu.%lu", GET_VERSION_MAJOR(version), GET_VERSION_MINOR(version), GET_VERSION_REVISION(version));
+
+        sz = (u32)sprintf(buf, (const char *)osdata_cfw_version_template_xml, versionString, commitHash, isRelease ? "Yes" : "No");
+
+        return GDB_SendStreamData(ctx, buf, offset, length, sz, false);
+    }
+}
+
+GDB_DECLARE_XFER_OSDATA_HANDLER(Memory)
+{
+    if(write)
+        return GDB_HandleUnsupported(ctx);
+    else
+    {
+        if(ctx->memoryOsInfoXmlData[0] == 0)
+        {
+            s64 out;
+            u32 applicationUsed, systemUsed, baseUsed;
+            u32 applicationTotal = *(vu32 *)0x1FF80040, systemTotal = *(vu32 *)0x1FF80044, baseTotal = *(vu32 *)0x1FF80048;
+
+            svcGetSystemInfo(&out, 0, 1);
+            applicationUsed = (u32)out;
+
+            svcGetSystemInfo(&out, 0, 2);
+            systemUsed = (u32)out;
+
+            svcGetSystemInfo(&out, 0, 3);
+            baseUsed = (u32)out;
+
+            sprintf(ctx->memoryOsInfoXmlData, (const char *)osdata_memory_template_xml,
+                applicationUsed, applicationTotal - applicationUsed, applicationTotal, (u32)((5ULL + ((1000ULL * applicationUsed) / applicationTotal)) / 10ULL),
+                systemUsed, systemTotal - systemUsed, systemTotal, (u32)((5ULL + ((1000ULL * systemUsed) / systemTotal)) / 10ULL),
+                baseUsed, baseTotal - baseUsed, baseTotal, (u32)((5ULL + ((1000ULL * baseUsed) / baseTotal)) / 10ULL)
+            );
+        }
+
+        u32 size = strlen(ctx->memoryOsInfoXmlData);
+        int n = GDB_SendStreamData(ctx, ctx->memoryOsInfoXmlData, offset, length, size, false);
+
+        if(offset + length >= size)
+            ctx->memoryOsInfoXmlData[0] = 0; // we're done, invalidate
+
+        return n;
+    }
+}
+
+GDB_DECLARE_XFER_OSDATA_HANDLER(Processes)
+{
+    if(write)
+        return GDB_HandleUnsupported(ctx);
+    else
+    {
+        if(ctx->processesOsInfoXmlData[0] == 0)
+        {
+            static const char header[] =
+            /*"<?xml version=\"1.0\"?>"
+            "<!DOCTYPE target SYSTEM \"osdata.dtd\">" IDA rejects the xml header*/
+            "<osdata type=\"processes\">";
+
+            static const char item[] =
+            "<item>"
+            "<column name=\"pid\">%lu</column>"
+            "<column name=\"command\">%s</column>"
+            "</item>";
+
+            static const char footer[] = "</osdata>";
+
+            int n;
+            u32 pos = 0;
+
+            u32 pidList[0x40];
+            s32 processAmount;
+
+            strcpy(ctx->processesOsInfoXmlData, header);
+            pos = sizeof(header) - 1;
+            svcGetProcessList(&processAmount, pidList, 0x40);
+
+            for(s32 i = 0; i < processAmount; i++)
+            {
+                u32 pid = pidList[i];
+                char name[9] = { 0 };
+                s64 out;
+                Handle processHandle;
+                Result res = svcOpenProcess(&processHandle, pidList[i]);
+                if(R_FAILED(res))
+                    continue;
+
+                svcGetProcessInfo(&out, processHandle, 0x10000);
+                memcpy(name, &out, 8);
+                svcCloseHandle(processHandle);
+
+                n = sprintf(ctx->processesOsInfoXmlData + pos, item, pid, name);
+                pos += (u32)n;
+            }
+
+            strcpy(ctx->processesOsInfoXmlData + pos, footer);
+            pos = sizeof(footer) - 1;
+        }
+
+        u32 size = strlen(ctx->processesOsInfoXmlData);
+        int n = GDB_SendStreamData(ctx, ctx->processesOsInfoXmlData, offset, length, size, false);
+
+        if(offset + length >= size)
+            ctx->processesOsInfoXmlData[0] = 0; // we're done, invalidate
+
+        return n;
+    }
+}
+
+GDB_DECLARE_XFER_HANDLER(OsData)
+{
+    if(strcmp(annex, "") == 0 && !write)
+        return GDB_SendStreamData(ctx, (const char *)osdata_xml, offset, length, osdata_xml_size, false);
+    else
+    {
+        for(u32 i = 0; i < sizeof(xferOsDataCommandHandlers) / sizeof(xferOsDataCommandHandlers[0]); i++)
+        {
+            if(strcmp(annex, xferOsDataCommandHandlers[i].name) == 0)
+                return xferOsDataCommandHandlers[i].handler(ctx, write, offset, length);
+        }
+    }
+
+    return GDB_HandleUnsupported(ctx);
+}
+
+GDB_DECLARE_QUERY_HANDLER(Xfer)
+{
+    const char *objectStart = ctx->commandData;
+    char *objectEnd = (char*)strchr(objectStart, ':');
+    if(objectEnd == NULL) return -1;
+    *objectEnd = 0;
+
+    char *opStart = objectEnd + 1;
+    char *opEnd = (char*)strchr(opStart, ':');
+    if(opEnd == NULL) return -1;
+    *opEnd = 0;
+
+    char *annexStart = opEnd + 1;
+    char *annexEnd = (char*)strchr(annexStart, ':');
+    if(annexEnd == NULL) return -1;
+    *annexEnd = 0;
+
+    const char *offStart = annexEnd + 1;
+    u32 offset, length;
+
+    bool write;
+    const char *pos;
+    if(strcmp(opStart, "read") == 0)
+    {
+        u32 lst[2];
+        if(GDB_ParseHexIntegerList(lst, offStart, 2, 0) == NULL)
+            return GDB_ReplyErrno(ctx, EILSEQ);
+
+        offset = lst[0];
+        length = lst[1];
+        write = false;
+    }
+    else if(strcmp(opStart, "write") == 0)
+    {
+        pos = GDB_ParseHexIntegerList(&offset, offStart, 1, ':');
+        if(pos == NULL || *pos++ != ':')
+            return GDB_ReplyErrno(ctx, EILSEQ);
+
+        u32 len = strlen(pos);
+        if(len == 0 || (len % 2) != 0)
+            return GDB_ReplyErrno(ctx, EILSEQ);
+        length = len / 2;
+        write = true;
+    }
+    else
+        return GDB_ReplyErrno(ctx, EILSEQ);
+
+    for(u32 i = 0; i < sizeof(xferCommandHandlers) / sizeof(xferCommandHandlers[0]); i++)
+    {
+        if(strcmp(objectStart, xferCommandHandlers[i].name) == 0)
+        {
+            if(write)
+                ctx->commandData = (char *)pos;
+
+            return xferCommandHandlers[i].handler(ctx, write, annexStart, offset, length);
+        }
+    }
+
+    return GDB_HandleUnsupported(ctx);
+}