/* Shared memory region layout */
Region 0: Control - ring headers, metadata
  offset 0: memif_shm_t { cookie, version, ... }
  offset N: memif_ring_t[0] { head, tail, flags, desc[ring_size] }
  offset M: memif_ring_t[1] { ... }  /* one ring per queue */

Region 1+: Data - packet buffers
  Large contiguous buffer space subdivided into fixed-size slots
  Each slot = memif_buffer_size bytes (default 2048)

/* Descriptor - one per buffer slot */
typedef struct {
    u16  flags;         /* MEMIF_DESC_FLAG_NEXT = chained buffer */
    u16  region;        /* which shared memory region holds the data */
    u32  length;        /* bytes of valid data */
    u32  offset;        /* byte offset within the region */
    u32  metadata;      /* opaque: user can store anything */
} memif_desc_t;

/* Ring header */
typedef struct {
    u16  head;          /* producer writes here */
    u16  tail;          /* consumer reads here */
    u16  flags;         /* MEMIF_RING_FLAG_MASK_INT: disable interrupts */
    memif_desc_t desc[ring_size];
} memif_ring_t;

/* TX side: advance head after filling descriptors */
/* RX side: read from tail, advance tail after processing */
/* ring is full when (head - tail) == ring_size */

/* Include */
#include "libmemif.h"

/* Step 1: Initialise the library */
memif_init(NULL, "my_app", NULL, NULL, NULL);

/* Step 2: Create a socket (path must match VPP's socket) */
memif_socket_handle_t sock;
memif_socket_args_t sock_args = {
    .path = "/run/vpp/memif-a.sock",
};
memif_create_socket(&sock, &sock_args, NULL);

/* Step 3: Create the memif connection as client (slave) */
memif_conn_handle_t conn;
memif_conn_args_t args = {
    .socket     = sock,
    .interface_id = 0,
    .is_master  = 0,        /* 0 = client/slave */
    .num_s2m_rings = 1,     /* slave-to-master queues */
    .num_m2s_rings = 1,
    .buffer_size   = 2048,
    .log2_ring_size = 10,   /* ring_size = 1024 */
};
memif_create(&conn, &args,
    on_connect_cb, on_disconnect_cb, on_interrupt_cb, NULL);

/* Step 4: Poll the socket (drives connection setup) */
while (running) {
    memif_poll_event(sock, 0 /* timeout ms */);
}

/* Step 5: TX - after on_connect_cb fires */
memif_buffer_t bufs[16];
u16 n_alloc;
memif_buffer_alloc(conn, 0 /* queue */, bufs, 16, &n_alloc, 2048);
for (i = 0; i < n_alloc; i++) {
    /* bufs[i].data points to the shared memory region */
    memcpy(bufs[i].data, my_packet_data, my_packet_len);
    bufs[i].len = my_packet_len;
}
u16 n_tx;
memif_tx_burst(conn, 0, bufs, n_alloc, &n_tx);

/* Step 6: RX */
memif_buffer_t rx_bufs[256];
u16 n_rx;
memif_rx_burst(conn, 0, rx_bufs, 256, &n_rx);
for (i = 0; i < n_rx; i++) {
    process_packet(rx_bufs[i].data, rx_bufs[i].len);
}
memif_refill_queue(conn, 0, n_rx, 0);