```c
 /**
   * @brief  Check the ETH link state then update ETH driver and netif link         accordingly.
   * @retval None
   */
 void ethernet_link_check_state(struct netif *netif)
 {
   ETH_MACConfigTypeDef MACConf = {0};
   int32_t PHYLinkState = 0;
   uint32_t linkchanged = 0U, speed = 0U, duplex = 0U;

   PHYLinkState = USER_PHY_GetLinkState(&USER_PHY);

   if(netif_is_link_up(netif) && (PHYLinkState <= USER_PHY_STATUS_LINK_DOWN))
   {
     printf("netif_is_link_up, PHYLinkState=%ld\r\n", PHYLinkState);
     HAL_ETH_Stop(&heth);
     netif_set_down(netif);
     netif_set_link_down(netif);
   }
   else if(!netif_is_link_up(netif) && (PHYLinkState > USER_PHY_STATUS_LINK_DOWN))
   {
     printf("netif_is_link_down, PHYLinkState=%ld\r\n", PHYLinkState);
     switch (PHYLinkState)
     {
       case USER_PHY_STATUS_100MBITS_FULLDUPLEX:
         duplex = ETH_FULLDUPLEX_MODE;
         speed = ETH_SPEED_100M;
         linkchanged = 1;
         break;
       case USER_PHY_STATUS_100MBITS_HALFDUPLEX:
         duplex = ETH_HALFDUPLEX_MODE;
         speed = ETH_SPEED_100M;
         linkchanged = 1;
         break;
       case USER_PHY_STATUS_10MBITS_FULLDUPLEX:
         duplex = ETH_FULLDUPLEX_MODE;
         speed = ETH_SPEED_10M;
         linkchanged = 1;
         break;
       case USER_PHY_STATUS_10MBITS_HALFDUPLEX:
         duplex = ETH_HALFDUPLEX_MODE;
         speed = ETH_SPEED_10M;
         linkchanged = 1;
         break;
       default:
         break;
     }

     if(linkchanged)
     {
       /* Get MAC Config MAC */
       HAL_ETH_GetMACConfig(&heth, &MACConf);
       MACConf.DuplexMode = duplex;
       MACConf.Speed = speed;
       HAL_ETH_SetMACConfig(&heth, &MACConf);
       HAL_ETH_Start(&heth);
       netif_set_up(netif);
       netif_set_link_up(netif);
       printf("linkchanged, DuplexMode:%ld, Speed:%ld \r\n", duplex, speed);
     }
   }
 }
 ```

void MX_LWIP_Init(void);

static void Ethernet_Link_Periodic_Handle(struct netif *netif)
{
/* USER CODE BEGIN 4_4_1 */
/* USER CODE END 4_4_1 */

  /* Ethernet Link every 100ms */
  if (HAL_GetTick() - EthernetLinkTimer >= 100)
  {
    EthernetLinkTimer = HAL_GetTick();
    ethernet_link_check_state(netif);
  }
/* USER CODE BEGIN 4_4 */
/* USER CODE END 4_4 */
}

/**
 * ----------------------------------------------------------------------
 * Function given to help user to continue LwIP Initialization
 * Up to user to complete or change this function ...
 * Up to user to call this function in main.c in while (1) of main(void)
 *-----------------------------------------------------------------------
 * Read a received packet from the Ethernet buffers
 * Send it to the lwIP stack for handling
 * Handle timeouts if LWIP_TIMERS is set and without RTOS
 * Handle the llink status if LWIP_NETIF_LINK_CALLBACK is set and without RTOS
 */
void MX_LWIP_Process(void){
  ethernetif_input(&gnetif);
  sys_check_timeouts();
  Ethernet_Link_Periodic_Handle(&gnetif);
}

/**
  * @brief  Notify the User about the network interface config status
  */
static void ethernet_link_status_updated(struct netif *netif)

/* Start DHCP negotiation for a network interface (IPv4) */
  dhcp_start(&gnetif);

if (!netif_is_link_up(netif)) {
    /* set state INIT and wait for dhcp_network_changed() to call dhcp_discover() */
    dhcp_set_state(dhcp, DHCP_STATE_INIT);
    return ERR_OK;
  }

void
netif_set_link_up(struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();
...

#if LWIP_DHCP
    dhcp_network_changed(netif);
#endif /* LWIP_DHCP */

uint32_t wait_time = 0;
  while (wait_time < 30000) {  // 30 秒超时
    MX_LWIP_Process();

    if (gnetif.ip_addr.addr != 0) {
      printf("DHCP 成功！\n");
      break;
    }

    if (wait_time % 5000 == 0) {
      printf("等待 DHCP... %ld ms\n", wait_time);
    }

    HAL_Delay(100);
    wait_time += 100;
  }

ping 192.167.46.28

事件发生 → LwIP调用回调函数 → 你的代码被执行
        （网络数据到达、连接建立、定时器超时等）

struct tcp_pcb *tcp_server_pcb;

// 创建新的TCP PCB（控制块）
tcp_server_pcb = tcp_new();  // 相当于socket()创建
if (tcp_server_pcb == NULL) {
    // 内存不足，创建失败
}

err_t err;

// 绑定IP和端口
err = tcp_bind(tcp_server_pcb, IP_ADDR_ANY, 8080);
if (err != ERR_OK) {
    // 绑定失败（如端口被占用）
    tcp_abort(tcp_server_pcb);
    return;
}

// 进入监听状态，指定最大待处理连接数
tcp_server_pcb = tcp_listen(tcp_server_pcb);
if (tcp_server_pcb == NULL) {
    // 监听失败
    return;
}

// 设置连接建立回调函数
tcp_accept(tcp_server_pcb, tcp_server_accept_callback);

// 当客户端连接时，LwIP自动调用此函数
static err_t tcp_server_accept_callback(
    void *arg, 
    struct tcp_pcb *newpcb,  // 为新连接创建的PCB
    err_t err
) {
    if (err != ERR_OK || newpcb == NULL) {
        return ERR_VAL;
    }

    // 为新连接设置数据接收回调
    tcp_recv(newpcb, tcp_server_recv_callback);
    // 设置错误回调
    tcp_err(newpcb, tcp_server_error_callback);
    // 设置发送完成回调
    tcp_sent(newpcb, tcp_server_sent_callback);

    // 可在此保存连接上下文（arg参数）
    return ERR_OK;
}

static err_t tcp_server_recv_callback(
    void *arg,
    struct tcp_pcb *tpcb,
    struct pbuf *p,  // 接收到的数据包（pbuf链）
    err_t err
) {
    if (p == NULL) {
        // p为NULL表示连接关闭
        tcp_close(tpcb);
        return ERR_OK;
    }

    if (err != ERR_OK) {
        // 接收错误，释放pbuf
        if (p != NULL) pbuf_free(p);
        return err;
    }

    // 处理接收到的数据
    // p->payload指向数据，p->len是数据长度

    // 告诉TCP已经处理完这些数据（更新接收窗口）
    tcp_recved(tpcb, p->tot_len);

    // 释放pbuf（重要！）
    pbuf_free(p);

    return ERR_OK;
}

struct tcp_pcb *tcp_client_pcb;
ip_addr_t server_ip;

// 解析服务器IP
IP4_ADDR(&server_ip, 192, 168, 1, 100);

// 创建PCB
tcp_client_pcb = tcp_new();

// 设置回调函数
tcp_recv(tcp_client_pcb, tcp_client_recv_callback);
tcp_err(tcp_client_pcb, tcp_client_error_callback);

// 发起连接（非阻塞，立即返回）
tcp_connect(tcp_client_pcb, &server_ip, 8080, tcp_client_connected_callback);

static void tcp_client_connected_callback(
    void *arg, 
    struct tcp_pcb *tpcb, 
    err_t err
) {
    if (err != ERR_OK) {
        // 连接失败
        return;
    }

    // 连接成功，可以开始发送数据
    const char *data = "Hello Server";
    tcp_write(tpcb, data, strlen(data), TCP_WRITE_FLAG_COPY);
    tcp_output(tpcb);  // 立即发送
}

// 1. 创建UDP PCB
struct udp_pcb *udp_pcb = udp_new();

// 2. 绑定本地端口（可选）
udp_bind(udp_pcb, IP_ADDR_ANY, 8080);

// 3. 设置接收回调
udp_recv(udp_pcb, udp_recv_callback, NULL);

// 4. 发送数据
struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, data_len, PBUF_RAM);
memcpy(p->payload, data, data_len);

// 设置目标地址
ip_addr_t dest_ip;
IP4_ADDR(&dest_ip, 192, 168, 1, 100);

// 发送（无连接，每次指定目标）
udp_sendto(udp_pcb, p, &dest_ip, 8080);
pbuf_free(p);  // 释放pbuf

void udp_recv_callback(
    void *arg,
    struct udp_pcb *pcb,
    struct pbuf *p,
    const ip_addr_t *addr,
    u16_t port
) {
    // addr和port是发送方的地址和端口
    // p是接收到的数据

    // 处理数据...

    pbuf_free(p);  // 必须释放
}

#define LWIP_TCP                1      // 启用TCP
#define LWIP_UDP                1      // 启用UDP
#define LWIP_RAW                1      // 启用RAW API
#define TCP_LISTEN_BACKLOG      5      // 监听队列长度
#define LWIP_CALLBACK_API       1      // 启用回调API

#include "lwip/api.h"          // Netconn API 主要函数声明

struct netconn {
  enum netconn_type type;     // 连接类型：TCP/UDP/RAW
  enum netconn_state state;   // 连接状态
  union {
    struct tcp_pcb *tcp;      // TCP协议控制块
    struct udp_pcb *udp;      // UDP协议控制块
  } pcb;
  sys_sem_t op_completed;     // 操作完成信号量
  sys_mbox_t recvmbox;        // 接收数据邮箱
  // ... 其他内部字段
};

// 创建TCP类型的netconn
struct netconn *server_conn = netconn_new(NETCONN_TCP);

// 绑定到本地地址和端口
netconn_bind(server_conn, IP_ADDR_ANY, 8080);

// 开始监听，指定最大等待连接数
netconn_listen(server_conn);

struct netconn *new_conn;
err_t err;

// 阻塞等待客户端连接
err = netconn_accept(server_conn, &new_conn);

if (err == ERR_OK) {
    // new_conn是与客户端通信的专用连接
    // 可在此创建线程处理该连接
}

struct netbuf *buf;
char *data;
u16_t len;

// 阻塞接收数据
netconn_recv(new_conn, &buf);

// 从netbuf中提取数据
netbuf_data(buf, (void **)&data, &len);

// 处理数据...

// 发送响应（自动复制数据）
netconn_write(new_conn, "ACK", 3, NETCONN_COPY);

// 释放netbuf
netbuf_delete(buf);

// 关闭连接（发送FIN）
netconn_close(new_conn);

// 释放netconn结构
netconn_delete(new_conn);

struct netconn *client_conn;
ip_addr_t server_addr;

// 创建连接对象
client_conn = netconn_new(NETCONN_TCP);

// 设置服务器地址
IP4_ADDR(&server_addr, 192, 168, 1, 100);

// 阻塞连接服务器
netconn_connect(client_conn, &server_addr, 8080);

// 设置非阻塞模式
netconn_set_nonblocking(client_conn, 1);

// 非阻塞接收（立即返回）
err = netconn_recv(client_conn, &buf);
if (err == ERR_WOULDBLOCK) {
    // 没有数据可用
}

struct netconn *udp_conn;
struct netbuf *buf;
struct ip_addr *addr;
u16_t port;

// 创建UDP连接
udp_conn = netconn_new(NETCONN_UDP);

// 绑定本地端口
netconn_bind(udp_conn, IP_ADDR_ANY, 8080);

// 接收数据（包含源地址信息）
netconn_recv(udp_conn, &buf);

// 获取发送方地址
addr = netbuf_fromaddr(buf);
port = netbuf_fromport(buf);

// 发送回复到原地址
netconn_send(udp_conn, buf);

// 创建UDP连接（无需绑定）
struct netconn *udp_client = netconn_new(NETCONN_UDP);

// 创建发送缓冲区
struct netbuf *send_buf = netbuf_new();

// 向缓冲区填充数据
char *payload = "Hello UDP";
netbuf_alloc(send_buf, strlen(payload));
memcpy(netbuf_data(send_buf), payload, strlen(payload));

// 发送到指定地址
netconn_sendto(udp_client, send_buf, &server_addr, 8080);

// 清理
netbuf_delete(send_buf);

// 设置接收回调（替代阻塞接收）
netconn_recv_callback(conn, my_recv_callback, my_arg);

// 回调函数原型
void my_recv_callback(struct netconn *conn, 
                     enum netconn_evt evt,
                     u16_t len)
{
    switch(evt) {
        case NETCONN_EVT_RCVPLUS:  // 有数据到达
            // 可以调用netconn_recv_nonblock接收
            break;
        case NETCONN_EVT_SENDPLUS: // 发送缓冲区可用
            break;
        case NETCONN_EVT_ERROR:    // 发生错误
            break;
    }
}

// 创建和释放netbuf
struct netbuf *netbuf_new(void);
void netbuf_delete(struct netbuf *buf);

// 数据操作
void *netbuf_alloc(struct netbuf *buf, u16_t size);
err_t netbuf_ref(struct netbuf *buf, const void *dataptr, u16_t size);
void netbuf_free(struct netbuf *buf);

// 数据访问
err_t netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len);
struct ip_addr *netbuf_fromaddr(struct netbuf *buf);
u16_t netbuf_fromport(struct netbuf *buf);

// Netconn专用错误码
#define NETCONN_EAGAIN    -1    // 重试（非阻塞模式）
#define NETCONN_INPROGRESS -2   // 操作进行中
#define NETCONN_ABORTED   -3    // 操作被中止
#define NETCONN_CLOSED    -4    // 连接已关闭
#define NETCONN_RESET     -5    // 连接被重置

err_t err;

// 标准错误检查
err = netconn_write(conn, data, len, flags);
if (err != ERR_OK) {
    switch(err) {
        case ERR_MEM:           // 内存不足
        case ERR_TIMEOUT:       // 操作超时
        case ERR_CLSD:          // 连接关闭
        // ... 其他错误处理
    }
}

#define LWIP_NETCONN                    1    // 启用Netconn API
#define TCPIP_MBOX_SIZE                 8    // TCPIP线程邮箱大小
#define DEFAULT_THREAD_STACKSIZE        1024 // 默认线程栈大小
#define DEFAULT_RAW_RECVMBOX_SIZE       8    // RAW PCB接收邮箱大小
#define DEFAULT_UDP_RECVMBOX_SIZE       8    // UDP接收邮箱大小
#define DEFAULT_TCP_RECVMBOX_SIZE       8    // TCP接收邮箱大小

// Netconn API必须在TCPIP线程上下文中执行
// 典型的主线程初始化：
void tcpip_init_done_fn(void *arg) {
    // LwIP初始化完成后执行
    sys_sem_signal(init_sem);
}

int main() {
    sys_sem_t init_sem;
    sys_sem_new(&init_sem, 0);

    // 初始化LwIP，指定回调
    tcpip_init(tcpip_init_done_fn, &init_sem);

    // 等待初始化完成
    sys_sem_wait(&init_sem);

    // 现在可以在主线程中使用Netconn API
    // 或创建专用线程处理网络连接
}

// Netconn对象不是完全线程安全的
// 需要额外的保护机制：

// 方案1：每个线程使用独立的netconn
struct netconn *thread_local_conn = netconn_new(NETCONN_TCP);

// 方案2：使用互斥锁保护共享netconn
sys_mutex_t conn_mutex;
sys_mutex_new(&conn_mutex);

sys_mutex_lock(&conn_mutex);
// 操作共享的netconn
netconn_write(shared_conn, data, len, flags);
sys_mutex_unlock(&conn_mutex);

// 零拷贝发送（需保证数据在回调期间有效）
netconn_write_vectors(conn, iovec, count, flags);

// 异步发送（立即返回）
netconn_write_async(conn, data, len, flags, callback, arg);

// 设置发送缓冲区大小
netconn_set_sendbuf(conn, size);

// 设置接收缓冲区大小
netconn_set_recvbuf(conn, size);

// 获取当前缓冲区使用情况
u16_t sendbuf_used = netconn_get_sendbuf_used(conn);
u16_t recvbuf_used = netconn_get_recvbuf_used(conn);

// 检查连接是否有效
int netconn_is_valid(struct netconn *conn);

// 获取连接状态
enum netconn_state state = netconn_get_state(conn);

// 检查是否可写（发送缓冲区可用）
int writable = netconn_is_writable(conn);

// 检查是否有待读数据
int readable = netconn_is_readable(conn);

// 设置接收超时（毫秒）
netconn_set_recvtimeout(conn, timeout_ms);

// 设置发送超时
netconn_set_sendtimeout(conn, timeout_ms);

// 设置连接超时
netconn_set_connecttimeout(conn, timeout_ms);

// 启用Netconn调试
#define NETCONN_DEBUG LWIP_DBG_ON

// 获取连接调试信息
void netconn_debug_print(struct netconn *conn) {
    LWIP_DEBUGF(NETCONN_DEBUG, 
                "Netconn %p: type=%d, state=%d\n",
                conn, conn->type, conn->state);
}

// 跟踪API调用
#define NETCONN_TRACE 1

// 获取Netconn内存使用统计
void netconn_memp_stats(void);

// 获取活动连接数
int active_connections = netconn_get_active_count();

// 获取各类型连接统计
struct netconn_stats stats;
netconn_get_stats(&stats);

#include "lwip/sockets.h"     // Socket API 主要函数声明
#include "lwip/netdb.h"       // 网络数据库函数（gethostbyname等）
#include <errno.h>            // 错误码定义

// IPv4 地址结构（主要使用）
struct sockaddr_in {
    sa_family_t    sin_family;     // 地址族：AF_INET
    in_port_t      sin_port;       // 端口号（网络字节序）
    struct in_addr sin_addr;       // IP地址结构
    unsigned char  sin_zero[8];    // 填充字节
};

// 通用地址结构（用于类型转换）
struct sockaddr {
    sa_family_t sa_family;         // 地址族
    char        sa_data[14];       // 地址数据
};

int socket(int domain, int type, int protocol);

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

struct sockaddr_in local_addr;
memset(&local_addr, 0, sizeof(local_addr));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(8080);          // 主机序转网络序
local_addr.sin_addr.s_addr = INADDR_ANY;    // 绑定到所有接口

bind(sockfd, (struct sockaddr*)&local_addr, sizeof(local_addr));

int listen(int sockfd, int backlog);

// 创建、绑定、监听三步曲
int server_fd = socket(AF_INET, SOCK_STREAM, 0);
bind(server_fd, ...);
listen(server_fd, 5);

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int client_fd = accept(server_fd, 
                      (struct sockaddr*)&client_addr, 
                      &client_len);

// 获取客户端IP和端口
char *client_ip = inet_ntoa(client_addr.sin_addr);
uint16_t client_port = ntohs(client_addr.sin_port);

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

int client_fd = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(80);
inet_aton("192.168.1.100", &server_addr.sin_addr);

connect(client_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

int send_all(int sockfd, const void *buf, size_t len) {
    size_t total_sent = 0;
    while (total_sent < len) {
        ssize_t sent = send(sockfd, 
                           (char*)buf + total_sent, 
                           len - total_sent, 
                           0);
        if (sent <= 0) return -1;  // 出错或连接关闭
        total_sent += sent;
    }
    return total_sent;
}

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

if (recv_len < 0) {
    switch (errno) {
        case EWOULDBLOCK:  // 非阻塞模式下无数据
            // 可稍后重试
            break;
        case ECONNRESET:   // 连接被对端重置
            // 需要关闭套接字
            close(sockfd);
            break;
        // ... 其他错误
    }
}

int close(int sockfd);

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);

int udp_fd = socket(AF_INET, SOCK_DGRAM, 0);

struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(8080);
inet_aton("192.168.1.100", &dest_addr.sin_addr);

sendto(udp_fd, data, data_len, 0, 
       (struct sockaddr*)&dest_addr, sizeof(dest_addr));

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);

struct sockaddr_in sender_addr;
socklen_t addrlen = sizeof(sender_addr);

ssize_t recv_len = recvfrom(udp_fd, buffer, sizeof(buffer), 0,
                           (struct sockaddr*)&sender_addr, &addrlen);

if (recv_len > 0) {
    // 获取发送方IP和端口
    char *sender_ip = inet_ntoa(sender_addr.sin_addr);
    uint16_t sender_port = ntohs(sender_addr.sin_port);
}

int setsockopt(int sockfd, int level, int optname,
               const void *optval, socklen_t optlen);

struct timeval timeout;
timeout.tv_sec = 5;   // 5秒
timeout.tv_usec = 0;

setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, 
           &timeout, sizeof(timeout));

setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, 
           &timeout, sizeof(timeout));

int reuse = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, 
           &reuse, sizeof(reuse));

int keepalive = 1;
int keepidle = 60;    // 空闲60秒后开始发送保活探测
int keepinterval = 5; // 探测间隔5秒
int keepcount = 3;    // 最多探测3次

setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));
setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &keepidle, sizeof(keepidle));
setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &keepinterval, sizeof(keepinterval));
setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT, &keepcount, sizeof(keepcount));

int getsockopt(int sockfd, int level, int optname,
               void *optval, socklen_t *optlen);

int error = 0;
socklen_t len = sizeof(error);
getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len);

#include <fcntl.h>

int set_nonblocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags < 0) return -1;
    return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
}

// 设置非阻塞
set_nonblocking(sockfd);

// 接收数据（立即返回）
ssize_t recv_len = recv(sockfd, buffer, sizeof(buffer), 0);

if (recv_len < 0) {
    if (errno == EWOULDBLOCK) {
        // 没有数据可读，正常情况
    } else {
        // 真实错误
    }
}

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

fd_set readfds;
struct timeval timeout;

while (1) {
    FD_ZERO(&readfds);
    FD_SET(sockfd1, &readfds);
    FD_SET(sockfd2, &readfds);

    timeout.tv_sec = 1;
    timeout.tv_usec = 0;

    int ret = select(sockfd2 + 1, &readfds, NULL, NULL, &timeout);

    if (ret > 0) {
        if (FD_ISSET(sockfd1, &readfds)) {
            // sockfd1 有数据可读
        }
        if (FD_ISSET(sockfd2, &readfds)) {
            // sockfd2 有数据可读
        }
    } else if (ret == 0) {
        // 超时
    } else {
        // 错误
    }
}

#include "lwip/def.h"

uint16_t htons(uint16_t hostshort);  // 主机序 -> 网络序（16位）
uint16_t ntohs(uint16_t netshort);   // 网络序 -> 主机序（16位）
uint32_t htonl(uint32_t hostlong);   // 主机序 -> 网络序（32位）
uint32_t ntohl(uint32_t netlong);    // 网络序 -> 主机序（32位）

// 字符串转IP地址（推荐）
int inet_aton(const char *cp, struct in_addr *inp);

// IP地址转字符串
char *inet_ntoa(struct in_addr in);

// 现代版本（支持IPv6）
const char *inet_ntop(int af, const void *src, 
                      char *dst, socklen_t size);
int inet_pton(int af, const char *src, void *dst);

#include "lwip/netdb.h"

struct hostent *gethostbyname(const char *name);

// 使用示例
struct hostent *host = gethostbyname("www.example.com");
if (host) {
    struct in_addr **addr_list = (struct in_addr**)host->h_addr_list;
    for (int i = 0; addr_list[i] != NULL; i++) {
        printf("IP: %s\n", inet_ntoa(*addr_list[i]));
    }
}

int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int shutdown(int sockfd, int how);

#define LWIP_SOCKET                  1    // 启用Socket API
#define LWIP_COMPAT_SOCKETS          1    // 兼容标准Socket
#define LWIP_SO_RCVTIMEO             1    // 启用接收超时
#define LWIP_SO_SNDTIMEO             1    // 启用发送超时
#define LWIP_SO_RCVBUF               1    // 启用接收缓冲区
#define SO_REUSE                     1    // 启用地址重用

// 内存配置（根据应用调整）
#define MEM_SIZE                    (16*1024)
#define MEMP_NUM_NETBUF             8
#define MEMP_NUM_NETCONN            8
#define MEMP_NUM_TCP_PCB            5
#define MEMP_NUM_TCP_PCB_LISTEN     5

int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
    printf("socket failed: errno=%d\n", errno);
    return -1;
}

struct sockaddr_in addr;
// ... 设置地址

if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
    printf("connect failed: errno=%d\n", errno);
    close(sockfd);
    return -1;
}

// 数据收发
ssize_t len = send(sockfd, data, data_len, 0);
if (len < 0) {
    printf("send failed: errno=%d\n", errno);
}

// 清理
close(sockfd);

// 使用 MSG_DONTWAIT 进行非阻塞发送
ssize_t len = send(sockfd, data, data_len, MSG_DONTWAIT);

// 使用 MSG_MORE 提示更多数据将发送
send(sockfd, data1, len1, MSG_MORE);
send(sockfd, data2, len2, 0);  // 实际发送

// 设置发送缓冲区大小
int sndbuf_size = 8192;
setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, sizeof(sndbuf_size));

// 设置接收缓冲区大小
int rcvbuf_size = 8192;
setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, sizeof(rcvbuf_size));

// 在 lwipopts.h 中启用调试
#define SOCKETS_DEBUG               LWIP_DBG_ON

// 调试函数
void socket_debug_print(int sockfd) {
    struct sockaddr_in local_addr, remote_addr;
    socklen_t len = sizeof(local_addr);

    getsockname(sockfd, (struct sockaddr*)&local_addr, &len);
    getpeername(sockfd, (struct sockaddr*)&remote_addr, &len);

    LWIP_DEBUGF(SOCKETS_DEBUG, 
                "Socket %d: Local %s:%d, Remote %s:%d\n",
                sockfd,
                inet_ntoa(local_addr.sin_addr), ntohs(local_addr.sin_port),
                inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port));
}

// 获取当前打开的套接字数
extern int lwip_socket_counter;

// 打印统计信息
void print_socket_stats(void) {
    printf("Active sockets: %d\n", lwip_socket_counter);
}

// 1. 部分函数可能未实现
// 如：getaddrinfo(), sendmsg(), recvmsg()

// 2. 选项支持可能有限
// 某些SO_*选项可能不可用

// 3. 文件描述符与套接字描述符分开
// LwIP中socket返回的描述符与文件系统无关

// LwIP的Socket API本身是线程安全的
// 但同一个套接字在多个线程中操作需要额外保护：

// 方案1：每个线程使用独立套接字
int thread1_sock = socket(...);
int thread2_sock = socket(...);

// 方案2：使用互斥锁保护共享套接字
#include "FreeRTOS.h"
#include "semphr.h"

SemaphoreHandle_t sock_mutex = xSemaphoreCreateMutex();

xSemaphoreTake(sock_mutex, portMAX_DELAY);
send(shared_sock, data, len, 0);
xSemaphoreGive(sock_mutex);