izzy/dolphin
0
0
Fork 0
mirror of https://github.com/izzy2lost/dolphin.git synced 2026-06-19 01:16:48 -07:00
Code Issues Packages Projects Releases Wiki Activity

Update log types names from IPC_HLE to IOS

Browse Source 
For consistency with the other changes.

WII_IPC_DVD was changed to IOS_DI, as this describes what the log type
is used for in a more specific way.
This commit is contained in:
Léo Lam
2017-01-18 21:43:37 +01:00
parent 49b9c723e2
commit ef5a855b8e
33 changed files with 796 additions and 819 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Core/Common/Logging/Log.h
+11 -11
View File
@@ -27,6 +27,17 @@ enum LOG_TYPE
GDB_STUB,
GPFIFO,
HOST_GPU,
IOS,
IOS_DI,
IOS_ES,
IOS_FILEIO,
IOS_HID,
IOS_NET,
IOS_SD,
IOS_SSL,
IOS_STM,
IOS_WC24,
IOS_WIIMOTE,
MASTER_LOG,
MEMMAP,
MEMCARD_MANAGER,
@@ -42,17 +53,6 @@ enum LOG_TYPE
VIDEO,
VIDEOINTERFACE,
WII_IPC,
WII_IPC_DVD,
WII_IPC_ES,
WII_IPC_FILEIO,
WII_IPC_HID,
WII_IPC_HLE,
WII_IPC_NET,
WII_IPC_SD,
WII_IPC_SSL,
WII_IPC_STM,
WII_IPC_WC24,
WII_IPC_WIIMOTE,
WIIMOTE,
NUMBER_OF_LOGS // Must be last
Source/Core/Common/Logging/LogManager.cpp
+11 -11
View File
@@ -61,6 +61,17 @@ LogManager::LogManager()
m_Log[LogTypes::GDB_STUB] = new LogContainer("GDB_STUB", "GDB Stub");
m_Log[LogTypes::GPFIFO] = new LogContainer("GP", "GPFifo");
m_Log[LogTypes::HOST_GPU] = new LogContainer("Host GPU", "Host GPU");
m_Log[LogTypes::IOS] = new LogContainer("IOS", "IOS");
m_Log[LogTypes::IOS_DI] = new LogContainer("IOS_DI", "IOS - Drive Interface");
m_Log[LogTypes::IOS_ES] = new LogContainer("IOS_ES", "IOS - ETicket Services");
m_Log[LogTypes::IOS_FILEIO] = new LogContainer("IOS_FILEIO", "IOS - FileIO");
m_Log[LogTypes::IOS_HID] = new LogContainer("IOS_HID", "IOS - USB_HID");
m_Log[LogTypes::IOS_SD] = new LogContainer("IOS_SD", "IOS - SDIO");
m_Log[LogTypes::IOS_SSL] = new LogContainer("IOS_SSL", "IOS - SSL");
m_Log[LogTypes::IOS_STM] = new LogContainer("IOS_STM", "IOS - State Transition Manager");
m_Log[LogTypes::IOS_NET] = new LogContainer("IOS_NET", "IOS - Network");
m_Log[LogTypes::IOS_WC24] = new LogContainer("IOS_WC24", "IOS - WiiConnect24");
m_Log[LogTypes::IOS_WIIMOTE] = new LogContainer("IOS_WIIMOTE", "IOS - Wii Remote");
m_Log[LogTypes::MASTER_LOG] = new LogContainer("*", "Master Log");
m_Log[LogTypes::MEMCARD_MANAGER] = new LogContainer("MemCard Manager", "MemCard Manager");
m_Log[LogTypes::MEMMAP] = new LogContainer("MI", "MI & memmap");
@@ -77,17 +88,6 @@ LogManager::LogManager()
m_Log[LogTypes::VIDEOINTERFACE] = new LogContainer("VI", "Video Interface (VI)");
m_Log[LogTypes::WIIMOTE] = new LogContainer("Wiimote", "Wiimote");
m_Log[LogTypes::WII_IPC] = new LogContainer("WII_IPC", "WII IPC");
m_Log[LogTypes::WII_IPC_DVD] = new LogContainer("WII_IPC_DVD", "WII IPC DVD");
m_Log[LogTypes::WII_IPC_ES] = new LogContainer("WII_IPC_ES", "WII IPC ES");
m_Log[LogTypes::WII_IPC_FILEIO] = new LogContainer("WII_IPC_FILEIO", "WII IPC FILEIO");
m_Log[LogTypes::WII_IPC_HID] = new LogContainer("WII_IPC_HID", "WII IPC HID");
m_Log[LogTypes::WII_IPC_HLE] = new LogContainer("WII_IPC_HLE", "WII IPC HLE");
m_Log[LogTypes::WII_IPC_SD] = new LogContainer("WII_IPC_SD", "WII IPC SD");
m_Log[LogTypes::WII_IPC_SSL] = new LogContainer("WII_IPC_SSL", "WII IPC SSL");
m_Log[LogTypes::WII_IPC_STM] = new LogContainer("WII_IPC_STM", "WII IPC STM");
m_Log[LogTypes::WII_IPC_NET] = new LogContainer("WII_IPC_NET", "WII IPC NET");
m_Log[LogTypes::WII_IPC_WC24] = new LogContainer("WII_IPC_WC24", "WII IPC WC24");
m_Log[LogTypes::WII_IPC_WIIMOTE] = new LogContainer("WII_IPC_WIIMOTE", "WII IPC WIIMOTE");
RegisterListener(LogListener::FILE_LISTENER,
new FileLogListener(File::GetUserPath(F_MAINLOG_IDX)));
Source/Core/Core/HW/DVDInterface.cpp
+2 -2
View File
@@ -729,7 +729,7 @@ bool ExecuteReadCommand(u64 DVD_offset, u32 output_address, u32 DVD_length, u32
void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_address,
u32 output_length, bool reply_to_ios)
{
ReplyType reply_type = reply_to_ios ? ReplyType::IOS_HLE : ReplyType::Interrupt;
ReplyType reply_type = reply_to_ios ? ReplyType::IOS : ReplyType::Interrupt;
DIInterruptType interrupt_type = INT_TCINT;
s64 ticks_until_completion = SystemTimers::GetTicksPerSecond() / 15000;
bool command_handled_by_thread = false;
@@ -1153,7 +1153,7 @@ void FinishExecutingCommand(ReplyType reply_type, DIInterruptType interrupt_type
break;
}
case ReplyType::IOS_HLE:
case ReplyType::IOS:
{
auto di = IOS::HLE::GetDeviceByName("/dev/di");
if (di)
Source/Core/Core/HW/DVDInterface.h
+1 -1
View File
@@ -96,7 +96,7 @@ enum DIInterruptType : int
enum class ReplyType : u32
{
Interrupt,
IOS_HLE,
IOS,
DTK
};
Source/Core/Core/HW/WiimoteEmu/Speaker.cpp
+1 -1
View File
@@ -110,7 +110,7 @@ void Wiimote::SpeakerData(wm_speaker_data* sd)
}
else
{
ERROR_LOG(WII_IPC_WIIMOTE, "Unknown speaker format %x", m_reg_speaker.format);
ERROR_LOG(IOS_WIIMOTE, "Unknown speaker format %x", m_reg_speaker.format);
return;
}
Source/Core/Core/IOS/DI/DI.cpp
+5 -6
View File
@@ -36,7 +36,7 @@ void DI::DoState(PointerWrap& p)
IPCCommandResult DI::IOCtl(const IOSIOCtlRequest& request)
{
// DI IOCtls are handled in a special way by Dolphin
// compared to other WII_IPC_HLE functions.
// compared to other IOS functions.
// This is a wrapper around DVDInterface's ExecuteCommand,
// which will execute commands more or less asynchronously.
// Only one command can be executed at a time, so commands
@@ -95,15 +95,14 @@ IPCCommandResult DI::IOCtlV(const IOSIOCtlVRequest& request)
{
case DVDInterface::DVDLowOpenPartition:
{
_dbg_assert_msg_(WII_IPC_DVD, request.in_vectors[1].address == 0,
"DVDLowOpenPartition with ticket");
_dbg_assert_msg_(WII_IPC_DVD, request.in_vectors[2].address == 0,
_dbg_assert_msg_(IOS_DI, request.in_vectors[1].address == 0, "DVDLowOpenPartition with ticket");
_dbg_assert_msg_(IOS_DI, request.in_vectors[2].address == 0,
"DVDLowOpenPartition with cert chain");
u64 const partition_offset = ((u64)Memory::Read_U32(request.in_vectors[0].address + 4) << 2);
DVDInterface::ChangePartition(partition_offset);
INFO_LOG(WII_IPC_DVD, "DVDLowOpenPartition: partition_offset 0x%016" PRIx64, partition_offset);
INFO_LOG(IOS_DI, "DVDLowOpenPartition: partition_offset 0x%016" PRIx64, partition_offset);
// Read TMD to the buffer
std::vector<u8> tmd_buffer = DVDInterface::GetVolume().GetTMD();
@@ -114,7 +113,7 @@ IPCCommandResult DI::IOCtlV(const IOSIOCtlVRequest& request)
break;
}
default:
request.DumpUnknown(GetDeviceName(), LogTypes::WII_IPC_DVD);
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_DI);
}
return GetDefaultReply(return_value);
}
Source/Core/Core/IOS/Device.cpp
+1 -1
View File
@@ -160,7 +160,7 @@ IPCCommandResult Device::Unsupported(const IOSRequest& request)
{IPC_CMD_SEEK, "Seek"},
{IPC_CMD_IOCTL, "IOCtl"},
{IPC_CMD_IOCTLV, "IOCtlV"}}};
WARN_LOG(WII_IPC_HLE, "%s does not support %s()", m_name.c_str(), names[request.command].c_str());
WARN_LOG(IOS, "%s does not support %s()", m_name.c_str(), names[request.command].c_str());
return GetDefaultReply(IPC_EINVAL);
}
Source/Core/Core/IOS/Device.h
+5 -5
View File
@@ -96,11 +96,11 @@ struct IOSIOCtlRequest final : IOSRequest
u32 buffer_out = 0;
u32 buffer_out_size = 0;
explicit IOSIOCtlRequest(u32 address);
void Log(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::WII_IPC_HLE,
void Log(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::IOS,
LogTypes::LOG_LEVELS level = LogTypes::LINFO) const;
void Dump(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::WII_IPC_HLE,
void Dump(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::IOS,
LogTypes::LOG_LEVELS level = LogTypes::LINFO) const;
void DumpUnknown(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::WII_IPC_HLE,
void DumpUnknown(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::IOS,
LogTypes::LOG_LEVELS level = LogTypes::LERROR) const;
};
@@ -122,9 +122,9 @@ struct IOSIOCtlVRequest final : IOSRequest
std::vector<IOVector> io_vectors;
explicit IOSIOCtlVRequest(u32 address);
bool HasInputVectorWithAddress(u32 vector_address) const;
void Dump(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::WII_IPC_HLE,
void Dump(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::IOS,
LogTypes::LOG_LEVELS level = LogTypes::LINFO) const;
void DumpUnknown(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::WII_IPC_HLE,
void DumpUnknown(const std::string& description, LogTypes::LOG_TYPE type = LogTypes::IOS,
LogTypes::LOG_LEVELS level = LogTypes::LERROR) const;
};
Source/Core/Core/IOS/DeviceStub.cpp
+4 -4
View File
@@ -17,26 +17,26 @@ Stub::Stub(u32 device_id, const std::string& device_name) : Device(device_id, de
IOSReturnCode Stub::Open(const IOSOpenRequest& request)
{
WARN_LOG(WII_IPC_HLE, "%s faking Open()", m_name.c_str());
WARN_LOG(IOS, "%s faking Open()", m_name.c_str());
m_is_active = true;
return IPC_SUCCESS;
}
void Stub::Close()
{
WARN_LOG(WII_IPC_HLE, "%s faking Close()", m_name.c_str());
WARN_LOG(IOS, "%s faking Close()", m_name.c_str());
m_is_active = false;
}
IPCCommandResult Stub::IOCtl(const IOSIOCtlRequest& request)
{
WARN_LOG(WII_IPC_HLE, "%s faking IOCtl()", m_name.c_str());
WARN_LOG(IOS, "%s faking IOCtl()", m_name.c_str());
return GetDefaultReply(IPC_SUCCESS);
}
IPCCommandResult Stub::IOCtlV(const IOSIOCtlVRequest& request)
{
WARN_LOG(WII_IPC_HLE, "%s faking IOCtlV()", m_name.c_str());
WARN_LOG(IOS, "%s faking IOCtlV()", m_name.c_str());
return GetDefaultReply(IPC_SUCCESS);
}
} // namespace Device
Source/Core/Core/IOS/ES/ES.cpp
+107 -120
View File
File diff suppressed because it is too large Load Diff
Source/Core/Core/IOS/FS/FS.cpp
+56 -57
View File
@@ -84,7 +84,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
if (!IsValidWiiPath(relative_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", relative_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", relative_path.c_str());
return_value = FS_EINVAL;
break;
}
@@ -92,11 +92,11 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
// the Wii uses this function to define the type (dir or file)
std::string DirName(HLE_IPC_BuildFilename(relative_path));
INFO_LOG(WII_IPC_FILEIO, "FS: IOCTL_READ_DIR %s", DirName.c_str());
INFO_LOG(IOS_FILEIO, "FS: IOCTL_READ_DIR %s", DirName.c_str());
if (!File::Exists(DirName))
{
WARN_LOG(WII_IPC_FILEIO, "FS: Search not found: %s", DirName.c_str());
WARN_LOG(IOS_FILEIO, "FS: Search not found: %s", DirName.c_str());
return_value = FS_ENOENT;
break;
}
@@ -105,7 +105,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
// It's not a directory, so error.
// Games don't usually seem to care WHICH error they get, as long as it's <
// Well the system menu CARES!
WARN_LOG(WII_IPC_FILEIO, "\tNot a directory - return FS_EINVAL");
WARN_LOG(IOS_FILEIO, "\tNot a directory - return FS_EINVAL");
return_value = FS_EINVAL;
break;
}
@@ -116,7 +116,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
if ((request.in_vectors.size() == 1) && (request.io_vectors.size() == 1))
{
size_t numFile = entry.children.size();
INFO_LOG(WII_IPC_FILEIO, "\t%zu files found", numFile);
INFO_LOG(IOS_FILEIO, "\t%zu files found", numFile);
Memory::Write_U32((u32)numFile, request.io_vectors[0].address);
}
@@ -150,7 +150,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
*pFilename++ = 0x00; // termination
numFiles++;
INFO_LOG(WII_IPC_FILEIO, "\tFound: %s", FileName.c_str());
INFO_LOG(IOS_FILEIO, "\tFound: %s", FileName.c_str());
}
Memory::Write_U32((u32)numFiles, request.io_vectors[1].address);
@@ -162,9 +162,9 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
case IOCTLV_GETUSAGE:
{
_dbg_assert_(WII_IPC_FILEIO, request.io_vectors.size() == 2);
_dbg_assert_(WII_IPC_FILEIO, request.io_vectors[0].size == 4);
_dbg_assert_(WII_IPC_FILEIO, request.io_vectors[1].size == 4);
_dbg_assert_(IOS_FILEIO, request.io_vectors.size() == 2);
_dbg_assert_(IOS_FILEIO, request.io_vectors[0].size == 4);
_dbg_assert_(IOS_FILEIO, request.io_vectors[1].size == 4);
// this command sucks because it asks of the number of used
// fsBlocks and inodes
@@ -174,7 +174,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
if (!IsValidWiiPath(relativepath))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", relativepath.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", relativepath.c_str());
return_value = FS_EINVAL;
break;
}
@@ -183,7 +183,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
u32 fsBlocks = 0;
u32 iNodes = 0;
INFO_LOG(WII_IPC_FILEIO, "IOCTL_GETUSAGE %s", path.c_str());
INFO_LOG(IOS_FILEIO, "IOCTL_GETUSAGE %s", path.c_str());
if (File::IsDirectory(path))
{
// LPFaint99: After I found that setting the number of inodes to the number of children + 1
@@ -209,14 +209,14 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
}
return_value = IPC_SUCCESS;
INFO_LOG(WII_IPC_FILEIO, "FS: fsBlock: %i, iNodes: %i", fsBlocks, iNodes);
INFO_LOG(IOS_FILEIO, "FS: fsBlock: %i, iNodes: %i", fsBlocks, iNodes);
}
else
{
fsBlocks = 0;
iNodes = 0;
return_value = IPC_SUCCESS;
WARN_LOG(WII_IPC_FILEIO, "FS: fsBlock failed, cannot find directory: %s", path.c_str());
WARN_LOG(IOS_FILEIO, "FS: fsBlock failed, cannot find directory: %s", path.c_str());
}
Memory::Write_U32(fsBlocks, request.io_vectors[0].address);
@@ -225,7 +225,7 @@ IPCCommandResult FS::IOCtlV(const IOSIOCtlVRequest& request)
break;
default:
request.DumpUnknown(GetDeviceName(), LogTypes::WII_IPC_FILEIO);
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_FILEIO);
break;
}
@@ -248,7 +248,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
if (request.buffer_out_size < 0x1c)
return -1017;
WARN_LOG(WII_IPC_FILEIO, "FS: GET STATS - returning static values for now");
WARN_LOG(IOS_FILEIO, "FS: GET STATS - returning static values for now");
NANDStat fs;
@@ -269,7 +269,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
case IOCTL_CREATE_DIR:
{
_dbg_assert_(WII_IPC_FILEIO, request.buffer_out_size == 0);
_dbg_assert_(IOS_FILEIO, request.buffer_out_size == 0);
u32 Addr = request.buffer_in;
u32 OwnerID = Memory::Read_U32(Addr);
@@ -279,7 +279,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
const std::string wii_path = Memory::GetString(Addr, 64);
if (!IsValidWiiPath(wii_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path.c_str());
return FS_EINVAL;
}
std::string DirName(HLE_IPC_BuildFilename(wii_path));
@@ -287,12 +287,12 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
Addr += 9; // owner attribs, permission
u8 Attribs = Memory::Read_U8(Addr);
INFO_LOG(WII_IPC_FILEIO, "FS: CREATE_DIR %s, OwnerID %#x, GroupID %#x, Attributes %#x",
INFO_LOG(IOS_FILEIO, "FS: CREATE_DIR %s, OwnerID %#x, GroupID %#x, Attributes %#x",
DirName.c_str(), OwnerID, GroupID, Attribs);
DirName += DIR_SEP;
File::CreateFullPath(DirName);
_dbg_assert_msg_(WII_IPC_FILEIO, File::IsDirectory(DirName), "FS: CREATE_DIR %s failed",
_dbg_assert_msg_(IOS_FILEIO, File::IsDirectory(DirName), "FS: CREATE_DIR %s failed",
DirName.c_str());
return IPC_SUCCESS;
@@ -310,7 +310,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
const std::string wii_path = Memory::GetString(Addr, 64);
if (!IsValidWiiPath(wii_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path.c_str());
return FS_EINVAL;
}
std::string Filename = HLE_IPC_BuildFilename(wii_path);
@@ -324,13 +324,13 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
u8 Attributes = Memory::Read_U8(Addr);
Addr += 1;
INFO_LOG(WII_IPC_FILEIO, "FS: SetAttrib %s", Filename.c_str());
DEBUG_LOG(WII_IPC_FILEIO, " OwnerID: 0x%08x", OwnerID);
DEBUG_LOG(WII_IPC_FILEIO, " GroupID: 0x%04x", GroupID);
DEBUG_LOG(WII_IPC_FILEIO, " OwnerPerm: 0x%02x", OwnerPerm);
DEBUG_LOG(WII_IPC_FILEIO, " GroupPerm: 0x%02x", GroupPerm);
DEBUG_LOG(WII_IPC_FILEIO, " OtherPerm: 0x%02x", OtherPerm);
DEBUG_LOG(WII_IPC_FILEIO, " Attributes: 0x%02x", Attributes);
INFO_LOG(IOS_FILEIO, "FS: SetAttrib %s", Filename.c_str());
DEBUG_LOG(IOS_FILEIO, " OwnerID: 0x%08x", OwnerID);
DEBUG_LOG(IOS_FILEIO, " GroupID: 0x%04x", GroupID);
DEBUG_LOG(IOS_FILEIO, " OwnerPerm: 0x%02x", OwnerPerm);
DEBUG_LOG(IOS_FILEIO, " GroupPerm: 0x%02x", GroupPerm);
DEBUG_LOG(IOS_FILEIO, " OtherPerm: 0x%02x", OtherPerm);
DEBUG_LOG(IOS_FILEIO, " Attributes: 0x%02x", Attributes);
return IPC_SUCCESS;
}
@@ -338,7 +338,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
case IOCTL_GET_ATTR:
{
_dbg_assert_msg_(WII_IPC_FILEIO, request.buffer_out_size == 76,
_dbg_assert_msg_(IOS_FILEIO, request.buffer_out_size == 76,
" GET_ATTR needs an 76 bytes large output buffer but it is %i bytes large",
request.buffer_out_size);
@@ -348,7 +348,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
const std::string wii_path = Memory::GetString(request.buffer_in, 64);
if (!IsValidWiiPath(wii_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path.c_str());
return FS_EINVAL;
}
std::string Filename = HLE_IPC_BuildFilename(wii_path);
@@ -358,19 +358,18 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
u8 Attributes = 0x00; // no attributes
if (File::IsDirectory(Filename))
{
INFO_LOG(WII_IPC_FILEIO, "FS: GET_ATTR Directory %s - all permission flags are set",
INFO_LOG(IOS_FILEIO, "FS: GET_ATTR Directory %s - all permission flags are set",
Filename.c_str());
}
else
{
if (File::Exists(Filename))
{
INFO_LOG(WII_IPC_FILEIO, "FS: GET_ATTR %s - all permission flags are set",
Filename.c_str());
INFO_LOG(IOS_FILEIO, "FS: GET_ATTR %s - all permission flags are set", Filename.c_str());
}
else
{
INFO_LOG(WII_IPC_FILEIO, "FS: GET_ATTR unknown %s", Filename.c_str());
INFO_LOG(IOS_FILEIO, "FS: GET_ATTR unknown %s", Filename.c_str());
return FS_ENOENT;
}
}
@@ -401,28 +400,28 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
case IOCTL_DELETE_FILE:
{
_dbg_assert_(WII_IPC_FILEIO, request.buffer_out_size == 0);
_dbg_assert_(IOS_FILEIO, request.buffer_out_size == 0);
int Offset = 0;
const std::string wii_path = Memory::GetString(request.buffer_in + Offset, 64);
if (!IsValidWiiPath(wii_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path.c_str());
return FS_EINVAL;
}
std::string Filename = HLE_IPC_BuildFilename(wii_path);
Offset += 64;
if (File::Delete(Filename))
{
INFO_LOG(WII_IPC_FILEIO, "FS: DeleteFile %s", Filename.c_str());
INFO_LOG(IOS_FILEIO, "FS: DeleteFile %s", Filename.c_str());
}
else if (File::DeleteDir(Filename))
{
INFO_LOG(WII_IPC_FILEIO, "FS: DeleteDir %s", Filename.c_str());
INFO_LOG(IOS_FILEIO, "FS: DeleteDir %s", Filename.c_str());
}
else
{
WARN_LOG(WII_IPC_FILEIO, "FS: DeleteFile %s - failed!!!", Filename.c_str());
WARN_LOG(IOS_FILEIO, "FS: DeleteFile %s - failed!!!", Filename.c_str());
}
return IPC_SUCCESS;
@@ -431,13 +430,13 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
case IOCTL_RENAME_FILE:
{
_dbg_assert_(WII_IPC_FILEIO, request.buffer_out_size == 0);
_dbg_assert_(IOS_FILEIO, request.buffer_out_size == 0);
int Offset = 0;
const std::string wii_path = Memory::GetString(request.buffer_in + Offset, 64);
if (!IsValidWiiPath(wii_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path.c_str());
return FS_EINVAL;
}
std::string Filename = HLE_IPC_BuildFilename(wii_path);
@@ -446,7 +445,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
const std::string wii_path_rename = Memory::GetString(request.buffer_in + Offset, 64);
if (!IsValidWiiPath(wii_path_rename))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path_rename.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path_rename.c_str());
return FS_EINVAL;
}
std::string FilenameRename = HLE_IPC_BuildFilename(wii_path_rename);
@@ -464,11 +463,11 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
// finally try to rename the file
if (File::Rename(Filename, FilenameRename))
{
INFO_LOG(WII_IPC_FILEIO, "FS: Rename %s to %s", Filename.c_str(), FilenameRename.c_str());
INFO_LOG(IOS_FILEIO, "FS: Rename %s to %s", Filename.c_str(), FilenameRename.c_str());
}
else
{
ERROR_LOG(WII_IPC_FILEIO, "FS: Rename %s to %s - failed", Filename.c_str(),
ERROR_LOG(IOS_FILEIO, "FS: Rename %s to %s - failed", Filename.c_str(),
FilenameRename.c_str());
return FS_ENOENT;
}
@@ -479,7 +478,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
case IOCTL_CREATE_FILE:
{
_dbg_assert_(WII_IPC_FILEIO, request.buffer_out_size == 0);
_dbg_assert_(IOS_FILEIO, request.buffer_out_size == 0);
u32 Addr = request.buffer_in;
u32 OwnerID = Memory::Read_U32(Addr);
@@ -489,7 +488,7 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
const std::string wii_path = Memory::GetString(Addr, 64);
if (!IsValidWiiPath(wii_path))
{
WARN_LOG(WII_IPC_FILEIO, "Not a valid path: %s", wii_path.c_str());
WARN_LOG(IOS_FILEIO, "Not a valid path: %s", wii_path.c_str());
return FS_EINVAL;
}
std::string Filename(HLE_IPC_BuildFilename(wii_path));
@@ -503,18 +502,18 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
u8 Attributes = Memory::Read_U8(Addr);
Addr++;
INFO_LOG(WII_IPC_FILEIO, "FS: CreateFile %s", Filename.c_str());
DEBUG_LOG(WII_IPC_FILEIO, " OwnerID: 0x%08x", OwnerID);
DEBUG_LOG(WII_IPC_FILEIO, " GroupID: 0x%04x", GroupID);
DEBUG_LOG(WII_IPC_FILEIO, " OwnerPerm: 0x%02x", OwnerPerm);
DEBUG_LOG(WII_IPC_FILEIO, " GroupPerm: 0x%02x", GroupPerm);
DEBUG_LOG(WII_IPC_FILEIO, " OtherPerm: 0x%02x", OtherPerm);
DEBUG_LOG(WII_IPC_FILEIO, " Attributes: 0x%02x", Attributes);
INFO_LOG(IOS_FILEIO, "FS: CreateFile %s", Filename.c_str());
DEBUG_LOG(IOS_FILEIO, " OwnerID: 0x%08x", OwnerID);
DEBUG_LOG(IOS_FILEIO, " GroupID: 0x%04x", GroupID);
DEBUG_LOG(IOS_FILEIO, " OwnerPerm: 0x%02x", OwnerPerm);
DEBUG_LOG(IOS_FILEIO, " GroupPerm: 0x%02x", GroupPerm);
DEBUG_LOG(IOS_FILEIO, " OtherPerm: 0x%02x", OtherPerm);
DEBUG_LOG(IOS_FILEIO, " Attributes: 0x%02x", Attributes);
// check if the file already exist
if (File::Exists(Filename))
{
INFO_LOG(WII_IPC_FILEIO, "\tresult = FS_EEXIST");
INFO_LOG(IOS_FILEIO, "\tresult = FS_EEXIST");
return FS_EEXIST;
}
@@ -523,23 +522,23 @@ s32 FS::ExecuteCommand(const IOSIOCtlRequest& request)
bool Result = File::CreateEmptyFile(Filename);
if (!Result)
{
ERROR_LOG(WII_IPC_FILEIO, "FS: couldn't create new file");
ERROR_LOG(IOS_FILEIO, "FS: couldn't create new file");
PanicAlert("FS: couldn't create new file");
return FS_EINVAL;
}
INFO_LOG(WII_IPC_FILEIO, "\tresult = IPC_SUCCESS");
INFO_LOG(IOS_FILEIO, "\tresult = IPC_SUCCESS");
return IPC_SUCCESS;
}
break;
case IOCTL_SHUTDOWN:
{
INFO_LOG(WII_IPC_FILEIO, "Wii called Shutdown()");
INFO_LOG(IOS_FILEIO, "Wii called Shutdown()");
// TODO: stop emulation
}
break;
default:
request.DumpUnknown(GetDeviceName(), LogTypes::WII_IPC_FILEIO);
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_FILEIO);
}
return FS_EINVAL;
Source/Core/Core/IOS/FS/FileIO.cpp
+16 -17
View File
@@ -78,7 +78,7 @@ FileIO::FileIO(u32 device_id, const std::string& device_name)
void FileIO::Close()
{
INFO_LOG(WII_IPC_FILEIO, "FileIO: Close %s (DeviceID=%08x)", m_name.c_str(), m_device_id);
INFO_LOG(IOS_FILEIO, "FileIO: Close %s (DeviceID=%08x)", m_name.c_str(), m_device_id);
m_Mode = 0;
// Let go of our pointer to the file, it will automatically close if we are the last handle
@@ -100,12 +100,12 @@ IOSReturnCode FileIO::Open(const IOSOpenRequest& request)
// It should be created by ISFS_CreateFile, not here
if (!File::Exists(m_filepath) || File::IsDirectory(m_filepath))
{
WARN_LOG(WII_IPC_FILEIO, "FileIO: Open (%s) failed - File doesn't exist %s", Modes[m_Mode],
WARN_LOG(IOS_FILEIO, "FileIO: Open (%s) failed - File doesn't exist %s", Modes[m_Mode],
m_filepath.c_str());
return FS_ENOENT;
}
INFO_LOG(WII_IPC_FILEIO, "FileIO: Open %s (%s == %08X)", m_name.c_str(), Modes[m_Mode], m_Mode);
INFO_LOG(IOS_FILEIO, "FileIO: Open %s (%s == %08X)", m_name.c_str(), Modes[m_Mode], m_Mode);
OpenFile();
m_is_active = true;
@@ -163,8 +163,8 @@ IPCCommandResult FileIO::Seek(const IOSSeekRequest& request)
if (m_file->IsOpen())
{
const u32 file_size = static_cast<u32>(m_file->GetSize());
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: Seek Pos: 0x%08x, Mode: %i (%s, Length=0x%08x)",
request.offset, request.mode, m_name.c_str(), file_size);
DEBUG_LOG(IOS_FILEIO, "FileIO: Seek Pos: 0x%08x, Mode: %i (%s, Length=0x%08x)", request.offset,
request.mode, m_name.c_str(), file_size);
switch (request.mode)
{
@@ -222,13 +222,12 @@ IPCCommandResult FileIO::Read(const IOSReadWriteRequest& request)
{
if (m_Mode == IOS_OPEN_WRITE)
{
WARN_LOG(WII_IPC_FILEIO,
"FileIO: Attempted to read 0x%x bytes to 0x%08x on a write-only file %s",
WARN_LOG(IOS_FILEIO, "FileIO: Attempted to read 0x%x bytes to 0x%08x on a write-only file %s",
request.size, request.buffer, m_name.c_str());
}
else
{
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: Read 0x%x bytes to 0x%08x from %s", request.size,
DEBUG_LOG(IOS_FILEIO, "FileIO: Read 0x%x bytes to 0x%08x from %s", request.size,
request.buffer, m_name.c_str());
m_file->Seek(m_SeekPos, SEEK_SET); // File might be opened twice, need to seek before we read
return_value = static_cast<u32>(
@@ -245,8 +244,8 @@ IPCCommandResult FileIO::Read(const IOSReadWriteRequest& request)
}
else
{
ERROR_LOG(WII_IPC_FILEIO, "FileIO: Failed to read from %s (Addr=0x%08x Size=0x%x) - file could "
"not be opened or does not exist",
ERROR_LOG(IOS_FILEIO, "FileIO: Failed to read from %s (Addr=0x%08x Size=0x%x) - file could "
"not be opened or does not exist",
m_name.c_str(), request.buffer, request.size);
return_value = FS_ENOENT;
}
@@ -261,13 +260,13 @@ IPCCommandResult FileIO::Write(const IOSReadWriteRequest& request)
{
if (m_Mode == IOS_OPEN_READ)
{
WARN_LOG(WII_IPC_FILEIO,
WARN_LOG(IOS_FILEIO,
"FileIO: Attempted to write 0x%x bytes from 0x%08x to a read-only file %s",
request.size, request.buffer, m_name.c_str());
}
else
{
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: Write 0x%04x bytes from 0x%08x to %s", request.size,
DEBUG_LOG(IOS_FILEIO, "FileIO: Write 0x%04x bytes from 0x%08x to %s", request.size,
request.buffer, m_name.c_str());
m_file->Seek(m_SeekPos,
SEEK_SET); // File might be opened twice, need to seek before we write
@@ -280,8 +279,8 @@ IPCCommandResult FileIO::Write(const IOSReadWriteRequest& request)
}
else
{
ERROR_LOG(WII_IPC_FILEIO, "FileIO: Failed to read from %s (Addr=0x%08x Size=0x%x) - file could "
"not be opened or does not exist",
ERROR_LOG(IOS_FILEIO, "FileIO: Failed to read from %s (Addr=0x%08x Size=0x%x) - file could "
"not be opened or does not exist",
m_name.c_str(), request.buffer, request.size);
return_value = FS_ENOENT;
}
@@ -291,7 +290,7 @@ IPCCommandResult FileIO::Write(const IOSReadWriteRequest& request)
IPCCommandResult FileIO::IOCtl(const IOSIOCtlRequest& request)
{
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: IOCtl (Device=%s)", m_name.c_str());
DEBUG_LOG(IOS_FILEIO, "FileIO: IOCtl (Device=%s)", m_name.c_str());
s32 return_value = IPC_SUCCESS;
switch (request.request)
@@ -300,7 +299,7 @@ IPCCommandResult FileIO::IOCtl(const IOSIOCtlRequest& request)
{
if (m_file->IsOpen())
{
DEBUG_LOG(WII_IPC_FILEIO, "File: %s, Length: %" PRIu64 ", Pos: %i", m_name.c_str(),
DEBUG_LOG(IOS_FILEIO, "File: %s, Length: %" PRIu64 ", Pos: %i", m_name.c_str(),
m_file->GetSize(), m_SeekPos);
Memory::Write_U32(static_cast<u32>(m_file->GetSize()), request.buffer_out);
Memory::Write_U32(m_SeekPos, request.buffer_out + 4);
@@ -313,7 +312,7 @@ IPCCommandResult FileIO::IOCtl(const IOSIOCtlRequest& request)
break;
default:
request.Log(GetDeviceName(), LogTypes::WII_IPC_FILEIO, LogTypes::LERROR);
request.Log(GetDeviceName(), LogTypes::IOS_FILEIO, LogTypes::LERROR);
}
return GetDefaultReply(return_value);
Source/Core/Core/IOS/IPC.cpp
+8 -8
View File
@@ -124,7 +124,7 @@ std::shared_ptr<T> AddDevice(const char* device_name)
void Reinit()
{
std::lock_guard<std::mutex> lock(s_device_map_mutex);
_assert_msg_(WII_IPC_HLE, s_device_map.empty(), "Reinit called while already initialized");
_assert_msg_(IOS, s_device_map.empty(), "Reinit called while already initialized");
Device::ES::m_ContentFile = "";
num_devices = 0;
@@ -352,10 +352,10 @@ static std::shared_ptr<Device::Device> GetUnusedESDevice()
static s32 OpenDevice(const IOSOpenRequest& request)
{
const s32 new_fd = GetFreeDeviceID();
INFO_LOG(WII_IPC_HLE, "Opening %s (mode %d, fd %d)", request.path.c_str(), request.flags, new_fd);
INFO_LOG(IOS, "Opening %s (mode %d, fd %d)", request.path.c_str(), request.flags, new_fd);
if (new_fd < 0 || new_fd >= IPC_MAX_FDS)
{
ERROR_LOG(WII_IPC_HLE, "Couldn't get a free fd, too many open files");
ERROR_LOG(IOS, "Couldn't get a free fd, too many open files");
return FS_EFDEXHAUSTED;
}
@@ -377,7 +377,7 @@ static s32 OpenDevice(const IOSOpenRequest& request)
if (!device)
{
ERROR_LOG(WII_IPC_HLE, "Unknown device: %s", request.path.c_str());
ERROR_LOG(IOS, "Unknown device: %s", request.path.c_str());
return IPC_ENOENT;
}
@@ -418,7 +418,7 @@ static IPCCommandResult HandleCommand(const IOSRequest& request)
case IPC_CMD_IOCTLV:
return device->IOCtlV(IOSIOCtlVRequest{request.address});
default:
_assert_msg_(WII_IPC_HLE, false, "Unexpected command: %x", request.command);
_assert_msg_(IOS, false, "Unexpected command: %x", request.command);
return Device::Device::GetDefaultReply(IPC_EINVAL);
}
}
@@ -472,7 +472,7 @@ void Update()
if (s_request_queue.size())
{
GenerateAck(s_request_queue.front());
DEBUG_LOG(WII_IPC_HLE, "||-- Acknowledge IPC Request @ 0x%08x", s_request_queue.front());
DEBUG_LOG(IOS, "||-- Acknowledge IPC Request @ 0x%08x", s_request_queue.front());
u32 command = s_request_queue.front();
s_request_queue.pop_front();
ExecuteCommand(command);
@@ -482,7 +482,7 @@ void Update()
if (s_reply_queue.size())
{
GenerateReply(s_reply_queue.front());
DEBUG_LOG(WII_IPC_HLE, "<<-- Reply to IPC Request @ 0x%08x", s_reply_queue.front());
DEBUG_LOG(IOS, "<<-- Reply to IPC Request @ 0x%08x", s_reply_queue.front());
s_reply_queue.pop_front();
return;
}
@@ -490,7 +490,7 @@ void Update()
if (s_ack_queue.size())
{
GenerateAck(s_ack_queue.front());
WARN_LOG(WII_IPC_HLE, "<<-- Double-ack to IPC Request @ 0x%08x", s_ack_queue.front());
WARN_LOG(IOS, "<<-- Double-ack to IPC Request @ 0x%08x", s_ack_queue.front());
s_ack_queue.pop_front();
return;
}
Source/Core/Core/IOS/Network/Config.cpp
+1 -1
View File
@@ -44,7 +44,7 @@ void WiiNetConfig::WriteConfig() const
if (!File::CreateFullPath(File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/" WII_SYSCONF_DIR
"/net/02/"))
{
ERROR_LOG(WII_IPC_NET, "Failed to create directory for network config file");
ERROR_LOG(IOS_NET, "Failed to create directory for network config file");
}
}
Source/Core/Core/IOS/Network/NWC24Config.cpp
+6 -6
View File
@@ -36,7 +36,7 @@ void NWC24Config::ReadConfig()
{
const s32 config_error = CheckNwc24Config();
if (config_error)
ERROR_LOG(WII_IPC_WC24, "There is an error in the config for for WC24: %d", config_error);
ERROR_LOG(IOS_WC24, "There is an error in the config for for WC24: %d", config_error);
}
}
else
@@ -51,7 +51,7 @@ void NWC24Config::WriteConfig() const
{
if (!File::CreateFullPath(File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/" WII_WC24CONF_DIR))
{
ERROR_LOG(WII_IPC_WC24, "Failed to create directory for WC24");
ERROR_LOG(IOS_WC24, "Failed to create directory for WC24");
}
}
@@ -105,21 +105,21 @@ s32 NWC24Config::CheckNwc24Config() const
// 'WcCf' magic
if (Magic() != 0x57634366)
{
ERROR_LOG(WII_IPC_WC24, "Magic mismatch");
ERROR_LOG(IOS_WC24, "Magic mismatch");
return -14;
}
const u32 checksum = CalculateNwc24ConfigChecksum();
DEBUG_LOG(WII_IPC_WC24, "Checksum: %X", checksum);
DEBUG_LOG(IOS_WC24, "Checksum: %X", checksum);
if (Checksum() != checksum)
{
ERROR_LOG(WII_IPC_WC24, "Checksum mismatch expected %X and got %X", checksum, Checksum());
ERROR_LOG(IOS_WC24, "Checksum mismatch expected %X and got %X", checksum, Checksum());
return -14;
}
if (IdGen() > 0x1F)
{
ERROR_LOG(WII_IPC_WC24, "Id gen error");
ERROR_LOG(IOS_WC24, "Id gen error");
return -14;
}
Source/Core/Core/IOS/Network/Net.cpp
+76 -76
View File
@@ -84,16 +84,16 @@ IPCCommandResult NetKDRequest::IOCtl(const IOSIOCtlRequest& request)
{
case IOCTL_NWC24_SUSPEND_SCHEDULAR:
// NWC24iResumeForCloseLib from NWC24SuspendScheduler (Input: none, Output: 32 bytes)
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_SUSPEND_SCHEDULAR - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_SUSPEND_SCHEDULAR - NI");
Memory::Write_U32(0, request.buffer_out); // no error
break;
case IOCTL_NWC24_EXEC_TRY_SUSPEND_SCHEDULAR: // NWC24iResumeForCloseLib
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_TRY_SUSPEND_SCHEDULAR - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_TRY_SUSPEND_SCHEDULAR - NI");
break;
case IOCTL_NWC24_EXEC_RESUME_SCHEDULAR: // NWC24iResumeForCloseLib
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_RESUME_SCHEDULAR - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_EXEC_RESUME_SCHEDULAR - NI");
Memory::Write_U32(0, request.buffer_out); // no error
break;
@@ -101,29 +101,29 @@ IPCCommandResult NetKDRequest::IOCtl(const IOSIOCtlRequest& request)
Memory::Write_U32(0, request.buffer_out);
Memory::Write_U32(0, request.buffer_out + 4);
return_value = 0;
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_STARTUP_SOCKET - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_STARTUP_SOCKET - NI");
break;
case IOCTL_NWC24_CLEANUP_SOCKET:
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_CLEANUP_SOCKET - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_CLEANUP_SOCKET - NI");
break;
case IOCTL_NWC24_LOCK_SOCKET: // WiiMenu
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_LOCK_SOCKET - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_LOCK_SOCKET - NI");
break;
case IOCTL_NWC24_UNLOCK_SOCKET:
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_UNLOCK_SOCKET - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_UNLOCK_SOCKET - NI");
break;
case IOCTL_NWC24_REQUEST_REGISTER_USER_ID:
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_REGISTER_USER_ID");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_REGISTER_USER_ID");
Memory::Write_U32(0, request.buffer_out);
Memory::Write_U32(0, request.buffer_out + 4);
break;
case IOCTL_NWC24_REQUEST_GENERATED_USER_ID: // (Input: none, Output: 32 bytes)
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_GENERATED_USER_ID");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_GENERATED_USER_ID");
if (config.CreationStage() == NWC24::NWC24Config::NWC24_IDCS_INITIAL)
{
std::string settings_Filename(
@@ -179,20 +179,20 @@ IPCCommandResult NetKDRequest::IOCtl(const IOSIOCtlRequest& request)
break;
case IOCTL_NWC24_GET_SCHEDULAR_STAT:
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_GET_SCHEDULAR_STAT - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_GET_SCHEDULAR_STAT - NI");
break;
case IOCTL_NWC24_SAVE_MAIL_NOW:
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_SAVE_MAIL_NOW - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_SAVE_MAIL_NOW - NI");
break;
case IOCTL_NWC24_REQUEST_SHUTDOWN:
// if ya set the IOS version to a very high value this happens ...
INFO_LOG(WII_IPC_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_SHUTDOWN - NI");
INFO_LOG(IOS_WC24, "NET_KD_REQ: IOCTL_NWC24_REQUEST_SHUTDOWN - NI");
break;
default:
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
}
return GetDefaultReply(return_value);
@@ -311,12 +311,12 @@ static void GetMacAddress(u8* mac)
SaveMacAddress(mac);
if (!wireless_mac.empty())
{
ERROR_LOG(WII_IPC_NET, "The MAC provided (%s) is invalid. We have "
"generated another one for you.",
ERROR_LOG(IOS_NET, "The MAC provided (%s) is invalid. We have "
"generated another one for you.",
Common::MacAddressToString(mac).c_str());
}
}
INFO_LOG(WII_IPC_NET, "Using MAC address: %s", Common::MacAddressToString(mac).c_str());
INFO_LOG(IOS_NET, "Using MAC address: %s", Common::MacAddressToString(mac).c_str());
}
// **********************************************************************************
@@ -342,37 +342,37 @@ IPCCommandResult NetNCDManage::IOCtlV(const IOSIOCtlVRequest& request)
break;
case IOCTLV_NCD_GETCONFIG:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETCONFIG");
INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETCONFIG");
config.WriteToMem(request.io_vectors.at(0).address);
common_vector = 1;
break;
case IOCTLV_NCD_SETCONFIG:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: IOCTLV_NCD_SETCONFIG");
INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_SETCONFIG");
config.ReadFromMem(request.in_vectors.at(0).address);
break;
case IOCTLV_NCD_READCONFIG:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: IOCTLV_NCD_READCONFIG");
INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_READCONFIG");
config.ReadConfig();
config.WriteToMem(request.io_vectors.at(0).address);
common_vector = 1;
break;
case IOCTLV_NCD_WRITECONFIG:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: IOCTLV_NCD_WRITECONFIG");
INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_WRITECONFIG");
config.ReadFromMem(request.in_vectors.at(0).address);
config.WriteConfig();
break;
case IOCTLV_NCD_GETLINKSTATUS:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETLINKSTATUS");
INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETLINKSTATUS");
// Always connected
Memory::Write_U32(Net::ConnectionSettings::LINK_WIRED, request.io_vectors.at(0).address + 4);
break;
case IOCTLV_NCD_GETWIRELESSMACADDRESS:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETWIRELESSMACADDRESS");
INFO_LOG(IOS_NET, "NET_NCD_MANAGE: IOCTLV_NCD_GETWIRELESSMACADDRESS");
u8 address[Common::MAC_ADDRESS_SIZE];
GetMacAddress(address);
@@ -380,7 +380,7 @@ IPCCommandResult NetNCDManage::IOCtlV(const IOSIOCtlVRequest& request)
break;
default:
INFO_LOG(WII_IPC_NET, "NET_NCD_MANAGE IOCtlV: %#x", request.request);
INFO_LOG(IOS_NET, "NET_NCD_MANAGE IOCtlV: %#x", request.request);
break;
}
@@ -466,7 +466,7 @@ IPCCommandResult NetWDCommand::IOCtlV(const IOSIOCtlVRequest& request)
case IOCTLV_WD_RECV_FRAME:
case IOCTLV_WD_RECV_NOTIFICATION:
default:
request.Dump(GetDeviceName(), LogTypes::WII_IPC_NET, LogTypes::LINFO);
request.Dump(GetDeviceName(), LogTypes::IOS_NET, LogTypes::LINFO);
}
return GetDefaultReply(return_value);
@@ -478,7 +478,7 @@ NetIPTop::NetIPTop(u32 device_id, const std::string& device_name) : Device(devic
{
#ifdef _WIN32
int ret = WSAStartup(MAKEWORD(2, 2), &InitData);
INFO_LOG(WII_IPC_NET, "WSAStartup: %d", ret);
INFO_LOG(IOS_NET, "WSAStartup: %d", ret);
#endif
}
@@ -551,7 +551,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
{
case IOCTL_SO_STARTUP:
{
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
break;
}
case IOCTL_SO_SOCKET:
@@ -562,8 +562,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
WiiSockMan& sm = WiiSockMan::GetInstance();
return_value = sm.NewSocket(af, type, prot);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_SOCKET "
"Socket: %08x (%d,%d,%d), BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
INFO_LOG(IOS_NET, "IOCTL_SO_SOCKET "
"Socket: %08x (%d,%d,%d), BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
return_value, af, type, prot, request.buffer_in, request.buffer_in_size,
request.buffer_out, request.buffer_out_size);
break;
@@ -574,7 +574,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
WiiSockMan& sm = WiiSockMan::GetInstance();
return_value = sm.NewSocket(pf, SOCK_RAW, IPPROTO_ICMP);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_ICMPSOCKET(%x) %d", pf, return_value);
INFO_LOG(IOS_NET, "IOCTL_SO_ICMPSOCKET(%x) %d", pf, return_value);
break;
}
case IOCTL_SO_CLOSE:
@@ -583,7 +583,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
u32 fd = Memory::Read_U32(request.buffer_in);
WiiSockMan& sm = WiiSockMan::GetInstance();
return_value = sm.DeleteSocket(fd);
INFO_LOG(WII_IPC_NET, "%s(%x) %x",
INFO_LOG(IOS_NET, "%s(%x) %x",
request.request == IOCTL_SO_ICMPCLOSE ? "IOCTL_SO_ICMPCLOSE" : "IOCTL_SO_CLOSE", fd,
return_value);
break;
@@ -603,7 +603,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
/////////////////////////////////////////////////////////////
case IOCTL_SO_SHUTDOWN:
{
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
u32 fd = Memory::Read_U32(request.buffer_in);
u32 how = Memory::Read_U32(request.buffer_in + 4);
@@ -617,7 +617,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
u32 BACKLOG = Memory::Read_U32(request.buffer_in + 0x04);
u32 ret = listen(fd, BACKLOG);
return_value = WiiSockMan::GetNetErrorCode(ret, "SO_LISTEN", false);
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
break;
}
case IOCTL_SO_GETSOCKOPT:
@@ -626,7 +626,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
u32 level = Memory::Read_U32(request.buffer_out + 4);
u32 optname = Memory::Read_U32(request.buffer_out + 8);
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
// Do the level/optname translation
int nat_level = -1, nat_optname = -1;
@@ -668,10 +668,10 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
optlen = std::min(optlen, (u32)sizeof(optval));
Memory::CopyFromEmu(optval, request.buffer_in + 0x10, optlen);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_SETSOCKOPT(%08x, %08x, %08x, %08x) "
"BufferIn: (%08x, %i), BufferOut: (%08x, %i)"
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx",
INFO_LOG(IOS_NET, "IOCTL_SO_SETSOCKOPT(%08x, %08x, %08x, %08x) "
"BufferIn: (%08x, %i), BufferOut: (%08x, %i)"
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx",
fd, level, optname, optlen, request.buffer_in, request.buffer_in_size,
request.buffer_out, request.buffer_out_size, optval[0], optval[1], optval[2],
optval[3], optval[4], optval[5], optval[6], optval[7], optval[8], optval[9],
@@ -699,7 +699,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
if (nat_level == -1 || nat_optname == -1)
{
INFO_LOG(WII_IPC_NET, "SO_SETSOCKOPT: unknown level %d or optname %d", level, optname);
INFO_LOG(IOS_NET, "SO_SETSOCKOPT: unknown level %d or optname %d", level, optname);
// Default to the given level/optname. They match on Windows...
nat_level = level;
@@ -714,7 +714,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
sockaddr sa;
socklen_t sa_len;
@@ -722,7 +722,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
int ret = getsockname(fd, &sa, &sa_len);
if (request.buffer_out_size < 2 + sizeof(sa.sa_data))
WARN_LOG(WII_IPC_NET, "IOCTL_SO_GETSOCKNAME output buffer is too small. Truncating");
WARN_LOG(IOS_NET, "IOCTL_SO_GETSOCKNAME output buffer is too small. Truncating");
if (request.buffer_out_size > 0)
Memory::Write_U8(request.buffer_out_size, request.buffer_out);
@@ -745,7 +745,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
int ret = getpeername(fd, &sa, &sa_len);
if (request.buffer_out_size < 2 + sizeof(sa.sa_data))
WARN_LOG(WII_IPC_NET, "IOCTL_SO_GETPEERNAME output buffer is too small. Truncating");
WARN_LOG(IOS_NET, "IOCTL_SO_GETPEERNAME output buffer is too small. Truncating");
if (request.buffer_out_size > 0)
Memory::Write_U8(request.buffer_out_size, request.buffer_out);
@@ -755,7 +755,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
Memory::CopyToEmu(request.buffer_out + 2, &sa.sa_data,
std::min<size_t>(sizeof(sa.sa_data), request.buffer_out_size - 2));
INFO_LOG(WII_IPC_NET, "IOCTL_SO_GETPEERNAME(%x)", fd);
INFO_LOG(IOS_NET, "IOCTL_SO_GETPEERNAME(%x)", fd);
return_value = ret;
break;
@@ -763,7 +763,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
case IOCTL_SO_GETHOSTID:
{
request.Log(GetDeviceName(), LogTypes::WII_IPC_WC24);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
#ifdef _WIN32
DWORD forwardTableSize, ipTableSize, result;
@@ -831,8 +831,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
if (remoteHost == nullptr || remoteHost->h_addr_list == nullptr ||
remoteHost->h_addr_list[0] == nullptr)
{
INFO_LOG(WII_IPC_NET, "IOCTL_SO_INETATON = -1 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: None",
INFO_LOG(IOS_NET, "IOCTL_SO_INETATON = -1 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: None",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size);
return_value = 0;
@@ -840,8 +840,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
else
{
Memory::Write_U32(Common::swap32(*(u32*)remoteHost->h_addr_list[0]), request.buffer_out);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_INETATON = 0 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: %08X",
INFO_LOG(IOS_NET, "IOCTL_SO_INETATON = 0 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: %08X",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size, Common::swap32(*(u32*)remoteHost->h_addr_list[0]));
return_value = 1;
@@ -852,8 +852,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
case IOCTL_SO_INETPTON:
{
std::string address = Memory::GetString(request.buffer_in);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_INETPTON "
"(Translating: %s)",
INFO_LOG(IOS_NET, "IOCTL_SO_INETPTON "
"(Translating: %s)",
address.c_str());
return_value = inet_pton(address.c_str(), Memory::GetPointer(request.buffer_out + 4));
break;
@@ -868,7 +868,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
sprintf(ip_s, "%i.%i.%i.%i", Memory::Read_U8(request.buffer_in + 8),
Memory::Read_U8(request.buffer_in + 8 + 1), Memory::Read_U8(request.buffer_in + 8 + 2),
Memory::Read_U8(request.buffer_in + 8 + 3));
INFO_LOG(WII_IPC_NET, "IOCTL_SO_INETNTOP %s", ip_s);
INFO_LOG(IOS_NET, "IOCTL_SO_INETNTOP %s", ip_s);
Memory::CopyToEmu(request.buffer_out, (u8*)ip_s, strlen(ip_s));
break;
}
@@ -890,7 +890,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
int nfds = request.buffer_out_size / 0xc;
if (nfds == 0)
ERROR_LOG(WII_IPC_NET, "Hidden POLL");
ERROR_LOG(IOS_NET, "Hidden POLL");
std::vector<pollfd_t> ufds(nfds);
@@ -909,16 +909,16 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
ufds[i].events |= map.native;
unhandled_events &= ~map.wii;
}
DEBUG_LOG(WII_IPC_NET, "IOCTL_SO_POLL(%d) "
"Sock: %08x, Unknown: %08x, Events: %08x, "
"NativeEvents: %08x",
DEBUG_LOG(IOS_NET, "IOCTL_SO_POLL(%d) "
"Sock: %08x, Unknown: %08x, Events: %08x, "
"NativeEvents: %08x",
i, ufds[i].fd, unknown, events, ufds[i].events);
// Do not pass return-only events to the native poll
ufds[i].events &= ~(POLLERR | POLLHUP | POLLNVAL | UNSUPPORTED_WSAPOLL);
if (unhandled_events)
ERROR_LOG(WII_IPC_NET, "SO_POLL: unhandled Wii event types: %04x", unhandled_events);
ERROR_LOG(IOS_NET, "SO_POLL: unhandled Wii event types: %04x", unhandled_events);
}
int ret = poll(ufds.data(), nfds, timeout);
@@ -939,7 +939,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
// Memory::Write_U32(events, request.buffer_out + 0xc*i + 4); //events
Memory::Write_U32(revents, request.buffer_out + 0xc * i + 8); // revents
DEBUG_LOG(WII_IPC_NET, "IOCTL_SO_POLL socket %d wevents %08X events %08X revents %08X", i,
DEBUG_LOG(IOS_NET, "IOCTL_SO_POLL socket %d wevents %08X events %08X revents %08X", i,
revents, ufds[i].events, ufds[i].revents);
}
@@ -951,7 +951,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
{
if (request.buffer_out_size != 0x460)
{
ERROR_LOG(WII_IPC_NET, "Bad buffer size for IOCTL_SO_GETHOSTBYNAME");
ERROR_LOG(IOS_NET, "Bad buffer size for IOCTL_SO_GETHOSTBYNAME");
return_value = -1;
break;
}
@@ -959,8 +959,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
std::string hostname = Memory::GetString(request.buffer_in);
hostent* remoteHost = gethostbyname(hostname.c_str());
INFO_LOG(WII_IPC_NET, "IOCTL_SO_GETHOSTBYNAME "
"Address: %s, BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
INFO_LOG(IOS_NET, "IOCTL_SO_GETHOSTBYNAME "
"Address: %s, BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size);
@@ -968,7 +968,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
{
for (int i = 0; remoteHost->h_aliases[i]; ++i)
{
DEBUG_LOG(WII_IPC_NET, "alias%i:%s", i, remoteHost->h_aliases[i]);
DEBUG_LOG(IOS_NET, "alias%i:%s", i, remoteHost->h_aliases[i]);
}
for (int i = 0; remoteHost->h_addr_list[i]; ++i)
@@ -976,7 +976,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
u32 ip = Common::swap32(*(u32*)(remoteHost->h_addr_list[i]));
std::string ip_s = StringFromFormat("%i.%i.%i.%i", ip >> 24, (ip >> 16) & 0xff,
(ip >> 8) & 0xff, ip & 0xff);
DEBUG_LOG(WII_IPC_NET, "addr%i:%s", i, ip_s.c_str());
DEBUG_LOG(IOS_NET, "addr%i:%s", i, ip_s.c_str());
}
// Host name; located immediately after struct
@@ -986,7 +986,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
u32 name_length = (u32)strlen(remoteHost->h_name) + 1;
if (name_length > (GETHOSTBYNAME_IP_LIST_OFFSET - GETHOSTBYNAME_STRUCT_SIZE))
{
ERROR_LOG(WII_IPC_NET, "Hostname too long in IOCTL_SO_GETHOSTBYNAME");
ERROR_LOG(IOS_NET, "Hostname too long in IOCTL_SO_GETHOSTBYNAME");
return_value = -1;
break;
}
@@ -1026,7 +1026,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
request.buffer_out + 4);
// Returned struct must be ipv4.
_assert_msg_(WII_IPC_NET,
_assert_msg_(IOS_NET,
remoteHost->h_addrtype == AF_INET && remoteHost->h_length == sizeof(u32),
"returned host info is not IPv4");
Memory::Write_U16(AF_INET, request.buffer_out + 8);
@@ -1043,10 +1043,10 @@ IPCCommandResult NetIPTop::IOCtl(const IOSIOCtlRequest& request)
}
case IOCTL_SO_ICMPCANCEL:
ERROR_LOG(WII_IPC_NET, "IOCTL_SO_ICMPCANCEL");
ERROR_LOG(IOS_NET, "IOCTL_SO_ICMPCANCEL");
default:
request.DumpUnknown(GetDeviceName(), LogTypes::WII_IPC_NET);
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_NET);
}
return GetDefaultReply(return_value);
@@ -1070,8 +1070,8 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
param5 = Memory::Read_U32(request.io_vectors[0].address + 4);
}
INFO_LOG(WII_IPC_NET, "IOCTLV_SO_GETINTERFACEOPT(%08X, %08X, %X, %X, %X) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i) ",
INFO_LOG(IOS_NET, "IOCTLV_SO_GETINTERFACEOPT(%08X, %08X, %X, %X, %X) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i) ",
param, param2, param3, param4, param5, request.in_vectors[0].address,
request.in_vectors[0].size,
request.in_vectors.size() > 1 ? request.in_vectors[1].address : 0,
@@ -1122,8 +1122,8 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
if (AdapterList->IfIndex == dwBestIfIndex && AdapterList->FirstDnsServerAddress &&
AdapterList->OperStatus == IfOperStatusUp)
{
INFO_LOG(WII_IPC_NET, "Name of valid interface: %S", AdapterList->FriendlyName);
INFO_LOG(WII_IPC_NET, "DNS: %u.%u.%u.%u",
INFO_LOG(IOS_NET, "Name of valid interface: %S", AdapterList->FriendlyName);
INFO_LOG(IOS_NET, "DNS: %u.%u.%u.%u",
(unsigned char)
AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2],
(unsigned char)
@@ -1179,7 +1179,7 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
break;
default:
ERROR_LOG(WII_IPC_NET, "Unknown param2: %08X", param2);
ERROR_LOG(IOS_NET, "Unknown param2: %08X", param2);
break;
}
break;
@@ -1288,7 +1288,7 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
ret = -305;
}
request.Dump(GetDeviceName(), LogTypes::WII_IPC_NET, LogTypes::LINFO);
request.Dump(GetDeviceName(), LogTypes::IOS_NET, LogTypes::LINFO);
return_value = ret;
break;
}
@@ -1308,7 +1308,7 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
if (num_ip != 1)
{
INFO_LOG(WII_IPC_NET, "IOCTLV_SO_ICMPPING %i IPs", num_ip);
INFO_LOG(IOS_NET, "IOCTLV_SO_ICMPPING %i IPs", num_ip);
}
ip_info.length = Memory::Read_U8(request.in_vectors[0].address + 16);
@@ -1318,12 +1318,12 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
if (ip_info.length != 8 || ip_info.addr_family != AF_INET)
{
INFO_LOG(WII_IPC_NET, "IOCTLV_SO_ICMPPING strange IPInfo:\n"
"length %x addr_family %x",
INFO_LOG(IOS_NET, "IOCTLV_SO_ICMPPING strange IPInfo:\n"
"length %x addr_family %x",
ip_info.length, ip_info.addr_family);
}
INFO_LOG(WII_IPC_NET, "IOCTLV_SO_ICMPPING %x", ip_info.ip);
INFO_LOG(IOS_NET, "IOCTLV_SO_ICMPPING %x", ip_info.ip);
sockaddr_in addr;
addr.sin_family = AF_INET;
@@ -1356,7 +1356,7 @@ IPCCommandResult NetIPTop::IOCtlV(const IOSIOCtlVRequest& request)
break;
}
default:
request.DumpUnknown(GetDeviceName(), LogTypes::WII_IPC_NET);
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_NET);
}
return GetDefaultReply(return_value);
Source/Core/Core/IOS/Network/Net.h
+1 -1
View File
@@ -164,7 +164,7 @@ public:
break;
default:
ERROR_LOG(WII_IPC_NET, "%s - unknown IOCtl: %x", GetDeviceName().c_str(), request.request);
ERROR_LOG(IOS_NET, "%s - unknown IOCtl: %x", GetDeviceName().c_str(), request.request);
break;
}
Source/Core/Core/IOS/Network/SSL.cpp
+53 -53
View File
@@ -81,7 +81,7 @@ int NetSSL::GetSSLFreeID() const
IPCCommandResult NetSSL::IOCtl(const IOSIOCtlRequest& request)
{
request.Log(GetDeviceName(), LogTypes::WII_IPC_SSL, LogTypes::LINFO);
request.Log(GetDeviceName(), LogTypes::IOS_SSL, LogTypes::LINFO);
return GetDefaultReply(IPC_SUCCESS);
}
@@ -185,10 +185,10 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
Memory::Write_U32(SSL_ERR_FAILED, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_NEW (%d, %s) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_NEW (%d, %s) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
verifyOption, hostname.c_str(), BufferIn, BufferInSize, BufferIn2, BufferInSize2,
BufferIn3, BufferInSize3, BufferOut, BufferOutSize, BufferOut2, BufferOutSize2,
BufferOut3, BufferOutSize3);
@@ -222,20 +222,20 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SHUTDOWN "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SHUTDOWN "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
break;
}
case IOCTLV_NET_SSL_SETROOTCA:
{
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETROOTCA "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETROOTCA "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
@@ -262,7 +262,7 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
Memory::Write_U32(SSL_OK, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETROOTCA = %d", ret);
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETROOTCA = %d", ret);
}
else
{
@@ -272,10 +272,10 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
}
case IOCTLV_NET_SSL_SETBUILTINCLIENTCERT:
{
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
@@ -300,21 +300,21 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
Memory::Write_U32(SSL_OK, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT = (%d, %d)", ret, pk_ret);
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT = (%d, %d)", ret, pk_ret);
}
else
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT invalid sslID = %d", sslID);
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT invalid sslID = %d", sslID);
}
break;
}
case IOCTLV_NET_SSL_REMOVECLIENTCERT:
{
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_REMOVECLIENTCERT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_REMOVECLIENTCERT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
@@ -331,7 +331,7 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
else
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT invalid sslID = %d", sslID);
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT invalid sslID = %d", sslID);
}
break;
}
@@ -354,16 +354,16 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
mbedtls_ssl_conf_ca_chain(&ssl->config, &ssl->cacert, nullptr);
Memory::Write_U32(SSL_OK, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA = %d", ret);
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA = %d", ret);
}
else
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
break;
@@ -376,7 +376,7 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
WII_SSL* ssl = &_SSL[sslID];
mbedtls_ssl_setup(&ssl->ctx, &ssl->config);
ssl->sockfd = Memory::Read_U32(BufferOut2);
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_CONNECT socket = %d", ssl->sockfd);
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_CONNECT socket = %d", ssl->sockfd);
mbedtls_ssl_set_bio(&ssl->ctx, &ssl->sockfd, mbedtls_net_send, mbedtls_net_recv, nullptr);
Memory::Write_U32(SSL_OK, BufferIn);
}
@@ -384,10 +384,10 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_CONNECT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_CONNECT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
break;
@@ -420,13 +420,13 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_WRITE "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_WRITE "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
INFO_LOG(WII_IPC_SSL, "%s", Memory::GetString(BufferOut2).c_str());
INFO_LOG(IOS_SSL, "%s", Memory::GetString(BufferOut2).c_str());
break;
}
case IOCTLV_NET_SSL_READ:
@@ -444,10 +444,10 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
Memory::Write_U32(SSL_ERR_ID, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_READ(%d)"
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_READ(%d)"
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
ret, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3,
BufferOut, BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
break;
@@ -463,20 +463,20 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
{
Memory::Write_U32(SSL_ERR_ID, BufferIn);
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETROOTCADEFAULT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETROOTCADEFAULT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
break;
}
case IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT:
{
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferIn3, BufferInSize3, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2, BufferOut3, BufferOutSize3);
@@ -492,7 +492,7 @@ IPCCommandResult NetSSL::IOCtlV(const IOSIOCtlVRequest& request)
break;
}
default:
request.DumpUnknown(GetDeviceName(), LogTypes::WII_IPC_SSL);
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_SSL);
}
// SSL return codes are written to BufferIn
Source/Core/Core/IOS/Network/Socket.cpp
+18 -18
View File
@@ -50,7 +50,7 @@ static s32 TranslateErrorCode(s32 native_error, bool isRW)
switch (native_error)
{
case ERRORCODE(EMSGSIZE):
ERROR_LOG(WII_IPC_NET, "Find out why this happened, looks like PEEK failure?");
ERROR_LOG(IOS_NET, "Find out why this happened, looks like PEEK failure?");
return -1; // Should be -SO_EMSGSIZE
case EITHER(WSAENOTSOCK, EBADF):
return -SO_EBADF;
@@ -103,7 +103,7 @@ s32 WiiSockMan::GetNetErrorCode(s32 ret, const char* caller, bool isRW)
return ret;
}
ERROR_LOG(WII_IPC_NET, "%s failed with error %d: %s, ret= %d", caller, errorCode,
ERROR_LOG(IOS_NET, "%s failed with error %d: %s, ret= %d", caller, errorCode,
DecodeError(errorCode), ret);
s32 ReturnValue = TranslateErrorCode(errorCode, isRW);
@@ -176,10 +176,10 @@ s32 WiiSocket::FCntl(u32 cmd, u32 arg)
}
else
{
ERROR_LOG(WII_IPC_NET, "SO_FCNTL unknown command");
ERROR_LOG(IOS_NET, "SO_FCNTL unknown command");
}
INFO_LOG(WII_IPC_NET, "IOCTL_SO_FCNTL(%08x, %08X, %08X)", fd, cmd, arg);
INFO_LOG(IOS_NET, "IOCTL_SO_FCNTL(%08x, %08X, %08X)", fd, cmd, arg);
return ret;
}
@@ -213,8 +213,8 @@ void WiiSocket::Update(bool read, bool write, bool except)
int ret = bind(fd, (sockaddr*)&local_name, sizeof(local_name));
ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_BIND", false);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_BIND (%08X %s:%d) = %d ", fd,
inet_ntoa(local_name.sin_addr), Common::swap16(local_name.sin_port), ret);
INFO_LOG(IOS_NET, "IOCTL_SO_BIND (%08X %s:%d) = %d ", fd, inet_ntoa(local_name.sin_addr),
Common::swap16(local_name.sin_port), ret);
break;
}
case IOCTL_SO_CONNECT:
@@ -226,7 +226,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
int ret = connect(fd, (sockaddr*)&local_name, sizeof(local_name));
ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_CONNECT", false);
INFO_LOG(WII_IPC_NET, "IOCTL_SO_CONNECT (%08x, %s:%d)", fd, inet_ntoa(local_name.sin_addr),
INFO_LOG(IOS_NET, "IOCTL_SO_CONNECT (%08x, %s:%d)", fd, inet_ntoa(local_name.sin_addr),
Common::swap16(local_name.sin_port));
break;
}
@@ -252,7 +252,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
WiiSockMan::GetInstance().AddSocket(ReturnValue);
ioctl.Log("IOCTL_SO_ACCEPT", LogTypes::WII_IPC_NET);
ioctl.Log("IOCTL_SO_ACCEPT", LogTypes::IOS_NET);
break;
}
default:
@@ -315,7 +315,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
{
char error_buffer[256] = "";
mbedtls_strerror(ret, error_buffer, sizeof(error_buffer));
ERROR_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE: %s", error_buffer);
ERROR_LOG(IOS_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE: %s", error_buffer);
}
switch (ret)
{
@@ -337,7 +337,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
char error_buffer[256] = "";
int res = mbedtls_ssl_get_verify_result(ctx);
mbedtls_x509_crt_verify_info(error_buffer, sizeof(error_buffer), "", res);
ERROR_LOG(WII_IPC_SSL, "MBEDTLS_ERR_X509_CERT_VERIFY_FAILED (verify_result = %d): %s",
ERROR_LOG(IOS_SSL, "MBEDTLS_ERR_X509_CERT_VERIFY_FAILED (verify_result = %d): %s",
res, error_buffer);
if (res & MBEDTLS_X509_BADCERT_CN_MISMATCH)
@@ -375,9 +375,9 @@ void WiiSocket::Update(bool read, bool write, bool except)
}
}
INFO_LOG(WII_IPC_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE = (%d) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE = (%d) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
ret, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2);
break;
@@ -497,7 +497,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_SENDTO", true);
DEBUG_LOG(
WII_IPC_NET,
IOS_NET,
"%s = %d Socket: %08x, BufferIn: (%08x, %i), BufferIn2: (%08x, %i), %u.%u.%u.%u",
has_destaddr ? "IOCTLV_SO_SENDTO " : "IOCTLV_SO_SEND ", ReturnValue, fd, BufferIn,
BufferInSize, BufferIn2, BufferInSize2, local_name.sin_addr.s_addr & 0xFF,
@@ -542,9 +542,9 @@ void WiiSocket::Update(bool read, bool write, bool except)
ReturnValue =
WiiSockMan::GetNetErrorCode(ret, BufferOutSize2 ? "SO_RECVFROM" : "SO_RECV", true);
INFO_LOG(WII_IPC_NET, "%s(%d, %p) Socket: %08X, Flags: %08X, "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
INFO_LOG(IOS_NET, "%s(%d, %p) Socket: %08X, Flags: %08X, "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
BufferOutSize2 ? "IOCTLV_SO_RECVFROM " : "IOCTLV_SO_RECV ", ReturnValue, data,
fd, flags, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferOut,
BufferOutSize, BufferOut2, BufferOutSize2);
@@ -567,7 +567,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
ReturnValue != -SO_EALREADY) ||
(it->is_ssl && ReturnValue != SSL_ERR_WAGAIN && ReturnValue != SSL_ERR_RAGAIN))
{
DEBUG_LOG(WII_IPC_NET,
DEBUG_LOG(IOS_NET,
"IOCTL(V) Sock: %08x ioctl/v: %d returned: %d nonBlock: %d forceNonBlock: %d", fd,
it->is_ssl ? (int)it->ssl_type : (int)it->net_type, ReturnValue, nonBlock,
forceNonBlock);
Source/Core/Core/IOS/Network/Socket.h
+2 -2
View File
@@ -232,8 +232,8 @@ public:
auto socket_entry = WiiSockets.find(sock);
if (socket_entry == WiiSockets.end())
{
ERROR_LOG(WII_IPC_NET, "DoSock: Error, fd not found (%08x, %08X, %08X)", sock,
request.address, type);
ERROR_LOG(IOS_NET, "DoSock: Error, fd not found (%08x, %08X, %08X)", sock, request.address,
type);
EnqueueReply(request, -SO_EBADF);
}
else

Some files were not shown because too many files have changed in this diff Show More