network_interface: Cleanup code

1 files changed, 83 insertions, 76 deletions

diff --git a/src/core/network/network_interface.cpp b/src/core/network/network_interface.cpp
index a8f41c6bc..6811f21b1 100644
--- a/src/core/network/network_interface.cpp
+++ b/src/core/network/network_interface.cpp
@@ -37,73 +37,73 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
             AF_INET, GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_GATEWAYS,
             nullptr, adapter_addresses.data(), &buf_size);
 
-        if (ret == ERROR_BUFFER_OVERFLOW) {
-            adapter_addresses.resize((buf_size / sizeof(IP_ADAPTER_ADDRESSES)) + 1);
-        } else {
+        if (ret != ERROR_BUFFER_OVERFLOW) {
             break;
         }
+
+        adapter_addresses.resize((buf_size / sizeof(IP_ADAPTER_ADDRESSES)) + 1);
     }
 
-    if (ret == NO_ERROR) {
-        std::vector<NetworkInterface> result;
+    if (ret != NO_ERROR) {
+        LOG_ERROR(Network, "Failed to get network interfaces with GetAdaptersAddresses");
+        return {};
+    }
 
-        for (auto current_address = adapter_addresses.data(); current_address != nullptr;
-             current_address = current_address->Next) {
-            if (current_address->FirstUnicastAddress == nullptr ||
-                current_address->FirstUnicastAddress->Address.lpSockaddr == nullptr) {
-                continue;
-            }
+    std::vector<NetworkInterface> result;
 
-            if (current_address->OperStatus != IfOperStatusUp) {
-                continue;
-            }
+    for (auto current_address = adapter_addresses.data(); current_address != nullptr;
+         current_address = current_address->Next) {
+        if (current_address->FirstUnicastAddress == nullptr ||
+            current_address->FirstUnicastAddress->Address.lpSockaddr == nullptr) {
+            continue;
+        }
 
-            const auto ip_addr = Common::BitCast<struct sockaddr_in>(
-                                     *current_address->FirstUnicastAddress->Address.lpSockaddr)
-                                     .sin_addr;
+        if (current_address->OperStatus != IfOperStatusUp) {
+            continue;
+        }
 
-            ULONG mask = 0;
-            if (ConvertLengthToIpv4Mask(current_address->FirstUnicastAddress->OnLinkPrefixLength,
-                                        &mask) != NO_ERROR) {
-                LOG_ERROR(Network, "Failed to convert IPv4 prefix length to subnet mask");
-                continue;
-            }
+        const auto ip_addr = Common::BitCast<struct sockaddr_in>(
+                                 *current_address->FirstUnicastAddress->Address.lpSockaddr)
+                                 .sin_addr;
 
-            struct in_addr gateway = {.S_un{.S_addr{0}}};
-            if (current_address->FirstGatewayAddress != nullptr &&
-                current_address->FirstGatewayAddress->Address.lpSockaddr != nullptr) {
-                gateway = Common::BitCast<struct sockaddr_in>(
-                              *current_address->FirstGatewayAddress->Address.lpSockaddr)
-                              .sin_addr;
-            }
+        ULONG mask = 0;
+        if (ConvertLengthToIpv4Mask(current_address->FirstUnicastAddress->OnLinkPrefixLength,
+                                    &mask) != NO_ERROR) {
+            LOG_ERROR(Network, "Failed to convert IPv4 prefix length to subnet mask");
+            continue;
+        }
 
-            result.push_back(NetworkInterface{
-                .name{Common::UTF16ToUTF8(std::wstring{current_address->FriendlyName})},
-                .ip_address{ip_addr},
-                .subnet_mask = in_addr{.S_un{.S_addr{mask}}},
-                .gateway = gateway});
+        struct in_addr gateway = {.S_un{.S_addr{0}}};
+        if (current_address->FirstGatewayAddress != nullptr &&
+            current_address->FirstGatewayAddress->Address.lpSockaddr != nullptr) {
+            gateway = Common::BitCast<struct sockaddr_in>(
+                          *current_address->FirstGatewayAddress->Address.lpSockaddr)
+                          .sin_addr;
         }
 
-        return result;
-    } else {
-        LOG_ERROR(Network, "Failed to get network interfaces with GetAdaptersAddresses");
-        return {};
+        result.emplace_back(NetworkInterface{
+            .name{Common::UTF16ToUTF8(std::wstring{current_address->FriendlyName})},
+            .ip_address{ip_addr},
+            .subnet_mask = in_addr{.S_un{.S_addr{mask}}},
+            .gateway = gateway});
     }
+
+    return result;
 }
 
 #else
 
 std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
-    std::vector<NetworkInterface> result;
-
     struct ifaddrs* ifaddr = nullptr;
 
     if (getifaddrs(&ifaddr) != 0) {
         LOG_ERROR(Network, "Failed to get network interfaces with getifaddrs: {}",
                   std::strerror(errno));
-        return result;
+        return {};
     }
 
+    std::vector<NetworkInterface> result;
+
     for (auto ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
         if (ifa->ifa_addr == nullptr || ifa->ifa_netmask == nullptr) {
             continue;
@@ -117,55 +117,62 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
             continue;
         }
 
-        std::uint32_t gateway{0};
+        u32 gateway{};
+
         std::ifstream file{"/proc/net/route"};
-        if (file.is_open()) {
+        if (!file.is_open()) {
+            LOG_ERROR(Network, "Failed to open \"/proc/net/route\"");
 
-            // ignore header
-            file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            result.emplace_back(NetworkInterface{
+                .name{ifa->ifa_name},
+                .ip_address{Common::BitCast<struct sockaddr_in>(*ifa->ifa_addr).sin_addr},
+                .subnet_mask{Common::BitCast<struct sockaddr_in>(*ifa->ifa_netmask).sin_addr},
+                .gateway{in_addr{.s_addr = gateway}}});
+            continue;
+        }
 
-            bool gateway_found = false;
+        // ignore header
+        file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
-            for (std::string line; std::getline(file, line);) {
-                std::istringstream iss{line};
+        bool gateway_found = false;
 
-                std::string iface_name{};
-                iss >> iface_name;
-                if (iface_name != ifa->ifa_name) {
-                    continue;
-                }
+        for (std::string line; std::getline(file, line);) {
+            std::istringstream iss{line};
 
-                iss >> std::hex;
+            std::string iface_name;
+            iss >> iface_name;
+            if (iface_name != ifa->ifa_name) {
+                continue;
+            }
 
-                std::uint32_t dest{0};
-                iss >> dest;
-                if (dest != 0) {
-                    // not the default route
-                    continue;
-                }
+            iss >> std::hex;
 
-                iss >> gateway;
+            u32 dest{};
+            iss >> dest;
+            if (dest != 0) {
+                // not the default route
+                continue;
+            }
 
-                std::uint16_t flags{0};
-                iss >> flags;
+            iss >> gateway;
 
-                // flag RTF_GATEWAY (defined in <linux/route.h>)
-                if ((flags & 0x2) == 0) {
-                    continue;
-                }
+            u16 flags{};
+            iss >> flags;
 
-                gateway_found = true;
-                break;
+            // flag RTF_GATEWAY (defined in <linux/route.h>)
+            if ((flags & 0x2) == 0) {
+                continue;
             }
 
-            if (!gateway_found) {
-                gateway = 0;
-            }
-        } else {
-            LOG_ERROR(Network, "Failed to open \"/proc/net/route\"");
+            gateway_found = true;
+            break;
+        }
+
+        if (!gateway_found) {
+            gateway = 0;
         }
 
-        result.push_back(NetworkInterface{
+        result.emplace_back(NetworkInterface{
             .name{ifa->ifa_name},
             .ip_address{Common::BitCast<struct sockaddr_in>(*ifa->ifa_addr).sin_addr},
             .subnet_mask{Common::BitCast<struct sockaddr_in>(*ifa->ifa_netmask).sin_addr},