Triforce: Rename IPOverrides to IPRedirections.

6 files changed, 113 insertions, 110 deletions

diff --git a/Source/Core/Core/Config/MainSettings.cpp b/Source/Core/Core/Config/MainSettings.cpp
index bc749b4b37..6d5f260f07 100644
--- a/Source/Core/Core/Config/MainSettings.cpp
+++ b/Source/Core/Core/Config/MainSettings.cpp
@@ -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.
diff --git a/Source/Core/Core/Config/MainSettings.h b/Source/Core/Core/Config/MainSettings.h
index dfbf166758..38c8fdc365 100644
--- a/Source/Core/Core/Config/MainSettings.h
+++ b/Source/Core/Core/Config/MainSettings.h
@@ -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
 
diff --git a/Source/Core/Core/HW/DVD/AMMediaboard.cpp b/Source/Core/Core/HW/DVD/AMMediaboard.cpp
index 38f98ef53d..5cd69f8a62 100644
--- a/Source/Core/Core/HW/DVD/AMMediaboard.cpp
+++ b/Source/Core/Core/HW/DVD/AMMediaboard.cpp
@@ -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));
   }
 
diff --git a/Source/Core/Core/HW/DVD/AMMediaboard.h b/Source/Core/Core/HW/DVD/AMMediaboard.h
index f33dc177ec..4fa649c8bb 100644
--- a/Source/Core/Core/HW/DVD/AMMediaboard.h
+++ b/Source/Core/Core/HW/DVD/AMMediaboard.h
@@ -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);
 
diff --git a/Source/Core/DolphinQt/Debugger/NetworkWidget.cpp b/Source/Core/DolphinQt/Debugger/NetworkWidget.cpp
index 77733bf252..c32f55c1b5 100644
--- a/Source/Core/DolphinQt/Debugger/NetworkWidget.cpp
+++ b/Source/Core/DolphinQt/Debugger/NetworkWidget.cpp
@@ -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));
   }
 }
 
diff --git a/Source/Core/DolphinQt/Settings/TriforcePane.cpp b/Source/Core/DolphinQt/Settings/TriforcePane.cpp
index 6efb9b94b2..025bbe0bd1 100644
--- a/Source/Core/DolphinQt/Settings/TriforcePane.cpp
+++ b/Source/Core/DolphinQt/Settings/TriforcePane.cpp
@@ -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(this, &IPAddressOverridesDialog::accepted, this, &IPAddressOverridesDialog::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(button_box, &QDialogButtonBox::accepted, this, &IPRedirectionsDialog::accept);
+  connect(button_box, &QDialogButtonBox::rejected, this, &IPRedirectionsDialog::reject);
+
+  connect(this, &IPRedirectionsDialog::accepted, this, &IPRedirectionsDialog::SaveConfig);
+
+  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);
 }