LibCore+RequestServer: Return size_t from system read/write functions

The system uses ssize_t so it can return -1 in case of an error. But in
our case, we will transform that to an AK::Error, thus we never return
-1. Let's return size_t instead.

Author: trflynn89

Libraries/LibCore/File.cpp

@@ -125,7 +125,7 @@ ErrorOr<Bytes> File::read_some(Bytes buffer)
         return Error::from_errno(EBADF);
     }
 
-    ssize_t nread = TRY(System::read(m_fd, buffer));
+    auto nread = TRY(System::read(m_fd, buffer));
     m_last_read_was_eof = nread == 0;
     m_file_offset += nread;
     return buffer.trim(nread);

Libraries/LibCore/Socket.cpp

@@ -126,7 +126,7 @@ ErrorOr<Bytes> PosixSocketHelper::read(Bytes buffer, int flags)
         return Error::from_errno(ENOTCONN);
     }
 
-    ssize_t nread = TRY(System::recv(m_fd, buffer, flags));
+    auto nread = TRY(System::recv(m_fd, buffer, flags));
     if (nread == 0)
         did_reach_eof_on_read();
 
@@ -150,7 +150,7 @@ ErrorOr<size_t> PosixSocketHelper::write(ReadonlyBytes buffer, int flags)
         return Error::from_errno(ENOTCONN);
     }
 
-    return TRY(System::send(m_fd, buffer, flags));
+    return System::send(m_fd, buffer, flags);
 }
 
 void PosixSocketHelper::close()
@@ -410,7 +410,7 @@ ErrorOr<void> LocalSocket::send_fd(int fd)
 #endif
 }
 
-ErrorOr<ssize_t> LocalSocket::send_message(ReadonlyBytes data, int flags, Vector<int, 1> fds)
+ErrorOr<size_t> LocalSocket::send_message(ReadonlyBytes data, int flags, Vector<int, 1> fds)
 {
     size_t const num_fds = fds.size();
     if (num_fds == 0)
@@ -439,7 +439,7 @@ ErrorOr<ssize_t> LocalSocket::send_message(ReadonlyBytes data, int flags, Vector
     msg.msg_control = header;
     msg.msg_controllen = CMSG_LEN(fd_payload_size);
 
-    return TRY(Core::System::sendmsg(m_helper.fd(), &msg, default_flags() | flags));
+    return Core::System::sendmsg(m_helper.fd(), &msg, default_flags() | flags);
 }
 
 ErrorOr<Bytes> LocalSocket::receive_message(AK::Bytes buffer, int flags, Vector<int>& fds)

Libraries/LibCore/Socket.h

@@ -322,7 +322,7 @@ class LocalSocket final : public Socket {
     ErrorOr<void> send_fd(int fd);
 
     ErrorOr<Bytes> receive_message(Bytes buffer, int flags, Vector<int>& fds);
-    ErrorOr<ssize_t> send_message(ReadonlyBytes msg, int flags, Vector<int, 1> fds = {});
+    ErrorOr<size_t> send_message(ReadonlyBytes msg, int flags, Vector<int, 1> fds = {});
 
     ErrorOr<pid_t> peer_pid() const;
     ErrorOr<Bytes> read_without_waiting(Bytes buffer);

Libraries/LibCore/System.cpp

@@ -255,17 +255,17 @@ ErrorOr<struct stat> lstat(StringView path)
     return st;
 }
 
-ErrorOr<ssize_t> read(int fd, Bytes buffer)
+ErrorOr<size_t> read(int fd, Bytes buffer)
 {
-    ssize_t rc = ::read(fd, buffer.data(), buffer.size());
+    auto rc = ::read(fd, buffer.data(), buffer.size());
     if (rc < 0)
         return Error::from_syscall("read"sv, errno);
     return rc;
 }
 
-ErrorOr<ssize_t> write(int fd, ReadonlyBytes buffer)
+ErrorOr<size_t> write(int fd, ReadonlyBytes buffer)
 {
-    ssize_t rc = ::write(fd, buffer.data(), buffer.size());
+    auto rc = ::write(fd, buffer.data(), buffer.size());
     if (rc < 0)
         return Error::from_syscall("write"sv, errno);
     return rc;
@@ -557,47 +557,47 @@ ErrorOr<void> connect(int sockfd, struct sockaddr const* address, socklen_t addr
     return {};
 }
 
-ErrorOr<ssize_t> send(int sockfd, ReadonlyBytes data, int flags)
+ErrorOr<size_t> send(int sockfd, ReadonlyBytes data, int flags)
 {
     auto sent = ::send(sockfd, data.data(), data.size(), flags);
     if (sent < 0)
         return Error::from_syscall("send"sv, errno);
     return sent;
 }
 
-ErrorOr<ssize_t> sendmsg(int sockfd, const struct msghdr* message, int flags)
+ErrorOr<size_t> sendmsg(int sockfd, const struct msghdr* message, int flags)
 {
     auto sent = ::sendmsg(sockfd, message, flags);
     if (sent < 0)
         return Error::from_syscall("sendmsg"sv, errno);
     return sent;
 }
 
-ErrorOr<ssize_t> sendto(int sockfd, ReadonlyBytes data, int flags, struct sockaddr const* destination, socklen_t destination_length)
+ErrorOr<size_t> sendto(int sockfd, ReadonlyBytes data, int flags, struct sockaddr const* destination, socklen_t destination_length)
 {
     auto sent = ::sendto(sockfd, data.data(), data.size(), flags, destination, destination_length);
     if (sent < 0)
         return Error::from_syscall("sendto"sv, errno);
     return sent;
 }
 
-ErrorOr<ssize_t> recv(int sockfd, Bytes buffer, int flags)
+ErrorOr<size_t> recv(int sockfd, Bytes buffer, int flags)
 {
     auto received = ::recv(sockfd, buffer.data(), buffer.size(), flags);
     if (received < 0)
         return Error::from_syscall("recv"sv, errno);
     return received;
 }
 
-ErrorOr<ssize_t> recvmsg(int sockfd, struct msghdr* message, int flags)
+ErrorOr<size_t> recvmsg(int sockfd, struct msghdr* message, int flags)
 {
     auto received = ::recvmsg(sockfd, message, flags);
     if (received < 0)
         return Error::from_syscall("recvmsg"sv, errno);
     return received;
 }
 
-ErrorOr<ssize_t> recvfrom(int sockfd, Bytes buffer, int flags, struct sockaddr* address, socklen_t* address_length)
+ErrorOr<size_t> recvfrom(int sockfd, Bytes buffer, int flags, struct sockaddr* address, socklen_t* address_length)
 {
     auto received = ::recvfrom(sockfd, buffer.data(), buffer.size(), flags, address, address_length);
     if (received < 0)
@@ -879,7 +879,7 @@ ErrorOr<size_t> transfer_file_through_pipe(int source_fd, int target_fd, size_t
     auto* mapped = TRY(mmap(nullptr, mapped_source_length, PROT_READ, MAP_SHARED, source_fd, aligned_source_offset));
     ScopeGuard guard { [&]() { (void)munmap(mapped, mapped_source_length); } };
 
-    return TRY(write(target_fd, { static_cast<u8*>(mapped) + offset_adjustment, source_length }));
+    return write(target_fd, { static_cast<u8*>(mapped) + offset_adjustment, source_length });
 #endif
 }
 

Libraries/LibCore/System.h

@@ -87,8 +87,8 @@ ErrorOr<void> close(int fd);
 ErrorOr<void> ftruncate(int fd, off_t length);
 ErrorOr<struct stat> stat(StringView path);
 ErrorOr<struct stat> lstat(StringView path);
-ErrorOr<ssize_t> read(int fd, Bytes buffer);
-ErrorOr<ssize_t> write(int fd, ReadonlyBytes buffer);
+ErrorOr<size_t> read(int fd, Bytes buffer);
+ErrorOr<size_t> write(int fd, ReadonlyBytes buffer);
 ErrorOr<int> dup(int source_fd);
 ErrorOr<int> dup2(int source_fd, int destination_fd);
 ErrorOr<ByteString> getcwd();
@@ -117,12 +117,12 @@ ErrorOr<void> bind(int sockfd, struct sockaddr const*, socklen_t);
 ErrorOr<void> listen(int sockfd, int backlog);
 ErrorOr<int> accept(int sockfd, struct sockaddr*, socklen_t*);
 ErrorOr<void> connect(int sockfd, struct sockaddr const*, socklen_t);
-ErrorOr<ssize_t> send(int sockfd, ReadonlyBytes, int flags);
-ErrorOr<ssize_t> sendmsg(int sockfd, const struct msghdr*, int flags);
-ErrorOr<ssize_t> sendto(int sockfd, ReadonlyBytes, int flags, struct sockaddr const*, socklen_t);
-ErrorOr<ssize_t> recv(int sockfd, Bytes, int flags);
-ErrorOr<ssize_t> recvmsg(int sockfd, struct msghdr*, int flags);
-ErrorOr<ssize_t> recvfrom(int sockfd, Bytes, int flags, struct sockaddr*, socklen_t*);
+ErrorOr<size_t> send(int sockfd, ReadonlyBytes, int flags);
+ErrorOr<size_t> sendmsg(int sockfd, const struct msghdr*, int flags);
+ErrorOr<size_t> sendto(int sockfd, ReadonlyBytes, int flags, struct sockaddr const*, socklen_t);
+ErrorOr<size_t> recv(int sockfd, Bytes, int flags);
+ErrorOr<size_t> recvmsg(int sockfd, struct msghdr*, int flags);
+ErrorOr<size_t> recvfrom(int sockfd, Bytes, int flags, struct sockaddr*, socklen_t*);
 ErrorOr<void> getsockopt(int sockfd, int level, int option, void* value, socklen_t* value_size);
 ErrorOr<void> setsockopt(int sockfd, int level, int option, void const* value, socklen_t value_size);
 ErrorOr<void> getsockname(int sockfd, struct sockaddr*, socklen_t*);

Libraries/LibCore/SystemWindows.cpp

@@ -47,15 +47,15 @@ ErrorOr<void> close(int handle)
     return {};
 }
 
-ErrorOr<ssize_t> read(int handle, Bytes buffer)
+ErrorOr<size_t> read(int handle, Bytes buffer)
 {
     DWORD n_read = 0;
     if (!ReadFile(to_handle(handle), buffer.data(), buffer.size(), &n_read, NULL))
         return Error::from_windows_error();
     return n_read;
 }
 
-ErrorOr<ssize_t> write(int handle, ReadonlyBytes buffer)
+ErrorOr<size_t> write(int handle, ReadonlyBytes buffer)
 {
     DWORD n_written = 0;
     if (!WriteFile(to_handle(handle), buffer.data(), buffer.size(), &n_written, NULL))
@@ -261,7 +261,7 @@ ErrorOr<void> connect(int sockfd, struct sockaddr const* address, socklen_t addr
     return {};
 }
 
-ErrorOr<ssize_t> send(int sockfd, ReadonlyBytes data, int flags)
+ErrorOr<size_t> send(int sockfd, ReadonlyBytes data, int flags)
 {
     auto sent = ::send(sockfd, reinterpret_cast<char const*>(data.data()), static_cast<int>(data.size()), flags);
 
@@ -276,15 +276,15 @@ ErrorOr<ssize_t> send(int sockfd, ReadonlyBytes data, int flags)
     return sent;
 }
 
-ErrorOr<ssize_t> sendto(int sockfd, ReadonlyBytes data, int flags, struct sockaddr const* destination, socklen_t destination_length)
+ErrorOr<size_t> sendto(int sockfd, ReadonlyBytes data, int flags, struct sockaddr const* destination, socklen_t destination_length)
 {
     auto sent = ::sendto(sockfd, reinterpret_cast<char const*>(data.data()), static_cast<int>(data.size()), flags, destination, destination_length);
     if (sent == SOCKET_ERROR)
         return Error::from_windows_error();
     return sent;
 }
 
-ErrorOr<ssize_t> recvfrom(int sockfd, Bytes buffer, int flags, struct sockaddr* address, socklen_t* address_length)
+ErrorOr<size_t> recvfrom(int sockfd, Bytes buffer, int flags, struct sockaddr* address, socklen_t* address_length)
 {
     auto received = ::recvfrom(sockfd, reinterpret_cast<char*>(buffer.data()), static_cast<int>(buffer.size()), flags, address, address_length);
     if (received == SOCKET_ERROR)
@@ -422,7 +422,7 @@ ErrorOr<size_t> transfer_file_through_pipe(int source_fd, int target_fd, size_t
     auto* mapped = TRY(mmap(nullptr, mapped_source_length, PROT_READ, MAP_SHARED, source_fd, aligned_source_offset));
     ScopeGuard guard { [&]() { (void)munmap(mapped, mapped_source_length); } };
 
-    return TRY(send(target_fd, { static_cast<u8*>(mapped) + offset_adjustment, source_length }, 0));
+    return send(target_fd, { static_cast<u8*>(mapped) + offset_adjustment, source_length }, 0);
 }
 
 }

Libraries/LibCore/UDPServerWindows.cpp

@@ -70,7 +70,7 @@ ErrorOr<ByteBuffer> UDPServer::receive(size_t size)
 ErrorOr<size_t> UDPServer::send(ReadonlyBytes buffer, sockaddr_in const& to)
 {
     socklen_t to_len = sizeof(to);
-    return TRY(Core::System::sendto(m_fd, buffer, 0, (sockaddr const*)&to, to_len));
+    return Core::System::sendto(m_fd, buffer, 0, (sockaddr const*)&to, to_len);
 }
 
 Optional<IPv4Address> UDPServer::local_address() const

Services/RequestServer/RequestPipe.cpp

@@ -56,7 +56,7 @@ ErrorOr<RequestPipe> RequestPipe::create()
 #endif
 }
 
-ErrorOr<ssize_t> RequestPipe::write(ReadonlyBytes bytes)
+ErrorOr<size_t> RequestPipe::write(ReadonlyBytes bytes)
 {
 #if defined(AK_OS_WINDOWS)
     return Core::System::send(m_writer_fd, bytes, 0);

Services/RequestServer/RequestPipe.h

@@ -23,7 +23,7 @@ class RequestPipe {
     int reader_fd() const { return m_reader_fd; }
     int writer_fd() const { return m_writer_fd; }
 
-    ErrorOr<ssize_t> write(ReadonlyBytes bytes);
+    ErrorOr<size_t> write(ReadonlyBytes bytes);
 
 private:
     RequestPipe(int reader_fd, int writer_fd);