rte_posix_osadapter_netlink.c

Go to the documentation of this file.

#define _POSIX_C_SOURCE 200809L

#include "rte/posix_osadapter/rte_posix_osadapter.h"
#include "rte_posix_osadapter_poll.h"
#include "rte_posix_osadapter_sockbuf.h"
 
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "rte/oal/memory/rte_mem_util.h"
#include "rte/oal/log/rte_log.h"
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

#define POSIX_NETLINK_UDP_HELLO ((uint8_t)0xA5U)
#define POSIX_NETLINK_UDP_HELLO_ACK ((uint8_t)0x5AU)
#define POSIX_NETLINK_UDP_HELLO_PERIOD_MS (20U)
 
typedef struct
{
    int                fd;
    size_t             message_size;
    bool               listen;    
    socklen_t          peer_len;
    struct sockaddr_in peer;      
} posix_netlink_state_t;
 
/* C99-compatible static assert: posix_netlink_state_t must fit inside
 * rte_netlink_storage_t's reserved bytes. */
typedef char posix_netlink_storage_fits_[(sizeof(posix_netlink_state_t) <= sizeof(rte_netlink_storage_t)) ? 1
                                                                                                              : -1];
 
static rte_status_t set_nonblocking(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);
 
    if (flags < 0)
    {
        return RTE_STATUS_INTERNAL_ERROR;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) != 0)
    {
        return RTE_STATUS_INTERNAL_ERROR;
    }
    return RTE_STATUS_OK;
}
 
static void compute_deadline(rte_duration_ms_t timeout_ms, struct timespec *out_deadline)
{
    (void)clock_gettime(CLOCK_MONOTONIC, out_deadline);
    out_deadline->tv_sec += (time_t)(timeout_ms / 1000U);
    out_deadline->tv_nsec += (long)((timeout_ms % 1000U) * 1000000L);
    if (out_deadline->tv_nsec >= 1000000000L)
    {
        out_deadline->tv_sec += 1;
        out_deadline->tv_nsec -= 1000000000L;
    }
}

static bool same_peer(const struct sockaddr_in *a, const struct sockaddr_in *b)
{
    return (a->sin_addr.s_addr == b->sin_addr.s_addr) && (a->sin_port == b->sin_port);
}
 
static rte_status_t open_listen_udp(const rte_netlink_config_t *config, int *out_fd, struct sockaddr_in *out_peer,
                                    socklen_t *out_peer_len)
{
    int fd;
    int reuse = 1;
    struct sockaddr_in bind_addr;
    struct sockaddr_in peer_addr;
    struct timespec deadline;
    uint8_t ack_byte = POSIX_NETLINK_UDP_HELLO_ACK;
    socklen_t peer_addr_len = sizeof(peer_addr);
 
    fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd >= 0)
    {
        /* Not inherited across execv(): the in-process REBOOT re-execs this binary, and an inherited listening socket
         * kept receiving datagrams for its port that nobody read (Docker: sockets piled up with every reboot). */
        (void)fcntl(fd, F_SETFD, FD_CLOEXEC);
    }
    if (fd < 0)
    {
        return RTE_STATUS_INTERNAL_ERROR;
    }
    (void)setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
 
    rte_mem_set(&bind_addr, 0, sizeof(bind_addr));
    bind_addr.sin_family = AF_INET;
    bind_addr.sin_port = htons(config->port);
    if (config->host == NULL)
    {
        bind_addr.sin_addr.s_addr = INADDR_ANY;
    }
    else if (inet_pton(AF_INET, config->host, &bind_addr.sin_addr) != 1)
    {
        (void)close(fd);
        return RTE_STATUS_INVALID_PARAM;
    }
 
    if (bind(fd, (struct sockaddr *)&bind_addr, sizeof(bind_addr)) != 0)
    {
        char msg[80];
 
        (void)snprintf(msg, sizeof(msg), "RTE: open_listen_udp: bind port %u failed errno=%d", config->port, errno);
        rte_log_write(RTE_LOG_LEVEL_ERROR, "RTE", msg);
        (void)close(fd);
        return RTE_STATUS_INTERNAL_ERROR;
    }
    {
        char msg[80];
 
        (void)snprintf(msg, sizeof(msg), "RTE: open UDP listen bound port %u successfully (fd=%d)", config->port, fd);
        rte_log_write(RTE_LOG_LEVEL_INFO, "RTE", msg);
    }
    /* REQ-OAL-NETLINK-015: configured buffer sizes before the handshake; both 0 -> no call at all. */
    {
        const rte_status_t buf_status = posix_socket_apply_buffers(fd, config);
 
        if (buf_status != RTE_STATUS_OK)
        {
            (void)close(fd);
            return buf_status;
        }
    }
    if (set_nonblocking(fd) != RTE_STATUS_OK)
    {
        (void)close(fd);
        return RTE_STATUS_INTERNAL_ERROR;
    }
 
    compute_deadline(config->connect_timeout_ms, &deadline);
    for (;;)
    {
        struct pollfd pfd;
        int wait_ms = posix_remaining_ms(&deadline);
        int rc;
        ssize_t n;
        uint8_t hello_byte;
 
        pfd.fd = fd;
        pfd.events = POLLIN;
        pfd.revents = 0;
        rc = poll(&pfd, 1, (wait_ms > 0) ? wait_ms : 0);
        if (rc == 0)
        {
            (void)close(fd);
            return RTE_STATUS_TIMEOUT;
        }
        if (rc < 0)
        {
            if (errno == EINTR)
            {
                if (wait_ms <= 0)
                {
                    (void)close(fd);
                    return RTE_STATUS_TIMEOUT;
                }
                continue;
            }
            (void)close(fd);
            return RTE_STATUS_INTERNAL_ERROR;
        }
 
        rte_mem_set(&peer_addr, 0, sizeof(peer_addr));
        peer_addr_len = sizeof(peer_addr);
        n = recvfrom(fd, &hello_byte, sizeof(hello_byte), 0, (struct sockaddr *)&peer_addr, &peer_addr_len);
        if (n < 0)
        {
            if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINTR))
            {
                continue;
            }
            {
                char msg[64];
 
                (void)snprintf(msg, sizeof(msg), "RTE: open_listen_udp: recvfrom failed errno=%d", errno);
                rte_log_write(RTE_LOG_LEVEL_ERROR, "RTE", msg);
            }
            (void)close(fd);
            return RTE_STATUS_INTERNAL_ERROR;
        }
        /* Any datagram identifies the peer, not only a HELLO: when THIS side restarted while the peer kept running,
         * the peer is already connected and never sends another HELLO, only its ordinary frames (that one frame is
         * dropped here). Requiring a HELLO left a restarted listener waiting forever. */
        (void)hello_byte;
        rte_log_write(RTE_LOG_LEVEL_INFO, "RTE", "RTE: open UDP listen learned its peer, sending ACK");
        break;
    }
 
    if (sendto(fd, &ack_byte, sizeof(ack_byte), 0, (struct sockaddr *)&peer_addr, peer_addr_len)
        != (ssize_t)sizeof(ack_byte))
    {
        char msg[64];
 
        (void)snprintf(msg, sizeof(msg), "RTE: open_listen_udp: send ACK failed errno=%d", errno);
        rte_log_write(RTE_LOG_LEVEL_ERROR, "RTE", msg);
        (void)close(fd);
        return RTE_STATUS_INTERNAL_ERROR;
    }
    rte_log_write(RTE_LOG_LEVEL_INFO, "RTE", "RTE: open UDP listen ACK sent OK");
 
    /* Deliberately no post-ACK "grace drain" wait here: an earlier version
     * of this function blocked open() for a further fixed window to
     * absorb any HELLO retransmits still in flight from the peer, but
     * that unconditionally delayed every LISTEN-role open() (and, in
     * turn, callers with a tight end-to-end budget - e.g.
     * RTE_EXAMPLE_AB_CHECKPOINT_MAX_DELAY_MS - built on the old TCP
     * OSAdapter's much faster connection establishment). A stray duplicate
     * HELLO that arrives after open() has already returned is instead
     * handled cheaply, on demand, inside backend_receive() below - no
     * fixed delay paid unless one actually shows up. */
    *out_fd = fd;
    *out_peer = peer_addr;
    *out_peer_len = peer_addr_len;
    return RTE_STATUS_OK;
}
 
static rte_status_t open_connect_udp(const rte_netlink_config_t *config, int *out_fd)
{
    struct addrinfo hints;
    struct addrinfo *resolved = NULL;
    char port_str[8];
    int fd;
    struct timespec deadline;
    struct timespec next_hello_deadline;
    uint8_t hello_byte = POSIX_NETLINK_UDP_HELLO;
 
    (void)snprintf(port_str, sizeof(port_str), "%u", (unsigned int)config->port);
    {
        char msg[96];
 
        (void)snprintf(msg, sizeof(msg), "RTE: opening UDP connection to host=%s port=%s", config->host, port_str);
        rte_log_write(RTE_LOG_LEVEL_DEBUG, "RTE", msg);
    }
 
    rte_mem_set(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_DGRAM;
    if (getaddrinfo(config->host, port_str, &hints, &resolved) != 0)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    fd = socket(resolved->ai_family, resolved->ai_socktype, resolved->ai_protocol);
    if (fd >= 0)
    {
        /* Not inherited across execv(): the in-process REBOOT re-execs this binary, and an inherited listening socket
         * kept receiving datagrams for its port that nobody read (Docker: sockets piled up with every reboot). */
        (void)fcntl(fd, F_SETFD, FD_CLOEXEC);
    }
    if (fd < 0)
    {
        freeaddrinfo(resolved);
        return RTE_STATUS_INTERNAL_ERROR;
    }
    /* REQ-OAL-NETLINK-015: configured buffer sizes before the handshake; both 0 -> no call at all. */
    {
        const rte_status_t buf_status = posix_socket_apply_buffers(fd, config);
 
        if (buf_status != RTE_STATUS_OK)
        {
            (void)close(fd);
            freeaddrinfo(resolved);
            return buf_status;
        }
    }
    if (set_nonblocking(fd) != RTE_STATUS_OK)
    {
        (void)close(fd);
        freeaddrinfo(resolved);
        return RTE_STATUS_INTERNAL_ERROR;
    }
 
    /* connect() on a UDP socket only fixes the default peer address
     * locally - it performs no network I/O and gives no signal that the
     * peer is actually reachable, unlike TCP's connect(). The HELLO/
     * HELLO_ACK exchange below is what makes RTE_STATUS_OK meaningful. */
    if (connect(fd, resolved->ai_addr, resolved->ai_addrlen) != 0)
    {
        char msg[64];
 
        (void)snprintf(msg, sizeof(msg), "RTE: open UDP connect failed errno=%d", errno);
        rte_log_write(RTE_LOG_LEVEL_ERROR, "RTE", msg);
        (void)close(fd);
        freeaddrinfo(resolved);
        return RTE_STATUS_INTERNAL_ERROR;
    }
    {
        char msg[64];
 
        (void)snprintf(msg, sizeof(msg), "RTE: open UDP connect succeeded (fd=%d)", fd);
        rte_log_write(RTE_LOG_LEVEL_INFO, "RTE", msg);
    }
    freeaddrinfo(resolved);
 
    compute_deadline(config->connect_timeout_ms, &deadline);
    compute_deadline(0U, &next_hello_deadline); /* send the first HELLO immediately */
    rte_log_write(RTE_LOG_LEVEL_DEBUG, "RTE", "RTE: open UDP handshake entering loop");
    for (;;)
    {
        struct pollfd pfd;
        int wait_ms = posix_remaining_ms(&deadline);
        int hello_wait_ms;
        int poll_wait_ms;
        int rc;
        ssize_t n;
        uint8_t ack_byte;
 
        /* Deliberately no per-iteration log line here: this loop's own
         * HELLO retry cadence (POSIX_NETLINK_UDP_HELLO_PERIOD_MS, 20ms)
         * means a per-iteration DEBUG line fires roughly 50x/second for
         * as long as the peer isn't up yet - real overhead during a
         * connection-establishment window that later turned out to
         * matter for a known-fragile startup negotiation race
         * (ab_gp_channel_crosscompare.c's NEGOTIATION MISMATCH ->
         * REBOOT path, common_config.h's own ADR-029 comment on it) -
         * only genuinely exceptional outcomes (an unhandled send error
         * below) are worth a log line at this cadence. */
        if (wait_ms <= 0)
        {
            (void)close(fd);
            return RTE_STATUS_TIMEOUT;
        }
 
        hello_wait_ms = posix_remaining_ms(&next_hello_deadline);
        if (hello_wait_ms <= 0)
        {
            ssize_t sres = send(fd, &hello_byte, sizeof(hello_byte), 0);
 
            if ((sres < 0) && (errno != ECONNREFUSED) &&
                (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != ENOTCONN) &&
                (errno != EHOSTUNREACH) && (errno != EADDRNOTAVAIL) && (errno != EPIPE) &&
                (errno != ECONNRESET) && (errno != ENETUNREACH))
            {
                char msg[64];
 
                (void)snprintf(msg, sizeof(msg), "RTE: open_connect_udp: unhandled send error errno=%d", errno);
                rte_log_write(RTE_LOG_LEVEL_ERROR, "RTE", msg);
                (void)close(fd);
                return RTE_STATUS_INTERNAL_ERROR;
            }
            compute_deadline((rte_duration_ms_t)POSIX_NETLINK_UDP_HELLO_PERIOD_MS, &next_hello_deadline);
            hello_wait_ms = posix_remaining_ms(&next_hello_deadline);
        }
 
        poll_wait_ms = (hello_wait_ms < wait_ms) ? hello_wait_ms : wait_ms;
        pfd.fd = fd;
        pfd.events = POLLIN;
        pfd.revents = 0;
        rc = poll(&pfd, 1, poll_wait_ms);
        if (rc < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            (void)close(fd);
            return RTE_STATUS_INTERNAL_ERROR;
        }
        if (rc == 0)
        {
            continue; /* hello-resend tick or spurious wake - re-evaluate both deadlines */
        }
 
        n = recv(fd, &ack_byte, sizeof(ack_byte), MSG_PEEK);
        if (n < 0)
        {
            if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINTR) || (errno == ECONNREFUSED) ||
                (errno == ENOTCONN) || (errno == EHOSTUNREACH) || (errno == EPIPE) || (errno == ECONNRESET) ||
                (errno == ENETUNREACH))
            {
                continue; /* including ECONNREFUSED/ENOTCONN/ECONNRESET: peer not up yet */
            }
            {
                char msg[64];
 
                (void)snprintf(msg, sizeof(msg), "RTE: open_connect_udp: recv failed errno=%d", errno);
                rte_log_write(RTE_LOG_LEVEL_ERROR, "RTE", msg);
            }
            (void)close(fd);
            return RTE_STATUS_INTERNAL_ERROR;
        }
        {
            char msg[64];
 
            (void)snprintf(msg, sizeof(msg), "RTE: open_connect_udp: peeked n=%ld byte=%02x", (long)n, ack_byte);
            rte_log_write(RTE_LOG_LEVEL_DEBUG, "RTE", msg);
        }
        if ((n == (ssize_t)sizeof(ack_byte)) && (ack_byte == POSIX_NETLINK_UDP_HELLO_ACK))
        {
            uint8_t consumed_byte;
 
            (void)recv(fd, &consumed_byte, sizeof(consumed_byte), 0); /* actually consume the ACK */
            rte_log_write(RTE_LOG_LEVEL_INFO, "RTE", "RTE: open UDP connect consumed ACK successfully");
            break;
        }
        /* Not our handshake ACK (or a duplicate HELLO we ourselves sent
         * echoing back is impossible - this is a unidirectional wait) -
         * leave it queued for the caller's first real receive() and keep
         * waiting within the same deadline. */
    }
 
    *out_fd = fd;
    return RTE_STATUS_OK;
}
 
static rte_status_t osadapter_open(rte_netlink_storage_t *storage, const rte_netlink_config_t *config,
                                   rte_netlink_handle_t *out_handle)
{
    posix_netlink_state_t *state;
    int fd = -1;
    rte_status_t status;
    struct sockaddr_in peer;
    socklen_t peer_len = 0;
 
    if ((storage == NULL) || (config == NULL) || (out_handle == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    {
        char msg[96];
 
        (void)snprintf(msg, sizeof(msg), "RTE: osadapter_open role=%d host=%s port=%u", config->role,
                        config->host ? config->host : "NULL", config->port);
        rte_log_write(RTE_LOG_LEVEL_DEBUG, "RTE", msg);
    }
    rte_mem_set(&peer, 0, sizeof(peer));
    if (config->role == RTE_NETLINK_ROLE_LISTEN)
    {
        status = open_listen_udp(config, &fd, &peer, &peer_len);
    }
    else
    {
        status = open_connect_udp(config, &fd);
    }
    {
        char msg[64];
 
        (void)snprintf(msg, sizeof(msg), "RTE: osadapter_open (role=%d) returned status=%d", config->role, (int)status);
        rte_log_write(RTE_LOG_LEVEL_DEBUG, "RTE", msg);
    }
    if (status != RTE_STATUS_OK)
    {
        return status;
    }
 
    state = (posix_netlink_state_t *)(void *)storage;
    state->fd = fd;
    state->message_size = config->message_size;
    state->listen = (config->role == RTE_NETLINK_ROLE_LISTEN);
    state->peer = peer;
    state->peer_len = peer_len;
    *out_handle = (rte_netlink_handle_t)(void *)storage;
    return RTE_STATUS_OK;
}
 
static rte_status_t backend_send(rte_netlink_handle_t handle, const void *message, size_t message_size,
                                   rte_duration_ms_t timeout_ms)
{
    posix_netlink_state_t *state = (posix_netlink_state_t *)(void *)handle;
    struct timespec deadline;
    bool first_iteration = true;
 
    if ((state == NULL) || (message == NULL) || (message_size == 0U))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    compute_deadline(timeout_ms, &deadline);
    for (;;)
    {
        struct pollfd pfd;
            int wait_ms = posix_remaining_ms(&deadline);
            int rc;
            ssize_t n;
 
            if (!first_iteration && (wait_ms <= 0))
            {
                return RTE_STATUS_TIMEOUT;
            }
            first_iteration = false;
            if (wait_ms < 0)
            {
                wait_ms = 0;
            }
            pfd.fd = state->fd;
            pfd.events = POLLOUT;
            pfd.revents = 0;
            rc = poll(&pfd, 1, wait_ms);
        if (rc == 0)
        {
            return RTE_STATUS_TIMEOUT;
        }
        if (rc < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return RTE_STATUS_INTERNAL_ERROR;
        }
 
        n = state->listen
                ? sendto(state->fd, message, message_size, 0, (const struct sockaddr *)&state->peer, state->peer_len)
                : send(state->fd, message, message_size, 0);
        if (n < 0)
        {
            if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINTR))
            {
                continue;
            }
            if (errno == ECONNREFUSED)
            {
                return RTE_STATUS_HARDWARE_FAULT;
            }
            return RTE_STATUS_INTERNAL_ERROR;
        }
        if ((size_t)n != message_size)
        {
            /* A connected SOCK_DGRAM send() is documented atomic-or-fails;
             * a short write here means an unexpected kernel condition, not
             * a partial transfer to resume (there is nothing to loop for,
             * unlike a TCP stream). */
            return RTE_STATUS_INTERNAL_ERROR;
        }
        return RTE_STATUS_OK;
    }
}
 
static rte_status_t backend_receive(rte_netlink_handle_t handle, void *out_message, size_t buffer_size,
                                      rte_duration_ms_t timeout_ms)
{
    posix_netlink_state_t *state = (posix_netlink_state_t *)(void *)handle;
    struct timespec deadline;
    bool first_iteration = true;
 
    if ((state == NULL) || (out_message == NULL) || (buffer_size == 0U))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    compute_deadline(timeout_ms, &deadline);
    for (;;)
    {
        struct pollfd pfd;
        int wait_ms = posix_remaining_ms(&deadline);
        int rc;
        ssize_t n;
 
        if (!first_iteration && (wait_ms <= 0))
        {
            return RTE_STATUS_TIMEOUT;
        }
        first_iteration = false;
        if (wait_ms < 0)
        {
            wait_ms = 0;
        }
        pfd.fd = state->fd;
        pfd.events = POLLIN;
        pfd.revents = 0;
        rc = poll(&pfd, 1, wait_ms);
        if (rc == 0)
        {
            return RTE_STATUS_TIMEOUT;
        }
        if (rc < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return RTE_STATUS_INTERNAL_ERROR;
        }
 
        /* Linux: MSG_TRUNC makes the kernel report the datagram's real
         * length even if it exceeded buffer_size, so the length check
         * below rejects an oversized datagram as well as an undersized
         * one. Darwin does not honour MSG_TRUNC as a recvfrom() input
         * flag, so flags are 0 there: an oversized datagram is silently
         * truncated to buffer_size and accepted as a full-size frame
         * (RTE_STATUS_OK) - only an undersized one is detected. */
        {
            struct sockaddr_in src;
            socklen_t src_len = sizeof(src);
#ifdef __APPLE__
            n = recvfrom(state->fd, out_message, buffer_size, 0, (struct sockaddr *)&src, &src_len);
#else
            n = recvfrom(state->fd, out_message, buffer_size, MSG_TRUNC, (struct sockaddr *)&src, &src_len);
#endif
            if ((n >= 0) && state->listen && !same_peer(&src, &state->peer))
            {
                /* LISTEN role, datagram from a source other than the learned peer. A HELLO means the peer restarted
                 * (new source port): re-learn it and answer, so the link recovers. Anything else is a stray. */
                if ((n == (ssize_t)sizeof(uint8_t)) && (((const uint8_t *)out_message)[0] == POSIX_NETLINK_UDP_HELLO))
                {
                    const uint8_t ack = POSIX_NETLINK_UDP_HELLO_ACK;
 
                    state->peer = src;
                    state->peer_len = src_len;
                    (void)sendto(state->fd, &ack, sizeof(ack), 0, (const struct sockaddr *)&src, src_len);
                    rte_log_write(RTE_LOG_LEVEL_INFO, "RTE", "RTE: UDP listen re-learned a restarted peer");
                }
                continue;
            }
            if ((n == (ssize_t)sizeof(uint8_t)) && state->listen && (((const uint8_t *)out_message)[0] == POSIX_NETLINK_UDP_HELLO))
            {
                /* HELLO from the known peer address (retransmit): acknowledge again. */
                const uint8_t ack = POSIX_NETLINK_UDP_HELLO_ACK;
 
                (void)sendto(state->fd, &ack, sizeof(ack), 0, (const struct sockaddr *)&src, src_len);
                continue;
            }
        }
        if (n < 0)
        {
            if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINTR))
            {
                continue;
            }
            if (errno == ECONNREFUSED)
            {
                return RTE_STATUS_HARDWARE_FAULT;
            }
            return RTE_STATUS_INTERNAL_ERROR;
        }
        if ((size_t)n != buffer_size)
        {
            /* A lone HELLO/HELLO_ACK byte that outlived the handshake (a
             * retransmit already in flight when the peer stopped
             * resending, or open()'s own final ACK arriving late) is not
             * a wire violation - silently drop it and keep waiting within
             * the same deadline, matching a plain "nothing new yet" wait.
             * message_size is never 1 byte for any real link in this
             * example (smallest is ANSWER_WIRE_SIZE/M136_WIRE_SIZE at 8),
             * so this can never mask a genuine 1-byte application frame. */
            if ((n == (ssize_t)sizeof(uint8_t)) &&
                ((((const uint8_t *)out_message)[0] == POSIX_NETLINK_UDP_HELLO) ||
                 (((const uint8_t *)out_message)[0] == POSIX_NETLINK_UDP_HELLO_ACK)))
            {
                continue;
            }
            /* Anything else of the wrong length: this link's message_size
             * is fixed by config, so a datagram of any other length -
             * truncated, oversized, or a stray 0-byte datagram - is a
             * genuine wire protocol violation, not a value to silently
             * accept partial-length. */
            return RTE_STATUS_DATA_CORRUPTION;
        }
        return RTE_STATUS_OK;
    }
}
 
static rte_status_t osadapter_close(rte_netlink_handle_t handle)
{
    posix_netlink_state_t *state = (posix_netlink_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    (void)close(state->fd);
    return RTE_STATUS_OK;
}
 
static const rte_osadapter_netlink_t s_posix_netlink_osadapter = { osadapter_open, backend_send, backend_receive,
                                                                  osadapter_close };
 
const rte_osadapter_netlink_t *rte_posix_osadapter_netlink(void)
{
    return &s_posix_netlink_osadapter;
}