#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>

Classes
struct	MXSocket
	Cross-platform socket state used by the C API. More...
struct	MXSocketAddress

Macros
#define	mx_close_socket(s)
#define	MX_LEN(x)
#define	mx_set_err(e)
#define	NULL_SOCKET -1
#define	SOCK_EAGAIN EAGAIN
#define	SOCK_EBADF EBADF
#define	SOCK_ECONNABORTED ECONNABORTED
#define	SOCK_ECONNRESET ECONNRESET
#define	SOCK_EINTR EINTR
#define	SOCK_EINVAL EINVAL
#define	SOCK_ENOTSOCK ENOTSOCK
#define	SOCK_ERRNO errno
#define	SOCK_ESHUTDOWN ESHUTDOWN
#define	SOCK_EWOULDBLOCK EWOULDBLOCK

Typedefs
typedef int	mx_socket_fd

Functions
bool	mx_socket_accept (const MXSocket input, MXSocket output)
	Accept an incoming connection.
bool	mx_socket_bind (MXSocket s, const char port)
	Bind an Internet socket to a local port.
void	mx_socket_close (MXSocket *s)
	Close a socket if it is open.
bool	mx_socket_connect (MXSocket s, const char host, const char *port, int type)
	Connect an Internet socket to a remote host.
void	mx_socket_ignore_pipe_signal ()
	Ignore SIGPIPE on platforms that require it.
bool	mx_socket_init (MXSocket *s)
	Initialize a socket structure with default values.
bool	mx_socket_ipv6_bind (MXSocket s, const char port)
	Bind an IPv6 Internet socket to a local port.
bool	mx_socket_ipv6_connect (MXSocket s, const char host, const char *port, int type)
	Connect an IPv6 Internet socket to a remote host.
bool	mx_socket_ipv6_listen (MXSocket s, const char port, int backlog, int type)
	Create and bind an IPv6 Internet socket for listening.
ssize_t	mx_socket_ipv6_recvfrom (MXSocket sock, void buf, size_t bytes)
	Receive a datagram using an IPv6 Internet socket.
ssize_t	mx_socket_ipv6_sendto (MXSocket sock, const void buf, size_t bytes)
	Send a datagram using an IPv6 Internet socket.
bool	mx_socket_is_open (const MXSocket *s)
	Check whether the socket is open.
bool	mx_socket_listen (MXSocket s, const char port, int backlog, int type)
	Create and bind an Internet socket for listening.
ssize_t	mx_socket_read (MXSocket s, void data, size_t len, int flags)
	Read data from a socket.
ssize_t	mx_socket_read_all (MXSocket sock, void buf, size_t bytes)
	Read the requested number of bytes from a socket.
bool	mx_socket_readline (MXSocket s, char buffer, size_t len)
	Read a line of text from a socket.
ssize_t	mx_socket_recvfrom (MXSocket sock, void buf, size_t bytes)
	Receive a datagram using an Internet socket.
ssize_t	mx_socket_recvfrom_address (MXSocket sock, void buf, size_t bytes, MXSocketAddress *address)
ssize_t	mx_socket_send (MXSocket s, const void data, size_t len, int flags)
	Write data to a socket.
ssize_t	mx_socket_sendto (MXSocket sock, const void buf, size_t bytes)
	Send a datagram using an Internet socket.
ssize_t	mx_socket_sendto_address (MXSocket sock, const void buf, size_t bytes, const MXSocketAddress *address)
bool	mx_socket_set_blocking (MXSocket *s, bool state)
	Toggle blocking mode for a socket.
bool	mx_socket_unix_bind (MXSocket s, const char path)
	Bind a UNIX-domain socket to a local path.
bool	mx_socket_unix_connect (MXSocket s, const char path, int type)
	Connect a UNIX-domain socket to a local path.
bool	mx_socket_unix_listen (MXSocket s, const char path, int backlog, int type)
	Create and bind a UNIX-domain socket for listening.
ssize_t	mx_socket_unix_recvfrom (MXSocket sock, void buf, size_t bytes)
	Receive a datagram using a UNIX-domain socket.
ssize_t	mx_socket_unix_sendto (MXSocket sock, const void buf, size_t bytes)
	Send a datagram using a UNIX-domain socket.
bool	mx_socket_valid (const MXSocket *s)
	Check whether the socket handle is valid.
ssize_t	mx_socket_write_all (MXSocket sock, const void buf, size_t bytes)
	Write the requested number of bytes to a socket.

Macro Definition Documentation

◆ mx_close_socket

#define mx_close_socket ( s )

Value:

close(s)

Definition at line 49 of file mxsocket.h.

◆ MX_LEN

#define MX_LEN ( x )

Value:

(size_t)(x)

Definition at line 61 of file mxsocket.h.

◆ mx_set_err

#define mx_set_err ( e )

Value:

(errno = (e))

Definition at line 50 of file mxsocket.h.

◆ NULL_SOCKET

#define NULL_SOCKET -1

Definition at line 62 of file mxsocket.h.

◆ SOCK_EAGAIN

#define SOCK_EAGAIN EAGAIN

Definition at line 53 of file mxsocket.h.

◆ SOCK_EBADF

#define SOCK_EBADF EBADF

Definition at line 57 of file mxsocket.h.

◆ SOCK_ECONNABORTED

#define SOCK_ECONNABORTED ECONNABORTED

Definition at line 55 of file mxsocket.h.

◆ SOCK_ECONNRESET

#define SOCK_ECONNRESET ECONNRESET

Definition at line 60 of file mxsocket.h.

◆ SOCK_EINTR

#define SOCK_EINTR EINTR

Definition at line 52 of file mxsocket.h.

◆ SOCK_EINVAL

#define SOCK_EINVAL EINVAL

Definition at line 56 of file mxsocket.h.

◆ SOCK_ENOTSOCK

#define SOCK_ENOTSOCK ENOTSOCK

Definition at line 58 of file mxsocket.h.

◆ SOCK_ERRNO

#define SOCK_ERRNO errno

Definition at line 51 of file mxsocket.h.

◆ SOCK_ESHUTDOWN

#define SOCK_ESHUTDOWN ESHUTDOWN

Definition at line 59 of file mxsocket.h.

◆ SOCK_EWOULDBLOCK

#define SOCK_EWOULDBLOCK EWOULDBLOCK

Definition at line 54 of file mxsocket.h.

Typedef Documentation

◆ mx_socket_fd

typedef int mx_socket_fd

Definition at line 48 of file mxsocket.h.

Function Documentation

◆ mx_socket_accept()

bool mx_socket_accept	(	const MXSocket *	input,
		MXSocket *	output )

nodiscard

Accept an incoming connection.

Parameters

input	Listening socket.
output	Newly accepted socket state.

Returns: True on success.

Definition at line 278 of file mxsocket.c.

                                                                             {
    if (input == nullptr || output == nullptr)
        return false;
 
    if (!mx_socket_valid(input))
        return false;
 
    mx_socket_fd newfd = accept(input->sockfd, 0, 0);
#ifdef _WIN32
    if (newfd == INVALID_SOCKET)
        return false;
    u_long mode = input->blocking ? 0 : 1;
    if (ioctlsocket(newfd, FIONBIO, &mode) != 0) {
        mx_close_socket(newfd);
        return false;
    }
#else
    if (newfd == NULL_SOCKET)
        return false;
 
    int flags = fcntl(newfd, F_GETFL);
    if (flags == -1) {
        close(newfd);
        return false;
    }
    if (input->blocking)
        flags &= ~O_NONBLOCK;
    else
        flags |= O_NONBLOCK;
    if (fcntl(newfd, F_SETFL, flags) == -1) {
        mx_close_socket(newfd);
        return false;
    }
#endif
    if (mx_socket_valid(output))
        mx_socket_close(output);
    output->sockfd = newfd;
    output->addrlen = input->addrlen;
    output->blocking = input->blocking;
    output->sun = input->sun;
    output->inet = input->inet;
    output->inet6 = input->inet6;
    return true;
}

◆ mx_socket_bind()

bool mx_socket_bind	(	MXSocket *	s,
		const char *	port )

nodiscard

Bind an Internet socket to a local port.

Parameters

s	Socket state to configure.
port	Service or port name.

Returns: True on success.

Definition at line 370 of file mxsocket.c.

                                                                    {
    return mx_socket_inet_bind(sock, port, AF_INET);
}

◆ mx_socket_close()

void mx_socket_close ( MXSocket * s )

Close a socket if it is open.

Parameters

s	Socket state to close.

Definition at line 323 of file mxsocket.c.

                                     {
    if (sock == nullptr)
        return;
    if (mx_socket_valid(sock))
        mx_close_socket(sock->sockfd);
    sock->sockfd = NULL_SOCKET;
}

◆ mx_socket_connect()

bool mx_socket_connect	(	MXSocket *	s,
		const char *	host,
		const char *	port,
		int	type )

nodiscard

Connect an Internet socket to a remote host.

Parameters

s	Socket state to configure.
host	Remote host name or address.
port	Remote service or port name.
type	Socket kind, typically SOCK_STREAM or SOCK_DGRAM.

Returns: True on success.

Definition at line 362 of file mxsocket.c.

                                                                                                   {
    return mx_socket_inet_connect(sock, host, port, type, AF_INET);
}

◆ mx_socket_ignore_pipe_signal()

void mx_socket_ignore_pipe_signal ( )

Ignore SIGPIPE on platforms that require it.

Definition at line 577 of file mxsocket.c.

                                    {
#ifndef _WIN32
    signal(SIGPIPE, SIG_IGN);
#endif
}

◆ mx_socket_init()

bool mx_socket_init ( MXSocket * s )

nodiscard

Initialize a socket structure with default values.

Parameters

s	Socket state to initialize.

Returns: True on success.

Definition at line 407 of file mxsocket.c.

                                                  {
    if (sock == nullptr)
        return false;
    memset(sock, 0, sizeof(MXSocket));
    sock->sockfd = NULL_SOCKET;
    sock->blocking = true;
    return true;
}

◆ mx_socket_ipv6_bind()

bool mx_socket_ipv6_bind	(	MXSocket *	s,
		const char *	port )

nodiscard

Bind an IPv6 Internet socket to a local port.

Parameters

s	Socket state to configure.
port	Service or port name.

Returns: True on success.

Definition at line 374 of file mxsocket.c.

                                                                         {
    return mx_socket_inet_bind(sock, port, AF_INET6);
}

◆ mx_socket_ipv6_connect()

bool mx_socket_ipv6_connect	(	MXSocket *	s,
		const char *	host,
		const char *	port,
		int	type )

nodiscard

Connect an IPv6 Internet socket to a remote host.

Parameters

s	Socket state to configure.
host	Remote host name or address.
port	Remote service or port name.
type	Socket kind, typically SOCK_STREAM or SOCK_DGRAM.

Returns: True on success.

Definition at line 366 of file mxsocket.c.

                                                                                                        {
    return mx_socket_inet_connect(sock, host, port, type, AF_INET6);
}

◆ mx_socket_ipv6_listen()

bool mx_socket_ipv6_listen	(	MXSocket *	s,
		const char *	port,
		int	backlog,
		int	type )

nodiscard

Create and bind an IPv6 Internet socket for listening.

Parameters

s	Socket state to configure.
port	Service or port name to bind.
backlog	Maximum pending connection queue length.
type	Socket kind, typically SOCK_STREAM or SOCK_DGRAM.

Returns: True on success.

Definition at line 274 of file mxsocket.c.

                                                                                                  {
    return mx_socket_inet_listen(sock, port, backlog, type, AF_INET6);
}

◆ mx_socket_ipv6_recvfrom()

ssize_t mx_socket_ipv6_recvfrom	(	MXSocket *	sock,
		void *	buf,
		size_t	bytes )

Receive a datagram using an IPv6 Internet socket.

Parameters

sock	Socket state.
buf	Output buffer.
bytes	Maximum number of bytes to receive.

Returns: Number of bytes received, or a negative error value.

Definition at line 632 of file mxsocket.c.

                                                                             {
    if (sock == nullptr || buf == nullptr || src_bytes == 0)
        return -1;
 
    ssize_t bytes = 0;
    socklen_t len = (socklen_t)sizeof(struct sockaddr_storage);
    struct sockaddr_storage caddr;
    bytes = recvfrom(sock->sockfd, (char *)buf, MX_LEN(src_bytes), 0, (struct sockaddr *)&caddr, &len);
    if (bytes >= 0)
        mx_socket_store_inet_address(sock, (const struct sockaddr *)&caddr, len);
    return bytes;
}

◆ mx_socket_ipv6_sendto()

ssize_t mx_socket_ipv6_sendto	(	MXSocket *	sock,
		const void *	buf,
		size_t	bytes )

Send a datagram using an IPv6 Internet socket.

Parameters

sock	Socket state.
buf	Input buffer.
bytes	Number of bytes to send.

Returns: Number of bytes sent, or a negative error value.

Definition at line 592 of file mxsocket.c.

                                                                                 {
    if (sock == nullptr || buf == nullptr || src_bytes == 0)
        return -1;
 
    ssize_t bytes = 0;
    bytes = sendto(sock->sockfd, (const char *)buf, MX_LEN(src_bytes), 0, (struct sockaddr *)&sock->inet6, sock->addrlen);
    return bytes;
}

◆ mx_socket_is_open()

bool mx_socket_is_open ( const MXSocket * s )

nodiscard

Check whether the socket is open.

Parameters

s	Socket state to inspect.

Returns: True when the socket is open.

Definition at line 442 of file mxsocket.c.

                                                           {
    if (sock == nullptr || !mx_socket_valid(sock))
        return false;
    char c = 0;
#ifdef _WIN32
    ssize_t r = recv(sock->sockfd, &c, 1, MSG_PEEK);
#elif defined(MX_HAVE_MSG_DONTWAIT)
    ssize_t r = recv(sock->sockfd, &c, 1, MSG_PEEK | MSG_DONTWAIT);
#else
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(sock->sockfd, &readfds);
 
    struct timeval timeout = {0, 0};
    const int ready = select((int)(sock->sockfd + 1), &readfds, nullptr, nullptr, &timeout);
    if (ready < 0)
        return false;
    if (ready == 0)
        return true;
 
    ssize_t r = recv(sock->sockfd, &c, 1, MSG_PEEK);
#endif
    if (r == 0)
        return false;
    if (r > 0)
        return true;
    if (r < 0 && (SOCK_ERRNO == SOCK_EAGAIN || SOCK_ERRNO == SOCK_EWOULDBLOCK)) {
        return true;
    }
    return false;
}

◆ mx_socket_listen()

bool mx_socket_listen	(	MXSocket *	s,
		const char *	port,
		int	backlog,
		int	type )

nodiscard

Create and bind an Internet socket for listening.

Parameters

s	Socket state to configure.
port	Service or port name to bind.
backlog	Maximum pending connection queue length.
type	Socket kind, typically SOCK_STREAM or SOCK_DGRAM.

Returns: True on success.

Definition at line 270 of file mxsocket.c.

                                                                                             {
    return mx_socket_inet_listen(sock, port, backlog, type, AF_INET);
}

◆ mx_socket_read()

ssize_t mx_socket_read	(	MXSocket *	s,
		void *	data,
		size_t	len,
		int	flags )

Read data from a socket.

Parameters

s	Socket state.
data	Output buffer.
len	Number of bytes to read.
flags	Platform socket flags.

Returns: Number of bytes read, or a negative error value.

Definition at line 422 of file mxsocket.c.

                                                                         {
    if (sock == nullptr || buf == nullptr || len == 0)
        return -1;
    if (!mx_socket_valid(sock)) {
        mx_set_err(EBADF);
        return -1;
    }
    return recv(sock->sockfd, (char *)buf, MX_LEN(len), flags);
}

◆ mx_socket_read_all()

ssize_t mx_socket_read_all	(	MXSocket *	sock,
		void *	buf,
		size_t	bytes )

Read the requested number of bytes from a socket.

Parameters

sock	Socket state.
buf	Output buffer.
bytes	Number of bytes to read.

Returns: Number of bytes read, or a negative error value.

Definition at line 555 of file mxsocket.c.

                                                                    {
    if (sock == nullptr || buf == nullptr || bytes == 0)
        return -1;
 
    char *ptr = (char *)buf;
    size_t left = bytes;
    while (left > 0) {
        ssize_t bytes_read = recv(sock->sockfd, (char *)ptr, MX_LEN(left), 0);
        if (bytes_read == -1) {
            if (SOCK_ERRNO == SOCK_EINTR) {
                continue;
            }
            return -1;
        }
        if (bytes_read == 0)
            break;
        left -= (size_t)bytes_read;
        ptr += bytes_read;
    }
    return (ssize_t)(bytes - left);
}

◆ mx_socket_readline()

bool mx_socket_readline	(	MXSocket *	s,
		char **	buffer,
		size_t *	len )

nodiscard

Read a line of text from a socket.

Parameters

s	Socket state.
buffer	Output buffer pointer.
len	Output length.

Returns: True on success.

Definition at line 474 of file mxsocket.c.

                                                                                   {
    if (sock == nullptr || buffer == nullptr || size == nullptr)
        return false;
 
    if (!mx_socket_valid(sock)) {
        mx_set_err(EBADF);
        return false;
    }
 
    *buffer = nullptr;
    *size = 0;
 
    size_t init_size = 4096;
    char *temp = (char *)malloc(init_size + 1);
    if (temp == nullptr)
        return false;
    char c = 0;
    size_t index = 0;
    while (1) {
        ssize_t read_val = recv(sock->sockfd, &c, 1, 0);
        if (read_val > 0) {
            if (c == '\n')
                break;
            if (index >= init_size) {
                size_t new_init_size = init_size * 2;
                char *t = (char *)realloc(temp, new_init_size + 1);
                if (t == nullptr) {
                    free(temp);
                    return false;
                }
                temp = t;
                init_size = new_init_size;
            }
            temp[index++] = c;
            continue;
        }
        if (read_val == 0) {
            if (index == 0) {
                free(temp);
                return false;
            }
            break;
        }
 
        if (SOCK_ERRNO == SOCK_EINTR)
            continue;
 
        if (SOCK_ERRNO == SOCK_EAGAIN || SOCK_ERRNO == SOCK_EWOULDBLOCK) {
            if (!sock->blocking)
                break;
            continue;
        }
        free(temp);
        return false;
    }
    temp[index] = 0;
    *buffer = temp;
    *size = index;
    return true;
}

◆ mx_socket_recvfrom()

ssize_t mx_socket_recvfrom	(	MXSocket *	sock,
		void *	buf,
		size_t	bytes )

Receive a datagram using an Internet socket.

Parameters

sock	Socket state.
buf	Output buffer.
bytes	Maximum number of bytes to receive.

Returns: Number of bytes received, or a negative error value.

Definition at line 601 of file mxsocket.c.

                                                                        {
    if (sock == nullptr || buf == nullptr || src_bytes == 0)
        return -1;
 
    ssize_t bytes = 0;
    socklen_t len = (socklen_t)sizeof(struct sockaddr_storage);
    struct sockaddr_storage caddr;
    bytes = recvfrom(sock->sockfd, (char *)buf, MX_LEN(src_bytes), 0, (struct sockaddr *)&caddr, &len);
    if (bytes >= 0)
        mx_socket_store_inet_address(sock, (const struct sockaddr *)&caddr, len);
    return bytes;
}

◆ mx_socket_recvfrom_address()

ssize_t mx_socket_recvfrom_address	(	MXSocket *	sock,
		void *	buf,
		size_t	bytes,
		MXSocketAddress *	address )

Definition at line 614 of file mxsocket.c.

                                                                                                          {
    if (sock == nullptr || buf == nullptr || src_bytes == 0 || address == nullptr)
        return -1;
    address->length = (socklen_t)sizeof(address->storage);
    ssize_t bytes = recvfrom(sock->sockfd, (char *)buf, MX_LEN(src_bytes), 0,
                             (struct sockaddr *)&address->storage, &address->length);
    if (bytes >= 0)
        mx_socket_store_inet_address(sock, (const struct sockaddr *)&address->storage, address->length);
    return bytes;
}

◆ mx_socket_send()

ssize_t mx_socket_send	(	MXSocket *	s,
		const void *	data,
		size_t	len,
		int	flags )

Write data to a socket.

Parameters

s	Socket state.
data	Input buffer.
len	Number of bytes to send.
flags	Platform socket flags.

Returns: Number of bytes written, or a negative error value.

Definition at line 432 of file mxsocket.c.

                                                                               {
    if (sock == nullptr || buf == nullptr || len == 0)
        return -1;
    if (!mx_socket_valid(sock)) {
        mx_set_err(EBADF);
        return -1;
    }
    return send(sock->sockfd, (const char *)buf, MX_LEN(len), flags);
}

◆ mx_socket_sendto()

ssize_t mx_socket_sendto	(	MXSocket *	sock,
		const void *	buf,
		size_t	bytes )

Send a datagram using an Internet socket.

Parameters

sock	Socket state.
buf	Input buffer.
bytes	Number of bytes to send.

Returns: Number of bytes sent, or a negative error value.

Definition at line 583 of file mxsocket.c.

                                                                            {
    if (sock == nullptr || buf == nullptr || src_bytes == 0)
        return -1;
 
    ssize_t bytes = 0;
    bytes = sendto(sock->sockfd, (const char *)buf, MX_LEN(src_bytes), 0, (struct sockaddr *)&sock->inet, sock->addrlen);
    return bytes;
}

◆ mx_socket_sendto_address()

ssize_t mx_socket_sendto_address	(	MXSocket *	sock,
		const void *	buf,
		size_t	bytes,
		const MXSocketAddress *	address )

Definition at line 625 of file mxsocket.c.

                                                                                                                    {
    if (sock == nullptr || buf == nullptr || src_bytes == 0 || address == nullptr || address->length == 0)
        return -1;
    return sendto(sock->sockfd, (const char *)buf, MX_LEN(src_bytes), 0,
                  (const struct sockaddr *)&address->storage, address->length);
}

◆ mx_socket_set_blocking()

bool mx_socket_set_blocking	(	MXSocket *	s,
		bool	state )

nodiscard

Toggle blocking mode for a socket.

Parameters

s	Socket state to update.
state	Desired blocking state.

Returns: True on success.

Definition at line 331 of file mxsocket.c.

                                                                      {
    if (sock == nullptr)
        return false;
    if (mx_socket_valid(sock)) {
#ifdef _WIN32
        u_long mode = state ? 0 : 1;
        if (ioctlsocket(sock->sockfd, FIONBIO, &mode) != 0) {
            fprintf(stderr, "Error setting flags for: %d\n", (int)sock->sockfd);
            return false;
        }
#else
        int flags = fcntl(sock->sockfd, F_GETFL);
        if (flags == -1) {
            fprintf(stderr, "Error getting flags for: %d\n", sock->sockfd);
            return false;
        }
        if (state)
            flags &= ~O_NONBLOCK;
        else
            flags |= O_NONBLOCK;
        if (fcntl(sock->sockfd, F_SETFL, flags) == -1) {
            fprintf(stderr, "Error setting flags for: %d\n", sock->sockfd);
            return false;
        }
#endif
        sock->blocking = state;
    } else
        return false;
    return true;
}

◆ mx_socket_unix_bind()

bool mx_socket_unix_bind	(	MXSocket *	s,
		const char *	path )

nodiscard

Bind a UNIX-domain socket to a local path.

Parameters

s	Socket state to configure.
path	Filesystem path for the socket.

Returns: True on success.

Definition at line 378 of file mxsocket.c.

                                                                      {
    if (!mx_socket_init(s) || path == nullptr)
        return false;
 
    mx_socket_fd sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
#ifdef _WIN32
    if (sockfd == INVALID_SOCKET) {
#else
    if (sockfd == -1) {
#endif
        perror("socket");
        return false;
    }
    remove(path);
    struct sockaddr_un caddy;
    memset(&caddy, 0, sizeof(struct sockaddr_un));
    caddy.sun_family = AF_UNIX;
    strncpy(caddy.sun_path, path, sizeof(caddy.sun_path) - 1);
    if (bind(sockfd, (struct sockaddr *)&caddy, sizeof(caddy)) == -1) {
        perror("bind");
        mx_close_socket(sockfd);
        return false;
    }
    s->sun = caddy;
    s->addrlen = sizeof(caddy);
    s->sockfd = sockfd;
    return true;
}

◆ mx_socket_unix_connect()

bool mx_socket_unix_connect	(	MXSocket *	s,
		const char *	path,
		int	type )

nodiscard

Connect a UNIX-domain socket to a local path.

Parameters

s	Socket state to configure.
path	Filesystem path for the socket.
type	Socket kind, typically SOCK_STREAM or SOCK_DGRAM.

Returns: True on success.

Definition at line 241 of file mxsocket.c.

                                                                                      {
    if (path == nullptr)
        return false;
    if (!mx_socket_init(sock))
        return false;
    mx_socket_fd sockfd = NULL_SOCKET;
    struct sockaddr_un addr;
    memset(&addr, 0, sizeof(struct sockaddr_un));
    addr.sun_family = AF_UNIX;
    sockfd = socket(AF_UNIX, type, 0);
#ifdef _WIN32
    if (sockfd == INVALID_SOCKET) {
#else
    if (sockfd == -1) {
#endif
        perror("socket");
        return false;
    }
    strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
    if (connect(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
        perror("connect");
        mx_close_socket(sockfd);
        return false;
    }
    sock->sockfd = sockfd;
    sock->sun = addr;
    return true;
}

◆ mx_socket_unix_listen()

bool mx_socket_unix_listen	(	MXSocket *	s,
		const char *	path,
		int	backlog,
		int	type )

nodiscard

Create and bind a UNIX-domain socket for listening.

Parameters

s	Socket state to configure.
path	Filesystem path for the socket.
backlog	Maximum pending connection queue length.
type	Socket kind, typically SOCK_STREAM or SOCK_DGRAM.

Returns: True on success.

Definition at line 202 of file mxsocket.c.

                                                                                                  {
    if (path == nullptr)
        return false;
    if (!mx_socket_init(sock))
        return false;
    struct sockaddr_un addr;
    mx_socket_fd sockfd = socket(AF_UNIX, type, 0);
#ifdef _WIN32
    if (sockfd == INVALID_SOCKET) {
#else
    if (sockfd == -1) {
#endif
        perror("socket");
        return false;
    }
    if (remove(path) == -1 && errno == ENOENT) {
        perror("remove");
        mx_close_socket(sockfd);
        return false;
    }
    memset(&addr, 0, sizeof(struct sockaddr_un));
    strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
    addr.sun_family = AF_UNIX;
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
        perror("bind");
        mx_close_socket(sockfd);
        return false;
    }
 
    if (listen(sockfd, backlog) == -1) {
        perror("listen");
        mx_close_socket(sockfd);
        return false;
    }
    sock->sockfd = sockfd;
    sock->sun = addr;
    return true;
}

◆ mx_socket_unix_recvfrom()

ssize_t mx_socket_unix_recvfrom	(	MXSocket *	sock,
		void *	buf,
		size_t	bytes )

Receive a datagram using a UNIX-domain socket.

Parameters

sock	Socket state.
buf	Output buffer.
bytes	Maximum number of bytes to receive.

Returns: Number of bytes received, or a negative error value.

Definition at line 653 of file mxsocket.c.

                                                                             {
    if (sock == nullptr || buf == nullptr || src_bytes == 0)
        return -1;
 
    ssize_t bytes = 0;
    socklen_t len = (socklen_t)sizeof(struct sockaddr_storage);
    struct sockaddr_storage caddr;
    bytes = recvfrom(sock->sockfd, (char *)buf, MX_LEN(src_bytes), 0, (struct sockaddr *)&caddr, &len);
    return bytes;
}

◆ mx_socket_unix_sendto()

ssize_t mx_socket_unix_sendto	(	MXSocket *	sock,
		const void *	buf,
		size_t	bytes )

Send a datagram using a UNIX-domain socket.

Parameters

sock	Socket state.
buf	Input buffer.
bytes	Number of bytes to send.

Returns: Number of bytes sent, or a negative error value.

Definition at line 645 of file mxsocket.c.

                                                                                 {
    if (sock == nullptr || buf == nullptr || src_bytes == 0)
        return -1;
 
    ssize_t bytes = 0;
    bytes = sendto(sock->sockfd, (const char *)buf, MX_LEN(src_bytes), 0, (struct sockaddr *)&sock->sun, sock->addrlen);
    return bytes;
}

◆ mx_socket_valid()

bool mx_socket_valid ( const MXSocket * s )

nodiscard

Check whether the socket handle is valid.

Parameters

s	Socket state to inspect.

Returns: True when the handle is valid.

Definition at line 416 of file mxsocket.c.

                                                         {
    if (sock == nullptr)
        return false;
    return sock->sockfd != NULL_SOCKET;
}

◆ mx_socket_write_all()

ssize_t mx_socket_write_all	(	MXSocket *	sock,
		const void *	buf,
		size_t	bytes )

Write the requested number of bytes to a socket.

Parameters

sock	Socket state.
buf	Input buffer.
bytes	Number of bytes to write.

Returns: Number of bytes written, or a negative error value.

Definition at line 535 of file mxsocket.c.

                                                                           {
    if (sock == nullptr || buf == nullptr || bytes == 0)
        return -1;
 
    const char *ptr = (const char *)buf;
    size_t left = bytes;
    while (left > 0) {
        ssize_t written = send(sock->sockfd, (const char *)ptr, MX_LEN(left), 0);
        if (written == -1) {
            if (SOCK_ERRNO == SOCK_EINTR) {
                continue;
            }
            return -1;
        }
        left -= (size_t)written;
        ptr += written;
    }
    return (ssize_t)bytes;
}

MXVK Vulkan Framework 0.24.0 C++20 Vulkan rendering framework for practical 2D and 3D application development with SDL3.

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ mx_close_socket

◆ MX_LEN

◆ mx_set_err

◆ NULL_SOCKET

◆ SOCK_EAGAIN

◆ SOCK_EBADF

◆ SOCK_ECONNABORTED

◆ SOCK_ECONNRESET

◆ SOCK_EINTR

◆ SOCK_EINVAL

◆ SOCK_ENOTSOCK

◆ SOCK_ERRNO

◆ SOCK_ESHUTDOWN

◆ SOCK_EWOULDBLOCK

Typedef Documentation

◆ mx_socket_fd

Function Documentation

◆ mx_socket_accept()

◆ mx_socket_bind()

◆ mx_socket_close()

◆ mx_socket_connect()

◆ mx_socket_ignore_pipe_signal()

◆ mx_socket_init()

◆ mx_socket_ipv6_bind()

◆ mx_socket_ipv6_connect()

◆ mx_socket_ipv6_listen()

◆ mx_socket_ipv6_recvfrom()

◆ mx_socket_ipv6_sendto()

◆ mx_socket_is_open()

◆ mx_socket_listen()

◆ mx_socket_read()

◆ mx_socket_read_all()

◆ mx_socket_readline()

◆ mx_socket_recvfrom()

◆ mx_socket_recvfrom_address()

◆ mx_socket_send()

◆ mx_socket_sendto()

◆ mx_socket_sendto_address()

◆ mx_socket_set_blocking()

◆ mx_socket_unix_bind()

◆ mx_socket_unix_connect()

◆ mx_socket_unix_listen()

◆ mx_socket_unix_recvfrom()

◆ mx_socket_unix_sendto()

◆ mx_socket_valid()

◆ mx_socket_write_all()