sapi_posix_backend_channel_service.c

Go to the documentation of this file.

#define _POSIX_C_SOURCE 200809L

 
#include "safeapi/posix_backend/sapi_posix_backend_channel_service.h"
 
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "safeapi/oal/memory/sapi_mem_util.h"
 
typedef struct
{
    int fd;
    sapi_netlink_config_t config;
    struct sockaddr_in peer_addr;
    socklen_t peer_addr_len;
    bool has_peer_addr;
    bool initialized;
} sapi_posix_channel_state_t;
 
typedef char sapi_posix_channel_state_fits_[(sizeof(sapi_posix_channel_state_t) <=
                                             sizeof(sapi_channel_service_storage_t)) ? 1 : -1];
 
static sapi_posix_channel_resolve_fn s_resolver;
static void *s_resolver_context;
 
static sapi_posix_channel_state_t *channel_state(sapi_channel_service_storage_t *storage)
{
    return (sapi_posix_channel_state_t *)(void *)storage;
}
 
static sapi_status_t set_nonblocking(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t init_listen_socket(sapi_posix_channel_state_t *state)
{
    int fd;
    int reuse = 1;
    struct sockaddr_in bind_addr;
 
    if (state->fd >= 0)
    {
        return SAPI_STATUS_OK;
    }
 
    fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    (void)setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
#ifdef SO_REUSEPORT
    (void)setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse));
#endif
 
    sapi_mem_set(&bind_addr, 0, sizeof(bind_addr));
    bind_addr.sin_family = AF_INET;
    bind_addr.sin_port = htons(state->config.port);
    if (state->config.host == NULL)
    {
        bind_addr.sin_addr.s_addr = INADDR_ANY;
    }
    else if (inet_pton(AF_INET, state->config.host, &bind_addr.sin_addr) != 1)
    {
        (void)close(fd);
        return SAPI_STATUS_INVALID_PARAM;
    }
 
    if (bind(fd, (struct sockaddr *)&bind_addr, sizeof(bind_addr)) != 0)
    {
        (void)close(fd);
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    if (set_nonblocking(fd) != SAPI_STATUS_OK)
    {
        (void)close(fd);
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    state->fd = fd;
    return SAPI_STATUS_OK;
}
 
static sapi_status_t init_connect_socket(sapi_posix_channel_state_t *state)
{
    struct addrinfo hints;
    struct addrinfo *resolved = NULL;
    char port_str[8];
    int fd;
 
    if (state->fd >= 0)
    {
        return SAPI_STATUS_OK;
    }
 
    (void)snprintf(port_str, sizeof(port_str), "%u", (unsigned int)state->config.port);
    sapi_mem_set(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_DGRAM;
 
    if (getaddrinfo(state->config.host, port_str, &hints, &resolved) != 0)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
 
    fd = socket(resolved->ai_family, resolved->ai_socktype, resolved->ai_protocol);
    if (fd < 0)
    {
        perror("init_connect_socket: socket");
        freeaddrinfo(resolved);
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    if (set_nonblocking(fd) != SAPI_STATUS_OK)
    {
        perror("init_connect_socket: set_nonblocking");
        (void)close(fd);
        freeaddrinfo(resolved);
        return SAPI_STATUS_INTERNAL_ERROR;
    }
 
    if (connect(fd, resolved->ai_addr, resolved->ai_addrlen) != 0)
    {
        perror("init_connect_socket: connect");
        (void)close(fd);
        freeaddrinfo(resolved);
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    freeaddrinfo(resolved);
    state->fd = fd;
    {
        uint8_t hello = 0xA5U;
        (void)send(state->fd, &hello, 1, 0);
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_setup(sapi_channel_service_storage_t *storage, const char *channel_name)
{
    sapi_posix_channel_state_t *state;
    sapi_status_t status;
 
    if ((storage == NULL) || (channel_name == NULL) || (s_resolver == NULL))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    state = channel_state(storage);
    sapi_mem_set(state, 0, sizeof(*state));
    state->fd = -1;
    status = s_resolver(channel_name, &state->config, s_resolver_context);
    if (status != SAPI_STATUS_OK)
    {
        return status;
    }
    state->initialized = true;
    if (state->config.role == SAPI_NETLINK_ROLE_LISTEN)
    {
        return init_listen_socket(state);
    }
    return init_connect_socket(state);
}
 
static sapi_status_t backend_read(sapi_channel_service_storage_t *storage, void *data, size_t data_size,
                                  sapi_duration_ms_t timeout_ms)
{
    sapi_posix_channel_state_t *state;
    ssize_t n;
 
    if ((storage == NULL) || (data == NULL) || (data_size == 0U))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    state = channel_state(storage);
    if (!state->initialized)
    {
        return SAPI_STATUS_NOT_INITIALIZED;
    }
    if (state->fd < 0)
    {
        if (state->config.role == SAPI_NETLINK_ROLE_LISTEN)
        {
            if (init_listen_socket(state) != SAPI_STATUS_OK)
            {
                return SAPI_STATUS_TIMEOUT;
            }
        }
        else
        {
            if (init_connect_socket(state) != SAPI_STATUS_OK)
            {
                return SAPI_STATUS_TIMEOUT;
            }
        }
    }
 
    if (timeout_ms > 0U)
    {
        struct pollfd pfd;
        int rc;
 
        pfd.fd = state->fd;
        pfd.events = POLLIN;
        pfd.revents = 0;
        rc = poll(&pfd, 1, (int)timeout_ms);
        if (rc == 0)
        {
            return SAPI_STATUS_TIMEOUT;
        }
        if (rc < 0)
        {
            if (errno == EINTR)
            {
                return SAPI_STATUS_TIMEOUT;
            }
            return SAPI_STATUS_INTERNAL_ERROR;
        }
    }
 
    if (state->config.role == SAPI_NETLINK_ROLE_LISTEN)
    {
        while (1)
        {
            struct sockaddr_in src_addr;
            socklen_t addr_len = (socklen_t)sizeof(src_addr);
            sapi_mem_set(&src_addr, 0, sizeof(src_addr));
 
            n = recvfrom(state->fd, data, data_size, 0, (struct sockaddr *)&src_addr, &addr_len);
            if (n > 0)
            {
                state->peer_addr = src_addr;
                state->peer_addr_len = addr_len;
                state->has_peer_addr = true;
 
                if ((n == 1) && (((const uint8_t *)data)[0] == 0xA5U))
                {
                    uint8_t ack = 0x5AU;
                    (void)sendto(state->fd, &ack, 1, 0, (const struct sockaddr *)&src_addr, addr_len);
                    continue;
                }
            }
            break;
        }
    }
    else
    {
        while (1)
        {
            if (!state->has_peer_addr)
            {
                uint8_t hello = 0xA5U;
                (void)send(state->fd, &hello, 1, 0);
            }
            n = recv(state->fd, data, data_size, 0);
            if (n > 0)
            {
                if ((n == 1) && (((const uint8_t *)data)[0] == 0x5AU))
                {
                    state->has_peer_addr = true;
                    continue;
                }
                if ((n == 1) && (((const uint8_t *)data)[0] == 0xA5U))
                {
                    uint8_t ack = 0x5AU;
                    (void)send(state->fd, &ack, 1, 0);
                    state->has_peer_addr = true;
                    continue;
                }
            }
            break;
        }
    }
 
    if (n < 0)
    {
        if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINTR) || (errno == ECONNREFUSED) ||
            (errno == ENOTCONN) || (errno == EHOSTUNREACH) || (errno == EPIPE))
        {
            return SAPI_STATUS_TIMEOUT;
        }
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    if (n == 0)
    {
        return SAPI_STATUS_TIMEOUT;
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_send(sapi_channel_service_storage_t *storage, const void *data, size_t data_size,
                                  sapi_duration_ms_t timeout_ms)
{
    sapi_posix_channel_state_t *state;
    ssize_t n;
 
    if ((storage == NULL) || (data == NULL) || (data_size == 0U))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    state = channel_state(storage);
    if (!state->initialized)
    {
        return SAPI_STATUS_NOT_INITIALIZED;
    }
    if (state->fd < 0)
    {
        if (state->config.role == SAPI_NETLINK_ROLE_LISTEN)
        {
            if (init_listen_socket(state) != SAPI_STATUS_OK)
            {
                return SAPI_STATUS_TIMEOUT;
            }
        }
        else
        {
            if (init_connect_socket(state) != SAPI_STATUS_OK)
            {
                return SAPI_STATUS_TIMEOUT;
            }
        }
    }
 
    if (timeout_ms > 0U)
    {
        struct pollfd pfd;
        int rc;
 
        pfd.fd = state->fd;
        pfd.events = POLLOUT;
        pfd.revents = 0;
        rc = poll(&pfd, 1, (int)timeout_ms);
        if (rc == 0)
        {
            return SAPI_STATUS_TIMEOUT;
        }
        if (rc < 0)
        {
            if (errno == EINTR)
            {
                return SAPI_STATUS_TIMEOUT;
            }
            return SAPI_STATUS_INTERNAL_ERROR;
        }
    }
 
    if (state->config.role == SAPI_NETLINK_ROLE_LISTEN)
    {
        if (!state->has_peer_addr)
        {
            /* If no peer has spoken to this listen socket yet, drop outbound gracefully */
            return SAPI_STATUS_OK;
        }
        n = sendto(state->fd, data, data_size, 0, (const struct sockaddr *)&state->peer_addr, state->peer_addr_len);
    }
    else
    {
        n = send(state->fd, data, data_size, 0);
    }
 
    if (n < 0)
    {
        if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINTR) || (errno == ECONNREFUSED) ||
            (errno == ENOTCONN) || (errno == EHOSTUNREACH) || (errno == EADDRNOTAVAIL) || (errno == EPIPE))
        {
            return SAPI_STATUS_TIMEOUT;
        }
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_close(sapi_channel_service_storage_t *storage)
{
    sapi_posix_channel_state_t *state;
 
    if (storage == NULL)
    {
        return SAPI_STATUS_OK;
    }
    state = channel_state(storage);
    if (!state->initialized)
    {
        return SAPI_STATUS_OK;
    }
    state->initialized = false;
    if (state->fd >= 0)
    {
        (void)close(state->fd);
        state->fd = -1;
    }
    state->has_peer_addr = false;
    return SAPI_STATUS_OK;
}
 
static const sapi_channel_service_backend_t s_backend = {
    backend_setup,
    backend_read,
    backend_send,
    backend_close
};
 
sapi_status_t sapi_posix_backend_channel_service_register_resolver(sapi_posix_channel_resolve_fn resolver, void *context)
{
    if (resolver == NULL)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    s_resolver = resolver;
    s_resolver_context = context;
    return sapi_channel_service_register_backend(&s_backend);
}
 
const sapi_channel_service_backend_t *sapi_posix_backend_channel_service(void)
{
    return &s_backend;
}