121 Source/Core/Core/IOS/WFS/WFSSRV.cpp
View file
@@ -41,18 +41,18 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)
{
case IOCTL_WFS_INIT:
// TODO(wfs): Implement.
INFO_LOG(IOS_WFS, "IOCTL_WFS_INIT");
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_INIT");
break;

case IOCTL_WFS_UNKNOWN_8:
// TODO(wfs): Figure out what this actually does.
INFO_LOG(IOS_WFS, "IOCTL_WFS_UNKNOWN_8");
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_UNKNOWN_8");
Memory::Write_U8(7, request.buffer_out);
Memory::CopyToEmu(request.buffer_out + 1, "msc01\x00\x00\x00", 8);
break;

case IOCTL_WFS_SHUTDOWN:
INFO_LOG(IOS_WFS, "IOCTL_WFS_SHUTDOWN");
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_SHUTDOWN");

// Close all hanging attach/detach ioctls with an appropriate error code.
for (auto address : m_hanging)
@@ -66,118 +66,119 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)
break;

case IOCTL_WFS_DEVICE_INFO:
INFO_LOG(IOS_WFS, "IOCTL_WFS_DEVICE_INFO");
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_DEVICE_INFO");
Memory::Write_U64(16ull << 30, request.buffer_out); // 16GB storage.
Memory::Write_U8(4, request.buffer_out + 8);
break;

case IOCTL_WFS_GET_DEVICE_NAME:
{
INFO_LOG(IOS_WFS, "IOCTL_WFS_GET_DEVICE_NAME");
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_DEVICE_NAME");
Memory::Write_U8(static_cast<u8>(m_device_name.size()), request.buffer_out);
Memory::CopyToEmu(request.buffer_out + 1, m_device_name.data(), m_device_name.size());
break;
}

case IOCTL_WFS_ATTACH_DETACH_2:
// TODO(wfs): Implement.
INFO_LOG(IOS_WFS, "IOCTL_WFS_ATTACH_DETACH_2(%u)", request.request);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_ATTACH_DETACH_2({})", request.request);
Memory::Write_U32(1, request.buffer_out);
Memory::Write_U32(0, request.buffer_out + 4); // device id?
Memory::Write_U32(0, request.buffer_out + 8);
break;

case IOCTL_WFS_ATTACH_DETACH:
INFO_LOG(IOS_WFS, "IOCTL_WFS_ATTACH_DETACH(%u)", request.request);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_ATTACH_DETACH({})", request.request);

// Leave hanging, but we need to acknowledge the request at shutdown time.
m_hanging.push_back(request.address);
return GetNoReply();

case IOCTL_WFS_FLUSH:
// Nothing to do.
INFO_LOG(IOS_WFS, "IOCTL_WFS_FLUSH: doing nothing");
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_FLUSH: doing nothing");
break;

case IOCTL_WFS_MKDIR:
{
std::string path = NormalizePath(
const std::string path = NormalizePath(
Memory::GetString(request.buffer_in + 34, Memory::Read_U16(request.buffer_in + 32)));
std::string native_path = WFS::NativePath(path);
const std::string native_path = WFS::NativePath(path);

if (File::Exists(native_path))
{
INFO_LOG(IOS_WFS, "IOCTL_WFS_MKDIR(%s): already exists", path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_MKDIR({}): already exists", path);
return_error_code = WFS_EEXIST;
}
else if (!File::CreateDir(native_path))
{
INFO_LOG(IOS_WFS, "IOCTL_WFS_MKDIR(%s): no such file or directory", path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_MKDIR({}): no such file or directory", path);
return_error_code = WFS_ENOENT;
}
else
{
INFO_LOG(IOS_WFS, "IOCTL_WFS_MKDIR(%s): directory created", path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_MKDIR({}): directory created", path);
}
break;
}

// TODO(wfs): Globbing is not really implemented, we just fake the one case
// (listing /vol/*) which is required to get the installer to work.
case IOCTL_WFS_GLOB_START:
INFO_LOG(IOS_WFS, "IOCTL_WFS_GLOB_START(%u)", request.request);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GLOB_START({})", request.request);
Memory::Memset(request.buffer_out, 0, request.buffer_out_size);
Memory::CopyToEmu(request.buffer_out + 0x14, m_device_name.data(), m_device_name.size());
break;

case IOCTL_WFS_GLOB_NEXT:
INFO_LOG(IOS_WFS, "IOCTL_WFS_GLOB_NEXT(%u)", request.request);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GLOB_NEXT({})", request.request);
return_error_code = WFS_ENOENT;
break;

case IOCTL_WFS_GLOB_END:
INFO_LOG(IOS_WFS, "IOCTL_WFS_GLOB_END(%u)", request.request);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GLOB_END({})", request.request);
Memory::Memset(request.buffer_out, 0, request.buffer_out_size);
break;

case IOCTL_WFS_SET_HOMEDIR:
m_home_directory =
Memory::GetString(request.buffer_in + 2, Memory::Read_U16(request.buffer_in));
INFO_LOG(IOS_WFS, "IOCTL_WFS_SET_HOMEDIR: %s", m_home_directory.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_SET_HOMEDIR: {}", m_home_directory);
break;

case IOCTL_WFS_CHDIR:
m_current_directory =
Memory::GetString(request.buffer_in + 2, Memory::Read_U16(request.buffer_in));
INFO_LOG(IOS_WFS, "IOCTL_WFS_CHDIR: %s", m_current_directory.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_CHDIR: {}", m_current_directory);
break;

case IOCTL_WFS_GET_HOMEDIR:
INFO_LOG(IOS_WFS, "IOCTL_WFS_GET_HOMEDIR: %s", m_home_directory.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_HOMEDIR: {}", m_home_directory);
Memory::Write_U16(static_cast<u16>(m_home_directory.size()), request.buffer_out);
Memory::CopyToEmu(request.buffer_out + 2, m_home_directory.data(), m_home_directory.size());
break;

case IOCTL_WFS_GET_ATTRIBUTES:
{
std::string path = NormalizePath(
const std::string path = NormalizePath(
Memory::GetString(request.buffer_in + 2, Memory::Read_U16(request.buffer_in)));
std::string native_path = WFS::NativePath(path);
const std::string native_path = WFS::NativePath(path);

Memory::Memset(0, request.buffer_out, request.buffer_out_size);
if (!File::Exists(native_path))
{
INFO_LOG(IOS_WFS, "IOCTL_WFS_GET_ATTRIBUTES(%s): no such file or directory", path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_ATTRIBUTES({}): no such file or directory", path);
return_error_code = WFS_ENOENT;
}
else if (File::IsDirectory(native_path))
{
INFO_LOG(IOS_WFS, "IOCTL_WFS_GET_ATTRIBUTES(%s): directory", path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_ATTRIBUTES({}): directory", path);
Memory::Write_U32(0x80000000, request.buffer_out + 4);
}
else
{
u32 size = static_cast<u32>(File::GetSize(native_path));
INFO_LOG(IOS_WFS, "IOCTL_WFS_GET_ATTRIBUTES(%s): file with size %d", path.c_str(), size);
const auto size = static_cast<u32>(File::GetSize(native_path));
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_ATTRIBUTES({}): file with size {}", path, size);
Memory::Write_U32(size, request.buffer_out);
}
break;
@@ -199,13 +200,13 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)
{
const char* ioctl_name =
request.request == IOCTL_WFS_OPEN ? "IOCTL_WFS_OPEN" : "IOCTL_WFS_CREATE_OPEN";
u32 mode = request.request == IOCTL_WFS_OPEN ? Memory::Read_U32(request.buffer_in) : 2;
u16 path_len = Memory::Read_U16(request.buffer_in + 0x20);
const u32 mode = request.request == IOCTL_WFS_OPEN ? Memory::Read_U32(request.buffer_in) : 2;
const u16 path_len = Memory::Read_U16(request.buffer_in + 0x20);
std::string path = Memory::GetString(request.buffer_in + 0x22, path_len);

path = NormalizePath(path);

u16 fd = GetNewFileDescriptor();
const u16 fd = GetNewFileDescriptor();
FileDescriptor* fd_obj = &m_fds[fd];
fd_obj->in_use = true;
fd_obj->path = path;
@@ -214,13 +215,13 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)

if (!fd_obj->Open())
{
ERROR_LOG(IOS_WFS, "%s(%s, %d): error opening file", ioctl_name, path.c_str(), mode);
ERROR_LOG_FMT(IOS_WFS, "{}({}, {}): error opening file", ioctl_name, path, mode);
ReleaseFileDescriptor(fd);
return_error_code = WFS_ENOENT;
break;
}

INFO_LOG(IOS_WFS, "%s(%s, %d) -> %d", ioctl_name, path.c_str(), mode, fd);
INFO_LOG_FMT(IOS_WFS, "{}({}, {}) -> {}", ioctl_name, path, mode, fd);
if (request.request == IOCTL_WFS_OPEN)
{
Memory::Write_U16(fd, request.buffer_out + 0x14);
@@ -234,30 +235,30 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)

case IOCTL_WFS_GET_SIZE:
{
u16 fd = Memory::Read_U16(request.buffer_in);
const u16 fd = Memory::Read_U16(request.buffer_in);
FileDescriptor* fd_obj = FindFileDescriptor(fd);
if (fd_obj == nullptr)
{
ERROR_LOG(IOS_WFS, "IOCTL_WFS_GET_SIZE: invalid file descriptor %d", fd);
ERROR_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_SIZE: invalid file descriptor {}", fd);
return_error_code = WFS_EBADFD;
break;
}

u64 size = fd_obj->file.GetSize();
u32 truncated_size = static_cast<u32>(size);
INFO_LOG(IOS_WFS, "IOCTL_WFS_GET_SIZE(%d) -> %d", fd, truncated_size);
const u64 size = fd_obj->file.GetSize();
const u32 truncated_size = static_cast<u32>(size);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_SIZE({}) -> {}", fd, truncated_size);
if (size != truncated_size)
{
ERROR_LOG(IOS_WFS, "IOCTL_WFS_GET_SIZE: file %d too large (%" PRIu64 ")", fd, size);
ERROR_LOG_FMT(IOS_WFS, "IOCTL_WFS_GET_SIZE: file {} too large ({})", fd, size);
}
Memory::Write_U32(truncated_size, request.buffer_out);
break;
}

case IOCTL_WFS_CLOSE:
{
u16 fd = Memory::Read_U16(request.buffer_in + 0x4);
INFO_LOG(IOS_WFS, "IOCTL_WFS_CLOSE(%d)", fd);
const u16 fd = Memory::Read_U16(request.buffer_in + 0x4);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_CLOSE({})", fd);
ReleaseFileDescriptor(fd);
break;
}
@@ -266,31 +267,31 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)
{
// TODO(wfs): Figure out the exact semantics difference from the other
// close.
u16 fd = Memory::Read_U16(request.buffer_in + 0x4);
INFO_LOG(IOS_WFS, "IOCTL_WFS_CLOSE_2(%d)", fd);
const u16 fd = Memory::Read_U16(request.buffer_in + 0x4);
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_CLOSE_2({})", fd);
ReleaseFileDescriptor(fd);
break;
}

case IOCTL_WFS_READ:
case IOCTL_WFS_READ_ABSOLUTE:
{
u32 addr = Memory::Read_U32(request.buffer_in);
u32 position = Memory::Read_U32(request.buffer_in + 4); // Only for absolute.
u16 fd = Memory::Read_U16(request.buffer_in + 0xC);
u32 size = Memory::Read_U32(request.buffer_in + 8);
const u32 addr = Memory::Read_U32(request.buffer_in);
const u32 position = Memory::Read_U32(request.buffer_in + 4); // Only for absolute.
const u16 fd = Memory::Read_U16(request.buffer_in + 0xC);
const u32 size = Memory::Read_U32(request.buffer_in + 8);

bool absolute = request.request == IOCTL_WFS_READ_ABSOLUTE;
const bool absolute = request.request == IOCTL_WFS_READ_ABSOLUTE;

FileDescriptor* fd_obj = FindFileDescriptor(fd);
if (fd_obj == nullptr)
{
ERROR_LOG(IOS_WFS, "IOCTL_WFS_READ: invalid file descriptor %d", fd);
ERROR_LOG_FMT(IOS_WFS, "IOCTL_WFS_READ: invalid file descriptor {}", fd);
return_error_code = WFS_EBADFD;
break;
}

u64 previous_position = fd_obj->file.Tell();
const u64 previous_position = fd_obj->file.Tell();
if (absolute)
{
fd_obj->file.Seek(position, SEEK_SET);
@@ -307,31 +308,31 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)
fd_obj->position += read_bytes;
}

INFO_LOG(IOS_WFS, "IOCTL_WFS_READ: read %zd bytes from FD %d (%s)", read_bytes, fd,
fd_obj->path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_READ: read {} bytes from FD {} ({})", read_bytes, fd,
fd_obj->path);
return_error_code = static_cast<int>(read_bytes);
break;
}

case IOCTL_WFS_WRITE:
case IOCTL_WFS_WRITE_ABSOLUTE:
{
u32 addr = Memory::Read_U32(request.buffer_in);
u32 position = Memory::Read_U32(request.buffer_in + 4); // Only for absolute.
u16 fd = Memory::Read_U16(request.buffer_in + 0xC);
u32 size = Memory::Read_U32(request.buffer_in + 8);
const u32 addr = Memory::Read_U32(request.buffer_in);
const u32 position = Memory::Read_U32(request.buffer_in + 4); // Only for absolute.
const u16 fd = Memory::Read_U16(request.buffer_in + 0xC);
const u32 size = Memory::Read_U32(request.buffer_in + 8);

bool absolute = request.request == IOCTL_WFS_WRITE_ABSOLUTE;
const bool absolute = request.request == IOCTL_WFS_WRITE_ABSOLUTE;

FileDescriptor* fd_obj = FindFileDescriptor(fd);
if (fd_obj == nullptr)
{
ERROR_LOG(IOS_WFS, "IOCTL_WFS_WRITE: invalid file descriptor %d", fd);
ERROR_LOG_FMT(IOS_WFS, "IOCTL_WFS_WRITE: invalid file descriptor {}", fd);
return_error_code = WFS_EBADFD;
break;
}

u64 previous_position = fd_obj->file.Tell();
const u64 previous_position = fd_obj->file.Tell();
if (absolute)
{
fd_obj->file.Seek(position, SEEK_SET);
@@ -347,8 +348,8 @@ IPCCommandResult WFSSRV::IOCtl(const IOCtlRequest& request)
fd_obj->position += size;
}

INFO_LOG(IOS_WFS, "IOCTL_WFS_WRITE: written %d bytes from FD %d (%s)", size, fd,
fd_obj->path.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_WRITE: written {} bytes from FD {} ({})", size, fd,
fd_obj->path);
break;
}

@@ -368,7 +369,7 @@ s32 WFSSRV::Rename(std::string source, std::string dest) const
source = NormalizePath(source);
dest = NormalizePath(dest);

INFO_LOG(IOS_WFS, "IOCTL_WFS_RENAME: %s to %s", source.c_str(), dest.c_str());
INFO_LOG_FMT(IOS_WFS, "IOCTL_WFS_RENAME: {} to {}", source, dest);

const bool opened = std::any_of(m_fds.begin(), m_fds.end(),
[&](const auto& fd) { return fd.in_use && fd.path == source; });
@@ -480,7 +481,7 @@ bool WFSSRV::FileDescriptor::Open()
}
else
{
ERROR_LOG(IOS_WFS, "WFSOpen: invalid mode %d", mode);
ERROR_LOG_FMT(IOS_WFS, "WFSOpen: invalid mode {}", mode);
return false;
}