Added API scanner tool

New tool for issue #171 which links to libxenia to dump the API usage
from packaged content

src/xenia/tools/api-scanner/api_scanner_loader.cc

@@ -0,0 +1,189 @@
+/**
+ ******************************************************************************
+ * api-scanner - Scan for API imports from a packaged 360 game                *
+ ******************************************************************************
+ * Copyright 2015 x1nixmzeng. All rights reserved.                            *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "api_scanner_loader.h"
+#include "xenia/kernel/xam_module.h"
+#include "xenia/kernel/xboxkrnl_module.h"
+
+namespace xe {
+namespace tools {
+
+void apiscanner_logger::operator()(const LogType type, const char* szMessage) {
+  switch (type) {
+  case LT_WARNING:
+    fprintf(stderr, "[W] %s\n", szMessage);
+    break;
+  case LT_ERROR:
+    fprintf(stderr, "[!] %s\n", szMessage);
+    break;
+  default:
+    break;
+  }
+}
+
+apiscanner_loader::apiscanner_loader()
+  : export_resolver(nullptr)
+  , memory_(nullptr)
+{
+  export_resolver = std::make_unique<ExportResolver>();
+
+  kernel::XamModule::RegisterExportTable(export_resolver.get());
+  kernel::XboxkrnlModule::RegisterExportTable(export_resolver.get());
+
+  memory_ = std::make_unique<Memory>();
+  memory_->Initialize();
+}
+
+apiscanner_loader::~apiscanner_loader()
+{
+  if (export_resolver != nullptr) {
+    export_resolver.reset();
+  }
+
+  if (memory_ != nullptr) {
+    memory_.reset();
+  }
+}
+
+bool apiscanner_loader::LoadTitleImports(const std::wstring& target) {
+  auto type(file_system.InferType(target));
+  int result = file_system.InitializeFromPath(type, target);
+  if (result) {
+    log(log.LT_ERROR, "Could not load target");
+    return false;
+  }
+
+  return ReadTarget();
+}
+
+
+bool apiscanner_loader::ReadTarget() {
+  // XXX Do a wildcard search for all xex files?
+  const char path[] = "game:\\default.xex";
+
+  kernel::XFile* file(nullptr);
+  bool read_result(false);
+  auto fs_entry = file_system.ResolvePath(path);
+  if (!fs_entry) {
+    log(log.LT_WARNING, "Could not resolve xex path");
+    return false;
+  }
+
+  // If the FS supports mapping, map the file in and load from that.
+  if (fs_entry->can_map()) {
+    auto mmap = fs_entry->CreateMemoryMapping(kernel::fs::Mode::READ, 0, 0);
+    if (!mmap) {
+      if (file) {
+        file->Release();
+      }
+      log(log.LT_WARNING, "Could not map filesystem");
+      return false;
+    }
+
+    title res;
+    read_result = ExtractImports(mmap->address(), mmap->length(), res);
+    if (read_result) {
+      loaded_titles.push_back(res);
+    }
+  }
+  else {
+    kernel::XFileInfo file_info;
+    if (fs_entry->QueryInfo(&file_info)) {
+      if (file) {
+        file->Release();
+      }
+      log(log.LT_WARNING, "Could not read xex attributes");
+      return false;
+    }
+
+    // Load into memory
+    std::vector<uint8_t> buffer(file_info.file_length);
+
+    // XXX No kernel state again
+    int result = file_system.Open(std::move(fs_entry), nullptr,
+      kernel::fs::Mode::READ, false, &file);
+    if (result) {
+      if (file) {
+        file->Release();
+      }
+      log(log.LT_WARNING, "Could not open xex file");
+      return false;
+    }
+
+    size_t bytes_read = 0;
+    result = file->Read(buffer.data(), buffer.size(), 0, &bytes_read);
+    if (result) {
+      if (file) {
+        file->Release();
+      }
+      log(log.LT_ERROR, "Could not read xex data");
+      return false;
+    }
+
+    title res;
+    read_result = ExtractImports(buffer.data(), bytes_read, res);
+    if (read_result) {
+      loaded_titles.push_back(res);
+    }
+  }
+
+  if (file) {
+    file->Release();
+  }
+
+  return read_result;
+}
+
+bool apiscanner_loader::ExtractImports(const void* addr, const size_t length,
+  title& info)
+{
+  // Load the XEX into memory and decrypt.
+  xe_xex2_options_t xex_options = { 0 };
+  xe_xex2_ref xex_(xe_xex2_load(memory_.get(), addr, length, xex_options));
+  if (!xex_) {
+    log(log.LT_ERROR, "Failed to parse xex file");
+    return false;
+  }
+
+  const xe_xex2_header_t* header = xe_xex2_get_header(xex_);
+
+  info.title_id = header->execution_info.title_id;
+    
+  // XXX Copy out library versions?
+  for (size_t n = 0; n < header->import_library_count; n++) {
+    const xe_xex2_import_library_t* library = &header->import_libraries[n];
+
+    xe_xex2_import_info_t* import_infos;
+    size_t import_info_count;
+    if (!xe_xex2_get_import_infos(xex_, library, &import_infos,
+      &import_info_count)) {
+
+      for (size_t m = 0; m < import_info_count; m++) {
+        const xe_xex2_import_info_t* import_info = &import_infos[m];
+
+        KernelExport* kernel_export = export_resolver->GetExportByOrdinal(
+          library->name, import_info->ordinal);
+
+        if ((kernel_export && kernel_export->type == KernelExport::Variable)
+          || import_info->thunk_address) {
+          const std::string named(kernel_export ? kernel_export->name : "");
+          info.imports.push_back(named);
+        }
+      }
+    }
+  }
+
+  xe_xex2_dealloc(xex_);
+  std::sort(info.imports.begin(), info.imports.end());
+
+  return true;
+}
+
+} // tools
+} // xe