ALL THE ERROR CODES

src/core/internal_network/network.cpp

@@ -92,42 +92,42 @@ LINGER MakeLinger(bool enable, u32 linger_value) {
 
 Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
     switch (e) {
-    case 0: return Errno::SUCCESS;
+    case 0: return Errno::E_SUCCESS;
     case WSAECONNABORTED:
         if (call_type == CallType::Send) {
             // Winsock yields WSAECONNABORTED from `send` in situations where Unix
             // systems, and actual Switches, yield EPIPE.
-            return Errno::PIPE;
+            return Errno::E_PIPE;
         } else {
-            return Errno::CONNABORTED;
+            return Errno::E_CONNABORTED;
         }
-    case WSAEBADF: return Errno::BADF;
-    case WSAEINVAL: return Errno::INVAL;
-    case WSAEMFILE: return Errno::MFILE;
-    case WSAENOTCONN: return Errno::NOTCONN;
-    case WSAEWOULDBLOCK: return Errno::AGAIN;
-    case WSAECONNREFUSED: return Errno::CONNREFUSED;
-    case WSAECONNRESET: return Errno::CONNRESET;
-    case WSAEHOSTUNREACH: return Errno::HOSTUNREACH;
-    case WSAENETDOWN: return Errno::NETDOWN;
-    case WSAENETUNREACH: return Errno::NETUNREACH;
-    case WSAEMSGSIZE: return Errno::MSGSIZE;
-    case WSAETIMEDOUT: return Errno::TIMEDOUT;
-    case WSAEINPROGRESS: return Errno::INPROGRESS;
-    case WSAEISCONN: return Errno::ISCONN;
-    case WSAEADDRINUSE: return Errno::ADDRINUSE;
-    case WSAEADDRNOTAVAIL: return Errno::ADDRNOTAVAIL;
-    case WSAEPROTOTYPE: return Errno::PROTOTYPE;
-    case WSAENOPROTOOPT: return Errno::NOPROTOOPT;
-    case WSAEPROTONOSUPPORT: return Errno::PROTONOSUPPORT;
-    case WSAESOCKTNOSUPPORT: return Errno::SOCKTNOSUPPORT;
+    case WSAEBADF: return Errno::E_BADF;
+    case WSAEINVAL: return Errno::E_INVAL;
+    case WSAEMFILE: return Errno::E_MFILE;
+    case WSAENOTCONN: return Errno::E_NOTCONN;
+    case WSAEWOULDBLOCK: return Errno::E_AGAIN;
+    case WSAECONNREFUSED: return Errno::E_CONNREFUSED;
+    case WSAECONNRESET: return Errno::E_CONNRESET;
+    case WSAEHOSTUNREACH: return Errno::E_HOSTUNREACH;
+    case WSAENETDOWN: return Errno::E_NETDOWN;
+    case WSAENETUNREACH: return Errno::E_NETUNREACH;
+    case WSAEMSGSIZE: return Errno::E_MSGSIZE;
+    case WSAETIMEDOUT: return Errno::E_TIMEDOUT;
+    case WSAEINPROGRESS: return Errno::E_INPROGRESS;
+    case WSAEISCONN: return Errno::E_ISCONN;
+    case WSAEADDRINUSE: return Errno::E_ADDRINUSE;
+    case WSAEADDRNOTAVAIL: return Errno::E_ADDRNOTAVAIL;
+    case WSAEPROTOTYPE: return Errno::E_PROTOTYPE;
+    case WSAENOPROTOOPT: return Errno::E_NOPROTOOPT;
+    case WSAEPROTONOSUPPORT: return Errno::E_PROTONOSUPPORT;
+    case WSAESOCKTNOSUPPORT: return Errno::E_SOCKTNOSUPPORT;
 #ifdef WSAENOTSUP
     // Not defined by fucking MSVC because MSVC is stupid as shitfuckery
-    case WSAENOTSUP: return Errno::NOTSUP;
+    case WSAENOTSUP: return Errno::E_NOTSUP;
 #endif
     default:
         UNIMPLEMENTED_MSG("Unimplemented errno={}", e);
-        return Errno::OTHER;
+        return Errno::E_OTHER;
     }
 }
 
@@ -210,7 +210,7 @@ linger MakeLinger(bool enable, u32 linger_value) {
 
 Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
     switch (e) {
-    case 0: return Errno::SUCCESS;
+    case 0: return Errno::E_SUCCESS;
 #define NETWORK_ERROR_LIST \
     NETWORK_ERROR_ELEM(NOENT) \
     NETWORK_ERROR_ELEM(INTR) \
@@ -234,6 +234,7 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
     NETWORK_ERROR_ELEM(ISCONN) \
     NETWORK_ERROR_ELEM(PROTOTYPE) \
     NETWORK_ERROR_ELEM(NOPROTOOPT) \
+    NETWORK_ERROR_ELEM(AFNOSUPPORT) \
     NETWORK_ERROR_ELEM(PROTONOSUPPORT) \
     NETWORK_ERROR_ELEM(SOCKTNOSUPPORT) \
     NETWORK_ERROR_ELEM(NOTSUP) \
@@ -242,13 +243,13 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
     NETWORK_ERROR_ELEM(NOTSOCK) \
     NETWORK_ERROR_ELEM(ALREADY) \
     NETWORK_ERROR_ELEM(STALE)
-#define NETWORK_ERROR_ELEM(name) case E##name: return Errno::name;
+#define NETWORK_ERROR_ELEM(name) case E##name: return Errno::E_##name;
     NETWORK_ERROR_LIST
 #undef NETWORK_ERROR_ELEM
 #undef NETWORK_ERROR_LIST
     default:
         UNIMPLEMENTED_MSG("Unimplemented errno={} ({})", e, strerror(e));
-        return Errno::OTHER;
+        return Errno::E_OTHER;
     }
 }
 
@@ -261,7 +262,7 @@ Errno GetAndLogLastError(CallType call_type) {
     int e = errno;
 #endif
     const Errno err = TranslateNativeError(e, call_type);
-    if (err == Errno::AGAIN || err == Errno::TIMEDOUT || err == Errno::INPROGRESS) {
+    if (err == Errno::E_AGAIN || err == Errno::E_TIMEDOUT || err == Errno::E_INPROGRESS) {
         // These happen during normal operation, so only log them at debug level.
         LOG_DEBUG(Network, "Socket operation error: {}", Common::NativeErrorToString(e));
         return err;
@@ -909,7 +910,7 @@ std::pair<s32, Errno> Poll(std::span<HostPollFD> pollfds, s32 timeout) {
         ASSERT(std::all_of(host_pollfds.begin(), host_pollfds.end(), [](auto const fd) {
             return fd.revents == 0;
         }));
-        return {0, Errno::SUCCESS};
+        return {0, Errno::E_SUCCESS};
     }
 
     for (size_t i = 0; i < pollfds.size(); ++i)
@@ -919,7 +920,7 @@ std::pair<s32, Errno> Poll(std::span<HostPollFD> pollfds, s32 timeout) {
         ASSERT(res == SOCKET_ERROR);
         return {-1, GetAndLogLastError(CallType::Other)};
     }
-    return {res, Errno::SUCCESS};
+    return {res, Errno::E_SUCCESS};
 }
 
 Socket::~Socket() {
@@ -1035,7 +1036,7 @@ Errno Socket::GetSockOpt(Network::SocketLevel level, Network::OptName optname, s
     const int result = getsockopt(fd, native_level, native_optname, reinterpret_cast<char*>(value.data()), &len);
     if (result != SOCKET_ERROR) {
         ASSERT(len == socklen_t(value.size()));
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     }
     return GetAndLogLastError(CallType::Other);
 }
@@ -1043,7 +1044,7 @@ Errno Socket::GetSockOpt(Network::SocketLevel level, Network::OptName optname, s
 Errno Socket::SetNonBlock(bool enable) {
     if (EnableNonBlock(fd, enable)) {
         is_non_blocking = enable;
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     }
     return GetAndLogLastError(CallType::Other);
 }
@@ -1059,10 +1060,10 @@ Errno Socket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, s
             std::memcpy(&linger, optval.data(), sizeof(linger));
             auto const linger_optval = MakeLinger(bool(linger.onoff), linger.linger);
             if (setsockopt(fd, native_level, native_optname, reinterpret_cast<const char*>(&linger_optval), sizeof(linger_optval)) != SOCKET_ERROR)
-                return Errno::SUCCESS;
+                return Errno::E_SUCCESS;
             return GetAndLogLastError(CallType::Other);
         }
-        return Errno::INVAL;
+        return Errno::E_INVAL;
     } else if (optname == Network::OptName::RCVTIMEO || optname == Network::OptName::SNDTIMEO) {
         if (optval.size() >= sizeof(Network::Timeval)) {
             Network::Timeval guest_tv{};
@@ -1071,20 +1072,20 @@ Errno Socket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, s
             tv.tv_sec = guest_tv.tv_sec;
             tv.tv_usec = guest_tv.tv_usec;
             if (setsockopt(fd, native_level, native_optname, reinterpret_cast<const char*>(&tv), sizeof(tv)) != SOCKET_ERROR)
-                return Errno::SUCCESS;
+                return Errno::E_SUCCESS;
             return GetAndLogLastError(CallType::Other);
         }
-        return Errno::INVAL;
+        return Errno::E_INVAL;
     }
     if (setsockopt(fd, native_level, native_optname, reinterpret_cast<const char*>(optval.data()), socklen_t(optval.size())) != SOCKET_ERROR)
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     return GetAndLogLastError(CallType::Other);
 }
 
 Errno Socket::Initialize(Domain domain, Type type, Protocol protocol) {
     fd = socket(TranslateDomainToNative(domain), TranslateTypeToNative(type), TranslateProtocolToNative(protocol));
     if (fd != INVALID_SOCKET)
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     return GetAndLogLastError(CallType::Other);
 }
 
@@ -1102,7 +1103,7 @@ std::pair<Socket::AcceptResult, Errno> Socket::Accept() {
             pollres = WSAPoll(host_pollfds.data(), ULONG(host_pollfds.size()), -1);
             // Interrupt signaled before a client could be accepted, break
             if (host_pollfds[1].revents != 0)
-                return {AcceptResult{}, Errno::AGAIN};
+                return {AcceptResult{}, Errno::E_AGAIN};
         }
     }
 
@@ -1116,7 +1117,7 @@ std::pair<Socket::AcceptResult, Errno> Socket::Accept() {
         .sockaddr_in = TranslateToSockAddrIn(addr),
     };
 
-    return {std::move(result), Errno::SUCCESS};
+    return {std::move(result), Errno::E_SUCCESS};
 }
 
 Errno Socket::Connect(Network::SockAddrIn addr_in) {
@@ -1124,7 +1125,7 @@ Errno Socket::Connect(Network::SockAddrIn addr_in) {
     if (EnableNonBlock(fd, false)) {
         if (connect(fd, reinterpret_cast<sockaddr const*>(&host_addr_in), sizeof(host_addr_in)) != SOCKET_ERROR) {
             if (EnableNonBlock(fd, true)) {
-                return Errno::SUCCESS;
+                return Errno::E_SUCCESS;
             }
         }
     }
@@ -1136,7 +1137,7 @@ std::pair<Network::SockAddrIn, Errno> Socket::GetPeerName() {
     socklen_t addrlen = sizeof(addr);
     if (getpeername(fd, reinterpret_cast<sockaddr*>(&addr), &addrlen) == SOCKET_ERROR)
         return {Network::SockAddrIn{}, GetAndLogLastError(CallType::Other)};
-    return {TranslateToSockAddrIn(addr), Errno::SUCCESS};
+    return {TranslateToSockAddrIn(addr), Errno::E_SUCCESS};
 }
 
 std::pair<Network::SockAddrIn, Errno> Socket::GetSockName() {
@@ -1146,19 +1147,19 @@ std::pair<Network::SockAddrIn, Errno> Socket::GetSockName() {
         return {Network::SockAddrIn{}, GetAndLogLastError(CallType::Other)};
     }
 
-    return {TranslateToSockAddrIn(addr), Errno::SUCCESS};
+    return {TranslateToSockAddrIn(addr), Errno::E_SUCCESS};
 }
 
 Errno Socket::Bind(Network::SockAddrIn addr) {
     auto const addr_in = TranslateFromSockAddrIn(addr);
     if (bind(fd, reinterpret_cast<sockaddr const*>(&addr_in), sizeof(addr_in)) != SOCKET_ERROR)
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     return GetAndLogLastError(CallType::Other);
 }
 
 Errno Socket::Listen(s32 backlog) {
     if (listen(fd, backlog) != SOCKET_ERROR)
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     return GetAndLogLastError(CallType::Other);
 }
 
@@ -1176,10 +1177,10 @@ Errno Socket::Shutdown(ShutdownHow how) {
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented flag how={}", how);
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     }
     if (shutdown(fd, host_how) != SOCKET_ERROR) {
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     }
 
     return GetAndLogLastError(CallType::Other);
@@ -1224,7 +1225,7 @@ std::pair<s32, Errno> Socket::Recv(int flags, std::span<u8> message) {
     auto const native_flags = TranslateMsgOptToNative(flags);
     auto const result = recv(fd, reinterpret_cast<char*>(message.data()), int(message.size()), native_flags);
     if (result != SOCKET_ERROR)
-        return {s32(result), Errno::SUCCESS};
+        return {s32(result), Errno::E_SUCCESS};
     return {-1, GetAndLogLastError(CallType::Other)};
 }
 
@@ -1243,7 +1244,7 @@ std::pair<s32, Errno> Socket::RecvFrom(int flags, std::span<u8> message, Network
         if (addr) {
             *addr = TranslateToSockAddrIn(addr_in);
         }
-        return {s32(result), Errno::SUCCESS};
+        return {s32(result), Errno::E_SUCCESS};
     }
     return {-1, GetAndLogLastError(CallType::Other)};
 }
@@ -1259,7 +1260,7 @@ std::pair<s32, Errno> Socket::Send(std::span<const u8> message, int flags) {
 #endif
     const auto result = send(fd, reinterpret_cast<const char*>(message.data()), int(message.size()), native_flags);
     if (result != SOCKET_ERROR)
-        return {s32(result), Errno::SUCCESS};
+        return {s32(result), Errno::E_SUCCESS};
     return {-1, GetAndLogLastError(CallType::Send)};
 }
 
@@ -1283,7 +1284,7 @@ std::pair<s32, Errno> Socket::SendTo(u32 flags, std::span<const u8> message, con
 
     const auto result = sendto(fd, reinterpret_cast<const char*>(message.data()), int(message.size()), native_flags, reinterpret_cast<sockaddr const*>(to), to_len);
     if (result != SOCKET_ERROR)
-        return {s32(result), Errno::SUCCESS};
+        return {s32(result), Errno::E_SUCCESS};
     return {-1, GetAndLogLastError(CallType::Send)};
 }
 
@@ -1294,7 +1295,7 @@ Errno Socket::Close() {
     }
     fd = INVALID_SOCKET;
 
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<Errno, Errno> Socket::GetPendingError() {

src/core/internal_network/socket_icmp.cpp

@@ -44,54 +44,54 @@ Errno IcmpSocket::SetSockOpt(Network::SocketLevel level, Network::OptName optnam
     LOG_WARNING(Network, "(stubbed) level={},optname={},optval={}", level, optname, optval.size());
     if (optname == Network::OptName::RCVTIMEO) {
         if (optval.size() < sizeof(Network::Timeval))
-            return Errno::INVAL;
+            return Errno::E_INVAL;
         std::memcpy(&rcv_timeo, optval.data(), sizeof(rcv_timeo));
     }
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno IcmpSocket::Initialize(Domain domain, Type type, Protocol socket_protocol) {
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<IcmpSocket::AcceptResult, Errno> IcmpSocket::Accept() {
     LOG_WARNING(Network, "(stubbed) called");
-    return {AcceptResult{}, Errno::SUCCESS};
+    return {AcceptResult{}, Errno::E_SUCCESS};
 }
 
 Errno IcmpSocket::Connect(Network::SockAddrIn addr_in) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<Network::SockAddrIn, Errno> IcmpSocket::GetPeerName() {
     LOG_WARNING(Network, "(stubbed) called");
-    return {Network::SockAddrIn{}, Errno::SUCCESS};
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
 }
 
 std::pair<Network::SockAddrIn, Errno> IcmpSocket::GetSockName() {
     LOG_WARNING(Network, "(stubbed) called");
-    return {Network::SockAddrIn{}, Errno::SUCCESS};
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
 }
 
 Errno IcmpSocket::Bind(Network::SockAddrIn addr) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno IcmpSocket::Listen(s32 backlog) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno IcmpSocket::Shutdown(ShutdownHow how) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<s32, Errno> IcmpSocket::Recv(int flags, std::span<u8> message) {
     LOG_DEBUG(Network, "(stubbed) called");
-    return {s32(0), Errno::NOTCONN};
+    return {s32(0), Errno::E_NOTCONN};
 }
 
 std::pair<s32, Errno> IcmpSocket::RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) {
@@ -101,7 +101,7 @@ std::pair<s32, Errno> IcmpSocket::RecvFrom(int flags, std::span<u8> message, Net
 #if !defined(__OPENORBIS__) && (defined(__FreeBSD__) || defined(__linux__))
     if (addr) {
         if (seq_ident.empty())
-            return {0, Errno::SUCCESS};
+            return {0, Errno::E_SUCCESS};
         // PLEASE DON'T KILL ME, I SWEAR THIS IS LEGITIMATELY THE BEST WAY TO DO IT
         // IF YOU OPEN socket() GOOGLE WILL STRAIGHT UP IP BAN YOU AFTER 2 HOURS
         auto const rcv_timeout = std::max<u64>(rcv_timeo.tv_sec, 1);
@@ -127,12 +127,12 @@ std::pair<s32, Errno> IcmpSocket::RecvFrom(int flags, std::span<u8> message, Net
             data[3] = u8(csum); //lo
             auto const n = (std::max)(data.size(), message.size());
             std::copy(data.begin(), data.begin() + n, message.begin());
-            return {n, Errno::SUCCESS};
+            return {n, Errno::E_SUCCESS};
         }
-        return {-1, Errno::TIMEDOUT};
+        return {-1, Errno::E_TIMEDOUT};
     }
 #endif
-    return {-1, Errno::INVAL};
+    return {-1, Errno::E_INVAL};
 }
 
 std::pair<s32, Errno> IcmpSocket::Send(std::span<const u8> message, int flags) {
@@ -143,7 +143,7 @@ std::pair<s32, Errno> IcmpSocket::Send(std::span<const u8> message, int flags) {
         | (u32(message[6]) << 8)
         | (u32(message[7]) << 0)
     );
-    return {s32(0), Errno::NOTCONN};
+    return {s32(0), Errno::E_NOTCONN};
 }
 
 std::pair<s32, Errno> IcmpSocket::SendTo(u32 flags, std::span<const u8> message, const Network::SockAddrIn* addr) {
@@ -155,19 +155,19 @@ std::pair<s32, Errno> IcmpSocket::SendTo(u32 flags, std::span<const u8> message,
     // 4..6 -> ident
     // 6..8 -> seq
     if (!message.empty())
-        return {s32(message.size()), Errno::SUCCESS};
-    return {-1, Errno::INVAL};
+        return {s32(message.size()), Errno::E_SUCCESS};
+    return {-1, Errno::E_INVAL};
 }
 
 Errno IcmpSocket::Close() {
     LOG_DEBUG(Network, "called");
     fd = INVALID_SOCKET;
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<Errno, Errno> IcmpSocket::GetPendingError() {
     LOG_DEBUG(Network, "called");
-    return {Errno::SUCCESS, Errno::SUCCESS};
+    return {Errno::E_SUCCESS, Errno::E_SUCCESS};
 }
 
 bool IcmpSocket::IsOpened() const {
@@ -178,7 +178,7 @@ void IcmpSocket::HandleProxyPacket(const ProxyPacket& packet) {
     LOG_WARNING(Network, "(stubbed) called");
 }
 Errno IcmpSocket::SetNonBlock(bool enable) {
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 } // namespace Network

src/core/internal_network/socket_proxy.cpp

@@ -49,7 +49,7 @@ void ProxySocket::HandleProxyPacket(const ProxyPacket& packet) {
 
 Errno ProxySocket::SetNonBlock(bool enable) {
     blocking = !enable;
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno ProxySocket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval) {
@@ -65,59 +65,59 @@ Errno ProxySocket::SetSockOpt(Network::SocketLevel level, Network::OptName optna
         if (optname == Network::OptName::RCVTIMEO)
             receive_timeout = value;
     }
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno ProxySocket::Initialize(Domain domain, Type type, Protocol socket_protocol) {
     protocol = socket_protocol;
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<ProxySocket::AcceptResult, Errno> ProxySocket::Accept() {
     LOG_WARNING(Network, "(stubbed) called");
-    return {AcceptResult{}, Errno::SUCCESS};
+    return {AcceptResult{}, Errno::E_SUCCESS};
 }
 
 Errno ProxySocket::Connect(Network::SockAddrIn addr_in) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<Network::SockAddrIn, Errno> ProxySocket::GetPeerName() {
     LOG_WARNING(Network, "(stubbed) called");
-    return {Network::SockAddrIn{}, Errno::SUCCESS};
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
 }
 
 std::pair<Network::SockAddrIn, Errno> ProxySocket::GetSockName() {
     LOG_WARNING(Network, "(stubbed) called");
-    return {Network::SockAddrIn{}, Errno::SUCCESS};
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
 }
 
 Errno ProxySocket::Bind(Network::SockAddrIn addr) {
     if (is_bound) {
         LOG_WARNING(Network, "Rebinding Socket is unimplemented!");
-        return Errno::SUCCESS;
+        return Errno::E_SUCCESS;
     }
     local_endpoint = addr;
     is_bound = true;
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno ProxySocket::Listen(s32 backlog) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 Errno ProxySocket::Shutdown(ShutdownHow how) {
     LOG_WARNING(Network, "(stubbed) called");
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<s32, Errno> ProxySocket::Recv(int flags, std::span<u8> message) {
     LOG_WARNING(Network, "(stubbed) called");
     ASSERT(flags == 0);
     ASSERT(message.size() < std::size_t((std::numeric_limits<int>::max)()));
-    return {s32(0), Errno::SUCCESS};
+    return {s32(0), Errno::E_SUCCESS};
 }
 
 std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) {
@@ -139,7 +139,7 @@ std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, Ne
         }
 
         if (!blocking) {
-            return {-1, Errno::AGAIN};
+            return {-1, Errno::E_AGAIN};
         }
 
         std::this_thread::yield();
@@ -147,7 +147,7 @@ std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, Ne
         const auto time_diff = std::chrono::steady_clock::now() - timestamp;
         const auto time_diff_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_diff).count();
         if (time_diff_ms > timeout) {
-            return {-1, Errno::TIMEDOUT};
+            return {-1, Errno::E_TIMEDOUT};
         }
     }
 }
@@ -173,7 +173,7 @@ std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> messag
             if (!peek) {
                 received_packets.pop();
             }
-            return {-1, Errno::MSGSIZE};
+            return {-1, Errno::E_MSGSIZE};
         } else if (protocol == Protocol::TCP) {
             std::vector<u8> numArray(packet.data.size() - max_length);
             std::copy(packet.data.begin() + max_length, packet.data.end(), std::back_inserter(numArray));
@@ -187,14 +187,14 @@ std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> messag
         }
     }
 
-    return {u32(read_bytes), Errno::SUCCESS};
+    return {u32(read_bytes), Errno::E_SUCCESS};
 }
 
 std::pair<s32, Errno> ProxySocket::Send(std::span<const u8> message, int flags) {
     LOG_WARNING(Network, "(stubbed) called");
     ASSERT(message.size() < size_t((std::numeric_limits<int>::max)()));
     ASSERT(flags == 0);
-    return {s32(0), Errno::SUCCESS};
+    return {s32(0), Errno::E_SUCCESS};
 }
 
 void ProxySocket::SendPacket(ProxyPacket& packet) {
@@ -212,12 +212,12 @@ std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message
 
     if (!is_bound) {
         LOG_ERROR(Network, "ProxySocket is not bound!");
-        return {s32(message.size()), Errno::SUCCESS};
+        return {s32(message.size()), Errno::E_SUCCESS};
     }
 
     if (auto room_member = Network::GetRoomMember().lock()) {
         if (!room_member->IsConnected()) {
-            return {s32(message.size()), Errno::SUCCESS};
+            return {s32(message.size()), Errno::E_SUCCESS};
         }
     }
 
@@ -242,7 +242,7 @@ std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message
 
     SendPacket(packet);
 
-    return {s32(message.size()), Errno::SUCCESS};
+    return {s32(message.size()), Errno::E_SUCCESS};
 }
 
 Errno ProxySocket::Close() {
@@ -250,12 +250,12 @@ Errno ProxySocket::Close() {
     fd = INVALID_SOCKET;
     closed = true;
 
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<Errno, Errno> ProxySocket::GetPendingError() {
     LOG_DEBUG(Network, "called");
-    return {Errno::SUCCESS, Errno::SUCCESS};
+    return {Errno::E_SUCCESS, Errno::E_SUCCESS};
 }
 
 bool ProxySocket::IsOpened() const {

src/core/internal_network/socket_types.h

@@ -19,39 +19,139 @@
 namespace Network {
 
 enum class Errno : u32 {
-    SUCCESS = 0,
-    NOENT = 2,
-    INTR = 4,
-    IO = 5,
-    NOEXEC = 8,
-    BADF = 9,
-    AGAIN = 11,
-    INVAL = 22,
-    MFILE = 24,
-    PIPE = 32,
-    NOTSOCK = 88,
-    MSGSIZE = 90,
-    PROTOTYPE = 91,
-    NOPROTOOPT = 92,
-    PROTONOSUPPORT = 93,
-    SOCKTNOSUPPORT = 94,
-    NOTSUP = 95,
-    ADDRINUSE = 98,
-    ADDRNOTAVAIL = 99,
-    NETDOWN = 100,
-    NETUNREACH = 101,
-    CONNABORTED = 103,
-    CONNRESET = 104,
-    ISCONN = 106,
-    NOTCONN = 107,
-    TIMEDOUT = 110,
-    CONNREFUSED = 111,
-    HOSTUNREACH = 113,
-    ALREADY = 114,
-    INPROGRESS = 115,
-    STALE = 116,
-    /* made up error? */
-    OTHER = 196,
+    E_SUCCESS = 0,
+    E_PERM = 1,
+    E_NOENT = 2,
+    E_SRCH = 3,
+    E_INTR = 4,
+    E_IO = 5,
+    E_NXIO = 6,
+    E_2BIG = 7,
+    E_NOEXEC = 8,
+    E_BADF = 9,
+    E_CHILD = 10,
+    E_AGAIN = 11,
+    E_NOMEM = 12,
+    E_ACCES = 13,
+    E_FAULT = 14,
+    E_NOTBLK = 15,
+    E_BUSY = 16,
+    E_EXIST = 17,
+    E_XDEV = 18,
+    E_NODEV = 19,
+    E_NOTDIR = 20,
+    E_ISDIR = 21,
+    E_INVAL = 22,
+    E_NFILE = 23,
+    E_MFILE = 24,
+    E_NOTTY = 25,
+    E_TXTBSY = 26,
+    E_FBIG = 27,
+    E_NOSPC = 28,
+    E_SPIPE = 29,
+    E_ROFS = 30,
+    E_MLINK = 31,
+    E_PIPE = 32,
+    E_DOM = 33,
+    E_RANGE = 34,
+    E_DEADLK = 35,
+    E_NAMETOOLONG = 36,
+    E_NOLCK = 37,
+    E_NOSYS = 38,
+    E_NOTEMPTY = 39,
+    E_LOOP = 40,
+    E_NOMSG = 42,
+    E_IDRM = 43,
+    E_CHRNG = 44,
+    E_L2NSYNC = 45,
+    E_L3HLT = 46,
+    E_L3RST = 47,
+    E_LNRNG = 48,
+    E_UNATCH = 49,
+    E_NOCSI = 50,
+    E_L2HLT = 51,
+    E_BADE = 52,
+    E_BADR = 53,
+    E_XFULL = 54,
+    E_NOANO = 55,
+    E_BADRQC = 56,
+    E_BADSSL = 57,
+    E_BFONT = 59,
+    E_NOSTR = 60,
+    E_NODATA = 61,
+    E_TIME = 62,
+    E_NOSR = 63,
+    E_NONET = 64,
+    E_NOPKG = 65,
+    E_REMOTE = 66,
+    E_NOLINK = 67,
+    E_ADV = 68,
+    E_SRMNT = 69,
+    E_COMM = 70,
+    E_PROTO = 71,
+    E_MULTIHOP = 72,
+    E_DOTDOT = 73,
+    E_BADMSG = 74,
+    E_OVERFLOW = 75,
+    E_NOTUNUQ = 76,
+    E_BADFD = 77,
+    E_REMCHG = 78,
+    E_LIBACC = 79,
+    E_LIBBAD = 80,
+    E_LIBSCN = 81,
+    E_LIBMAX = 82,
+    E_LIBEXEC = 83,
+    E_ILSEQ = 84,
+    E_RESTART = 85,
+    E_STRPIPE = 86,
+    E_USERS = 87,
+    E_NOTSOCK = 88,
+    E_DESTADDRREQ = 89,
+    E_MSGSIZE = 90,
+    E_PROTOTYPE = 91,
+    E_NOPROTOOPT = 92,
+    E_PROTONOSUPPORT = 93,
+    E_SOCKTNOSUPPORT = 94,
+    E_OPNOTSUPP = 95,
+    E_PFNOSUPPORT = 96,
+    E_AFNOSUPPORT = 97,
+    E_ADDRINUSE = 98,
+    E_ADDRNOTAVAIL = 99,
+    E_NETDOWN = 100,
+    E_NETUNREACH = 101,
+    E_NETRESET = 102,
+    E_CONNABORTED = 103,
+    E_CONNRESET = 104,
+    E_NOBUFS = 105,
+    E_ISCONN = 106,
+    E_NOTCONN = 107,
+    E_SHUTDOWN = 108,
+    E_TOOMANYREFS = 109,
+    E_TIMEDOUT = 110,
+    E_CONNREFUSED = 111,
+    E_HOSTDOWN = 112,
+    E_HOSTUNREACH = 113,
+    E_ALREADY = 114,
+    E_INPROGRESS = 115,
+    E_STALE = 116,
+    E_UCLEAN = 117,
+    E_NOTNAM = 118,
+    E_NAVAIL = 119,
+    E_ISNAM = 120,
+    E_REMOTEIO = 121,
+    E_DQUOT = 122,
+    E_NOMEDIUM = 123,
+    E_MEDIUMTYPE = 124,
+    E_CANCELED = 125,
+    E_NOKEY = 126,
+    E_KEYEXPIRED = 127,
+    E_KEYREVOKED = 128,
+    E_KEYREJECTED = 129,
+    E_OWNERDEAD = 130,
+    E_NOTRECOVERABLE = 131,
+    E_RFKILL = 132,
+    E_HWPOISON = 133,
+    E_PROCLIM = 156,
 };
 
 enum class GetAddrInfoError : s32 {