network.c File Reference

🌐 Cross-platform socket I/O with timeout management and connection handling More...

Go to the source code of this file.

Functions
ssize_t	send_with_timeout (socket_t sockfd, const void *data, size_t len, uint64_t timeout_ns)
	Send data with timeout using chunked transmission.
ssize_t	recv_with_timeout (socket_t sockfd, void *buf, size_t len, uint64_t timeout_ns)
	Receive data with timeout.
int	accept_with_timeout (socket_t listenfd, struct sockaddr *addr, socklen_t *addrlen, uint64_t timeout_ns)
	Accept connection with timeout.
asciichat_error_t	set_socket_timeout (socket_t sockfd, uint64_t timeout_ns)
	Set socket timeout.
asciichat_error_t	set_socket_keepalive (socket_t sockfd)
	Set socket keepalive.
asciichat_error_t	set_socket_nonblocking (socket_t sockfd)
	Set socket non-blocking.
asciichat_error_t	socket_configure_buffers (socket_t sockfd)
	Configure socket buffers and TCP_NODELAY for optimal performance.
const char *	network_error_string ()
	Get human-readable error string for network errors.
bool	connect_with_timeout (socket_t sockfd, const struct sockaddr *addr, socklen_t addrlen, int timeout_seconds)
	Connect with timeout.

Detailed Description

🌐 Cross-platform socket I/O with timeout management and connection handling

Definition in file network/network.c.

Function Documentation

accept_with_timeout()

int accept_with_timeout	(	socket_t	listenfd,
		struct sockaddr *	addr,
		socklen_t *	addrlen,
		uint64_t	timeout_ns
	)

Accept connection with timeout.

Parameters

listenfd	Listening socket
addr	Client address structure
addrlen	Length of address structure
timeout_seconds	Timeout in seconds

Returns

Client socket, or -1 on error

Definition at line 250 of file network/network.c.

                                                                                                           {
  // Set up poll for accept timeout (in nanoseconds)
  struct pollfd pfd;
  pfd.fd = listenfd;
  pfd.events = POLLIN;
  pfd.revents = 0;
 
  int result = socket_poll(&pfd, 1, (int64_t)timeout_ns);
 
  if (result <= 0) {
    if (result == 0) {
      // Timeout is expected behavior for server waiting for connections
      asciichat_errno = ERROR_NETWORK_TIMEOUT;
      asciichat_errno_context.code = ERROR_NETWORK_TIMEOUT;
      asciichat_errno_context.has_system_error = true;
      asciichat_errno_context.system_errno = ETIMEDOUT;
      return -1;
    }
 
    if (network_handle_select_error(result)) {
      return -1; // Don't retry for accept
    }
    return -1;
  }
 
  // Check if socket is ready
  if (!(pfd.revents & POLLIN)) {
    asciichat_errno = ERROR_NETWORK_TIMEOUT;
    asciichat_errno_context.code = ERROR_NETWORK_TIMEOUT;
    asciichat_errno_context.has_system_error = true;
    asciichat_errno_context.system_errno = ETIMEDOUT;
    return -1;
  }
 
  // Check if socket is still valid before attempting accept
  if (listenfd == INVALID_SOCKET_VALUE) {
    SET_ERRNO(ERROR_NETWORK, "accept_with_timeout: listening socket is closed");
    return -1;
  }
 
  socket_t accept_result = socket_accept(listenfd, addr, addrlen);
 
  if (accept_result == INVALID_SOCKET_VALUE) {
    // Check if this is a socket closed error (common during shutdown)
    int error_code = socket_get_last_error();
 
    if (socket_is_invalid_socket_error(error_code)) {
      // During shutdown, don't log this as an error since it's expected behavior
      asciichat_errno = ERROR_NETWORK;
      asciichat_errno_context.code = ERROR_NETWORK;
      asciichat_errno_context.has_system_error = false;
    } else {
      SET_ERRNO_SYS(ERROR_NETWORK_BIND, "accept_with_timeout accept failed: %s", socket_get_error_string());
    }
    return -1;
  }
 
  return (int)accept_result;
}

References asciichat_errno, asciichat_errno_context, and error_code.

connect_with_timeout()

bool connect_with_timeout	(	socket_t	sockfd,
		const struct sockaddr *	addr,
		socklen_t	addrlen,
		int	timeout_seconds
	)

Connect with timeout.

Parameters

sockfd	Socket file descriptor
addr	Address to connect to
addrlen	Address length
timeout_seconds	Timeout in seconds

Returns

true on success, false on failure

Definition at line 441 of file network/network.c.

                                                                                                                {
  if (sockfd == INVALID_SOCKET_VALUE) {
    errno = EBADF;
    return false;
  }
 
  // Set socket to non-blocking for timeout control
  if (set_socket_nonblocking(sockfd) != ASCIICHAT_OK) {
    return false;
  }
 
  // Attempt connection
  int result = connect(sockfd, addr, addrlen);
 
  if (result == 0) {
    // Connected immediately
    return true;
  }
 
  // Check if connection is in progress (expected for non-blocking sockets)
  int error = socket_get_last_error();
  if (!socket_is_in_progress_error(error) && !socket_is_would_block_error(error)) {
    return false;
  }
 
  // Use select to wait for connection with timeout
  fd_set write_fds;
  struct timeval timeout;
 
  socket_fd_zero(&write_fds);
  socket_fd_set(sockfd, &write_fds);
 
  timeout.tv_sec = timeout_seconds;
  timeout.tv_usec = 0;
 
  result = socket_select(sockfd, NULL, &write_fds, NULL, &timeout);
 
  if (result <= 0) {
    return false; // Timeout or error
  }
 
  if (!socket_fd_isset(sockfd, &write_fds)) {
    return false; // Socket not ready
  }
 
  // Check if connection was successful
  int error_code = 0;
  socklen_t error_len = sizeof(error_code);
 
  if (socket_getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error_code, &error_len) != 0) {
    return false;
  }
 
  if (error_code != 0) {
    return false;
  }
 
  // Connection successful - restore blocking mode
  if (socket_set_blocking(sockfd) != 0) {
    log_warn("Failed to restore socket to blocking mode after connect");
    // Continue anyway - non-blocking mode works but may cause issues with send/recv
  }
 
  return true;
}

References error_code, and set_socket_nonblocking().

Referenced by server_connection_establish(), and tcp_client_connect().

network_error_string()

const char * network_error_string

(

)

Get human-readable error string for network errors.

Parameters

error_code

Error code

Returns

Error string

Definition at line 429 of file network/network.c.

                                   {
  return socket_get_error_string();
}

Referenced by add_client(), server_connection_establish(), socket_configure_buffers(), and tcp_client_connect().

recv_with_timeout()

ssize_t recv_with_timeout	(	socket_t	sockfd,
		void *	buf,
		size_t	len,
		uint64_t	timeout_ns
	)

Receive data with timeout.

Parameters

sockfd	Socket file descriptor
buf	Buffer to receive data
len	Length of buffer
timeout_seconds	Timeout in seconds

Returns

Number of bytes received, or -1 on error

Definition at line 182 of file network/network.c.

                                                                                       {
  if (sockfd == INVALID_SOCKET_VALUE) {
    errno = EBADF;
    return -1;
  }
 
  ssize_t total_received = 0;
  char *data = (char *)buf;
 
  while (total_received < (ssize_t)len) {
    // Set up poll for read timeout (in nanoseconds)
    struct pollfd pfd;
    pfd.fd = sockfd;
    pfd.events = POLLIN;
    pfd.revents = 0;
 
    int64_t effective_timeout_ns = network_is_test_environment() ? (1LL * NS_PER_SEC_INT) : (int64_t)timeout_ns;
    int result = socket_poll(&pfd, 1, effective_timeout_ns);
    if (result <= 0) {
      if (result == 0) {
        SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "recv_with_timeout timed out after %llu nanoseconds",
                      (unsigned long long)timeout_ns);
        return -1;
      }
      if (network_handle_select_error(result)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    // Check if socket is ready
    if (!(pfd.revents & POLLIN)) {
      SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "recv_with_timeout socket not ready after poll");
      return -1;
    }
 
    // Calculate how much we still need to receive
    size_t bytes_to_recv = len - (size_t)total_received;
    ssize_t received = socket_recv(sockfd, data + total_received, bytes_to_recv, 0);
 
    if (received < 0) {
      int error = errno;
      if (network_handle_recv_error(error)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    if (received == 0) {
      // Connection closed by peer
      log_debug("Connection closed by peer during recv");
      return total_received; // Return what we got so far
    }
 
    total_received += received;
  }
 
  return total_received;
}

Referenced by packet_receive(), and receive_packet_secure().

send_with_timeout()

ssize_t send_with_timeout	(	socket_t	sockfd,
		const void *	data,
		size_t	len,
		uint64_t	timeout_ns
	)

Send data with timeout using chunked transmission.

Parameters

sockfd	Socket file descriptor
data	Data to send
len	Length of data
timeout_seconds	Timeout in seconds

Returns

Number of bytes sent, or -1 on error

Definition at line 112 of file network/network.c.

                                                                                              {
  if (sockfd == INVALID_SOCKET_VALUE) {
    errno = EBADF;
    return -1;
  }
 
  size_t total_sent = 0;
  const char *data_ptr = (const char *)data;
 
  while (total_sent < len) {
    // Calculate chunk size
    size_t bytes_to_send = len - total_sent;
    const size_t MAX_CHUNK_SIZE = 65536; // 64KB chunks for reliable TCP transmission
    if (bytes_to_send > MAX_CHUNK_SIZE) {
      bytes_to_send = MAX_CHUNK_SIZE;
    }
 
    // Set up poll for write timeout (in nanoseconds)
    struct pollfd pfd;
    pfd.fd = sockfd;
    pfd.events = POLLOUT;
    pfd.revents = 0;
 
    int64_t effective_timeout_ns = network_is_test_environment() ? (100LL * NS_PER_MS_INT) : (int64_t)timeout_ns;
    int result = socket_poll(&pfd, 1, effective_timeout_ns);
    if (result <= 0) {
      if (result == 0) {
        SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "send_with_timeout timed out after %llu nanoseconds",
                      (unsigned long long)timeout_ns);
        return -1;
      }
      if (network_handle_select_error(result)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    // Check if socket is ready for writing
    if (!(pfd.revents & POLLOUT)) {
      SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "send_with_timeout socket not ready for writing after poll");
      return -1;
    }
 
    // Use platform-specific send
    ssize_t sent = socket_send(sockfd, data_ptr + total_sent, bytes_to_send, 0);
 
    if (sent < 0) {
      int error = errno;
      if (network_handle_send_error(error)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    if (sent > 0) {
      total_sent += (size_t)sent;
    }
  }
 
  return (ssize_t)total_sent;
}

Referenced by packet_send().

set_socket_keepalive()

asciichat_error_t set_socket_keepalive

(

socket_t

sockfd

)

Set socket keepalive.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 355 of file network/network.c.

                                                        {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket file descriptor");
  }
  int result = socket_set_keepalive_params(sockfd, true, KEEPALIVE_IDLE, KEEPALIVE_INTERVAL, KEEPALIVE_COUNT);
  if (result != 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket keepalive parameters");
  }
  return ASCIICHAT_OK;
}

set_socket_nonblocking()

asciichat_error_t set_socket_nonblocking

(

socket_t

sockfd

)

Set socket non-blocking.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 371 of file network/network.c.

                                                          {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket file descriptor");
  }
  int result = socket_set_nonblocking(sockfd, true);
  if (result != 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket non-blocking mode");
  }
  return ASCIICHAT_OK;
}

Referenced by connect_with_timeout().

set_socket_timeout()

asciichat_error_t set_socket_timeout	(	socket_t	sockfd,
		uint64_t	timeout_ns
	)

Set socket timeout.

Parameters

sockfd	Socket file descriptor
timeout_ns	Timeout in nanoseconds (converted to milliseconds for socket level)

Returns

ASCIICHAT_OK on success, error code on failure

Sets socket-level timeouts (SO_RCVTIMEO/SO_SNDTIMEO) as a safety net fallback. Actual precision depends on platform: milliseconds on most systems, microseconds on some. Works in conjunction with application-level timeouts via socket_poll.

Definition at line 320 of file network/network.c.

                                                                           {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket file descriptor");
  }
 
  // Convert nanoseconds to milliseconds for socket-level timeout
  // Note: socket-level timeouts have ~millisecond granularity on most platforms
  uint64_t timeout_ms = timeout_ns / (1000 * 1000);
  if (timeout_ms == 0 && timeout_ns > 0) {
    timeout_ms = 1; // Ensure at least 1ms for non-zero timeouts
  }
 
  // Set both receive and send timeouts using struct timeval
  struct timeval tv;
  tv.tv_sec = (time_t)(timeout_ms / 1000);
  tv.tv_usec = (long)((timeout_ms % 1000) * 1000);
 
  // Set receive timeout
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) != 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket receive timeout");
  }
 
  // Set send timeout
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) != 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket send timeout");
  }
 
  return ASCIICHAT_OK;
}

Referenced by add_client().

socket_configure_buffers()

asciichat_error_t socket_configure_buffers

(

socket_t

sockfd

)

Configure socket buffers and TCP_NODELAY for optimal performance.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, ERROR_NETWORK_CONFIG on failure

Definition at line 387 of file network/network.c.

                                                            {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Invalid socket file descriptor");
  }
 
  int failed_options = 0;
 
  // Attempt to configure 1MB send buffer for optimal frame transmission
  int send_buffer_size = 1024 * 1024;
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &send_buffer_size, sizeof(send_buffer_size)) < 0) {
    log_warn("Failed to set send buffer size to 1MB: %s", network_error_string());
    failed_options++;
  }
 
  // Attempt to configure 1MB receive buffer for optimal frame reception
  int recv_buffer_size = 1024 * 1024;
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recv_buffer_size, sizeof(recv_buffer_size)) < 0) {
    log_warn("Failed to set receive buffer size to 1MB: %s", network_error_string());
    failed_options++;
  }
 
  // Attempt to enable TCP_NODELAY to disable Nagle's algorithm for low-latency transmission
  // This must be set even if buffer configuration fails, as it's essential for real-time video.
  int tcp_nodelay = 1;
  if (socket_setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay, sizeof(tcp_nodelay)) < 0) {
    log_warn("Failed to set TCP_NODELAY: %s", network_error_string());
    failed_options++;
  }
 
  // Return error only if ALL options failed
  if (failed_options >= 3) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to configure all socket options");
  }
 
  return ASCIICHAT_OK;
}

References network_error_string().

Referenced by server_connection_establish(), and tcp_client_connect().