ui: Add basic reporting stubs

ui/Makefile.objs

@@ -39,6 +39,7 @@ sdl.mo-objs := \
 	xemu-net.o \
 	xemu-settings.o \
 	xemu-shaders.o \
+	xemu-reporting.o \
 
 ui/xemu-shaders.o: ui/shader/xemu-logo-frag.h
 

ui/xemu-hud.cc

@@ -34,6 +34,7 @@
 #include "xemu-net.h"
 #include "xemu-os-utils.h"
 #include "xemu-xbe.h"
+#include "xemu-reporting.h"
 
 #include "imgui/imgui.h"
 #include "imgui/examples/imgui_impl_sdl.h"
@@ -940,11 +941,32 @@ const char *get_cpu_info(void)
 class CompatibilityReporter
 {
 public:
+    CompatibilityReport report;
+    bool dirty;
     bool is_open;
+    std::string serialized_report;
 
     CompatibilityReporter()
     {
         is_open = false;
+
+        report.token = "";
+        report.xemu_version = xemu_version;
+        report.xemu_branch = xemu_branch;
+        report.xemu_commit = xemu_commit;
+        report.xemu_date = xemu_date;
+#if defined(__linux__)
+        report.os_platform = "Linux";
+#elif defined(_WIN32)
+        report.os_platform = "Windows";
+#elif defined(__APPLE__)
+        report.os_platform = "macOS";
+#else
+        report.os_platform = "Unknown";
+#endif
+        report.os_version = xemu_get_os_info();
+        report.cpu = get_cpu_info();
+        dirty = true;
     }
 
     ~CompatibilityReporter()
@@ -958,58 +980,25 @@ public:
         ImVec2 size(450*g_ui_scale, 475*g_ui_scale);
 
         ImGui::SetNextWindowSize(size, ImGuiCond_Appearing);
-        if (!ImGui::Begin("Report Compatibility", &is_open, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse)) {
+        if (!ImGui::Begin("Report Compatibility", &is_open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
             ImGui::End();
             return;
         }
 
-        static char gpu_info[1024];
-        static char xbe_info[512];
-        static char report_info[4096];
-        static int report_info_initialized = 0;
-
         if (ImGui::IsWindowAppearing()) {
-            // Refresh whenever the window is re-opened
+            report.gl_vendor = (const char *)glGetString(GL_VENDOR);
-            report_info_initialized = 0;
+            report.gl_renderer = (const char *)glGetString(GL_RENDERER);
-        }
+            report.gl_version = (const char *)glGetString(GL_VERSION);
-
+            report.gl_shading_language_version = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
-        if (!report_info_initialized) {
+            struct xbe_info *xbe = xemu_get_xbe_info();
-            struct xbe_info *xbe = xemu_get_xbe_info(); 
+            if (xbe != NULL) {
-            snprintf(
+                report.xbe_timestamp = xbe->timedate;
-                gpu_info,
+                report.xbe_cert_timestamp = xbe->cert_timedate;
-                sizeof(gpu_info),
+                report.xbe_cert_title_id = xbe->cert_title_id;
-                "%s, %s, %s, %s",
+                report.xbe_cert_region = xbe->cert_region;
-                glGetString(GL_VENDOR),
+                report.xbe_cert_disc_num = xbe->cert_disc_num;
-                glGetString(GL_RENDERER),
+                report.xbe_cert_version = xbe->cert_version;
-                glGetString(GL_VERSION),
-                glGetString(GL_SHADING_LANGUAGE_VERSION)
-                );
-
-            if (xbe) {
-                snprintf(xbe_info, sizeof(xbe_info),
-                    "%s v1.%02d", xbe->cert_title_id_str, xbe->cert_version);
-            } else {
-                xbe_info[0] = '\x00';
             }
-
-            snprintf(
-                report_info,
-                sizeof(report_info),
-                "xemu:   %s [branch %s on %s]\n"
-                "OS:     %s\n"
-                "CPU:    %s\n"
-                "GPU:    %s\n"
-                "XBE:    %s",
-                xemu_version,
-                xemu_branch,
-                xemu_date,
-                xemu_get_os_info(),
-                get_cpu_info(),
-                gpu_info,
-                xbe_info
-                );
-
-            report_info_initialized = 1;
         }
 
         ImGui::TextWrapped(
@@ -1025,19 +1014,21 @@ public:
 
         ImGui::Columns(2, "", false);
         ImGui::SetColumnWidth(0, ImGui::GetWindowWidth()*0.25);
-
-        char buf[64];
-        buf[0] = '\x00';
         
         ImGui::Text("User Token");
         ImGui::SameLine();
         HelpMarker("Optional. This is a unique token that users may "
             "provide in order to expedite publication of their compatibility "
-            "reports.");    
+            "reports. If a token is not provided, reports will be published "
+            "with submitters public IP address.");    
         ImGui::NextColumn();
         float item_width = ImGui::GetColumnWidth()-20*g_ui_scale;
         ImGui::SetNextItemWidth(item_width*0.70);
-        ImGui::InputText("###UserToken", buf, sizeof(buf), 0);
+        static char token_buf[512] = {0};
+        if (ImGui::InputText("###UserToken", token_buf, sizeof(token_buf), 0)) {
+            report.token = token_buf;
+            dirty = true;
+        }
         ImGui::SameLine();
         if (ImGui::Button("Get Token")) {
             xemu_open_web_browser("https://xemu.app");
@@ -1048,28 +1039,48 @@ public:
         ImGui::NextColumn();
         static int playability;
         ImGui::SetNextItemWidth(item_width);
-        ImGui::Combo("###PlayabilityRating", &playability,
+        const char *playability_names[] = {
-            "Unknown\0" "Broken\0" "Intro/Menus\0" "Starts\0" "Playable\0" "Perfect\0");
+            "Unknown",
+            "Broken",
+            "Intro/Menus",
+            "Starts",
+            "Playable",
+            "Perfect",
+        };
+        if (ImGui::Combo("###PlayabilityRating", &playability,
+            "Unknown\0" "Broken\0" "Intro/Menus\0" "Starts\0" "Playable\0" "Perfect\0")) {
+            report.compat_rating = playability_names[playability];
+            dirty = true;
+        }
         ImGui::NextColumn();
         
         ImGui::Columns(1);
         
-        char description[255] = {0};
+        static char description[1024] = {0};
         ImGui::Text("Description");
-        ImGui::InputTextMultiline("###desc", description, sizeof(description), ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 6), 0);
+        if (ImGui::InputTextMultiline("###desc", description, sizeof(description), ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 6), 0)) {
+            report.compat_comments = description;
+            dirty = true;
+        }
 
-        ImGui::Text("Additional Information");
+        if (ImGui::TreeNode("Full Report Information")) {
-        ImGui::PushFont(g_fixed_width_font);
+            ImGui::PushFont(g_fixed_width_font);
-        ImGui::InputTextMultiline("##build_info", report_info, sizeof(report_info), ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 7), ImGuiInputTextFlags_ReadOnly);
+            if (dirty) {
-        ImGui::PopFont();
+                serialized_report = report.GetSerializedReport();
+                dirty = false;
+            }
+            ImGui::InputTextMultiline("##build_info", (char*)serialized_report.c_str(), strlen(serialized_report.c_str())+1, ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 7), ImGuiInputTextFlags_ReadOnly);
+            ImGui::PopFont();
+            ImGui::TreePop();
+        }
 
         ImGui::Columns(1);
 
-        ImGui::SetCursorPosY(ImGui::GetWindowHeight()-(10+25)*g_ui_scale);
         ImGui::SetCursorPosX(ImGui::GetWindowWidth()-(120+10)*g_ui_scale);
 
         ImGui::SetItemDefaultFocus();
         if (ImGui::Button("Send", ImVec2(120*g_ui_scale, 0))) {
+            report.Send();
         }
         
         ImGui::End();
@@ -1085,8 +1096,6 @@ static CompatibilityReporter compatibility_reporter_window;
 static NotificationManager notification_manager;
 static std::deque<const char *> g_errors;
 
-
-
 class FirstBootWindow
 {
 public:

ui/xemu-reporting.cc

@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include "xemu-reporting.h"
+
+#define CPPHTTPLIB_OPENSSL_SUPPORT 1
+#include "httplib.h"
+
+#include "json.hpp"
+using json = nlohmann::json;
+
+CompatibilityReport::CompatibilityReport()
+{
+}
+
+CompatibilityReport::~CompatibilityReport()
+{
+}
+
+const std::string &CompatibilityReport::GetSerializedReport()
+{
+	json report = {
+		{"token", token},
+		{"xemu_version", xemu_version},
+		{"xemu_branch", xemu_branch},
+		{"xemu_commit", xemu_commit},
+		{"xemu_date", xemu_date},
+		{"os_platform", os_platform},
+		{"os_version", os_version},
+		{"cpu", cpu},
+		{"gl_vendor", gl_vendor},
+		{"gl_renderer", gl_renderer},
+		{"gl_version", gl_version},
+		{"gl_shading_language_version", gl_shading_language_version},
+		{"memory", memory},
+		{"xbe_timestamp", xbe_timestamp},
+		{"xbe_cert_timestamp", xbe_cert_timestamp},
+		{"xbe_cert_title_id", xbe_cert_title_id},
+		{"xbe_cert_region", xbe_cert_region},
+		{"xbe_cert_disc_num", xbe_cert_disc_num},
+		{"xbe_cert_version", xbe_cert_version},
+		{"compat_rating", compat_rating},
+		{"compat_comments", compat_comments},
+	};
+	serialized = report.dump(2); 
+	return serialized;
+}
+
+void CompatibilityReport::Send()
+{
+	// Serialize the report
+	const std::string &s = GetSerializedReport();
+
+	fprintf(stderr, "%s\n", s.c_str());
+
+	httplib::SSLClient cli("127.0.0.1", 443);
+	// httplib::SSLClient cli("reports.xemu.app", 443);
+
+	cli.set_follow_location(true);
+	cli.set_timeout_sec(5);
+	// cli.enable_server_certificate_verification(true); // FIXME: Package cert bundle
+
+	auto res = cli.Post("/compatibility", s, "application/json");
+
+	if (!res) {
+#if 0 // FIXME: Handle SSL certificate verification failure
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+	    auto result = cli.get_openssl_verify_result();
+	    if (result) {
+	      fprintf(stderr, "verify error: %s\n", X509_verify_cert_error_string(result));
+	    }
+#endif
+#endif
+	    return;
+	}
+
+	fprintf(stderr, "%d\n", res->status);
+}

ui/xemu-reporting.h

@@ -0,0 +1,61 @@
+/*
+ * xemu Reporting
+ *
+ * Title compatibility and bug report submission.
+ *
+ * Copyright (C) 2020 Matt Borgerson
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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/>.
+ */
+
+#ifndef XEMU_REPORTING_H
+#define XEMU_REPORTING_H
+
+#include <string>
+#include <stdint.h>
+
+class CompatibilityReport {
+public:
+	std::string token;
+	std::string xemu_version;
+	std::string xemu_branch;
+	std::string xemu_commit;
+	std::string xemu_date;
+	std::string os_platform;
+	std::string os_version;
+	std::string cpu;
+	std::string gl_vendor;
+	std::string gl_renderer;
+	std::string gl_version;
+	std::string gl_shading_language_version;
+	std::string memory;
+	uint32_t xbe_timestamp;
+	uint32_t xbe_cert_timestamp;
+	uint32_t xbe_cert_title_id;
+	uint32_t xbe_cert_region;
+	uint32_t xbe_cert_disc_num;
+	uint32_t xbe_cert_version;
+	std::string compat_rating;
+	std::string compat_comments;
+
+	std::string serialized;
+
+public:
+	CompatibilityReport();
+	~CompatibilityReport();
+	void Send();
+	const std::string &GetSerializedReport();
+};
+
+#endif

xemu-xbe.c

@@ -6,72 +6,8 @@
 #include "monitor/hmp-target.h"
 #include "sysemu/hw_accel.h"
 
-#if 0
+// #include "base64/base64.h"
-// http://www.caustik.com/cxbx/download/xbe.htm
+// #include "base64/base64.c"
-struct xbe_header
-{
-    uint32_t m_magic;                         // magic number [should be "XBEH"]
-    uint8_t  m_digsig[256];                   // digital signature
-    uint32_t m_base;                          // base address
-    uint32_t m_sizeof_headers;                // size of headers
-    uint32_t m_sizeof_image;                  // size of image
-    uint32_t m_sizeof_image_header;           // size of image header
-    uint32_t m_timedate;                      // timedate stamp
-    uint32_t m_certificate_addr;              // certificate address
-    uint32_t m_sections;                      // number of sections
-    uint32_t m_section_headers_addr;          // section headers address
-
-    struct init_flags
-    {
-        uint32_t m_mount_utility_drive    : 1;  // mount utility drive flag
-        uint32_t m_format_utility_drive   : 1;  // format utility drive flag
-        uint32_t m_limit_64mb             : 1;  // limit development kit run time memory to 64mb flag
-        uint32_t m_dont_setup_harddisk    : 1;  // don't setup hard disk flag
-        uint32_t m_unused                 : 4;  // unused (or unknown)
-        uint32_t m_unused_b1              : 8;  // unused (or unknown)
-        uint32_t m_unused_b2              : 8;  // unused (or unknown)
-        uint32_t m_unused_b3              : 8;  // unused (or unknown)
-    } m_init_flags;
-
-    uint32_t m_entry;                         // entry point address
-    uint32_t m_tls_addr;                      // thread local storage directory address
-    uint32_t m_pe_stack_commit;               // size of stack commit
-    uint32_t m_pe_heap_reserve;               // size of heap reserve
-    uint32_t m_pe_heap_commit;                // size of heap commit
-    uint32_t m_pe_base_addr;                  // original base address
-    uint32_t m_pe_sizeof_image;               // size of original image
-    uint32_t m_pe_checksum;                   // original checksum
-    uint32_t m_pe_timedate;                   // original timedate stamp
-    uint32_t m_debug_pathname_addr;           // debug pathname address
-    uint32_t m_debug_filename_addr;           // debug filename address
-    uint32_t m_debug_unicode_filename_addr;   // debug unicode filename address
-    uint32_t m_kernel_image_thunk_addr;       // kernel image thunk address
-    uint32_t m_nonkernel_import_dir_addr;     // non kernel import directory address
-    uint32_t m_library_versions;              // number of library versions
-    uint32_t m_library_versions_addr;         // library versions address
-    uint32_t m_kernel_library_version_addr;   // kernel library version address
-    uint32_t m_xapi_library_version_addr;     // xapi library version address
-    uint32_t m_logo_bitmap_addr;              // logo bitmap address
-    uint32_t m_logo_bitmap_size;              // logo bitmap size
-};
-
-struct xbe_certificate
-{
-    uint32_t m_size;                          // size of certificate
-    uint32_t m_timedate;                      // timedate stamp
-    uint32_t m_titleid;                       // title id
-    uint16_t m_title_name[40];                // title name (unicode)
-    uint32_t m_alt_title_id[0x10];            // alternate title ids
-    uint32_t m_allowed_media;                 // allowed media types
-    uint32_t m_game_region;                   // game region
-    uint32_t m_game_ratings;                  // game ratings
-    uint32_t m_disk_number;                   // disk number
-    uint32_t m_version;                       // version
-    uint8_t  m_lan_key[16];                   // lan key
-    uint8_t  m_sig_key[16];                   // signature key
-    uint8_t  m_title_alt_sig_key[16][16];     // alternate signature keys
-};
-#endif
 
 static int virt_to_phys(target_ulong virt_addr, hwaddr *phys_addr)
 {
@@ -96,54 +32,99 @@ static int virt_to_phys(target_ulong virt_addr, hwaddr *phys_addr)
     return 0;
 }
 
+static ssize_t virt_dma_memory_read(vaddr vaddr, void *buf, size_t len)
+{
+    size_t num_bytes_read = 0;
+
+    while (num_bytes_read < len) {
+        // Get physical page for this offset
+        hwaddr phys_addr = 0;
+        if (virt_to_phys(vaddr+num_bytes_read, &phys_addr) != 0) {
+            return -1;
+        }
+
+        // Read contents from the page
+        size_t bytes_in_chunk = (len-num_bytes_read) & (TARGET_PAGE_SIZE-1);
+        // FIXME: Check return value
+        dma_memory_read(&address_space_memory, phys_addr, buf + num_bytes_read, bytes_in_chunk);
+
+        num_bytes_read += bytes_in_chunk;
+    }
+
+    return num_bytes_read;
+}
+
 // Get current XBE info
 struct xbe_info *xemu_get_xbe_info(void)
 {
-    static struct xbe_info xbe_info;
+    vaddr xbe_hdr_addr_virt = 0x10000;
-    hwaddr hdr_addr;
 
-    // Get physical page offset of headers
+    static struct xbe_info xbe_info;
-    if (virt_to_phys(0x10000, &hdr_addr) != 0) {
+
+    if (xbe_info.headers) {
+        free(xbe_info.headers);
+        xbe_info.headers = NULL;
+    }
+
+    // Get physical page of headers
+    hwaddr hdr_addr_phys = 0;
+    if (virt_to_phys(xbe_hdr_addr_virt, &hdr_addr_phys) != 0) {
         return NULL;
     }
 
-    // Check signature
+    // Check `XBEH` signature
-    uint32_t sig = ldl_le_phys(&address_space_memory, hdr_addr);
+    uint32_t sig = ldl_le_phys(&address_space_memory, hdr_addr_phys);
     if (sig != 0x48454258) {
         return NULL;
     }
 
-    xbe_info.timedate = ldl_le_phys(&address_space_memory, hdr_addr+0x114);
+    // Determine full length of headers
-
+    xbe_info.headers_len = ldl_le_phys(&address_space_memory,
-    // Find certificate (likely on same page, but be safe and map it)
+        hdr_addr_phys + offsetof(struct xbe_header, m_sizeof_headers));
-    uint32_t cert_addr_virt = ldl_le_phys(&address_space_memory, hdr_addr+0x118);
+    if (xbe_info.headers_len > 4*TARGET_PAGE_SIZE) {
-    if (cert_addr_virt == 0) {
+        // Headers are unusually large
         return NULL;
     }
 
-    hwaddr cert_addr;
+    xbe_info.headers = malloc(xbe_info.headers_len);
-    if (virt_to_phys(cert_addr_virt, &cert_addr) != 0) {
+    assert(xbe_info.headers != NULL);
+    
+    // Read all XBE headers
+    ssize_t bytes_read = virt_dma_memory_read(xbe_hdr_addr_virt,
+                                              xbe_info.headers,
+                                              xbe_info.headers_len);
+    if (bytes_read != xbe_info.headers_len) {
+        // Failed to read headers
         return NULL;
     }
 
-    // Extract title info from certificate
+    // Extract XBE header fields
-    xbe_info.cert_timedate = ldl_le_phys(&address_space_memory, cert_addr+0x04);
+    xbe_info.xbe_hdr = (struct xbe_header *)xbe_info.headers;
-    xbe_info.cert_title_id = ldl_le_phys(&address_space_memory, cert_addr+0x08);
+    xbe_info.timedate = ldl_le_p(&xbe_info.xbe_hdr->m_timedate);
-    xbe_info.cert_version  = ldl_le_phys(&address_space_memory, cert_addr+0xac);
 
-    // Generate friendly name for title id
+    // Get certificate
-    uint8_t pub_hi = xbe_info.cert_title_id >> 24;
+    uint32_t cert_addr_virt = ldl_le_p(&xbe_info.xbe_hdr->m_certificate_addr);
-    uint8_t pub_lo = xbe_info.cert_title_id >> 16;
+    if ((cert_addr_virt == 0) || ((cert_addr_virt + sizeof(struct xbe_certificate)) > (xbe_hdr_addr_virt + xbe_info.headers_len))) {
-
+        // Invalid certificate header (a valid certificate is expected for official titles)
-    if ((65 > pub_hi) || (pub_hi > 90) || (65 > pub_lo) || (pub_lo > 90)) {
+        return NULL;
-        // Non-printable publisher id
-        snprintf(xbe_info.cert_title_id_str, sizeof(xbe_info.cert_title_id_str),
-            "0x%08x", xbe_info.cert_title_id);
-    } else {
-        // Printable publisher id
-        snprintf(xbe_info.cert_title_id_str, sizeof(xbe_info.cert_title_id_str),
-            "%c%c-%03u", pub_hi, pub_lo, xbe_info.cert_title_id & 0xffff);
     }
+    
+    // Extract certificate fields
+    xbe_info.xbe_cert = (struct xbe_certificate *)(xbe_info.headers + cert_addr_virt - xbe_hdr_addr_virt);
+    xbe_info.cert_timedate = ldl_le_p(&xbe_info.xbe_cert->m_timedate);
+    xbe_info.cert_title_id = ldl_le_p(&xbe_info.xbe_cert->m_titleid);
+    xbe_info.cert_version = ldl_le_p(&xbe_info.xbe_cert->m_version);
+    xbe_info.cert_region = ldl_le_p(&xbe_info.xbe_cert->m_game_region);
+    xbe_info.cert_disc_num = ldl_le_p(&xbe_info.xbe_cert->m_disk_number);
+
+#if 0
+    // Dump base64 version of headers
+    FILE *fd = fopen("dump2.bin", "wb");
+    void *b64buf = malloc(xbe_info.headers_len*2);
+    int enc = base64_encode(xbe_info.headers, xbe_info.headers_len, b64buf);
+    fwrite(b64buf, 1, enc, fd);
+    free(b64buf);
+#endif
 
     return &xbe_info;
 }

xemu-xbe.h

@@ -24,12 +24,89 @@
 
 #include <stdint.h>
 
+// http://www.caustik.com/cxbx/download/xbe.htm
+#pragma pack(1)
+struct xbe_header
+{
+    uint32_t m_magic;                         // magic number [should be "XBEH"]
+    uint8_t  m_digsig[256];                   // digital signature
+    uint32_t m_base;                          // base address
+    uint32_t m_sizeof_headers;                // size of headers
+    uint32_t m_sizeof_image;                  // size of image
+    uint32_t m_sizeof_image_header;           // size of image header
+    uint32_t m_timedate;                      // timedate stamp
+    uint32_t m_certificate_addr;              // certificate address
+    uint32_t m_sections;                      // number of sections
+    uint32_t m_section_headers_addr;          // section headers address
+
+    struct init_flags
+    {
+        uint32_t m_mount_utility_drive    : 1;  // mount utility drive flag
+        uint32_t m_format_utility_drive   : 1;  // format utility drive flag
+        uint32_t m_limit_64mb             : 1;  // limit development kit run time memory to 64mb flag
+        uint32_t m_dont_setup_harddisk    : 1;  // don't setup hard disk flag
+        uint32_t m_unused                 : 4;  // unused (or unknown)
+        uint32_t m_unused_b1              : 8;  // unused (or unknown)
+        uint32_t m_unused_b2              : 8;  // unused (or unknown)
+        uint32_t m_unused_b3              : 8;  // unused (or unknown)
+    } m_init_flags;
+
+    uint32_t m_entry;                         // entry point address
+    uint32_t m_tls_addr;                      // thread local storage directory address
+    uint32_t m_pe_stack_commit;               // size of stack commit
+    uint32_t m_pe_heap_reserve;               // size of heap reserve
+    uint32_t m_pe_heap_commit;                // size of heap commit
+    uint32_t m_pe_base_addr;                  // original base address
+    uint32_t m_pe_sizeof_image;               // size of original image
+    uint32_t m_pe_checksum;                   // original checksum
+    uint32_t m_pe_timedate;                   // original timedate stamp
+    uint32_t m_debug_pathname_addr;           // debug pathname address
+    uint32_t m_debug_filename_addr;           // debug filename address
+    uint32_t m_debug_unicode_filename_addr;   // debug unicode filename address
+    uint32_t m_kernel_image_thunk_addr;       // kernel image thunk address
+    uint32_t m_nonkernel_import_dir_addr;     // non kernel import directory address
+    uint32_t m_library_versions;              // number of library versions
+    uint32_t m_library_versions_addr;         // library versions address
+    uint32_t m_kernel_library_version_addr;   // kernel library version address
+    uint32_t m_xapi_library_version_addr;     // xapi library version address
+    uint32_t m_logo_bitmap_addr;              // logo bitmap address
+    uint32_t m_logo_bitmap_size;              // logo bitmap size
+};
+
+struct xbe_certificate
+{
+    uint32_t m_size;                          // size of certificate
+    uint32_t m_timedate;                      // timedate stamp
+    uint32_t m_titleid;                       // title id
+    uint16_t m_title_name[40];                // title name (unicode)
+    uint32_t m_alt_title_id[0x10];            // alternate title ids
+    uint32_t m_allowed_media;                 // allowed media types
+    uint32_t m_game_region;                   // game region
+    uint32_t m_game_ratings;                  // game ratings
+    uint32_t m_disk_number;                   // disk number
+    uint32_t m_version;                       // version
+    uint8_t  m_lan_key[16];                   // lan key
+    uint8_t  m_sig_key[16];                   // signature key
+    uint8_t  m_title_alt_sig_key[16][16];     // alternate signature keys
+};
+#pragma pack()
+
 struct xbe_info {
+	// Typically accessed fields extracted from heeaders
     uint32_t timedate;
     uint32_t cert_timedate;
     uint32_t cert_title_id;
-    char     cert_title_id_str[12];
     uint32_t cert_version;
+	uint32_t cert_region;
+	uint32_t cert_disc_num;
+
+	// Full XBE headers, copied into a temporary buffer
+	uint8_t *headers;
+	uint32_t headers_len;
+
+	// Pointer into `headers` (note: little-endian!)
+	struct xbe_header *xbe_hdr;
+	struct xbe_certificate *xbe_cert;
 };
 
 #ifdef __cplusplus