Function accept [src]
Accept a connection on a socket.
If sockfd is opened in non blocking mode, the function will
return error.WouldBlock when EAGAIN is received.
Prototype
pub fn accept( sock: socket_t, addr: ?*sockaddr, addr_size: ?*socklen_t, flags: u32, ) AcceptError!socket_t Parameters
sock: socket_tThis argument is a socket that has been created with socket, bound to a local address
with bind, and is listening for connections after a listen.
addr: ?*sockaddrThis argument is a pointer to a sockaddr structure. This structure is filled in with the
address of the peer socket, as known to the communications layer. The exact format of the
address returned addr is determined by the socket's address family (see socket and the
respective protocol man pages).
addr_size: ?*socklen_tThis argument is a value-result argument: the caller must initialize it to contain the
size (in bytes) of the structure pointed to by addr; on return it will contain the actual size
of the peer address.
The returned address is truncated if the buffer provided is too small; in this case, addr_size
will return a value greater than was supplied to the call.
flags: u32The following values can be bitwise ORed in flags to obtain different behavior:
SOCK.NONBLOCK - Set the NONBLOCK file status flag on the open file description (see open)
referred to by the new file descriptor. Using this flag saves extra calls to fcntl to achieve
the same result.
SOCK.CLOEXEC - Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor. See the
description of the CLOEXEC flag in open for reasons why this may be useful.
Possible Errors
Firewall rules forbid connection.
An incoming connection was indicated, but was subsequently terminated by the remote peer prior to accepting the call.
The file descriptor sockfd does not refer to a socket.
The network subsystem has failed.
The referenced socket is not a type that supports connection-oriented service.
The per-process limit on the number of open file descriptors has been reached.
Socket is not listening for new connections.
The system-wide limit on the total number of open files has been reached.
Not enough free memory. This often means that the memory allocation is limited by the socket buffer limits, not by the system memory.
The Operating System returned an undocumented error code.
This error is in theory not possible, but it would be better to handle this error than to invoke undefined behavior.
When this error code is observed, it usually means the Zig Standard Library needs a small patch to add the error code to the error set for the respective function.
This error occurs when no global event loop is configured, and accepting from the socket would block.
Source
pub fn accept(
/// This argument is a socket that has been created with `socket`, bound to a local address
/// with `bind`, and is listening for connections after a `listen`.
sock: socket_t,
/// This argument is a pointer to a sockaddr structure. This structure is filled in with the
/// address of the peer socket, as known to the communications layer. The exact format of the
/// address returned addr is determined by the socket's address family (see `socket` and the
/// respective protocol man pages).
addr: ?*sockaddr,
/// This argument is a value-result argument: the caller must initialize it to contain the
/// size (in bytes) of the structure pointed to by addr; on return it will contain the actual size
/// of the peer address.
///
/// The returned address is truncated if the buffer provided is too small; in this case, `addr_size`
/// will return a value greater than was supplied to the call.
addr_size: ?*socklen_t,
/// The following values can be bitwise ORed in flags to obtain different behavior:
/// * `SOCK.NONBLOCK` - Set the `NONBLOCK` file status flag on the open file description (see `open`)
/// referred to by the new file descriptor. Using this flag saves extra calls to `fcntl` to achieve
/// the same result.
/// * `SOCK.CLOEXEC` - Set the close-on-exec (`FD_CLOEXEC`) flag on the new file descriptor. See the
/// description of the `CLOEXEC` flag in `open` for reasons why this may be useful.
flags: u32,
) AcceptError!socket_t {
const have_accept4 = !(builtin.target.os.tag.isDarwin() or native_os == .windows or native_os == .haiku);
assert(0 == (flags & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC))); // Unsupported flag(s)
const accepted_sock: socket_t = while (true) {
const rc = if (have_accept4)
system.accept4(sock, addr, addr_size, flags)
else if (native_os == .windows)
windows.accept(sock, addr, addr_size)
else
system.accept(sock, addr, addr_size);
if (native_os == .windows) {
if (rc == windows.ws2_32.INVALID_SOCKET) {
switch (windows.ws2_32.WSAGetLastError()) {
.WSANOTINITIALISED => unreachable, // not initialized WSA
.WSAECONNRESET => return error.ConnectionResetByPeer,
.WSAEFAULT => unreachable,
.WSAEINVAL => return error.SocketNotListening,
.WSAEMFILE => return error.ProcessFdQuotaExceeded,
.WSAENETDOWN => return error.NetworkSubsystemFailed,
.WSAENOBUFS => return error.FileDescriptorNotASocket,
.WSAEOPNOTSUPP => return error.OperationNotSupported,
.WSAEWOULDBLOCK => return error.WouldBlock,
else => |err| return windows.unexpectedWSAError(err),
}
} else {
break rc;
}
} else {
switch (errno(rc)) {
.SUCCESS => break @intCast(rc),
.INTR => continue,
.AGAIN => return error.WouldBlock,
.BADF => unreachable, // always a race condition
.CONNABORTED => return error.ConnectionAborted,
.FAULT => unreachable,
.INVAL => return error.SocketNotListening,
.NOTSOCK => unreachable,
.MFILE => return error.ProcessFdQuotaExceeded,
.NFILE => return error.SystemFdQuotaExceeded,
.NOBUFS => return error.SystemResources,
.NOMEM => return error.SystemResources,
.OPNOTSUPP => unreachable,
.PROTO => return error.ProtocolFailure,
.PERM => return error.BlockedByFirewall,
else => |err| return unexpectedErrno(err),
}
}
};
errdefer switch (native_os) {
.windows => windows.closesocket(accepted_sock) catch unreachable,
else => close(accepted_sock),
};
if (!have_accept4) {
try setSockFlags(accepted_sock, flags);
}
return accepted_sock;
}