Atmosphere/stratosphere/ams_mitm/source/fs_mitm/fs_path_utils.cpp

270 lines
7.9 KiB
C++
Raw Normal View History

2019-03-22 16:51:47 +00:00
/*
2019-04-08 02:00:49 +00:00
* Copyright (c) 2018-2019 Atmosphère-NX
2019-03-22 16:51:47 +00:00
*
* 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 <cstring>
2019-03-22 18:52:03 +00:00
#include <cstdlib>
2019-03-22 16:51:47 +00:00
#include <switch.h>
#include <stratosphere.hpp>
2019-03-22 16:51:47 +00:00
#include "fs_path_utils.hpp"
Result FsPathUtils::VerifyPath(const char *path, size_t max_path_len, size_t max_name_len) {
const char *cur = path;
size_t name_len = 0;
for (size_t path_len = 0; path_len <= max_path_len && name_len <= max_name_len; path_len++) {
const char c = *(cur++);
2019-03-22 16:51:47 +00:00
/* If terminated, we're done. */
if (c == 0) {
2019-03-29 05:39:39 +00:00
return ResultSuccess;
2019-03-22 16:51:47 +00:00
}
/* TODO: Nintendo converts the path from utf-8 to utf-32, one character at a time. */
/* We should do this. */
/* Banned characters: :*?<>| */
if (c == ':' || c == '*' || c == '?' || c == '<' || c == '>' || c == '|') {
return ResultFsInvalidCharacter;
}
name_len++;
/* Check for separator. */
if (c == '/' || c == '\\') {
name_len = 0;
}
}
return ResultFsTooLongPath;
}
Result FsPathUtils::ConvertPathForServiceObject(FsPath *out, const char *path) {
/* Check for nullptr. */
if (out == nullptr || path == nullptr) {
return ResultFsInvalidPath;
}
/* Copy string, NULL terminate. */
/* NOTE: Nintendo adds an extra char at 0x301 for NULL terminator */
/* But then forces 0x300 to NULL anyway... */
std::strncpy(out->str, path, sizeof(out->str) - 1);
out->str[sizeof(out->str)-1] = 0;
/* Replace any instances of \ with / */
for (size_t i = 0; i < sizeof(out->str); i++) {
if (out->str[i] == '\\') {
out->str[i] = '/';
}
}
/* Nintendo allows some liberties if the path is a windows path. Who knows why... */
const auto prefix_len = FsPathUtils::IsWindowsAbsolutePath(path) ? 2 : 0;
const size_t max_len = (FS_MAX_PATH-1) - prefix_len;
return FsPathUtils::VerifyPath(out->str + prefix_len, max_len, max_len);
}
Result FsPathUtils::IsNormalized(bool *out, const char *path) {
/* Nintendo uses a state machine here. */
enum class PathState {
Start,
Normal,
FirstSeparator,
Separator,
CurrentDir,
ParentDir,
WindowsDriveLetter,
};
2019-06-20 11:04:33 +00:00
PathState state = PathState::Start;
2019-06-20 11:04:33 +00:00
for (const char *cur = path; *cur != 0; cur++) {
const char c = *cur;
switch (state) {
case PathState::Start:
if (IsWindowsDriveLetter(c)) {
state = PathState::WindowsDriveLetter;
} else if (c == '/') {
state = PathState::FirstSeparator;
} else {
return ResultFsInvalidPathFormat;
}
break;
case PathState::Normal:
if (c == '/') {
state = PathState::Separator;
}
break;
case PathState::FirstSeparator:
case PathState::Separator:
/* It is unclear why first separator and separator are separate states... */
if (c == '/') {
*out = false;
2019-03-29 05:39:39 +00:00
return ResultSuccess;
} else if (c == '.') {
state = PathState::CurrentDir;
} else {
state = PathState::Normal;
}
break;
case PathState::CurrentDir:
if (c == '/') {
*out = false;
2019-03-29 05:39:39 +00:00
return ResultSuccess;
} else if (c == '.') {
state = PathState::ParentDir;
} else {
state = PathState::Normal;
}
break;
case PathState::ParentDir:
if (c == '/') {
*out = false;
2019-03-29 05:39:39 +00:00
return ResultSuccess;
} else {
state = PathState::Normal;
}
break;
case PathState::WindowsDriveLetter:
if (c == ':') {
*out = true;
2019-03-29 05:39:39 +00:00
return ResultSuccess;
} else {
return ResultFsInvalidPathFormat;
}
break;
}
}
2019-06-20 11:04:33 +00:00
switch (state) {
case PathState::Start:
case PathState::WindowsDriveLetter:
return ResultFsInvalidPathFormat;
case PathState::FirstSeparator:
case PathState::Normal:
2019-03-26 16:05:19 +00:00
*out = true;
break;
case PathState::CurrentDir:
case PathState::ParentDir:
2019-03-26 16:05:19 +00:00
case PathState::Separator:
*out = false;
break;
}
2019-06-20 11:04:33 +00:00
2019-03-29 05:39:39 +00:00
return ResultSuccess;
}
2019-03-22 18:52:03 +00:00
Result FsPathUtils::Normalize(char *out, size_t max_out_size, const char *src, size_t *out_len) {
/* Paths must start with / */
if (src[0] != '/') {
return ResultFsInvalidPathFormat;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
bool skip_next_sep = false;
size_t i = 0;
size_t len = 0;
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
while (src[i] != 0) {
if (src[i] == '/') {
/* Swallow separators. */
while (src[++i] == '/') { }
if (src[i] == 0) {
break;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
/* Handle skip if needed */
if (!skip_next_sep) {
if (len + 1 == max_out_size) {
out[len] = 0;
2019-03-22 21:49:07 +00:00
if (out_len != nullptr) {
*out_len = len;
}
2019-03-22 18:52:03 +00:00
return ResultFsTooLongPath;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
out[len++] = '/';
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
/* TODO: N has some weird windows support stuff here under a bool. */
/* Boolean is normally false though? */
}
skip_next_sep = false;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
/* See length of current dir. */
size_t dir_len = 0;
while (src[i+dir_len] != '/' && src[i+dir_len] != 0) {
dir_len++;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
if (FsPathUtils::IsCurrentDirectory(&src[i])) {
skip_next_sep = true;
} else if (FsPathUtils::IsParentDirectory(&src[i])) {
if (len == 1) {
return ResultFsDirectoryUnobtainable;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
/* Walk up a directory. */
len -= 2;
while (out[len] != '/') {
len--;
}
} else {
/* Copy, possibly truncating. */
if (len + dir_len + 1 <= max_out_size) {
for (size_t j = 0; j < dir_len; j++) {
out[len++] = src[i+j];
}
} else {
const size_t copy_len = max_out_size - 1 - len;
for (size_t j = 0; j < copy_len; j++) {
out[len++] = src[i+j];
}
out[len] = 0;
2019-03-22 21:49:07 +00:00
if (out_len != nullptr) {
*out_len = len;
}
2019-03-22 18:52:03 +00:00
return ResultFsTooLongPath;
}
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
i += dir_len;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
if (skip_next_sep) {
len--;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
if (len == 0 && max_out_size) {
out[len++] = '/';
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
if (max_out_size < len - 1) {
return ResultFsTooLongPath;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
/* NULL terminate. */
out[len] = 0;
2019-03-22 21:49:07 +00:00
if (out_len != nullptr) {
*out_len = len;
}
2019-06-20 11:04:33 +00:00
2019-03-22 18:52:03 +00:00
/* Assert normalized. */
bool normalized = false;
2019-06-20 11:04:33 +00:00
R_ASSERT(FsPathUtils::IsNormalized(&normalized, out));
if (!normalized) {
2019-03-22 18:52:03 +00:00
std::abort();
}
2019-06-20 11:04:33 +00:00
2019-03-29 05:39:39 +00:00
return ResultSuccess;
}