ALL THE ERROR CODES

src/core/hle/service/sockets/bsd.cpp

@@ -31,14 +31,15 @@ namespace Service::Sockets {
 
 namespace {
 
-bool IsConnectionBased(Network::Type type) {
+[[nodiscard]] bool IsConnectionBased(Network::Type type) noexcept {
     switch (type) {
     case Network::Type::STREAM:
+    case Network::Type::SEQPACKET:
+    case Network::Type::RAW:
         return true;
     case Network::Type::DGRAM:
-        return false;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
+    case Network::Type::RDM:
+    case Network::Type::Unspecified:
         return false;
     }
 }
@@ -95,7 +96,7 @@ void BSD::ConnectWork::Execute(BSD* bsd) {
 void BSD::ConnectWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno == Network::Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(bsd_errno == Network::Errno::E_SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 
@@ -272,7 +273,7 @@ void BSD::GetPeerName(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno != Network::Errno::SUCCESS ? -1 : 0);
+    rb.Push<s32>(bsd_errno != Network::Errno::E_SUCCESS ? -1 : 0);
     rb.PushEnum(bsd_errno);
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
@@ -290,7 +291,7 @@ void BSD::GetSockName(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno != Network::Errno::SUCCESS ? -1 : 0);
+    rb.Push<s32>(bsd_errno != Network::Errno::E_SUCCESS ? -1 : 0);
     rb.PushEnum(bsd_errno);
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
@@ -310,7 +311,7 @@ void BSD::GetSockOpt(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(err == Network::Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(err == Network::Errno::E_SUCCESS ? 0 : -1);
     rb.PushEnum(err);
     rb.Push<u32>(static_cast<u32>(optval.size()));
 }
@@ -492,7 +493,7 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {
     if (auto* res = std::get_if<s32>(&res_v)) {
         rb.PushRaw(OutputParameters{
             .ret = *res,
-            .bsd_errno = Network::Errno::SUCCESS,
+            .bsd_errno = Network::Errno::E_SUCCESS,
         });
     } else {
         auto* err = std::get_if<Network::Errno>(&res_v);
@@ -510,7 +511,7 @@ void BSD::EventFd(HLERequestContext& ctx) {
 
     LOG_WARNING(Service, "(STUBBED) called. initval={}, flags={}", initval, flags);
 
-    BuildErrnoResponse(ctx, Network::Errno::SUCCESS);
+    BuildErrnoResponse(ctx, Network::Errno::E_SUCCESS);
 }
 
 template <typename Work>
@@ -526,7 +527,7 @@ std::pair<s32, Network::Errno> BSD::SocketImpl(Network::Domain domain, Network::
         if (type == Network::Type::RAW && domain == Network::Domain::INET && protocol == Network::Protocol::ICMP) {
             // fine, can use on bsd:s and bsd:u
         } else {
-            return {-1, Network::Errno::INVAL};
+            return {-1, Network::Errno::E_INVAL};
         }
     }
 
@@ -537,13 +538,13 @@ std::pair<s32, Network::Errno> BSD::SocketImpl(Network::Domain domain, Network::
     const s32 fd = FindFreeFileDescriptorHandle();
     if (fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return {-1, Network::Errno::MFILE};
+        return {-1, Network::Errno::E_MFILE};
     }
 
     if (Settings::values.airplane_mode.GetValue() && IsConnectionBased(type)) {
         LOG_ERROR(Service, "Airplane mode is enabled, cannot create socket");
         file_descriptors[fd].reset();
-        return {-1, Network::Errno::NOTCONN};
+        return {-1, Network::Errno::E_NOTCONN};
     }
 
     file_descriptors[fd] = FileDescriptor{};
@@ -566,7 +567,7 @@ std::pair<s32, Network::Errno> BSD::SocketImpl(Network::Domain domain, Network::
 
 #if defined(__unix__) && !defined(__APPLE__)
     // ...only unix has this issue it seems, ICMP works otherwise fine on win
-    if (bsd_errno != Network::Errno::SUCCESS
+    if (bsd_errno != Network::Errno::E_SUCCESS
     && (protocol == Network::Protocol::ICMP || protocol == Network::Protocol::ICMPV6)) {
         LOG_WARNING(Network, "Using ICMP emulated socket");
         descriptor.socket = std::make_shared<Network::IcmpSocket>();
@@ -582,20 +583,20 @@ std::pair<s32, Network::Errno> BSD::SocketImpl(Network::Domain domain, Network::
         file_descriptors[fd].reset();
         return {-1, bsd_errno};
     }
-    return {fd, Network::Errno::SUCCESS};
+    return {fd, Network::Errno::E_SUCCESS};
 }
 
 std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer, s32 nfds, s32 timeout) {
     LOG_DEBUG(Network, "nfds={},timeout={}", nfds, timeout);
     if (nfds <= 0) {
         // When no entries are provided, -1 is returned with errno zero
-        return {-1, Network::Errno::SUCCESS};
+        return {-1, Network::Errno::E_SUCCESS};
     }
     if (read_buffer.size() < nfds * sizeof(Network::PollFD)) {
-        return {-1, Network::Errno::INVAL};
+        return {-1, Network::Errno::E_INVAL};
     }
     if (write_buffer.size() < nfds * sizeof(Network::PollFD)) {
-        return {-1, Network::Errno::INVAL};
+        return {-1, Network::Errno::E_INVAL};
     }
 
     std::span<const Network::PollFD> in_fds(reinterpret_cast<const Network::PollFD*>(read_buffer.data()), nfds);
@@ -606,13 +607,13 @@ std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std:
         const s64 seconds = timeout / 1000;
         const u64 nanoseconds = 1'000'000 * (u64(timeout) % 1000);
         if (seconds < 0) {
-            return {-1, Network::Errno::INVAL};
+            return {-1, Network::Errno::E_INVAL};
         }
         if (nanoseconds > 999'999'999) {
-            return {-1, Network::Errno::INVAL};
+            return {-1, Network::Errno::E_INVAL};
         }
     } else if (timeout != -1) {
-        return {-1, Network::Errno::INVAL};
+        return {-1, Network::Errno::E_INVAL};
     }
 
     for (size_t i = 0; i < in_fds.size(); ++i) {
@@ -621,7 +622,7 @@ std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std:
             out_fds[i].revents = {};
             if (!file_descriptors[in_fds[i].fd])
                 out_fds[i].revents = Network::PollEvents::NVAL;
-            return {0, Network::Errno::SUCCESS};
+            return {0, Network::Errno::E_SUCCESS};
         }
     }
 
@@ -642,18 +643,18 @@ std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std:
 std::pair<s32, Network::Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     const s32 new_fd = FindFreeFileDescriptorHandle();
     if (new_fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return {-1, Network::Errno::MFILE};
+        return {-1, Network::Errno::E_MFILE};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
     auto [result, bsd_errno] = descriptor.socket->Accept();
-    if (bsd_errno != Network::Errno::SUCCESS) {
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
         return {-1, bsd_errno};
     }
 
@@ -663,18 +664,18 @@ std::pair<s32, Network::Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_bu
     new_descriptor.is_connection_based = descriptor.is_connection_based;
 
     PutValue(write_buffer, result.sockaddr_in);
-    return {new_fd, Network::Errno::SUCCESS};
+    return {new_fd, Network::Errno::E_SUCCESS};
 }
 
 Network::Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     ASSERT(addr.size() >= 16);
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     auto addr_in = GetValue<Network::SockAddrIn>(addr);
@@ -684,20 +685,20 @@ Network::Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
 Network::Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     ASSERT(addr.size() >= 16);
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     auto addr_in = GetValue<Network::SockAddrIn>(addr);
     const Network::Errno result = file_descriptors[fd]->socket->Connect(addr_in);
-    if (result == Network::Errno::ISCONN) {
+    if (result == Network::Errno::E_ISCONN) {
         LOG_DEBUG(Service, "returned ISCONN - socket already connected");
-        return Network::Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     }
 
     return result;
@@ -706,16 +707,16 @@ Network::Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
 Network::Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetPeerName();
-    if (bsd_errno != Network::Errno::SUCCESS) {
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
         return bsd_errno;
     }
     ASSERT(write_buffer.size() >= addr_in.len);
@@ -727,16 +728,16 @@ Network::Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
 Network::Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetSockName();
-    if (bsd_errno != Network::Errno::SUCCESS) {
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
         return bsd_errno;
     }
     ASSERT(write_buffer.size() >= addr_in.len);
@@ -748,11 +749,11 @@ Network::Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
 Network::Errno BSD::ListenImpl(s32 fd, s32 backlog) {
     LOG_DEBUG(Network, "fd={},backlog={}", fd, backlog);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     return file_descriptors[fd]->socket->Listen(backlog);
 }
@@ -760,41 +761,41 @@ Network::Errno BSD::ListenImpl(s32 fd, s32 backlog) {
 std::pair<s32, Network::Errno> BSD::FcntlImpl(s32 fd, Network::FcntlCmd cmd, s32 arg) {
     LOG_DEBUG(Network, "fd={},cmd={},arg={}", fd, u32(cmd), arg);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
     switch (cmd) {
     case Network::FcntlCmd::GETFL:
         ASSERT(arg == 0);
-        return {descriptor.flags, Network::Errno::SUCCESS};
+        return {descriptor.flags, Network::Errno::E_SUCCESS};
     case Network::FcntlCmd::SETFL: {
         const bool enable = (arg & u32(Network::FcntlFlags::NONBLOCK_NX)) != 0;
         const Network::Errno bsd_errno = descriptor.socket->SetNonBlock(enable);
-        if (bsd_errno != Network::Errno::SUCCESS) {
+        if (bsd_errno != Network::Errno::E_SUCCESS) {
             return {-1, bsd_errno};
         }
         descriptor.flags = arg;
-        return {0, Network::Errno::SUCCESS};
+        return {0, Network::Errno::E_SUCCESS};
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented cmd={}", cmd);
-        return {-1, Network::Errno::SUCCESS};
+        return {-1, Network::Errno::E_SUCCESS};
     }
 }
 
 Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::vector<u8>& optval) {
     LOG_DEBUG(Network, "fd={},level={},optname={}", fd, u32(level), u32(optname));
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     if (level != Network::SocketLevel::SOCKET) {
@@ -806,9 +807,9 @@ Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::
     switch (optname) {
     case Network::OptName::ERROR_: {
         auto [pending_err, getsockopt_err] = socket->GetPendingError();
-        if (getsockopt_err == Network::Errno::SUCCESS) {
+        if (getsockopt_err == Network::Errno::E_SUCCESS) {
             ASSERT_OR_EXECUTE_MSG(
-                optval.size() == sizeof(Network::Errno), { return Network::Errno::INVAL; },
+                optval.size() == sizeof(Network::Errno), { return Network::Errno::E_INVAL; },
                 "Incorrect getsockopt option size");
             optval.resize(sizeof(Network::Errno));
             PutValue(optval, pending_err);
@@ -817,18 +818,18 @@ Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented optname={}", optname);
-        return Network::Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     }
 }
 
 Network::Errno BSD::SetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval) {
     LOG_DEBUG(Service, "fd={},level={},optname={}", fd, level, optname);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     Network::SocketBase* const socket = file_descriptors[fd]->socket.get();
@@ -838,11 +839,11 @@ Network::Errno BSD::SetSockOptImpl(s32 fd, Network::SocketLevel level, Network::
 Network::Errno BSD::ShutdownImpl(s32 fd, s32 how) {
     LOG_DEBUG(Network, "fd={},how={}", fd, how);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     return file_descriptors[fd]->socket->Shutdown(Network::ShutdownHow(how));
 }
@@ -850,7 +851,7 @@ Network::Errno BSD::ShutdownImpl(s32 fd, s32 how) {
 std::pair<s32, Network::Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
     LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
@@ -873,7 +874,7 @@ std::pair<s32, Network::Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>&
 std::pair<s32, Network::Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message, std::vector<u8>& addr) {
     LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
@@ -917,11 +918,11 @@ std::pair<s32, Network::Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<
 std::pair<s32, Network::Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
     LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     return file_descriptors[fd]->socket->Send(message, flags);
 }
@@ -929,11 +930,11 @@ std::pair<s32, Network::Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const
 std::pair<s32, Network::Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message, std::span<const u8> addr) {
     LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Network::Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     Network::SockAddrIn addr_in{};
@@ -951,15 +952,15 @@ std::pair<s32, Network::Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<cons
 Network::Errno BSD::CloseImpl(s32 fd) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     auto const bsd_errno = file_descriptors[fd]->socket->Close();
-    if (bsd_errno != Network::Errno::SUCCESS) {
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
         return bsd_errno;
     }
 
@@ -972,13 +973,13 @@ Network::Errno BSD::CloseImpl(s32 fd) {
 std::variant<s32, Network::Errno> BSD::DuplicateSocketImpl(s32 fd) {
     LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     const s32 new_fd = FindFreeFileDescriptorHandle();
     if (!IsFileDescriptorValid(new_fd)) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return Network::Errno::MFILE;
+        return Network::Errno::E_MFILE;
     }
 
     file_descriptors[new_fd] = FileDescriptor{
@@ -1026,7 +1027,7 @@ void BSD::BuildErrnoResponse(HLERequestContext& ctx, Network::Errno bsd_errno) c
     IPC::ResponseBuilder rb{ctx, 4};
 
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno == Network::Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(bsd_errno == Network::Errno::E_SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 

src/core/hle/service/sockets/sfdnsres.cpp

@@ -126,15 +126,15 @@ static Network::Errno GetAddrInfoErrorToErrno(Network::GetAddrInfoError result)
     case Network::GetAddrInfoError::SUCCESS:
         // Note: Sometimes a successful lookup sets errno to EADDRNOTAVAIL for
         // some reason, but that doesn't seem useful to implement.
-        return Network::Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     case Network::GetAddrInfoError::AGAIN:
-        return Network::Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     case Network::GetAddrInfoError::NODATA:
-        return Network::Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     case Network::GetAddrInfoError::SERVICE:
-        return Network::Errno::INVAL;
+        return Network::Errno::E_INVAL;
     default:
-        return Network::Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     }
 }
 

src/core/hle/service/ssl/ssl.cpp

@@ -132,7 +132,7 @@ public:
                 auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
                 if (bsd) {
                     auto err = bsd->CloseImpl(fd);
-                    if (err != Network::Errno::SUCCESS) {
+                    if (err != Network::Errno::E_SUCCESS) {
                         LOG_ERROR(Service_SSL, "Failed to close duplicated socket: {}", err);
                     }
                 }
@@ -203,7 +203,7 @@ private:
 
         const bool non_block = mode == IoMode::NonBlocking;
         const Network::Errno error = socket->SetNonBlock(non_block);
-        if (error != Network::Errno::SUCCESS) {
+        if (error != Network::Errno::E_SUCCESS) {
             LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
         }
         return ResultSuccess;

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -290,10 +290,10 @@ public:
         BIO_clear_retry_flags(bio);
         auto [actual, err] = self->socket->Send({reinterpret_cast<const u8*>(buf), len}, 0);
         switch (err) {
-        case Network::Errno::SUCCESS:
+        case Network::Errno::E_SUCCESS:
             *actual_p = actual;
             return 1;
-        case Network::Errno::AGAIN:
+        case Network::Errno::E_AGAIN:
             BIO_set_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
             return 0;
         default:
@@ -309,13 +309,13 @@ public:
         BIO_clear_retry_flags(bio);
         auto [actual, err] = self->socket->Recv(0, {reinterpret_cast<u8*>(buf), len});
         switch (err) {
-        case Network::Errno::SUCCESS:
+        case Network::Errno::E_SUCCESS:
             *actual_p = actual;
             if (actual == 0) {
                 self->got_read_eof = true;
             }
             return actual ? 1 : 0;
-        case Network::Errno::AGAIN:
+        case Network::Errno::E_AGAIN:
             BIO_set_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
             return 0;
         default:

src/core/hle/service/ssl/ssl_backend_schannel.cpp

@@ -146,11 +146,11 @@ public:
         const auto read_span = std::span(ciphertext_read_buf).subspan(offset, fill_size);
         const auto [actual, err] = socket->Recv(0, read_span);
         switch (err) {
-        case Network::Errno::SUCCESS:
+        case Network::Errno::E_SUCCESS:
             ASSERT(static_cast<size_t>(actual) <= fill_size);
             ciphertext_read_buf.resize(offset + actual);
             return ResultSuccess;
-        case Network::Errno::AGAIN:
+        case Network::Errno::E_AGAIN:
             ciphertext_read_buf.resize(offset);
             return ResultWouldBlock;
         default:
@@ -165,12 +165,12 @@ public:
         while (!ciphertext_write_buf.empty()) {
             const auto [actual, err] = socket->Send(ciphertext_write_buf, 0);
             switch (err) {
-            case Network::Errno::SUCCESS:
+            case Network::Errno::E_SUCCESS:
                 ASSERT(static_cast<size_t>(actual) <= ciphertext_write_buf.size());
                 ciphertext_write_buf.erase(ciphertext_write_buf.begin(),
                                            ciphertext_write_buf.begin() + actual);
                 break;
-            case Network::Errno::AGAIN:
+            case Network::Errno::E_AGAIN:
                 return ResultWouldBlock;
             default:
                 LOG_ERROR(Service_SSL, "Socket send returned Network::Errno {}", err);

src/core/hle/service/ssl/ssl_backend_securetransport.cpp

@@ -195,7 +195,7 @@ public:
             LOG_CRITICAL(Service_SSL, "op={}, offset={} actual={}/{} err={}", is_read, offset,
                          actual, cur.size(), static_cast<s32>(err));
             switch (err) {
-            case Network::Errno::SUCCESS:
+            case Network::Errno::E_SUCCESS:
                 offset += actual;
                 if (actual == 0) {
                     ASSERT(is_read);
@@ -203,7 +203,7 @@ public:
                     return errSecEndOfData;
                 }
                 break;
-            case Network::Errno::AGAIN:
+            case Network::Errno::E_AGAIN:
                 *dataLength = offset;
                 return errSSLWouldBlock;
             default:

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 {

src/tests/core/internal_network/network.cpp

@@ -15,7 +15,7 @@ TEST_CASE("Network::Errors", "[core]") {
     Network::Socket socks[2];
     for (Network::Socket& sock : socks) {
         REQUIRE(sock.Initialize(Network::Domain::INET, Network::Type::STREAM,
-                                Network::Protocol::TCP) == Network::Errno::SUCCESS);
+                                Network::Protocol::TCP) == Network::Errno::E_SUCCESS);
     }
 
     Network::SockAddrIn addr{
@@ -25,8 +25,8 @@ TEST_CASE("Network::Errors", "[core]") {
         {127, 0, 0, 1},
         {},
     };
-    REQUIRE(socks[0].Connect(addr) == Network::Errno::CONNREFUSED);
+    REQUIRE(socks[0].Connect(addr) == Network::Errno::E_CONNREFUSED);
 
     std::vector<u8> message{1, 2, 3, 4};
-    REQUIRE(socks[1].Recv(0, message).second == Network::Errno::NOTCONN);
+    REQUIRE(socks[1].Recv(0, message).second == Network::Errno::E_NOTCONN);
 }