socket.h

Go to the documentation of this file.

#pragma once
#include <libplatform/socket.h>
 
#if 0

 
#include <stdbool.h>
#include <string.h> // For memcpy used in common.h
#include <sys/types.h>
 
// Define ssize_t for Windows - avoid circular include with string.h
#ifdef _WIN32
#include <basetsd.h> // For SSIZE_T
#ifndef _SSIZE_T_DEFINED
typedef SSIZE_T ssize_t;
#define _SSIZE_T_DEFINED
#endif
#include <winsock2.h>
#include <ws2tcpip.h> // Includes TCP_NODELAY and other TCP options
typedef SOCKET socket_t;
#define INVALID_SOCKET_VALUE INVALID_SOCKET
typedef int socklen_t;
typedef unsigned long nfds_t;
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h> // For TCP_NODELAY and other TCP options
#include <arpa/inet.h>
#include <poll.h>
typedef int socket_t;
#define INVALID_SOCKET_VALUE (-1)
#endif
 
#include "../common.h"
 
// ============================================================================
// Socket Functions
// ============================================================================

asciichat_error_t socket_init(void);

void socket_cleanup(void);

socket_t socket_create(const char *name, int domain, int type, int protocol);

int socket_close(socket_t sock);

int socket_bind(socket_t sock, const struct sockaddr *addr, socklen_t addrlen);

int socket_listen(socket_t sock, int backlog);

socket_t socket_accept(socket_t sock, struct sockaddr *addr, socklen_t *addrlen, const char *name);

int socket_connect(socket_t sock, const struct sockaddr *addr, socklen_t addrlen);

#define SOCKET_IOV_MAX 16
#define SOCKET_ZEROCOPY_THRESHOLD (64 * 1024)
#define SOCKET_STREAM_SEND_BUFFER (64U * 1024U)
#define SOCKET_STREAM_SEND_RESERVE (2U * SOCKET_STREAM_SEND_BUFFER)
 
#define SOCKET_SEND_BUFFER_MAX (32 * 1024 * 1024)
typedef struct {
  const void *data;
  size_t len;
} socket_buffer_t;

asciichat_error_t socket_sendv(socket_t sock, const socket_buffer_t *buffers, size_t count, size_t *sent);
asciichat_error_t socket_sendv_all(socket_t sock, const socket_buffer_t *buffers, size_t count, uint64_t timeout_ns);

typedef struct {
  uint64_t send_calls;
  uint64_t sent_bytes;
  uint64_t zerocopy_calls;
  uint64_t zerocopy_completions;
  uint64_t zerocopy_copied;
} socket_io_stats_t;
socket_io_stats_t socket_io_stats_get(void);
void socket_io_stats_reset(void);

typedef struct {
  void *data;
  size_t capacity;
  bool mapped;
  buffer_budget_t budget;
} socket_send_buffer_t;
asciichat_error_t socket_send_buffer_alloc(size_t capacity, socket_send_buffer_t *buffer);
void socket_send_buffer_free(socket_send_buffer_t *buffer);

asciichat_error_t socket_send_zerocopy(socket_t sock, const socket_send_buffer_t *buffer, size_t len,
                                       uint64_t timeout_ns, bool *supported, bool *copied);

asciichat_error_t socket_zerocopy_try(socket_t, const socket_send_buffer_t *, size_t offset, size_t length,
                                      size_t *sent, bool *supported);
asciichat_error_t socket_zerocopy_poll(socket_t, bool *completed, bool *copied);
 
ssize_t socket_send(socket_t sock, const void *buf, size_t len, int flags);

ssize_t socket_recv(socket_t sock, void *buf, size_t len, int flags);

ssize_t socket_sendto(socket_t sock, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr,
                      socklen_t addrlen);

ssize_t socket_recvfrom(socket_t sock, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);

int socket_setsockopt(socket_t sock, int level, int optname, const void *optval, socklen_t optlen);

int socket_getsockopt(socket_t sock, int level, int optname, void *optval, socklen_t *optlen);

int socket_set_timeout_ns(socket_t sock, uint64_t timeout_ns);

int socket_shutdown(socket_t sock, int how);

int socket_getpeername(socket_t sock, struct sockaddr *addr, socklen_t *addrlen);

int socket_getsockname(socket_t sock, struct sockaddr *addr, socklen_t *addrlen);

int socket_set_blocking(socket_t sock);

int socket_set_nonblocking(socket_t sock, bool nonblocking);

int socket_set_reuseaddr(socket_t sock, bool reuse);

int socket_set_nodelay(socket_t sock, bool nodelay);

int socket_set_keepalive(socket_t sock, bool keepalive);

int socket_set_keepalive_params(socket_t sock, bool enable, int idle, int interval, int count);

int socket_set_linger(socket_t sock, bool enable, int timeout);

int socket_set_timeout(socket_t sock, uint64_t timeout_ns);

int socket_set_buffer_sizes(socket_t sock, int recv_size, int send_size);

int socket_get_peer_address(socket_t sock, struct sockaddr *addr, socklen_t *addrlen);

int socket_get_error(socket_t sock);

void socket_optimize_for_streaming(socket_t sock);

int socket_get_last_error(void);

const char *socket_get_error_string(void);

int socket_poll(struct pollfd *fds, nfds_t nfds, int64_t timeout_ns);

int socket_select(socket_t max_fd, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

void socket_fd_zero(fd_set *set);

void socket_fd_set(socket_t sock, fd_set *set);

int socket_fd_isset(socket_t sock, fd_set *set);

int socket_get_fd(socket_t sock);

bool socket_is_valid(socket_t sock);

bool socket_is_would_block_error(int error_code);

bool socket_is_connection_reset_error(int error_code);

bool socket_is_invalid_socket_error(int error_code);

bool socket_is_in_progress_error(int error_code);
 
// Platform-specific error codes
#ifdef _WIN32
#define SOCKET_ERROR_WOULDBLOCK WSAEWOULDBLOCK
#define SOCKET_ERROR_INPROGRESS WSAEINPROGRESS
#define SOCKET_ERROR_AGAIN WSAEWOULDBLOCK
#else
#define SOCKET_ERROR_WOULDBLOCK EWOULDBLOCK
#define SOCKET_ERROR_INPROGRESS EINPROGRESS
#define SOCKET_ERROR_AGAIN EAGAIN
#endif
 
// Poll structure for Windows compatibility
#ifdef _WIN32
#ifndef POLLIN
#define POLLIN 0x001
#define POLLOUT 0x004
#define POLLERR 0x008
#define POLLHUP 0x010
#define POLLNVAL 0x020
#endif
 
// Windows 10 SDK already defines pollfd and nfds_t in winsock2.h
// Only define them if not available (e.g., older Windows or custom builds)
#if !defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_)
#ifndef HAVE_STRUCT_POLLFD
struct pollfd {
  socket_t fd;
  short events;
  short revents;
};
#endif
 
typedef unsigned long nfds_t;
#endif
#endif

 
// ============================================================================
// Socket Timeout Operations
// ============================================================================

int platform_socket_set_timeout(socket_t sock, uint64_t timeout_ns);

int platform_socket_connect_timeout(socket_t sock, const struct sockaddr *addr, socklen_t addr_len,
                                    uint64_t timeout_ns);
 
#endif