dahjah/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2026-02-16 18:12:49 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

Triforce: Rename IPOverrides to IPRedirections.

Browse Source
This commit is contained in:
Jordan Woyak 2026-02-14 02:58:52 -06:00
parent cbd43914a5
commit c28ec7a6d3
6 changed files with 111 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/Core/Core/Config/MainSettings.cpp
View File

@ -643,7 +643,7 @@ const std::array<Info<s16>, EMULATED_LOGITECH_MIC_COUNT> MAIN_LOGITECH_MIC_VOLUM
Info<s16>{{System::Main, "EmulatedUSBDevices", "LogitechMic3VolumeModifier"}, 0},
Info<s16>{{System::Main, "EmulatedUSBDevices", "LogitechMic4VolumeModifier"}, 0}};
static std::string GetDefaultTriforceIPOverrides()
static std::string GetDefaultTriforceIPRedirections()
{
#if defined(ANDROID)
return "0.0.0.0/0=127.0.0.1";
@ -679,8 +679,8 @@ static std::string GetDefaultTriforceIPOverrides()
#endif
}
const Info<std::string> MAIN_TRIFORCE_IP_OVERRIDES{{System::Main, "Core", "TriforceIPOverrides"},
GetDefaultTriforceIPOverrides()};
const Info<std::string> MAIN_TRIFORCE_IP_REDIRECTIONS{
{System::Main, "Core", "TriforceIPRedirections"}, GetDefaultTriforceIPRedirections()};
// The reason we need this function is because some memory card code
// expects to get a non-NTSC-K region even if we're emulating an NTSC-K Wii.

2
Source/Core/Core/Config/MainSettings.h
View File

@ -386,7 +386,7 @@ extern const std::array<Info<std::string>, EMULATED_LOGITECH_MIC_COUNT>
extern const std::array<Info<bool>, EMULATED_LOGITECH_MIC_COUNT> MAIN_LOGITECH_MIC_MUTED;
extern const std::array<Info<s16>, EMULATED_LOGITECH_MIC_COUNT> MAIN_LOGITECH_MIC_VOLUME_MODIFIER;
extern const Info<std::string> MAIN_TRIFORCE_IP_OVERRIDES;
extern const Info<std::string> MAIN_TRIFORCE_IP_REDIRECTIONS;
// GameCube path utility functions

46
Source/Core/Core/HW/DVD/AMMediaboard.cpp
View File

@ -507,7 +507,7 @@ static int PlatformPoll(std::span<WSAPOLLFD> pfds, std::chrono::milliseconds tim
#endif
}
std::optional<ParsedIPOverride> ParseIPOverride(std::string_view str)
std::optional<ParsedIPRedirection> ParseIPRedirection(std::string_view str)
{
// Everything after a space is the description.
const auto ip_pair_str = std::string_view{str.begin(), std::ranges::find(str, ' ')};
@ -518,7 +518,7 @@ std::optional<ParsedIPOverride> ParseIPOverride(std::string_view str)
const bool have_description = ip_pair_str.size() != str.size();
return ParsedIPOverride{
return ParsedIPRedirection{
.original = (*parts)[0],
.replacement = (*parts)[1],
.description = have_description ? str.substr(ip_pair_str.size() + 1) : std::string_view{},
@ -526,7 +526,7 @@ std::optional<ParsedIPOverride> ParseIPOverride(std::string_view str)
}
// Caller should check if it matches first!
Common::IPv4Port IPAddressOverride::ApplyOverride(Common::IPv4Port subject) const
Common::IPv4Port IPRedirection::Apply(Common::IPv4Port subject) const
{
// This logic could probably be better.
// Ranges of different sizes will be weird in general.
@ -555,26 +555,26 @@ Common::IPv4Port IPAddressOverride::ApplyOverride(Common::IPv4Port subject) cons
return subject;
}
Common::IPv4Port IPAddressOverride::ReverseOverride(Common::IPv4Port subject) const
Common::IPv4Port IPRedirection::Reverse(Common::IPv4Port subject) const
{
// Low effort implementation..
return IPAddressOverride{.original = replacement, .replacement = original}.ApplyOverride(subject);
return IPRedirection{.original = replacement, .replacement = original}.Apply(subject);
}
std::string IPAddressOverride::ToString() const
std::string IPRedirection::ToString() const
{
return fmt::format("{}={}", original.ToString(), replacement.ToString());
}
IPOverrides GetIPOverrides()
IPRedirections GetIPRedirections()
{
IPOverrides result;
IPRedirections result;
const auto ip_overrides_str = Config::Get(Config::MAIN_TRIFORCE_IP_OVERRIDES);
for (auto&& ip_pair : ip_overrides_str | std::views::split(','))
const auto ip_redirections_str = Config::Get(Config::MAIN_TRIFORCE_IP_REDIRECTIONS);
for (auto&& ip_pair : ip_redirections_str | std::views::split(','))
{
const auto ip_pair_str = std::string_view{ip_pair};
const auto parts = ParseIPOverride(ip_pair_str);
const auto parts = ParseIPRedirection(ip_pair_str);
if (parts.has_value())
{
const auto original = Common::StringToIPv4PortRange(parts->original);
@ -586,7 +586,7 @@ IPOverrides GetIPOverrides()
continue;
}
ERROR_LOG_FMT(AMMEDIABOARD, "Bad IP pair string: {}", ip_pair_str);
ERROR_LOG_FMT(AMMEDIABOARD, "Bad IP redirection string: {}", ip_pair_str);
}
}
@ -596,10 +596,10 @@ IPOverrides GetIPOverrides()
static std::optional<Common::IPv4Port> AdjustIPv4PortFromConfig(Common::IPv4Port subject)
{
// TODO: We should parse this elsewhere to avoid repeated string manipulations.
for (auto&& override : GetIPOverrides())
for (auto&& redirection : GetIPRedirections())
{
if (override.original.IsMatch(subject))
return override.ApplyOverride(subject);
if (redirection.original.IsMatch(subject))
return redirection.Apply(subject);
}
return std::nullopt;
@ -608,10 +608,10 @@ static std::optional<Common::IPv4Port> AdjustIPv4PortFromConfig(Common::IPv4Port
static std::optional<Common::IPv4Port> ReverseAdjustIPv4PortFromConfig(Common::IPv4Port subject)
{
// TODO: We should parse this elsewhere to avoid repeated string manipulations.
for (auto&& override : GetIPOverrides())
for (auto&& redirection : GetIPRedirections())
{
if (override.replacement.IsMatch(subject))
return override.ReverseOverride(subject);
if (redirection.replacement.IsMatch(subject))
return redirection.Reverse(subject);
}
return std::nullopt;
@ -665,7 +665,7 @@ static s32 NetDIMMConnect(GuestSocket guest_socket, const GuestSocketAddress& gu
addr.sin_addr = std::bit_cast<in_addr>(adjusted_ipv4port->ip_address);
addr.sin_port = adjusted_ipv4port->port;
INFO_LOG_FMT(AMMEDIABOARD, "NetDIMMConnect: Overriding to: {}:{}",
INFO_LOG_FMT(AMMEDIABOARD, "NetDIMMConnect: Redirecting to: {}:{}",
Common::IPAddressToString(adjusted_ipv4port->ip_address),
ntohs(adjusted_ipv4port->port));
}
@ -677,7 +677,7 @@ static s32 NetDIMMConnect(GuestSocket guest_socket, const GuestSocketAddress& gu
const auto host_socket = GetHostSocket(guest_socket);
// See if we have an override for the game modified IP.
// See if we have a redirection for the game modified IP.
// If so, adjust the source IP by binding the socket.
const auto adjusted_source_ipv4port = AdjustIPv4PortFromConfig({s_game_modified_ip_address, 0});
if (adjusted_source_ipv4port.has_value())
@ -880,8 +880,8 @@ static Common::IPv4Port GetAdjustedBindIPv4Port(Common::IPv4Port socket_addr)
if (std::bit_cast<u32>(considered_ipv4.ip_address) == INADDR_ANY)
{
// Because the game is binding to "0.0.0.0",
// use the "game modified" IP for override purposes.
// If no override applies, then we still bind "0.0.0.0".
// use the "game modified" IP for redirection purposes.
// If no redirection applies, then we still bind "0.0.0.0".
considered_ipv4.ip_address = s_game_modified_ip_address;
INFO_LOG_FMT(AMMEDIABOARD, "GetAdjustedBindIPv4Port: Considering game modified IP: {}",
Common::IPAddressToString(s_game_modified_ip_address));
@ -890,7 +890,7 @@ static Common::IPv4Port GetAdjustedBindIPv4Port(Common::IPv4Port socket_addr)
if (const auto adjusted_ipv4 = AdjustIPv4PortFromConfig(considered_ipv4))
{
socket_addr = *adjusted_ipv4;
INFO_LOG_FMT(AMMEDIABOARD, "GetAdjustedBindIPv4Port: Overriding to: {}:{}",
INFO_LOG_FMT(AMMEDIABOARD, "GetAdjustedBindIPv4Port: Redirecting to: {}:{}",
Common::IPAddressToString(socket_addr.ip_address), ntohs(socket_addr.port));
}

14
Source/Core/Core/HW/DVD/AMMediaboard.h
View File

@ -245,29 +245,29 @@ bool GetTestMenu();
void Shutdown();
void DoState(PointerWrap& p);
struct ParsedIPOverride
struct ParsedIPRedirection
{
std::string_view original;
std::string_view replacement;
std::string_view description;
};
std::optional<ParsedIPOverride> ParseIPOverride(std::string_view str);
std::optional<ParsedIPRedirection> ParseIPRedirection(std::string_view str);
struct IPAddressOverride
struct IPRedirection
{
Common::IPv4PortRange original;
Common::IPv4PortRange replacement;
// Caller should check if it matches first!
Common::IPv4Port ApplyOverride(Common::IPv4Port subject) const;
Common::IPv4Port ReverseOverride(Common::IPv4Port subject) const;
Common::IPv4Port Apply(Common::IPv4Port subject) const;
Common::IPv4Port Reverse(Common::IPv4Port subject) const;
std::string ToString() const;
};
using IPOverrides = std::vector<IPAddressOverride>;
using IPRedirections = std::vector<IPRedirection>;
IPOverrides GetIPOverrides();
IPRedirections GetIPRedirections();
s32 DebuggerGetSocket(u32 triforce_fd);

15
Source/Core/DolphinQt/Debugger/NetworkWidget.cpp
View File

@ -144,9 +144,10 @@ QTableWidgetItem* GetSocketName(s32 host_fd)
return new QTableWidgetItem(QStringLiteral("%1->%2").arg(sock_name).arg(peer_name));
}
QTableWidgetItem* GetSocketRedirections(s32 host_fd, const AMMediaboard::IPOverrides& ip_overrides)
QTableWidgetItem* GetSocketRedirections(s32 host_fd,
const AMMediaboard::IPRedirections& ip_redirections)
{
if (host_fd < 0 || ip_overrides.empty())
if (host_fd < 0 || ip_redirections.empty())
return new QTableWidgetItem();
sockaddr_in sock_addr;
@ -167,7 +168,7 @@ QTableWidgetItem* GetSocketRedirections(s32 host_fd, const AMMediaboard::IPOverr
QStringList sock_rules;
QStringList peer_rules;
for (const auto& rule : ip_overrides)
for (const auto& rule : ip_redirections)
{
if (rule.replacement.IsMatch(sock_ip_port))
sock_rules << QString::fromStdString(rule.ToString());
@ -294,7 +295,7 @@ void NetworkWidget::UpdateWiiSocketTable(Core::System& system)
{
// Show Wii socket blocking state
m_socket_table->showColumn(4);
// Hide Triforce IP overrides
// Hide Triforce IP redirections
m_socket_table->hideColumn(6);
auto* ios = system.GetIOS();
@ -339,9 +340,9 @@ void NetworkWidget::UpdateTriforceSocketTable()
{
// No easy way to get socket blocking state on Windows
m_socket_table->hideColumn(4);
// Show active IP overrides
// Show active IP redirections
m_socket_table->showColumn(6);
const auto ip_overrides = AMMediaboard::GetIPOverrides();
const auto ip_redirections = AMMediaboard::GetIPRedirections();
for (s32 triforce_fd = 0; triforce_fd != AMMediaboard::SOCKET_FD_MAX; ++triforce_fd)
{
m_socket_table->insertRow(triforce_fd);
@ -352,7 +353,7 @@ void NetworkWidget::UpdateTriforceSocketTable()
m_socket_table->setItem(triforce_fd, 3, GetSocketState(host_fd));
m_socket_table->setItem(triforce_fd, 4, new QTableWidgetItem(QTableWidget::tr("Unknown")));
m_socket_table->setItem(triforce_fd, 5, GetSocketName(host_fd));
m_socket_table->setItem(triforce_fd, 6, GetSocketRedirections(host_fd, ip_overrides));
m_socket_table->setItem(triforce_fd, 6, GetSocketRedirections(host_fd, ip_redirections));
}
}

136
Source/Core/DolphinQt/Settings/TriforcePane.cpp
View File

@ -29,10 +29,10 @@ constexpr int COLUMN_EMULATED = 0;
constexpr int COLUMN_REAL = 1;
constexpr int COLUMN_DESCRIPTION = 2;
class IPAddressOverridesDialog final : public QDialog
class IPRedirectionsDialog final : public QDialog
{
public:
explicit IPAddressOverridesDialog(QWidget* parent);
explicit IPRedirectionsDialog(QWidget* parent);
private:
void LoadConfig();
@ -41,7 +41,7 @@ private:
void LoadDefault();
void OnClear();
QTableWidget* m_ip_overrides_table;
QTableWidget* m_ip_redirections_table;
};
} // namespace
@ -65,45 +65,46 @@ TriforcePane::TriforcePane()
window->show();
});
auto* const ip_override_group = new QGroupBox{tr("IP Address Overrides")};
main_layout->addWidget(ip_override_group);
auto* const ip_redirection_group = new QGroupBox{tr("IP Address Redirections")};
main_layout->addWidget(ip_redirection_group);
auto* const ip_override_layout = new QVBoxLayout{ip_override_group};
auto* const ip_redirection_layout = new QVBoxLayout{ip_redirection_group};
auto* const configure_ip_overrides_button = new NonDefaultQPushButton{tr("Configure")};
ip_override_layout->addWidget(configure_ip_overrides_button);
auto* const configure_ip_redirections_button = new NonDefaultQPushButton{tr("Configure")};
ip_redirection_layout->addWidget(configure_ip_redirections_button);
connect(configure_ip_overrides_button, &QPushButton::clicked, this, [this] {
auto* const ip_overrides = new IPAddressOverridesDialog{this};
ip_overrides->setAttribute(Qt::WA_DeleteOnClose);
ip_overrides->open();
connect(configure_ip_redirections_button, &QPushButton::clicked, this, [this] {
auto* const ip_redirections = new IPRedirectionsDialog{this};
ip_redirections->setAttribute(Qt::WA_DeleteOnClose);
ip_redirections->open();
});
main_layout->addStretch(1);
}
IPAddressOverridesDialog::IPAddressOverridesDialog(QWidget* parent) : QDialog{parent}
IPRedirectionsDialog::IPRedirectionsDialog(QWidget* parent) : QDialog{parent}
{
setWindowTitle(tr("IP Address Overrides"));
setWindowTitle(tr("IP Address Redirections"));
auto* const main_layout = new QVBoxLayout{this};
auto* const load_default_button = new QPushButton(tr("Default"));
connect(load_default_button, &QPushButton::clicked, this, &IPAddressOverridesDialog::LoadDefault);
connect(load_default_button, &QPushButton::clicked, this, &IPRedirectionsDialog::LoadDefault);
auto* const clear_button = new QPushButton(tr("Clear"));
connect(clear_button, &QPushButton::clicked, this, &IPAddressOverridesDialog::OnClear);
connect(clear_button, &QPushButton::clicked, this, &IPRedirectionsDialog::OnClear);
m_ip_overrides_table = new QTableWidget;
main_layout->addWidget(m_ip_overrides_table);
m_ip_redirections_table = new QTableWidget;
main_layout->addWidget(m_ip_redirections_table);
m_ip_overrides_table->setColumnCount(3);
m_ip_overrides_table->setHorizontalHeaderLabels({tr("Emulated"), tr("Real"), tr("Description")});
m_ip_overrides_table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
m_ip_overrides_table->setSizeAdjustPolicy(QTableWidget::AdjustToContents);
m_ip_redirections_table->setColumnCount(3);
m_ip_redirections_table->setHorizontalHeaderLabels(
{tr("Emulated"), tr("Real"), tr("Description")});
m_ip_redirections_table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
m_ip_redirections_table->setSizeAdjustPolicy(QTableWidget::AdjustToContents);
m_ip_overrides_table->setEditTriggers(QAbstractItemView::DoubleClicked |
QAbstractItemView::EditKeyPressed);
m_ip_redirections_table->setEditTriggers(QAbstractItemView::DoubleClicked |
QAbstractItemView::EditKeyPressed);
auto* const button_box = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
main_layout->addWidget(button_box);
@ -111,75 +112,76 @@ IPAddressOverridesDialog::IPAddressOverridesDialog(QWidget* parent) : QDialog{pa
button_box->addButton(load_default_button, QDialogButtonBox::ActionRole);
button_box->addButton(clear_button, QDialogButtonBox::ActionRole);
connect(button_box, &QDialogButtonBox::accepted, this, &IPAddressOverridesDialog::accept);
connect(button_box, &QDialogButtonBox::rejected, this, &IPAddressOverridesDialog::reject);
connect(button_box, &QDialogButtonBox::accepted, this, &IPRedirectionsDialog::accept);
connect(button_box, &QDialogButtonBox::rejected, this, &IPRedirectionsDialog::reject);
connect(this, &IPAddressOverridesDialog::accepted, this, &IPAddressOverridesDialog::SaveConfig);
connect(this, &IPRedirectionsDialog::accepted, this, &IPRedirectionsDialog::SaveConfig);
connect(m_ip_overrides_table, &QTableWidget::itemChanged, this, [this](QTableWidgetItem* item) {
const int row_count = m_ip_overrides_table->rowCount();
const bool is_last_row = item->row() == row_count - 1;
if (is_last_row)
{
if (!item->text().isEmpty())
m_ip_overrides_table->insertRow(row_count);
}
else if (item->column() != COLUMN_DESCRIPTION && item->text().isEmpty())
{
// Just remove inner rows that have text erased.
// This UX could be less weird, but it's good enough for now.
m_ip_overrides_table->removeRow(item->row());
}
});
connect(m_ip_redirections_table, &QTableWidget::itemChanged, this,
[this](QTableWidgetItem* item) {
const int row_count = m_ip_redirections_table->rowCount();
const bool is_last_row = item->row() == row_count - 1;
if (is_last_row)
{
if (!item->text().isEmpty())
m_ip_redirections_table->insertRow(row_count);
}
else if (item->column() != COLUMN_DESCRIPTION && item->text().isEmpty())
{
// Just remove inner rows that have text erased.
// This UX could be less weird, but it's good enough for now.
m_ip_redirections_table->removeRow(item->row());
}
});
LoadConfig();
QtUtils::AdjustSizeWithinScreen(this);
}
void IPAddressOverridesDialog::LoadConfig()
void IPRedirectionsDialog::LoadConfig()
{
m_ip_overrides_table->setRowCount(0);
m_ip_redirections_table->setRowCount(0);
// Add the final empty row.
m_ip_overrides_table->insertRow(0);
m_ip_redirections_table->insertRow(0);
int row = 0;
const auto ip_overrides_str = Config::Get(Config::MAIN_TRIFORCE_IP_OVERRIDES);
for (auto&& ip_pair : ip_overrides_str | std::views::split(','))
const auto ip_redirections_str = Config::Get(Config::MAIN_TRIFORCE_IP_REDIRECTIONS);
for (auto&& ip_pair : ip_redirections_str | std::views::split(','))
{
const auto ip_pair_str = std::string_view{ip_pair};
const auto parsed = AMMediaboard::ParseIPOverride(ip_pair_str);
const auto parsed = AMMediaboard::ParseIPRedirection(ip_pair_str);
if (!parsed.has_value())
{
ERROR_LOG_FMT(COMMON, "Bad IP pair string: {}", ip_pair_str);
ERROR_LOG_FMT(COMMON, "Bad IP redirection string: {}", ip_pair_str);
continue;
}
m_ip_overrides_table->insertRow(row);
m_ip_redirections_table->insertRow(row);
m_ip_overrides_table->setItem(row, COLUMN_EMULATED,
new QTableWidgetItem(QString::fromUtf8(parsed->original)));
m_ip_overrides_table->setItem(row, COLUMN_REAL,
new QTableWidgetItem(QString::fromUtf8(parsed->replacement)));
m_ip_overrides_table->setItem(row, COLUMN_DESCRIPTION,
new QTableWidgetItem(QString::fromUtf8(parsed->description)));
m_ip_redirections_table->setItem(row, COLUMN_EMULATED,
new QTableWidgetItem(QString::fromUtf8(parsed->original)));
m_ip_redirections_table->setItem(row, COLUMN_REAL,
new QTableWidgetItem(QString::fromUtf8(parsed->replacement)));
m_ip_redirections_table->setItem(row, COLUMN_DESCRIPTION,
new QTableWidgetItem(QString::fromUtf8(parsed->description)));
++row;
}
}
void IPAddressOverridesDialog::SaveConfig() const
void IPRedirectionsDialog::SaveConfig() const
{
// Ignore our empty row.
const int row_count = m_ip_overrides_table->rowCount() - 1;
const int row_count = m_ip_redirections_table->rowCount() - 1;
std::vector<std::string> replacements(row_count);
for (int row = 0; row < row_count; ++row)
{
auto* const original_item = m_ip_overrides_table->item(row, COLUMN_EMULATED);
auto* const replacement_item = m_ip_overrides_table->item(row, COLUMN_REAL);
auto* const original_item = m_ip_redirections_table->item(row, COLUMN_EMULATED);
auto* const replacement_item = m_ip_redirections_table->item(row, COLUMN_REAL);
// Skip incomplete rows.
if (original_item == nullptr || replacement_item == nullptr)
@ -188,7 +190,7 @@ void IPAddressOverridesDialog::SaveConfig() const
replacements[row] = fmt::format("{}={}", StripWhitespace(original_item->text().toStdString()),
replacement_item->text().toStdString());
auto* const description_item = m_ip_overrides_table->item(row, COLUMN_DESCRIPTION);
auto* const description_item = m_ip_redirections_table->item(row, COLUMN_DESCRIPTION);
if (description_item == nullptr)
continue;
@ -198,22 +200,22 @@ void IPAddressOverridesDialog::SaveConfig() const
(replacements[row] += ' ') += description;
}
Config::SetBaseOrCurrent(Config::MAIN_TRIFORCE_IP_OVERRIDES,
Config::SetBaseOrCurrent(Config::MAIN_TRIFORCE_IP_REDIRECTIONS,
fmt::format("{}", fmt::join(replacements, ",")));
}
void IPAddressOverridesDialog::LoadDefault()
void IPRedirectionsDialog::LoadDefault()
{
// This alters the config before "OK" is pressed. Bad UX..
Config::SetBaseOrCurrent(Config::MAIN_TRIFORCE_IP_OVERRIDES, Config::DefaultState{});
Config::SetBaseOrCurrent(Config::MAIN_TRIFORCE_IP_REDIRECTIONS, Config::DefaultState{});
LoadConfig();
}
void IPAddressOverridesDialog::OnClear()
void IPRedirectionsDialog::OnClear()
{
m_ip_overrides_table->setRowCount(0);
m_ip_redirections_table->setRowCount(0);
// Add the final empty row.
m_ip_overrides_table->insertRow(0);
m_ip_redirections_table->insertRow(0);
}