17 files changed, 251 insertions, 49 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 2b26292fd..06df9a677 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -56,6 +56,7 @@ set(SRCS
             core_timing.cpp
             mem_map.cpp
             mem_map_funcs.cpp
+            settings.cpp
             system.cpp
             )
 
@@ -117,6 +118,7 @@ set(HEADERS
             core.h
             core_timing.h
             mem_map.h
+            settings.h
             system.h
             )
 
diff --git a/src/core/file_sys/archive_sdmc.cpp b/src/core/file_sys/archive_sdmc.cpp
index 30d33be5f..213923c02 100644
--- a/src/core/file_sys/archive_sdmc.cpp
+++ b/src/core/file_sys/archive_sdmc.cpp
@@ -24,6 +24,10 @@ Archive_SDMC::Archive_SDMC(const std::string& mount_point) {
 Archive_SDMC::~Archive_SDMC() {
 }
 
+/**
+ * Initialize the archive.
+ * @return true if it initialized successfully
+ */
 bool Archive_SDMC::Initialize() {
     if (!FileUtil::IsDirectory(mount_point)) {
         WARN_LOG(FILESYS, "Directory %s not found, disabling SDMC.", mount_point.c_str());
@@ -42,6 +46,8 @@ bool Archive_SDMC::Initialize() {
 std::unique_ptr<File> Archive_SDMC::OpenFile(const std::string& path, const Mode mode) const {
     DEBUG_LOG(FILESYS, "called path=%s mode=%d", path.c_str(), mode);
     File_SDMC* file = new File_SDMC(this, path, mode);
+    if (!file->Open())
+        return nullptr;
     return std::unique_ptr<File>(file);
 }
 
diff --git a/src/core/file_sys/archive_sdmc.h b/src/core/file_sys/archive_sdmc.h
index 946f8b957..f68648e6f 100644
--- a/src/core/file_sys/archive_sdmc.h
+++ b/src/core/file_sys/archive_sdmc.h
@@ -20,6 +20,10 @@ public:
     Archive_SDMC(const std::string& mount_point);
     ~Archive_SDMC() override;
 
+    /**
+     * Initialize the archive.
+     * @return true if it initialized successfully
+     */
     bool Initialize();
 
     /**
diff --git a/src/core/file_sys/directory.h b/src/core/file_sys/directory.h
index cf9a2010b..e10431337 100644
--- a/src/core/file_sys/directory.h
+++ b/src/core/file_sys/directory.h
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <cstddef>
+
 #include "common/common_types.h"
 
 #include "core/hle/kernel/kernel.h"
@@ -17,9 +19,9 @@ namespace FileSys {
 const size_t FILENAME_LENGTH = 0x20C / 2;
 struct Entry {
     char16_t filename[FILENAME_LENGTH]; // Entry name (UTF-16, null-terminated)
-    char short_name[8]; // 8.3 file name ('longfilename' -> 'LONGFI~1')
+    std::array<char, 9> short_name; // 8.3 file name ('longfilename' -> 'LONGFI~1', null-terminated)
     char unknown1; // unknown (observed values: 0x0A, 0x70, 0xFD)
-    char extension[3]; // 8.3 file extension (set to spaces for directories)
+    std::array<char, 4> extension; // 8.3 file extension (set to spaces for directories, null-terminated)
     char unknown2; // unknown (always 0x01)
     char unknown3; // unknown (0x00 or 0x08)
     char is_directory; // directory flag
@@ -29,6 +31,10 @@ struct Entry {
     u64 file_size; // file size (for files only)
 };
 static_assert(sizeof(Entry) == 0x228, "Directory Entry struct isn't exactly 0x228 bytes long!");
+static_assert(offsetof(Entry, short_name) == 0x20C, "Wrong offset for short_name in Entry.");
+static_assert(offsetof(Entry, extension) == 0x216, "Wrong offset for extension in Entry.");
+static_assert(offsetof(Entry, is_archive) == 0x21E, "Wrong offset for is_archive in Entry.");
+static_assert(offsetof(Entry, file_size) == 0x220, "Wrong offset for file_size in Entry.");
 
 class Directory : NonCopyable {
 public:
diff --git a/src/core/file_sys/directory_sdmc.cpp b/src/core/file_sys/directory_sdmc.cpp
index 11e867857..36951564d 100644
--- a/src/core/file_sys/directory_sdmc.cpp
+++ b/src/core/file_sys/directory_sdmc.cpp
@@ -20,8 +20,8 @@ Directory_SDMC::Directory_SDMC(const Archive_SDMC* archive, const std::string& p
     // the root directory we set while opening the archive.
     // For example, opening /../../usr/bin can give the emulated program your installed programs.
     std::string absolute_path = archive->GetMountPoint() + path;
-    entry_count = FileUtil::ScanDirectoryTree(absolute_path, entry);
-    current_entry = 0;
+    FileUtil::ScanDirectoryTree(absolute_path, directory);
+    children_iterator = directory.children.begin();
 }
 
 Directory_SDMC::~Directory_SDMC() {
@@ -35,44 +35,39 @@ Directory_SDMC::~Directory_SDMC() {
  * @return Number of entries listed
  */
 u32 Directory_SDMC::Read(const u32 count, Entry* entries) {
-    u32 i;
-    for (i = 0; i < count && current_entry < entry_count; ++i) {
-        FileUtil::FSTEntry file = entry.children[current_entry];
-        std::string filename = file.virtualName;
-        WARN_LOG(FILESYS, "File %s: size=%d dir=%d", filename.c_str(), file.size, file.isDirectory);
+    u32 entries_read = 0;
+
+    while (entries_read < count && children_iterator != directory.children.cend()) {
+        const FileUtil::FSTEntry& file = *children_iterator;
+        const std::string& filename = file.virtualName;
+        Entry& entry = entries[entries_read];
 
-        Entry* entry = &entries[i];
+        WARN_LOG(FILESYS, "File %s: size=%d dir=%d", filename.c_str(), file.size, file.isDirectory);
 
         // TODO(Link Mauve): use a proper conversion to UTF-16.
         for (int j = 0; j < FILENAME_LENGTH; ++j) {
-            entry->filename[j] = filename[j];
+            entry.filename[j] = filename[j];
             if (!filename[j])
                 break;
         }
 
-        // Split the filename into 8.3 format.
-        // TODO(Link Mauve): move that to common, I guess, and make it more robust to long filenames.
-        std::string::size_type n = filename.rfind('.');
-        if (n == std::string::npos) {
-            strncpy(entry->short_name, filename.c_str(), 8);
-            memset(entry->extension, '\0', 3);
-        } else {
-            strncpy(entry->short_name, filename.substr(0, n).c_str(), 8);
-            strncpy(entry->extension, filename.substr(n + 1).c_str(), 8);
-        }
+        FileUtil::SplitFilename83(filename, entry.short_name, entry.extension);
 
-        entry->is_directory = file.isDirectory;
-        entry->file_size = file.size;
+        entry.is_directory = file.isDirectory;
+        entry.is_hidden = (filename[0] == '.');
+        entry.is_read_only = 0;
+        entry.file_size = file.size;
 
         // We emulate a SD card where the archive bit has never been cleared, as it would be on
         // most user SD cards.
         // Some homebrews (blargSNES for instance) are known to mistakenly use the archive bit as a
         // file bit.
-        entry->is_archive = !file.isDirectory;
+        entry.is_archive = !file.isDirectory;
 
-        ++current_entry;
+        ++entries_read;
+        ++children_iterator;
     }
-    return i;
+    return entries_read;
 }
 
 /**
diff --git a/src/core/file_sys/directory_sdmc.h b/src/core/file_sys/directory_sdmc.h
index 0bc6c9eff..cb8d32fda 100644
--- a/src/core/file_sys/directory_sdmc.h
+++ b/src/core/file_sys/directory_sdmc.h
@@ -37,9 +37,12 @@ public:
     bool Close() const override;
 
 private:
-    u32 entry_count;
-    u32 current_entry;
-    FileUtil::FSTEntry entry;
+    u32 total_entries_in_directory;
+    FileUtil::FSTEntry directory;
+
+    // We need to remember the last entry we returned, so a subsequent call to Read will continue
+    // from the next one.  This iterator will always point to the next unread entry.
+    std::vector<FileUtil::FSTEntry>::iterator children_iterator;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/file.h b/src/core/file_sys/file.h
index f7b009f5a..4013b6c3e 100644
--- a/src/core/file_sys/file.h
+++ b/src/core/file_sys/file.h
@@ -19,6 +19,12 @@ public:
     virtual ~File() { }
 
     /**
+     * Open the file
+     * @return true if the file opened correctly
+     */
+    virtual bool Open() = 0;
+
+    /**
      * Read data from the file
      * @param offset Offset in bytes to start reading data from
      * @param length Length in bytes of data to read from file
@@ -31,8 +37,8 @@ public:
      * Write data to the file
      * @param offset Offset in bytes to start writing data to
      * @param length Length in bytes of data to write to file
-     * @param buffer Buffer to write data from
      * @param flush The flush parameters (0 == do not flush)
+     * @param buffer Buffer to read data from
      * @return Number of bytes written
      */
     virtual size_t Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const = 0;
@@ -44,6 +50,13 @@ public:
     virtual size_t GetSize() const = 0;
 
     /**
+     * Set the size of the file in bytes
+     * @param size New size of the file
+     * @return true if successful
+     */
+    virtual bool SetSize(const u64 size) const = 0;
+
+    /**
      * Close the file
      * @return true if the file closed correctly
      */
diff --git a/src/core/file_sys/file_romfs.cpp b/src/core/file_sys/file_romfs.cpp
index 00f3c2ea8..b55708df4 100644
--- a/src/core/file_sys/file_romfs.cpp
+++ b/src/core/file_sys/file_romfs.cpp
@@ -18,6 +18,14 @@ File_RomFS::~File_RomFS() {
 }
 
 /**
+ * Open the file
+ * @return true if the file opened correctly
+ */
+bool File_RomFS::Open() {
+    return false;
+}
+
+/**
  * Read data from the file
  * @param offset Offset in bytes to start reading data from
  * @param length Length in bytes of data to read from file
@@ -32,8 +40,8 @@ size_t File_RomFS::Read(const u64 offset, const u32 length, u8* buffer) const {
  * Write data to the file
  * @param offset Offset in bytes to start writing data to
  * @param length Length in bytes of data to write to file
- * @param buffer Buffer to write data from
  * @param flush The flush parameters (0 == do not flush)
+ * @param buffer Buffer to read data from
  * @return Number of bytes written
  */
 size_t File_RomFS::Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const {
@@ -49,6 +57,15 @@ size_t File_RomFS::GetSize() const {
 }
 
 /**
+ * Set the size of the file in bytes
+ * @param size New size of the file
+ * @return true if successful
+ */
+bool File_RomFS::SetSize(const u64 size) const {
+    return false;
+}
+
+/**
  * Close the file
  * @return true if the file closed correctly
  */
diff --git a/src/core/file_sys/file_romfs.h b/src/core/file_sys/file_romfs.h
index 5db43d4a0..5196701d3 100644
--- a/src/core/file_sys/file_romfs.h
+++ b/src/core/file_sys/file_romfs.h
@@ -20,6 +20,12 @@ public:
     ~File_RomFS() override;
 
     /**
+     * Open the file
+     * @return true if the file opened correctly
+     */
+    bool Open() override;
+
+    /**
      * Read data from the file
      * @param offset Offset in bytes to start reading data from
      * @param length Length in bytes of data to read from file
@@ -32,8 +38,8 @@ public:
      * Write data to the file
      * @param offset Offset in bytes to start writing data to
      * @param length Length in bytes of data to write to file
-     * @param buffer Buffer to write data from
      * @param flush The flush parameters (0 == do not flush)
+     * @param buffer Buffer to read data from
      * @return Number of bytes written
      */
     size_t Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const override;
@@ -45,6 +51,13 @@ public:
     size_t GetSize() const override;
 
     /**
+     * Set the size of the file in bytes
+     * @param size New size of the file
+     * @return true if successful
+     */
+    bool SetSize(const u64 size) const override;
+
+    /**
      * Close the file
      * @return true if the file closed correctly
      */
diff --git a/src/core/file_sys/file_sdmc.cpp b/src/core/file_sys/file_sdmc.cpp
index 76adc6403..26204392c 100644
--- a/src/core/file_sys/file_sdmc.cpp
+++ b/src/core/file_sys/file_sdmc.cpp
@@ -19,31 +19,56 @@ File_SDMC::File_SDMC(const Archive_SDMC* archive, const std::string& path, const
     // TODO(Link Mauve): normalize path into an absolute path without "..", it can currently bypass
     // the root directory we set while opening the archive.
     // For example, opening /../../etc/passwd can give the emulated program your users list.
-    std::string real_path = archive->GetMountPoint() + path;
+    this->path = archive->GetMountPoint() + path;
+    this->mode.hex = mode.hex;
+}
+
+File_SDMC::~File_SDMC() {
+    Close();
+}
 
-    if (!mode.create_flag && !FileUtil::Exists(real_path)) {
-        file = nullptr;
-        return;
+/**
+ * Open the file
+ * @return true if the file opened correctly
+ */
+bool File_SDMC::Open() {
+    if (!mode.create_flag && !FileUtil::Exists(path)) {
+        ERROR_LOG(FILESYS, "Non-existing file %s can’t be open without mode create.", path.c_str());
+        return false;
     }
 
     std::string mode_string;
-    if (mode.read_flag)
-        mode_string += "r";
-    if (mode.write_flag)
-        mode_string += "w";
+    if (mode.read_flag && mode.write_flag)
+        mode_string = "w+";
+    else if (mode.read_flag)
+        mode_string = "r";
+    else if (mode.write_flag)
+        mode_string = "w";
 
-    file = new FileUtil::IOFile(real_path, mode_string.c_str());
-}
-
-File_SDMC::~File_SDMC() {
-    Close();
+    file = new FileUtil::IOFile(path, mode_string.c_str());
+    return true;
 }
 
+/**
+ * Read data from the file
+ * @param offset Offset in bytes to start reading data from
+ * @param length Length in bytes of data to read from file
+ * @param buffer Buffer to read data into
+ * @return Number of bytes read
+ */
 size_t File_SDMC::Read(const u64 offset, const u32 length, u8* buffer) const {
     file->Seek(offset, SEEK_SET);
     return file->ReadBytes(buffer, length);
 }
 
+/**
+ * Write data to the file
+ * @param offset Offset in bytes to start writing data to
+ * @param length Length in bytes of data to write to file
+ * @param flush The flush parameters (0 == do not flush)
+ * @param buffer Buffer to read data from
+ * @return Number of bytes written
+ */
 size_t File_SDMC::Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const {
     file->Seek(offset, SEEK_SET);
     size_t written = file->WriteBytes(buffer, length);
@@ -52,10 +77,29 @@ size_t File_SDMC::Write(const u64 offset, const u32 length, const u32 flush, con
     return written;
 }
 
+/**
+ * Get the size of the file in bytes
+ * @return Size of the file in bytes
+ */
 size_t File_SDMC::GetSize() const {
-    return file->GetSize();
+    return static_cast<size_t>(file->GetSize());
+}
+
+/**
+ * Set the size of the file in bytes
+ * @param size New size of the file
+ * @return true if successful
+ */
+bool File_SDMC::SetSize(const u64 size) const {
+    file->Resize(size);
+    file->Flush();
+    return true;
 }
 
+/**
+ * Close the file
+ * @return true if the file closed correctly
+ */
 bool File_SDMC::Close() const {
     return file->Close();
 }
diff --git a/src/core/file_sys/file_sdmc.h b/src/core/file_sys/file_sdmc.h
index b2e46f449..df032f7c0 100644
--- a/src/core/file_sys/file_sdmc.h
+++ b/src/core/file_sys/file_sdmc.h
@@ -23,6 +23,12 @@ public:
     ~File_SDMC() override;
 
     /**
+     * Open the file
+     * @return true if the file opened correctly
+     */
+    bool Open() override;
+
+    /**
      * Read data from the file
      * @param offset Offset in bytes to start reading data from
      * @param length Length in bytes of data to read from file
@@ -35,8 +41,8 @@ public:
      * Write data to the file
      * @param offset Offset in bytes to start writing data to
      * @param length Length in bytes of data to write to file
-     * @param buffer Buffer to write data from
      * @param flush The flush parameters (0 == do not flush)
+     * @param buffer Buffer to read data from
      * @return Number of bytes written
      */
     size_t Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const override;
@@ -48,12 +54,21 @@ public:
     size_t GetSize() const override;
 
     /**
+     * Set the size of the file in bytes
+     * @param size New size of the file
+     * @return true if successful
+     */
+    bool SetSize(const u64 size) const override;
+
+    /**
      * Close the file
      * @return true if the file closed correctly
      */
     bool Close() const override;
 
 private:
+    std::string path;
+    Mode mode;
     FileUtil::IOFile* file;
 };
 
diff --git a/src/core/hle/kernel/archive.cpp b/src/core/hle/kernel/archive.cpp
index fa4972994..86aba7489 100644
--- a/src/core/hle/kernel/archive.cpp
+++ b/src/core/hle/kernel/archive.cpp
@@ -181,6 +181,14 @@ public:
             break;
         }
 
+        case FileCommand::SetSize:
+        {
+            u64 size = cmd_buff[1] | ((u64)cmd_buff[2] << 32);
+            DEBUG_LOG(KERNEL, "SetSize %s %s size=%d", GetTypeName().c_str(), GetName().c_str(), size);
+            backend->SetSize(size);
+            break;
+        }
+
         case FileCommand::Close:
         {
             DEBUG_LOG(KERNEL, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
@@ -366,6 +374,9 @@ Handle OpenFileFromArchive(Handle archive_handle, const std::string& path, const
     file->path = path;
     file->backend = archive->backend->OpenFile(path, mode);
 
+    if (!file->backend)
+        return 0;
+
     return handle;
 }
 
diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
index e97e7dbf7..3753f1107 100644
--- a/src/core/hle/service/apt.cpp
+++ b/src/core/hle/service/apt.cpp
@@ -73,6 +73,36 @@ void ReceiveParameter(Service::Interface* self) {
     WARN_LOG(KERNEL, "(STUBBED) called app_id=0x%08X, buffer_size=0x%08X", app_id, buffer_size);
 }
 
+/**
+* APT_U::GlanceParameter service function
+* Inputs:
+* 1 : AppID
+* 2 : Parameter buffer size, max size is 0x1000
+* Outputs:
+* 1 : Result of function, 0 on success, otherwise error code
+* 2 : Unknown, for now assume AppID of the process which sent these parameters
+* 3 : Unknown, for now assume Signal type
+* 4 : Actual parameter buffer size, this is <= to the the input size
+* 5 : Value
+* 6 : Handle from the source process which set the parameters, likely used for shared memory
+* 7 : Size
+* 8 : Output parameter buffer ptr
+*/
+void GlanceParameter(Service::Interface* self) {
+    u32* cmd_buff = Service::GetCommandBuffer();
+    u32 app_id = cmd_buff[1];
+    u32 buffer_size = cmd_buff[2];
+    cmd_buff[1] = 0; // No error
+    cmd_buff[2] = 0;
+    cmd_buff[3] = static_cast<u32>(SignalType::AppJustStarted); // Signal type
+    cmd_buff[4] = 0;
+    cmd_buff[5] = 0;
+    cmd_buff[6] = 0;
+    cmd_buff[7] = 0;
+    cmd_buff[8] = 0;
+    WARN_LOG(KERNEL, "(STUBBED) called app_id=0x%08X, buffer_size=0x%08X", app_id, buffer_size);
+}
+
 const Interface::FunctionInfo FunctionTable[] = {
     {0x00010040, GetLockHandle,         "GetLockHandle"},
     {0x00020080, Initialize,            "Initialize"},
@@ -87,7 +117,7 @@ const Interface::FunctionInfo FunctionTable[] = {
     {0x000B0040, InquireNotification,   "InquireNotification"},
     {0x000C0104, nullptr,               "SendParameter"},
     {0x000D0080, ReceiveParameter,      "ReceiveParameter"},
-    {0x000E0080, nullptr,               "GlanceParameter"},
+    {0x000E0080, GlanceParameter,       "GlanceParameter"},
     {0x000F0100, nullptr,               "CancelParameter"},
     {0x001000C2, nullptr,               "DebugFunc"},
     {0x001100C0, nullptr,               "MapProgramIdForDebug"},
@@ -152,6 +182,8 @@ const Interface::FunctionInfo FunctionTable[] = {
     {0x004C0000, nullptr,               "SetFatalErrDispMode"},
     {0x004D0080, nullptr,               "GetAppletProgramInfo"},
     {0x004E0000, nullptr,               "HardwareResetAsync"},
+    {0x004F0080, nullptr,               "SetApplicationCpuTimeLimit"},
+    {0x00500040, nullptr,               "GetApplicationCpuTimeLimit"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp
index accbe84e3..614d9584d 100644
--- a/src/core/hle/service/gsp.cpp
+++ b/src/core/hle/service/gsp.cpp
@@ -358,6 +358,7 @@ const Interface::FunctionInfo FunctionTable[] = {
     {0x001C0040, nullptr,                       "SetLedForceOff"},
     {0x001D0040, nullptr,                       "SetTestCommand"},
     {0x001E0080, nullptr,                       "SetInternalPriorities"},
+    {0x001F0082, nullptr,                       "StoreDataCache"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/mem_map_funcs.cpp b/src/core/mem_map_funcs.cpp
index f510df835..90951812b 100644
--- a/src/core/mem_map_funcs.cpp
+++ b/src/core/mem_map_funcs.cpp
@@ -287,7 +287,7 @@ void Write64(const VAddr addr, const u64 data) {
 }
 
 void WriteBlock(const VAddr addr, const u8* data, const size_t size) {
-    int offset = 0;
+    u32 offset = 0;
     while (offset < (size & ~3)) {
         Write32(addr + offset, *(u32*)&data[offset]);
         offset += 4;
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
new file mode 100644
index 000000000..c486f6274
--- /dev/null
+++ b/src/core/settings.cpp
@@ -0,0 +1,11 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "settings.h"
+
+namespace Settings {
+
+Values values = {};
+
+}
diff --git a/src/core/settings.h b/src/core/settings.h
new file mode 100644
index 000000000..a84c3d4b6
--- /dev/null
+++ b/src/core/settings.h
@@ -0,0 +1,29 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Settings {
+
+struct Values {
+    int pad_a_key;
+    int pad_b_key;
+    int pad_x_key;
+    int pad_y_key;
+    int pad_l_key;
+    int pad_r_key;
+    int pad_start_key;
+    int pad_select_key;
+    int pad_home_key;
+    int pad_dup_key;
+    int pad_ddown_key;
+    int pad_dleft_key;
+    int pad_dright_key;
+    int pad_sup_key;
+    int pad_sdown_key;
+    int pad_sleft_key;
+    int pad_sright_key;
+} extern values;
+
+}