feat: 初始化 OmniSocket 目录结构与底层网络接口

src/core/logger.c

@@ -0,0 +1,118 @@
+/*
+ * logger.c
+ * 性能统计与结构化日志实现
+ */
+
+#include "logger.h"
+#include "common.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+static OmniStats g_stats;
+
+static uint64_t now_ms(void)
+{
+    return omni_now_ms();
+}
+
+void logger_init(void)
+{
+    memset(&g_stats, 0, sizeof(g_stats));
+    g_stats.start_ms = now_ms();
+    g_stats.last_report_ms = g_stats.start_ms;
+}
+
+void logger_on_send(size_t bytes)
+{
+    g_stats.bytes_sent += bytes;
+    g_stats.send_count++;
+}
+
+void logger_on_recv(size_t bytes)
+{
+    g_stats.bytes_recv += bytes;
+    g_stats.recv_count++;
+}
+
+void logger_on_rtt(uint64_t rtt_ms)
+{
+    g_stats.last_rtt_ms = rtt_ms;
+    if (rtt_ms > g_stats.max_rtt_ms) {
+        g_stats.max_rtt_ms = rtt_ms;
+    }
+}
+
+void logger_on_kcp_retrans(uint64_t delta)
+{
+    g_stats.kcp_retrans += delta;
+}
+
+double logger_calculate_throughput(void)
+{
+    uint64_t now = now_ms();
+    uint64_t elapsed_ms = now - g_stats.start_ms;
+    if (elapsed_ms == 0) {
+        return 0.0;
+    }
+    double seconds = (double)elapsed_ms / 1000.0;
+    return (double)(g_stats.bytes_sent + g_stats.bytes_recv) / seconds;
+}
+
+static void print_timestamp(FILE *fp)
+{
+    uint64_t ms = now_ms();
+    fprintf(fp, "ts=%llu ", (unsigned long long)ms);
+}
+
+void logger_print_performance_log(const char *tag)
+{
+    uint64_t now = now_ms();
+    uint64_t elapsed_ms = now - g_stats.start_ms;
+    double thr = logger_calculate_throughput();
+
+    FILE *fp = stderr;
+    print_timestamp(fp);
+    fprintf(fp,
+            "level=INFO component=perf tag=%s "
+            "elapsed_ms=%llu bytes_sent=%llu bytes_recv=%llu "
+            "send_count=%llu recv_count=%llu "
+            "throughput_bytes_per_sec=%.2f "
+            "last_rtt_ms=%llu max_rtt_ms=%llu "
+            "kcp_retrans=%llu\n",
+            tag ? tag : "periodic",
+            (unsigned long long)elapsed_ms,
+            (unsigned long long)g_stats.bytes_sent,
+            (unsigned long long)g_stats.bytes_recv,
+            (unsigned long long)g_stats.send_count,
+            (unsigned long long)g_stats.recv_count,
+            thr,
+            (unsigned long long)g_stats.last_rtt_ms,
+            (unsigned long long)g_stats.max_rtt_ms,
+            (unsigned long long)g_stats.kcp_retrans);
+
+    g_stats.last_report_ms = now;
+}
+
+void logger_log(const char *level, const char *component,
+                const char *fmt, ...)
+{
+    FILE *fp = stderr;
+    print_timestamp(fp);
+    fprintf(fp, "level=%s component=%s ", level ? level : "INFO",
+            component ? component : "general");
+
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(fp, fmt, ap);
+    va_end(ap);
+
+    fputc('\n', fp);
+}
+
+OmniStats logger_get_snapshot(void)
+{
+    return g_stats;
+}
+

src/core/network.c

@@ -0,0 +1,123 @@
+/*
+ * network.c
+ * 协议分发与工厂模式实现
+ */
+
+#include "network.h"
+#include "common.h"
+#include "logger.h"
+
+#include <stdlib.h>
+
+/* TCP / UDP / KCP 在各自的实现文件中提供以下符号 */
+extern const struct ProtoVTable TCP_PROTO_VTABLE;
+extern const struct ProtoVTable UDP_PROTO_VTABLE;
+extern const struct ProtoVTable KCP_PROTO_VTABLE;
+
+struct OmniContext {
+    OmniProtocol proto;
+    OmniRole role;
+    const struct ProtoVTable *vt;
+    void *impl; /* 由具体协议实现使用的内部指针 */
+};
+
+/* 工厂：根据协议类型选择对应实现 */
+static const struct ProtoVTable *select_vtable(OmniProtocol proto)
+{
+    switch (proto) {
+    case OMNI_PROTO_TCP:
+        return &TCP_PROTO_VTABLE;
+    case OMNI_PROTO_UDP:
+        return &UDP_PROTO_VTABLE;
+    case OMNI_PROTO_KCP:
+        return &KCP_PROTO_VTABLE;
+    default:
+        return NULL;
+    }
+}
+
+OmniContext *omni_init(OmniRole role,
+                       OmniProtocol proto,
+                       const char *bind_ip,
+                       uint16_t bind_port,
+                       const char *peer_ip,
+                       uint16_t peer_port)
+{
+    logger_init();
+
+    const struct ProtoVTable *vt = select_vtable(proto);
+    if (!vt || !vt->init) {
+        logger_log("ERROR", "network", "select_vtable_failed proto=%d",
+                   (int)proto);
+        return NULL;
+    }
+
+    OmniContext *ctx = (OmniContext *)calloc(1, sizeof(OmniContext));
+    if (!ctx) {
+        logger_log("ERROR", "network", "calloc_OmniContext_failed");
+        return NULL;
+    }
+
+    ctx->proto = proto;
+    ctx->role = role;
+    ctx->vt = vt;
+
+    OmniContext *impl_ctx = vt->init(role, bind_ip, bind_port, peer_ip, peer_port);
+    if (!impl_ctx) {
+        logger_log("ERROR", "network", "proto_init_failed proto=%d", (int)proto);
+        free(ctx);
+        return NULL;
+    }
+
+    /* 简化：直接让 impl 指针等于协议实现返回的上下文 */
+    ctx->impl = impl_ctx;
+
+    logger_log("INFO", "network",
+               "omni_init_success proto=%d role=%d bind_port=%u peer_port=%u",
+               (int)proto, (int)role,
+               (unsigned)bind_port,
+               (unsigned)peer_port);
+
+    return ctx;
+}
+
+ssize_t omni_send(OmniContext *ctx, const void *buf, size_t len)
+{
+    if (!ctx || !ctx->vt || !ctx->vt->send) {
+        return OMNI_ERR_PARAM;
+    }
+
+    ssize_t n = ctx->vt->send((OmniContext *)ctx->impl, buf, len);
+    if (n > 0) {
+        logger_on_send((size_t)n);
+    }
+    logger_log("DEBUG", "network", "omni_send proto=%d bytes=%zd",
+               (int)ctx->proto, n);
+    return n;
+}
+
+ssize_t omni_recv(OmniContext *ctx, void *buf, size_t len)
+{
+    if (!ctx || !ctx->vt || !ctx->vt->recv) {
+        return OMNI_ERR_PARAM;
+    }
+
+    ssize_t n = ctx->vt->recv((OmniContext *)ctx->impl, buf, len);
+    if (n > 0) {
+        logger_on_recv((size_t)n);
+    }
+    logger_log("DEBUG", "network", "omni_recv proto=%d bytes=%zd",
+               (int)ctx->proto, n);
+    return n;
+}
+
+void omni_close(OmniContext *ctx)
+{
+    if (!ctx) return;
+    if (ctx->vt && ctx->vt->close && ctx->impl) {
+        ctx->vt->close((OmniContext *)ctx->impl);
+    }
+    logger_print_performance_log("final");
+    free(ctx);
+}
+

src/protocols/kcp_impl.c

@@ -0,0 +1,171 @@
+/*
+ * kcp_impl.c
+ * 基于 UDP 的 KCP 可靠传输实现
+ */
+
+#include "common.h"
+#include "network.h"
+#include "logger.h"
+#include "kcp/ikcp.h"
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+struct KcpContext {
+    int fd;
+    struct sockaddr_in peer_addr;
+    socklen_t peer_len;
+    ikcpcb *kcp;
+};
+
+static int kcp_output(const char *buf, int len, ikcpcb *kcp, void *user)
+{
+    (void)kcp;
+    struct KcpContext *ctx = (struct KcpContext *)user;
+    ssize_t n = sendto(ctx->fd, buf, (size_t)len, 0,
+                       (struct sockaddr *)&ctx->peer_addr, ctx->peer_len);
+    if (n < 0) {
+        logger_log("ERROR", "kcp", "sendto_failed errno=%d", errno);
+        return OMNI_ERR_IO;
+    }
+    return 0;
+}
+
+static OmniContext *kcp_init(OmniRole role,
+                             const char *bind_ip,
+                             uint16_t bind_port,
+                             const char *peer_ip,
+                             uint16_t peer_port)
+{
+    (void)role;
+
+    struct KcpContext *ctx = (struct KcpContext *)calloc(1, sizeof(*ctx));
+    if (!ctx) return NULL;
+
+    int fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (fd < 0) {
+        logger_log("ERROR", "kcp", "socket_failed errno=%d", errno);
+        free(ctx);
+        return NULL;
+    }
+
+    if (bind_port != 0) {
+        struct sockaddr_in addr;
+        memset(&addr, 0, sizeof(addr));
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(bind_port);
+        addr.sin_addr.s_addr = bind_ip ? inet_addr(bind_ip) : INADDR_ANY;
+        if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+            logger_log("ERROR", "kcp", "bind_failed errno=%d", errno);
+            close(fd);
+            free(ctx);
+            return NULL;
+        }
+    }
+
+    memset(&ctx->peer_addr, 0, sizeof(ctx->peer_addr));
+    ctx->peer_addr.sin_family = AF_INET;
+    ctx->peer_addr.sin_port = htons(peer_port);
+    ctx->peer_addr.sin_addr.s_addr = peer_ip ? inet_addr(peer_ip) : INADDR_ANY;
+    ctx->peer_len = sizeof(ctx->peer_addr);
+
+    ctx->fd = fd;
+
+    /* conv 可简单使用端口号 */
+    IUINT32 conv = (IUINT32)peer_port;
+    ikcpcb *kcp = ikcp_create(conv, ctx);
+    if (!kcp) {
+        logger_log("ERROR", "kcp", "ikcp_create_failed");
+        close(fd);
+        free(ctx);
+        return NULL;
+    }
+
+    ctx->kcp = kcp;
+
+    ikcp_setoutput(kcp, kcp_output);
+    ikcp_nodelay(kcp, 1, 10, 2, 1);
+    ikcp_wndsize(kcp, 128, 128);
+
+    logger_log("INFO", "kcp",
+               "init bind_port=%u peer_ip=%s peer_port=%u",
+               (unsigned)bind_port,
+               peer_ip ? peer_ip : "NULL",
+               (unsigned)peer_port);
+
+    return (OmniContext *)ctx;
+}
+
+static void kcp_update_loop(struct KcpContext *ctx)
+{
+    IUINT32 current = (IUINT32)omni_now_ms();
+    ikcp_update(ctx->kcp, current);
+
+    char buf[1500];
+    struct sockaddr_in from;
+    socklen_t fromlen = sizeof(from);
+    ssize_t n = recvfrom(ctx->fd, buf, sizeof(buf), MSG_DONTWAIT,
+                         (struct sockaddr *)&from, &fromlen);
+    if (n > 0) {
+        ctx->peer_addr = from;
+        ctx->peer_len = fromlen;
+        ikcp_input(ctx->kcp, buf, (long)n);
+    }
+}
+
+static ssize_t kcp_send(OmniContext *c, const void *buf, size_t len)
+{
+    struct KcpContext *ctx = (struct KcpContext *)c;
+    if (!ctx || !ctx->kcp) return OMNI_ERR_PARAM;
+
+    int rc = ikcp_send(ctx->kcp, (const char *)buf, (int)len);
+    if (rc < 0) {
+        logger_log("ERROR", "kcp", "ikcp_send_failed rc=%d", rc);
+        return OMNI_ERR_IO;
+    }
+
+    /* 驱动一次 flush */
+    kcp_update_loop(ctx);
+    return (ssize_t)len;
+}
+
+static ssize_t kcp_recv(OmniContext *c, void *buf, size_t len)
+{
+    struct KcpContext *ctx = (struct KcpContext *)c;
+    if (!ctx || !ctx->kcp) return OMNI_ERR_PARAM;
+
+    kcp_update_loop(ctx);
+
+    int n = ikcp_recv(ctx->kcp, (char *)buf, (int)len);
+    if (n < 0) {
+        return 0; /* 暂无数据 */
+    }
+    return (ssize_t)n;
+}
+
+static void kcp_close(OmniContext *c)
+{
+    struct KcpContext *ctx = (struct KcpContext *)c;
+    if (!ctx) return;
+    if (ctx->kcp) {
+        ikcp_release(ctx->kcp);
+    }
+    if (ctx->fd >= 0) {
+        close(ctx->fd);
+    }
+    free(ctx);
+}
+
+const struct ProtoVTable KCP_PROTO_VTABLE = {
+    .init = kcp_init,
+    .send = kcp_send,
+    .recv = kcp_recv,
+    .close = kcp_close,
+};
+

src/protocols/tcp_impl.c

@@ -0,0 +1,255 @@
+/*
+ * tcp_impl.c
+ * TCP 协议实现，带 16 字节包头解决粘包
+ */
+
+#include "common.h"
+#include "network.h"
+#include "logger.h"
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <netinet/tcp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+struct TcpContext {
+    int fd;
+};
+
+static int tcp_set_nodelay(int fd)
+{
+    int flag = 1;
+    return setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
+}
+
+static int tcp_set_reuseaddr(int fd)
+{
+    int flag = 1;
+    return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));
+}
+
+static int tcp_bind_and_listen(struct TcpContext *ctx,
+                               const char *bind_ip,
+                               uint16_t bind_port)
+{
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd < 0) {
+        logger_log("ERROR", "tcp", "socket_failed errno=%d", errno);
+        return -1;
+    }
+
+    tcp_set_reuseaddr(fd);
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(bind_port);
+    addr.sin_addr.s_addr = bind_ip ? inet_addr(bind_ip) : INADDR_ANY;
+
+    if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        logger_log("ERROR", "tcp", "bind_failed errno=%d", errno);
+        close(fd);
+        return -1;
+    }
+
+    if (listen(fd, 1) < 0) {
+        logger_log("ERROR", "tcp", "listen_failed errno=%d", errno);
+        close(fd);
+        return -1;
+    }
+
+    logger_log("INFO", "tcp", "listening port=%u", (unsigned)bind_port);
+
+    /* 简化：阻塞接受一个客户端，之后用于长连接 */
+    int cfd = accept(fd, NULL, NULL);
+    if (cfd < 0) {
+        logger_log("ERROR", "tcp", "accept_failed errno=%d", errno);
+        close(fd);
+        return -1;
+    }
+
+    close(fd);
+    tcp_set_nodelay(cfd);
+
+    ctx->fd = cfd;
+    return 0;
+}
+
+static int tcp_connect_peer(struct TcpContext *ctx,
+                            const char *peer_ip,
+                            uint16_t peer_port)
+{
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd < 0) {
+        logger_log("ERROR", "tcp", "socket_failed errno=%d", errno);
+        return -1;
+    }
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(peer_port);
+    addr.sin_addr.s_addr = inet_addr(peer_ip);
+
+    if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        logger_log("ERROR", "tcp", "connect_failed errno=%d", errno);
+        close(fd);
+        return -1;
+    }
+
+    tcp_set_nodelay(fd);
+    ctx->fd = fd;
+    logger_log("INFO", "tcp", "connected peer_ip=%s peer_port=%u",
+               peer_ip, (unsigned)peer_port);
+    return 0;
+}
+
+static ssize_t tcp_read_n(int fd, void *buf, size_t n)
+{
+    size_t off = 0;
+    char *p = (char *)buf;
+    while (off < n) {
+        ssize_t r = read(fd, p + off, n - off);
+        if (r < 0) {
+            if (errno == EINTR) continue;
+            return -1;
+        }
+        if (r == 0) {
+            return off; /* 对端关闭 */
+        }
+        off += (size_t)r;
+    }
+    return (ssize_t)off;
+}
+
+static ssize_t tcp_write_n(int fd, const void *buf, size_t n)
+{
+    size_t off = 0;
+    const char *p = (const char *)buf;
+    while (off < n) {
+        ssize_t r = write(fd, p + off, n - off);
+        if (r < 0) {
+            if (errno == EINTR) continue;
+            return -1;
+        }
+        off += (size_t)r;
+    }
+    return (ssize_t)off;
+}
+
+static OmniContext *tcp_init(OmniRole role,
+                             const char *bind_ip,
+                             uint16_t bind_port,
+                             const char *peer_ip,
+                             uint16_t peer_port)
+{
+    struct TcpContext *ctx = (struct TcpContext *)calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return NULL;
+    }
+
+    int rc;
+    if (role == OMNI_ROLE_SERVER) {
+        rc = tcp_bind_and_listen(ctx, bind_ip, bind_port);
+    } else {
+        if (!peer_ip || peer_port == 0) {
+            logger_log("ERROR", "tcp", "client_requires_peer_ip_port");
+            free(ctx);
+            return NULL;
+        }
+        rc = tcp_connect_peer(ctx, peer_ip, peer_port);
+    }
+
+    if (rc != 0) {
+        free(ctx);
+        return NULL;
+    }
+
+    return (OmniContext *)ctx;
+}
+
+static ssize_t tcp_send(OmniContext *c, const void *buf, size_t len)
+{
+    struct TcpContext *ctx = (struct TcpContext *)c;
+    if (!ctx || ctx->fd < 0) return OMNI_ERR_PARAM;
+
+    MsgHeader hdr;
+    hdr.magic = htonl(MSG_MAGIC);
+    hdr.length = htonl((uint32_t)len);
+    hdr.seq = 0; /* 如有需要，上层可扩展维护序列号 */
+
+    uint8_t header_buf[MSG_HEADER_SIZE];
+    memcpy(header_buf, &hdr, MSG_HEADER_SIZE);
+
+    ssize_t n1 = tcp_write_n(ctx->fd, header_buf, MSG_HEADER_SIZE);
+    if (n1 != (ssize_t)MSG_HEADER_SIZE) {
+        return OMNI_ERR_IO;
+    }
+
+    ssize_t n2 = tcp_write_n(ctx->fd, buf, len);
+    if (n2 != (ssize_t)len) {
+        return OMNI_ERR_IO;
+    }
+
+    return (ssize_t)len;
+}
+
+static ssize_t tcp_recv(OmniContext *c, void *buf, size_t len)
+{
+    struct TcpContext *ctx = (struct TcpContext *)c;
+    if (!ctx || ctx->fd < 0) return OMNI_ERR_PARAM;
+
+    uint8_t header_buf[MSG_HEADER_SIZE];
+    ssize_t n1 = tcp_read_n(ctx->fd, header_buf, MSG_HEADER_SIZE);
+    if (n1 <= 0) {
+        return n1; /* 0 表示对端关闭，负数为错误 */
+    }
+    if (n1 != (ssize_t)MSG_HEADER_SIZE) {
+        return OMNI_ERR_IO;
+    }
+
+    MsgHeader hdr;
+    memcpy(&hdr, header_buf, MSG_HEADER_SIZE);
+    if (ntohl(hdr.magic) != MSG_MAGIC) {
+        logger_log("ERROR", "tcp", "invalid_magic");
+        return OMNI_ERR_IO;
+    }
+
+    uint32_t payload_len = ntohl(hdr.length);
+    if (payload_len > len) {
+        logger_log("ERROR", "tcp", "buffer_too_small payload=%u buf_len=%zu",
+                   payload_len, len);
+        /* 简化：这里返回错误，实际可考虑丢弃或扩展缓冲区 */
+        return OMNI_ERR_PARAM;
+    }
+
+    ssize_t n2 = tcp_read_n(ctx->fd, buf, payload_len);
+    if (n2 != (ssize_t)payload_len) {
+        return OMNI_ERR_IO;
+    }
+
+    return (ssize_t)payload_len;
+}
+
+static void tcp_close(OmniContext *c)
+{
+    struct TcpContext *ctx = (struct TcpContext *)c;
+    if (!ctx) return;
+    if (ctx->fd >= 0) {
+        close(ctx->fd);
+    }
+    free(ctx);
+}
+
+const struct ProtoVTable TCP_PROTO_VTABLE = {
+    .init = tcp_init,
+    .send = tcp_send,
+    .recv = tcp_recv,
+    .close = tcp_close,
+};
+

src/protocols/udp_impl.c

@@ -0,0 +1,126 @@
+/*
+ * udp_impl.c
+ * UDP 协议实现（无连接，基础 sendto/recvfrom）
+ */
+
+#include "common.h"
+#include "network.h"
+#include "logger.h"
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+struct UdpContext {
+    int fd;
+    struct sockaddr_in peer_addr;
+    socklen_t peer_len;
+};
+
+static OmniContext *udp_init(OmniRole role,
+                             const char *bind_ip,
+                             uint16_t bind_port,
+                             const char *peer_ip,
+                             uint16_t peer_port)
+{
+    (void)role;
+
+    struct UdpContext *ctx = (struct UdpContext *)calloc(1, sizeof(*ctx));
+    if (!ctx) return NULL;
+
+    int fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (fd < 0) {
+        logger_log("ERROR", "udp", "socket_failed errno=%d", errno);
+        free(ctx);
+        return NULL;
+    }
+
+    if (bind_port != 0) {
+        struct sockaddr_in addr;
+        memset(&addr, 0, sizeof(addr));
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(bind_port);
+        addr.sin_addr.s_addr = bind_ip ? inet_addr(bind_ip) : INADDR_ANY;
+        if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+            logger_log("ERROR", "udp", "bind_failed errno=%d", errno);
+            close(fd);
+            free(ctx);
+            return NULL;
+        }
+    }
+
+    memset(&ctx->peer_addr, 0, sizeof(ctx->peer_addr));
+    ctx->peer_addr.sin_family = AF_INET;
+    ctx->peer_addr.sin_port = htons(peer_port);
+    ctx->peer_addr.sin_addr.s_addr = peer_ip ? inet_addr(peer_ip) : INADDR_ANY;
+    ctx->peer_len = sizeof(ctx->peer_addr);
+
+    ctx->fd = fd;
+
+    logger_log("INFO", "udp",
+               "init bind_port=%u peer_ip=%s peer_port=%u",
+               (unsigned)bind_port,
+               peer_ip ? peer_ip : "NULL",
+               (unsigned)peer_port);
+
+    return (OmniContext *)ctx;
+}
+
+static ssize_t udp_send(OmniContext *c, const void *buf, size_t len)
+{
+    struct UdpContext *ctx = (struct UdpContext *)c;
+    if (!ctx || ctx->fd < 0) return OMNI_ERR_PARAM;
+
+    ssize_t n = sendto(ctx->fd, buf, len, 0,
+                       (struct sockaddr *)&ctx->peer_addr, ctx->peer_len);
+    if (n < 0) {
+        logger_log("ERROR", "udp", "sendto_failed errno=%d", errno);
+        return OMNI_ERR_IO;
+    }
+    return n;
+}
+
+static ssize_t udp_recv(OmniContext *c, void *buf, size_t len)
+{
+    struct UdpContext *ctx = (struct UdpContext *)c;
+    if (!ctx || ctx->fd < 0) return OMNI_ERR_PARAM;
+
+    struct sockaddr_in from;
+    socklen_t fromlen = sizeof(from);
+    ssize_t n = recvfrom(ctx->fd, buf, len, 0,
+                         (struct sockaddr *)&from, &fromlen);
+    if (n < 0) {
+        if (errno == EINTR) return 0;
+        logger_log("ERROR", "udp", "recvfrom_failed errno=%d", errno);
+        return OMNI_ERR_IO;
+    }
+
+    /* 默认更新 peer 为最近一次通信对端，便于“伪长连接” */
+    ctx->peer_addr = from;
+    ctx->peer_len = fromlen;
+
+    return n;
+}
+
+static void udp_close(OmniContext *c)
+{
+    struct UdpContext *ctx = (struct UdpContext *)c;
+    if (!ctx) return;
+    if (ctx->fd >= 0) {
+        close(ctx->fd);
+    }
+    free(ctx);
+}
+
+const struct ProtoVTable UDP_PROTO_VTABLE = {
+    .init = udp_init,
+    .send = udp_send,
+    .recv = udp_recv,
+    .close = udp_close,
+};
+