RAW网络编程

LWIP提供了三种的可以被应用程序直接调用的接口API：

（1）       低水平的，基于内核/回调函数的API（后面称 RAW API）    适用于数据量不大，没有os的MCU

（2）       高水平的，连续的API（后面称LwIP API）                           这种方式最常用，需要os支持，适用于传输数据量大的场合

（3）       BSD风格的套接字API（后面称BSD socket）                       目前还不太稳定

本文介绍的是处于传输层的udp和tcp。两者的区别和各自使用的场合这里就不再赘叙

TCP/IP网络四层模型

1.RAW_UDP

（1）.udp简介

端口号表示发送和接收进程， UDP 协议使用端口号为不同的应用保留各自的数据传输通，UDP 和 TCP 协议都是采用端口号对同一时刻内多项应用同时发送和接收数据，而数据接收方则通过目标端口接收数据。有的网络应用只能使用预先为其预留或注册的静态端口；而另外一些网络应用则可以使用未被注册的动态端口。因为 UDP 报头使用两个字节存放端口号，所以端口号的有效范围是从 0 到 65535。一般来说，大于 49151 的端口号都代表动态端口。据报的长度是指包括报头和数据部分在内的总字节数。因为报头的长度是固定的，所以该域主要被用来计算可变长度的数据部分（又称为数据负载）。数据报的最大长度根据操作环境的不同而各异。从理论上说，包含报头在内的数据报的最大长度为 65535 字节。UDP 协议使用报头中的校验和来保证数据的安全 。

在LWIP中有关处理的函数关系如下：

（2）udp整个通信过程如下图：

（3）其实通讯过程很简单，下面看一下代码
    ① 接收函数就是遍历整个pbuf链表，将pbuf的数据存储区域payload里面的数据memcpy到数组里

 //UDP回调函数
 void udp_demo_recv(void *arg,struct udp_pcb *upcb,struct pbuf *p, struct ip4_addr *addr,u16_t port)
 {
     u32 data_len = ;
     struct pbuf *q;
     if(p!=NULL)    //接收到不为空的数据时
     {
         memset(udp_demo_recvbuf,,UDP_DEMO_RX_BUFSIZE);  //数据接收缓冲区清零
         for(q=p;q!=NULL;q=q->next)  //遍历完整个pbuf链表
         {
             //判断要拷贝到UDP_DEMO_RX_BUFSIZE中的数据是否大于UDP_DEMO_RX_BUFSIZE的剩余空间，如果大于
             //的话就只拷贝UDP_DEMO_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据
             if(q->len > (UDP_DEMO_RX_BUFSIZE-data_len)) memcpy(udp_demo_recvbuf+data_len,q->payload,(UDP_DEMO_RX_BUFSIZE-data_len));//拷贝数据
             else memcpy(udp_demo_recvbuf+data_len,q->payload,q->len);
             data_len += q->len;
             if(data_len > UDP_DEMO_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出
         }
         upcb->remote_ip=*addr;                 //记录远程主机的IP地址
         upcb->remote_port=port;              //记录远程主机的端口号
         udp_demo_flag|=<<;    //标记接收到数据了
         pbuf_free(p);//释放内存
     }
     else
     {
         debug("connect has been break !!!!\r\n");
     }
 }

udp_demo_recv

　　  ② 发送函数首先为pbuf申请内存，然后将要发送的内容复制到pbuf结构体中，最后发送出去

 //UDP服务器发送数据
 void udp_demo_senddata(struct udp_pcb *upcb)
 {
     struct pbuf *ptr;
     ptr=pbuf_alloc(PBUF_TRANSPORT,strlen((char*)udp_demo_sendbuf),PBUF_POOL); //申请内存
     if(ptr)
     {
         pbuf_take(ptr,(char*)udp_demo_sendbuf,strlen((char*)udp_demo_sendbuf)); //将tcp_demo_sendbuf中的数据打包进pbuf结构中
         udp_send(upcb,ptr);    //udp发送数据
         pbuf_free(ptr);//释放内存
     }
 }

udp_demo_senddata

③  关闭连接就是先断开连接，然后删除pcb控制块

 void udp_demo_connection_close(struct udp_pcb *upcb)
 {
     udp_disconnect(upcb);
     udp_remove(upcb);            //断开UDP连接
     udp_demo_flag &= ~(<<);    //标记连接断开
     debug("connect close!!!\r\n");
 }

udp_demo_connection_close

　　④ 测试函数就是按照上图的流程，很简单，不要忘记在测试函数循环中，调用LWIP内核需要定时处理的函数 sys_check_timeouts();

 //UDP 测试全局状态标记变量
 //bit7:没有用到
 //bit6:0,没有收到数据;1,收到数据了.
 //bit5:0,没有连接上;1,连接上了.
 //bit4~0:保留
 u8 udp_demo_flag = ;
 struct ip4_addr rmtipaddr;      //远端ip地址
 extern uint8_t REMOTE_IP_ADDRESS[];
 void udp_demo_test(void)
 {
     u8 *tbuf;
     err_t err;
     u8 res;
     struct udp_pcb *udppcb;      //定义一个TCP服务器控制块
     struct ip4_addr rmtipaddr;      //远端ip地址

     tbuf=malloc();    //申请内存
     if(tbuf==NULL)return;

     udppcb=udp_new();
     if(udppcb)
     {
         IP4_ADDR(&rmtipaddr,REMOTE_IP_ADDRESS[],REMOTE_IP_ADDRESS[],REMOTE_IP_ADDRESS[],REMOTE_IP_ADDRESS[]);
         err=udp_connect(udppcb,&rmtipaddr,UDP_DEMO_PORT);                      //UDP客户端连接到指定IP地址和端口号的服务器

         if(err==ERR_OK)
         {
             err=udp_bind(udppcb,IP_ADDR_ANY,UDP_DEMO_PORT);//绑定本地IP地址与端口号
             if(err==ERR_OK)    //绑定完成
             {
                 udp_recv(udppcb,udp_demo_recv,NULL);//注册接收回调函数
                 debug("STATUS Connected \r\n");
                 udp_demo_flag |= <<;            //标记已经连接上
                 debug("Recv Data: \r\n");
             }else res=;
         }else res=;
     }else res=;
     while(res==)
     {
         if(udp_demo_flag&<<)//是否收到数据?
         {
             udp_demo_flag&=~(<<);//标记数据已经被处理了.
             udp_demo_senddata(udppcb);
             debug("%s \r\n",udp_demo_recvbuf);
         }
         MX_LWIP_Process();
         delay_us();
     }
     udp_demo_connection_close(udppcb);
     free(tbuf);
 }

udp_demo_test

2.RAW TCP CLIENT

LWIP的各函数之间的关系如下图所示

可以看一下void tcp_client_test(void)这个测试函数，前面部分和udp一样，创建pcb控制块，然后直接调用tcp_connect进行连接，不过需要注册连接成功后的回调函数

 //TCP Client 测试全局状态标记变量
 //bit7:0,没有数据要发送;1,有数据要发送
 //bit6:0,没有收到数据;1,收到数据了.
 //bit5:0,没有连接上服务器;1,连接上服务器了.
 //bit4~0:保留
 u8 tcp_client_flag;

 void tcp_client_test(void)
 {
     struct tcp_pcb *tcppcb;      //定义一个TCP服务器控制块
     struct ip4_addr rmtipaddr;      //远端ip地址

     u8 *tbuf;
     u8 res=;
     u8 t=;
     tbuf = malloc();
     if(tbuf==NULL)return ;
     tcppcb=tcp_new();
     if(tcppcb)
     {
         IP4_ADDR(&rmtipaddr,REMOTE_IP_ADDRESS[],REMOTE_IP_ADDRESS[],REMOTE_IP_ADDRESS[],REMOTE_IP_ADDRESS[]);
       tcp_connect(tcppcb,&rmtipaddr,TCP_CLIENT_PORT,tcp_client_connected);
     }else res = ;
     delay_ms();

     while(!res)
     {
         if(tcp_client_flag&<<)
         {
             debug("recv data: ");
             debug("%s\r\n",tcp_client_recvbuf);
             tcp_client_usersent(tcppcb);
             tcp_client_flag&=~(<<);
         }

         MX_LWIP_Process();
         delay_ms();
         t++;
         if(t==)
         {
             if((tcp_client_flag&<<)==)
             {
                 tcp_client_connection_close(tcppcb,);//关闭连接
                 tcppcb=tcp_new();    //创建一个新的pcb
                 if(tcppcb)            //创建成功
                 {
                     tcp_connect(tcppcb,&rmtipaddr,TCP_CLIENT_PORT,tcp_client_connected);
                 }
             }
             t=;
         }
     }
         tcp_client_connection_close(tcppcb,);
         debug("TCP CLIENT BREAK!\r\n");
         free(tbuf);

 }

tcp_client_test

err_t tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err)

此函数主要是完成对接收、发送、错误、轮询函数的注册

 err_t tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err)
 {

     if(err==ERR_OK)
     {
         es=(struct tcp_client_struct*)malloc(sizeof(struct tcp_client_struct));  //申请内存
         if(es) //内存申请成功
         {

              es->state=ES_TCPCLIENT_CONNECTED;//状态为连接成功
             es->pcb=tpcb;
             es->p=NULL;
             tcp_arg(tpcb,es);                    //使用es更新tpcb的callback_arg
             tcp_recv(tpcb,tcp_client_recv);      //初始化LwIP的tcp_recv回调功能
             tcp_err(tpcb,tcp_client_error);     //初始化tcp_err()回调函数
             tcp_sent(tpcb,tcp_client_sent);        //初始化LwIP的tcp_sent回调功能
             tcp_poll(tpcb,tcp_client_poll,);     //初始化LwIP的tcp_poll回调功能
              tcp_client_flag|=<<;                 //标记连接到服务器了
             debug("tcp client connected !!!\r\n");
             err=ERR_OK;
         }else
         {
             debug("tcp client break !!!\r\n");
             tcp_client_connection_close(tpcb,es);//关闭连接
             err=ERR_MEM;    //返回内存分配错误
         }
     }else
     {
         tcp_client_connection_close(tpcb,);//关闭连接
     }
     return err;
 }

tcp_client_connected

err_t tcp_client_recv(void *arg,struct tcp_pcb *tpcb,struct pbuf *p,err_t err)

判断数据接收状态，运行UDP那一套

 err_t tcp_client_recv(void *arg,struct tcp_pcb *tpcb,struct pbuf *p,err_t err)
 {
     u32 data_len = ;
     struct pbuf *q;
 //    struct tcp_client_struct *es;
     err_t ret_err;
 if(p==NULL)//如果从服务器接收到空的数据帧就关闭连接
     {
         es->state=ES_TCPCLIENT_CLOSING;//需要关闭TCP 连接了
          es->p=p;
         ret_err=ERR_OK;
     }else if(err!= ERR_OK)//当接收到一个非空的数据帧,但是err!=ERR_OK
     {
         if(p)pbuf_free(p);//释放接收pbuf
         ret_err=err;
     }else if(es->state==ES_TCPCLIENT_CONNECTED)    //当处于连接状态时
     {
         if(p!=NULL)//当处于连接状态并且接收到的数据不为空时
         {
             memset(tcp_client_recvbuf,,TCP_CLIENT_RX_BUFSIZE);  //数据接收缓冲区清零
             for(q=p;q!=NULL;q=q->next)  //遍历完整个pbuf链表
             {
                 //判断要拷贝到TCP_CLIENT_RX_BUFSIZE中的数据是否大于TCP_CLIENT_RX_BUFSIZE的剩余空间，如果大于
                 //的话就只拷贝TCP_CLIENT_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据
                 if(q->len > (TCP_CLIENT_RX_BUFSIZE-data_len)) memcpy(tcp_client_recvbuf+data_len,q->payload,(TCP_CLIENT_RX_BUFSIZE-data_len));//拷贝数据
                 else memcpy(tcp_client_recvbuf+data_len,q->payload,q->len);
                 data_len += q->len;
                 if(data_len > TCP_CLIENT_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出
             }
             tcp_client_flag|=<<;        //标记接收到数据了
              tcp_recved(tpcb,p->tot_len);//用于获取接收数据,通知LWIP可以获取更多数据
             pbuf_free(p);      //释放内存
             ret_err=ERR_OK;
         }
     }else  //接收到数据但是连接已经关闭,
     {
         tcp_recved(tpcb,p->tot_len);//用于获取接收数据,通知LWIP可以获取更多数据
         es->p=NULL;
         pbuf_free(p); //释放内存
         ret_err=ERR_OK;
     }
     return ret_err;
 }

tcp_client_recv

err_t tcp_client_usersent(struct tcp_pcb *tpcb)

和udp一样

 //LWIP数据发送，用户应用程序调用此函数来发送数据
 //tpcb:TCP控制块
 //返回值:0，成功；其他，失败
 err_t tcp_client_usersent(struct tcp_pcb *tpcb)
 {
     err_t ret_err;
     struct tcp_client_struct *es;
     es=tpcb->callback_arg;
     if(es!=NULL)  //连接处于空闲可以发送数据
     {
         es->p=pbuf_alloc(PBUF_TRANSPORT, strlen((char*)tcp_client_sendbuf),PBUF_POOL);    //申请内存
         pbuf_take(es->p,(char*)tcp_client_sendbuf,strlen((char*)tcp_client_sendbuf));    //将tcp_client_sentbuf[]中的数据拷贝到es->p_tx中
         tcp_client_senddata(tpcb,es);//将tcp_client_sentbuf[]里面复制给pbuf的数据发送出去
         tcp_client_flag&=~(<<);    //清除数据发送标志
         if(es->p)pbuf_free(es->p);    //释放内存
         ret_err=ERR_OK;
     }else
     {
         tcp_abort(tpcb);//终止连接,删除pcb控制块
         ret_err=ERR_ABRT;
     }
     return ret_err;
 }

tcp_client_usersent

err_t tcp_client_poll(void *arg, struct tcp_pcb *tpcb)

tcp周期性调用的函数，可以用来检测连接状态

//lwIP tcp_poll的回调函数
err_t tcp_client_poll(void *arg, struct tcp_pcb *tpcb)
{
    err_t ret_err;
    struct tcp_client_struct *es;
    es=(struct tcp_client_struct*)arg;
    if(es->state==ES_TCPCLIENT_CLOSING)         //连接断开
    {
        debug("poll close\r\n");
         tcp_client_connection_close(tpcb,es);   //关闭TCP连接
    }
    ret_err=ERR_OK;
    return ret_err;
} 

tcp_client_poll

err_t tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)

检测到远程主机的应答后，发送函数

//lwIP tcp_sent的回调函数(当从远端主机接收到ACK信号后发送数据)
err_t tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
{
    struct tcp_client_struct *es;
    LWIP_UNUSED_ARG(len);
    es=(struct tcp_client_struct*)arg;
    if(es->p)tcp_client_senddata(tpcb,es);//发送数据
    return ERR_OK;
}
//此函数用来发送数据
void tcp_client_senddata(struct tcp_pcb *tpcb, struct tcp_client_struct * es)
{
    struct pbuf *ptr;
     err_t wr_err=ERR_OK;
    while((wr_err==ERR_OK)&&es->p&&(es->p->len<=tcp_sndbuf(tpcb)))
    {
        ptr=es->p;
        wr_err=tcp_write(tpcb,ptr->payload,ptr->len,); //将要发送的数据加入到发送缓冲队列中
        if(wr_err==ERR_OK)
        {
            es->p=ptr->next;            //指向下一个pbuf
            if(es->p)pbuf_ref(es->p);    //pbuf的ref加一
            pbuf_free(ptr);                //释放ptr
        }else if(wr_err==ERR_MEM)es->p=ptr;
        tcp_output(tpcb);                //将发送缓冲队列中的数据立即发送出去
    }
} 

tcp_client_sent

void tcp_client_connection_close(struct tcp_pcb *tpcb, struct tcp_client_struct * es)

删除PCB控制块，将回调函数指向空

 //关闭与服务器的连接
 void tcp_client_connection_close(struct tcp_pcb *tpcb, struct tcp_client_struct * es)
 {
     //移除回调
     tcp_abort(tpcb);//终止连接,删除pcb控制块
     tcp_arg(tpcb,NULL);
     tcp_recv(tpcb,NULL);
     tcp_sent(tpcb,NULL);
     tcp_err(tpcb,NULL);
     tcp_poll(tpcb,NULL,);
     if(es)free(es);
     tcp_client_flag&=~(<<);//标记连接断开了
 }

tcp_client_connection_close

3.RAW TCP SERVER

下面是从别的博客复制过来的一张图片，很清晰的描述了整个TCP server的通讯流程，从最底层到应用层

注意：tcp_client是从connect的时候就会注册那四个函数，而tcp_sever是没有connect的，在accpt的时候注册阻塞函数（阻塞函数中注册那四个函数），等待客户端的连接

除了这两个初始化步骤和阻塞函数与客户端不一样，其他的都差不多

 #include "raw_tcp_server_test.h"

 u8 tcp_server_recvbuf[TCP_SERVER_RX_BUFSIZE];    

 const char *tcp_server_sendbuf="Apollo STM32F7 TCP Server send data\r\n";

 //TCP Server 测试全局状态标记变量
 //bit7:0,没有数据要发送;1,有数据要发送
 //bit6:0,没有收到数据;1,收到数据了.
 //bit5:0,没有客户端连接上;1,有客户端连接上了.
 //bit4~0:保留
 u8 tcp_server_flag;     

 void tcp_server_test(void)
 {
     err_t err;
     struct tcp_pcb *tcppcbnew;      //定义一个TCP服务器控制块
     struct tcp_pcb *tcppcbconn;      //定义一个TCP服务器控制块

     u8 *tbuf;
     u8 rSes=;        

     tbuf=malloc();    //申请内存
     if(tbuf==NULL)return ;        //内存申请失败了,直接退出
     tcppcbnew=tcp_new();
     if(tcppcbnew)            //创建成功
     {
         err=tcp_bind(tcppcbnew,IP_ADDR_ANY,TCP_SERVER_PORT);
         if(err==ERR_OK)    //绑定完成
         {
             tcppcbconn=tcp_listen(tcppcbnew);             //设置tcppcb进入监听状态
             tcp_accept(tcppcbconn,tcp_server_accept);     //初始化LWIP的tcp_accept的回调函数
         }else rSes=;
     }else rSes=;
     while(rSes==)
     {
         if(tcp_server_flag&<<)//是否收到数据?
         {
             debug("recv data:  %s\r\n",tcp_server_recvbuf);
             tcp_server_flag&=~(<<);//标记数据已经被处理了.
             tcp_server_usersent(tcppcbnew);
         }
         MX_LWIP_Process();
         delay_ms();
     }
     tcp_server_connection_close(tcppcbnew,);//关闭TCP Server连接
     tcp_server_connection_close(tcppcbconn,);//关闭TCP Server连接
     tcp_server_remove_timewait();
     memset(tcppcbnew,,sizeof(struct tcp_pcb));
     memset(tcppcbconn,,sizeof(struct tcp_pcb));
     free(tbuf);
 }
 struct tcp_server_struct *Ses;
 err_t tcp_server_accept(void *arg,struct tcp_pcb *newpcb,err_t err)
 {
     err_t ret_err;

      LWIP_UNUSED_ARG(arg);
     LWIP_UNUSED_ARG(err);
     tcp_setprio(newpcb,TCP_PRIO_MIN);//设置新创建的pcb优先级

     Ses=(struct tcp_server_struct*)mem_malloc(sizeof(struct tcp_server_struct)); //分配内存
     if(Ses!=NULL) //内存分配成功
     {
         Ses->state=ES_TCPSERVER_ACCEPTED;      //接收连接
         Ses->pcb=newpcb;
         Ses->p=NULL;

         tcp_arg(newpcb,Ses);
         tcp_recv(newpcb,tcp_server_recv);    //初始化tcp_recv()的回调函数
         tcp_err(newpcb,tcp_server_error);     //初始化tcp_err()回调函数
         tcp_poll(newpcb,tcp_server_poll,);    //初始化tcp_poll回调函数
         tcp_sent(newpcb,tcp_server_sent);      //初始化发送回调函数
         debug("new client connected \r\n");
         tcp_server_flag|=<<;                //标记有客户端连上了
         ret_err=ERR_OK;
     }else ret_err=ERR_MEM;
     return ret_err;
 }

 err_t tcp_server_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
 {
     err_t ret_err;
     u32 data_len = ;
     struct pbuf *q;
       struct tcp_server_struct *Ses;
     LWIP_ASSERT("arg != NULL",arg != NULL);
     Ses=(struct tcp_server_struct *)arg;
     if(p==NULL) //从客户端接收到空数据
     {
         Ses->state=ES_TCPSERVER_CLOSING;//需要关闭TCP 连接了
         Ses->p=p;
         ret_err=ERR_OK;
     }else if(err!=ERR_OK)    //从客户端接收到一个非空数据,但是由于某种原因err!=ERR_OK
     {
         if(p)pbuf_free(p);    //释放接收pbuf
         ret_err=err;
     }else if(Ses->state==ES_TCPSERVER_ACCEPTED)     //处于连接状态
     {
         if(p!=NULL)  //当处于连接状态并且接收到的数据不为空时将其打印出来
         {
             memset(tcp_server_recvbuf,,TCP_SERVER_RX_BUFSIZE);  //数据接收缓冲区清零
             for(q=p;q!=NULL;q=q->next)  //遍历完整个pbuf链表
             {
                 //判断要拷贝到TCP_SERVER_RX_BUFSIZE中的数据是否大于TCP_SERVER_RX_BUFSIZE的剩余空间，如果大于
                 //的话就只拷贝TCP_SERVER_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据
                 if(q->len > (TCP_SERVER_RX_BUFSIZE-data_len)) memcpy(tcp_server_recvbuf+data_len,q->payload,(TCP_SERVER_RX_BUFSIZE-data_len));//拷贝数据
                 else memcpy(tcp_server_recvbuf+data_len,q->payload,q->len);
                 data_len += q->len;
                 if(data_len > TCP_SERVER_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出
             }
             tcp_server_flag|=<<;    //标记接收到数据了
             tcp_recved(tpcb,p->tot_len);//用于获取接收数据,通知LWIP可以获取更多数据
             pbuf_free(p);      //释放内存
             ret_err=ERR_OK;
         }
     }else//服务器关闭了
     {
         tcp_recved(tpcb,p->tot_len);//用于获取接收数据,通知LWIP可以获取更多数据
         Ses->p=NULL;
         pbuf_free(p); //释放内存
         ret_err=ERR_OK;
     }
     return ret_err;

 }
 //lwIP tcp_err函数的回调函数
 void tcp_server_error(void *arg,err_t err)
 {
     LWIP_UNUSED_ARG(err);
     debug("tcp error:%x\r\n",(u32)arg);
     if(arg!=NULL)mem_free(arg);//释放内存
 } 

 //LWIP数据发送，用户应用程序调用此函数来发送数据
 //tpcb:TCP控制块
 //返回值:0，成功；其他，失败
 err_t tcp_server_usersent(struct tcp_pcb *tpcb)
 {
     err_t ret_err;
     struct tcp_server_struct *Ses;
     Ses=tpcb->callback_arg;
     if(Ses!=NULL)  //连接处于空闲可以发送数据
     {
         Ses->p=pbuf_alloc(PBUF_TRANSPORT, strlen((char*)tcp_server_sendbuf),PBUF_POOL);    //申请内存
         pbuf_take(Ses->p,(char*)tcp_server_sendbuf,strlen((char*)tcp_server_sendbuf));    //将tcp_server_sentbuf[]中的数据拷贝到Ses->p_tx中
         tcp_server_senddata(tpcb,Ses);   //将tcp_server_sentbuf[]里面复制给pbuf的数据发送出去
         tcp_server_flag&=~(<<);        //清除数据发送标志
         if(Ses->p!=NULL)pbuf_free(Ses->p);//释放内存
         ret_err=ERR_OK;
     }else
     {
         tcp_abort(tpcb);//终止连接,删除pcb控制块
         ret_err=ERR_ABRT;
     }
     return ret_err;
 }

 //lwIP tcp_poll的回调函数
 err_t tcp_server_poll(void *arg, struct tcp_pcb *tpcb)
 {
     err_t ret_err;
     struct tcp_server_struct *Ses;
     Ses=(struct tcp_server_struct *)arg;
     if(Ses->state==ES_TCPSERVER_CLOSING)//需要关闭连接?执行关闭操作
     {
         tcp_server_connection_close(tpcb,Ses);//关闭连接
     }
     ret_err=ERR_OK;
     return ret_err;
 }
 //lwIP tcp_sent的回调函数(当从远端主机接收到ACK信号后发送数据)
 err_t tcp_server_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
 {
     struct tcp_server_struct *Ses;
     LWIP_UNUSED_ARG(len);
     Ses = (struct tcp_server_struct *) arg;
     if(Ses->p)tcp_server_senddata(tpcb,Ses);//发送数据
     return ERR_OK;
 }
 //此函数用来发送数据
 void tcp_server_senddata(struct tcp_pcb *tpcb, struct tcp_server_struct *Ses)
 {
     struct pbuf *ptr;
     u16 plen;
     err_t wr_err=ERR_OK;
     while((wr_err==ERR_OK)&&Ses->p&&(Ses->p->len<=tcp_sndbuf(tpcb)))
     {
         ptr=Ses->p;
         wr_err=tcp_write(tpcb,ptr->payload,ptr->len,);
         if(wr_err==ERR_OK)
         {
             plen=ptr->len;
             Ses->p=ptr->next;            //指向下一个pbuf
             if(Ses->p)pbuf_ref(Ses->p);    //pbuf的ref加一
             pbuf_free(ptr);
             tcp_recved(tpcb,plen);         //更新tcp窗口大小
         }else if(wr_err==ERR_MEM)Ses->p=ptr;
         tcp_output(tpcb);                //将发送缓冲队列中的数据立即发送出去
     }
     }

 //关闭tcp连接
 void tcp_server_connection_close(struct tcp_pcb *tpcb, struct tcp_server_struct *Ses)
 {
     tcp_close(tpcb);
     tcp_arg(tpcb,NULL);
     tcp_sent(tpcb,NULL);
     tcp_recv(tpcb,NULL);
     tcp_err(tpcb,NULL);
     tcp_poll(tpcb,NULL,);
     if(Ses)mem_free(Ses);
     tcp_server_flag&=~(<<);//标记连接断开了
 }
 extern void tcp_pcb_purge(struct tcp_pcb *pcb);    //在 tcp.c里面
 extern struct tcp_pcb *tcp_active_pcbs;            //在 tcp.c里面
 extern struct tcp_pcb *tcp_tw_pcbs;                //在 tcp.c里面
 //强制删除TCP Server主动断开时的time wait
 void tcp_server_remove_timewait(void)
 {
     struct tcp_pcb *pcb,*pcb2;
     u8 t=;
     while(tcp_active_pcbs!=NULL&&t<)
     {
         MX_LWIP_Process();    //继续轮询
         t++;
         delay_ms();            //等待tcp_active_pcbs为空
     }
     pcb=tcp_tw_pcbs;
     while(pcb!=NULL)//如果有等待状态的pcbs
     {
         tcp_pcb_purge(pcb);
         tcp_tw_pcbs=pcb->next;
         pcb2=pcb;
         pcb=pcb->next;
         memp_free(MEMP_TCP_PCB,pcb2);
     }
 }

tcp_server_test

******************************************************************

参考资料：

正点原子《stm32f7 lwip开发手册》

沧海一粟的《lwIP协议栈开发嵌入式网络的三种方法分析》

博客园地址：http://www.cnblogs.com/fozu/p/3613804.html