Marriage of Zephyr iface with zsock_select()

[bob2oneil]

I am trying to leverage the nice features automated for the Ethernet interface to create a data bridge to a virtual Ethernet interface as a simulated radio. The wired side may need to be promiscuous as I need to preserve some Layer 3 content including IP and UDP/TCP full headers, but maybe not the Layer 2 Ethernet interface. The wired interface will be configured to "multi home" all IPs that the interface will receive.

I am using the familiar multiplexed i/o zsock_select() of Linux lineage for reading and writing between two Ethernet interfaces - one created by Zephyr in the kernel configuration, and one that I will create runtime presumably as a virtual Ethernet interface.

I am trying to get to the underlying socket associated with the Zephyr created primary Ethernet interface from the iface (as shown in the code below which will compile when obtaining the file descriptor handle, but I do not think it correct). I assume, perhaps mistakenly, that Zephyr creates a socket as with the promiscuous socket network example.

It is also very likely that I will need to create the socket independent of the iface, and associate or bind this socket to the iface. The purpose of this question then is to determine if that is correct, or if the functional iface using the promiscuous behaviors has a functional promiscuous socket buried somewhere that should be exploited to avoid duplication.

This application code must run on both native_posix and qemu-riscv, and will eventually run on an embedded board, so it can not be native posix and/or x86 specific.

So my questions are:

1. How do I get the underlying socket file descriptor associated with the net_if iface for use with BSD style sockets that is not platform/board specific? Is there a socket created by default if the interface is configured to autostart and kernel configured, or is there no interface socket present at all? If the socket is created in addition to the existing net_if, are there anything necessary to bind the socket to that interface such as interface index? Do I need a create_socket() call and then bind this socket to the iface, or is socket already present in some form?

2. More broadly, is this architecturally a really bad idea, and I would be better off just creating the RAW socket on the fly without using Zephyr kernel configuration for the kernel-created wired interface providing settings for the wired interface?

3. Does this design not take advantage of any form of advanced buffering that is present in the net_if implementations? For example, is there a better implementation for sending and receiving packets than zsock_recv or zsock_send? Examples might be net_if_tx or perhaps an API where the packet gets queued like net_if_queue_tx. Another way of asking this question, does the zsock implementations sit on top of the net_if APIs, which I believe it doesn't, in an optimum way to take advantage of the interface tx and rx buffering? It appears that Zephyr utilizes a network packet currency of net_if, which contains the raw packet with a bunch of metadata. Is the raw packet data presumably returned from these APIs rather than the packet with metadata?

4. Is a promiscuous socket required to obtain the IP/UDP/TCP headers assuming all IPs addressed to the radio are going to be IPs assigned to the primary wired interface? I can probably reconstitute the 12-byte Ethernet header on the destination, so may not need the Layer 2 information. A raw socket providing the entire packet would work as well.

Attached is a sample test application as I explore the behavior.

#include <zephyr.h>
#include <errno.h>
#include <stdlib.h>
#include <shell/shell.h>
#include <init.h>
#include <kernel.h>
#include <net/net_core.h>
#include <net/promiscuous.h>
#include <net/udp.h>
#include <net/socket.h>
#include <net/ethernet.h>
#include <net/buf.h>
#include <net/net_ip.h>
#include <net/net_if.h>

#define IP_JUMBOPACKET 9014 // Size of a network jumbo packet

#ifdef CONFIG_ARCH_POSIX
#include "posix_cmdline.h"
#endif

#include <logging/log.h>
LOG_MODULE_REGISTER(promisc, LOG_LEVEL_INF);

static unsigned char recvPacket[IP_JUMBOPACKET];        // Receive buffer
static int recvPacketLength;                            // Receive buffer length (-1 on error)
static int8_t mac_addr[sizeof(struct net_eth_addr)];    // Primary interface MAC address

/**
 * @brief setup_ipv4
 * @param iface
 * @param ip
 */
static void setup_ipv4(struct net_if *iface, const char *ip)
{
    char hr_addr[NET_IPV4_ADDR_LEN];
    struct in_addr addr;

    LOG_INF("Adding IPv4 Address to Primary Ethernet interface as %s", ip);
    printk("Adding IPv4 Address to Primary Ethernet interface as %s\n", ip);

    if (net_addr_pton(AF_INET, ip, &addr))
    {
        LOG_ERR("Invalid address: %s", ip);
        return;
    }

    net_if_ipv4_addr_add(iface, &addr, NET_ADDR_MANUAL, 0);

    LOG_INF("IPv4 address: %s",
            log_strdup(net_addr_ntop(AF_INET, &addr, hr_addr,
                                     NET_IPV4_ADDR_LEN)));
}


static bool onWiredReceive(int sock, int& size, const zsock_timeval &tvNow)
{
    // Fill in size for any error exit
    size = 0;
    int bytesRead = zsock_recv(sock, (void *)recvPacket, recvPacketLength, 0);

    if (bytesRead < 0)
    {
        LOG_ERR("onWiredReceive: zsock_recv() error: %s", strerror(errno));
        return false;
    }

    // Fill in size value
    size = bytesRead;

    return true;
}


/**
 * @brief main
 */
void main(void)
{
    char ip[INET_ADDRSTRLEN + 1];

    // Get node Id from command line
    uint32_t nodeId = getNodeId();

#ifdef CONFIG_ARCH_POSIX
    if (nodeId > 32)
    {
        // Value will be set in posix_cmdline to -1 by default unless the
        // command line -nodeid=value is provided.
        if (nodeId != (uint32_t)-1)
        {
            printk("Node ID as %d specified from command line is invalid and will be set to 1\n", nodeId);
            LOG_ERR("Node ID as %d specified from command line is invalid and will be set to 1", nodeId);
        }

        nodeId = 1;
    }
#endif

    LOG_INF("Starting bridge application as node %d", nodeId);
    printk("Starting bridge application via printk as node %d\n", nodeId);

    // Delay to output some messages
    k_msleep(400);
    k_yield();

    struct net_if *iface = net_if_get_default();

    // Setup IPv4 address for interfaces
    if (iface)
    {
        // Setup IPv4 address for primary interface
#ifdef CONFIG_ARCH_POSIX
        // Single test platform separate IP testing
        snprintk(ip, sizeof(ip), "192.0.%d.1", nodeId);
#else
        snprintk(ip, sizeof(ip), "192.168.0.1");
#endif

        ip[INET_ADDRSTRLEN] = 0;
        setup_ipv4(iface, ip);

        // Setup IPv4 pseudo-multicast addresses for primary Ethernet interface
        // NOTE: do not assign on the host an IP address to route to the
        // 200.x.x.x pseudo-multicast network.
        for (unsigned int i = 1; i <= 255; i++)
        {
#ifdef CONFIG_ARCH_POSIX
            // Single test platform separate IP testing
            snprintk(ip, sizeof(ip), "200.168.%d.%d", nodeId, i);
#else
            snprintk(ip, sizeof(ip), "200.168.0.%d", i);
#endif
            ip[INET_ADDRSTRLEN] = 0;
            setup_ipv4(iface, ip);
        }
    }

    net_if_foreach(iface_cb, NULL);

    // Get Primary wired interface MAC address
    const struct device *dev = net_if_get_device(iface);
    struct eth_context *context = (struct eth_context *)dev->data;
    uint8_t *mac = context->mac_addr;
    for (unsigned i = 0; i < sizeof(mac_addr); i++)      
    {
        mac_addr[i] = mac[i];
    }

    zsock_fd_set readfds, writefds, exceptionfds;
    zsock_timeval tvNow, tvTimeout;
    int maxFD = 0;

    while (1)
    {
        // Prepare for select() multiplexing i/o statement
        ZSOCK_FD_ZERO(&readfds);
        ZSOCK_FD_ZERO(&writefds);
        ZSOCK_FD_ZERO(&exceptionfds);

        // Maximum file descriptor
        maxFD = 0;

        // Get device handle from iface
        const struct device *dev = net_if_get_device(iface);
        struct eth_context *context = (struct eth_context *)dev->data;

        // Get file descriptor for wired interface socket
        // IS THIS CORRECT?
        int wiredfd = *iface->if_dev->dev->handles;
        
        // Set maximum file descriptor based on monitored sockets
        maxFD = wiredfd;

        // If have something to transmit buffer, enable write check to that interface
        if (0)
        {
            ZSOCK_FD_SET(wiredfd, &writefds);
        }

        // Always have to enable read and exceptions on interface
        ZSOCK_FD_SET(wiredfd, &readfds);
        ZSOCK_FD_SET(wiredfd, &exceptionfds);

        // TODO: repeat for the virtual wireless interface
                

        // TODO: Dynamically calculate timeout
        tvTimeout.tv_sec = 5;
        tvTimeout.tv_usec = 0;

        // Wait for data to read or write between Ethernet interfaces or a timeout
        int count = zsock_select(maxFD + 1, &readfds, &writefds, &exceptionfds, &tvTimeout);

        // select statement error
        if (count == -1)
        {
            LOG_ERR("select error: %d", errno);
            continue;
        }

        // Device or interface read or write
        else if (count > 0)
        {
            // Wired interface

            // Host receive of packet
            if (ZSOCK_FD_ISSET(wiredfd, &readfds))
            {
                int bytesReceived = 0;
                onWiredReceive(wiredfd, bytesReceived, tvNow);
            }
            // Host write enabled
            else if (ZSOCK_FD_ISSET(wiredfd, &writefds))
            {
            }

            //  Wireless interface
            
            // TODO: flesh out for wirelessfd from virtual interface
        }
    }
}

[bob2oneil]

This has been resolved, I had a misunderstanding of the relationship between a promiscous interface, and a raw socket that is assigned to that interface. A raw socket is working currently bound to the iface.