网络编程笔记

网络编程

1. 概念

1.1 局域网

局域网：局域网将一定区域的各种计算机、外部设备和数据连接起来形成计算机通信的私有网络

广域网：又称广域网、外网、公网。是连接不同地区局域网或城域网计算机通信的远程公共网络

1.2 IP

本质是一个整形数，用于表示计算机在网络中的地址。IP协议版本有两个：IPV4和IPV6

• IPV4

  1. 使用一个32位的整形数表示一个IP地址，4个字节，int型

  2. 也可以使用点分十进制字符串描述这个IP地址：192.168.10.27

  3. 分成四份，每份1字节，8bit（char），最大值255

     1. 0.0.0.0是最小的ip地址
     2. 255.255.255.255是最大的IP地址

​ 4. 按照IPV4协议计算，可以使用的IP地址有2的32次方个

• IPV6

  1. 使用一个128位的整形数描述一个IP地址，16个字节

  2. 也可以使用一个字符串描述这个IP地址：2001:0db8:3c4d:0015:0000:0000:1a2b

  3. 分成了8份，每份2字节，每一部分以16进制的方式表示

  4. 按照协议IPV6计算，可以使用的IP地址有2的128次方个

     

  

1.3 端口

作用：定位到主机上的某一个进程，通过这个端口进程就可以接受对应的网络数据

端口也是一个整形数unsigned short，一个16位整型数，有效端口取值范围：0~65535

注意：一个进程不需要网络通信的话就不需要绑定端口，如果需要网络通信那么就需要绑定，一个端口对应一个进程，多个进程不能同时使用一个端口

1.4 OSI/ISO 模型

OSI，即开放式系统互联，一般都叫OSI参考模型。是ISO（国际标准化组织）在1985年研究的网络互联模型

2. 网络协议

TCP UDP IP 以太网

3. socket 编程

socket 对于程序员来说是一套网络通信接口，使用这套接口可以完成网络通信，网络通信主要分为两部分：客户端和服务器端。

需要了解三个概念：IP、端口、通信数据

3.1 字节序

概念：大于一个字节类型的数据在内存中的存放顺序，也就是说对于单字符来说是没有字节序问题，字符串是单字符的集合，因此字符串也没有字节序问题。

计算机通常采用的字节存储机制主要有两种：Big-endian大端存储和little-endian小端存储

• 小端->主机字节序

  数据的低位字节存储到内存的低地址位，数据的高位字节存储到内存的高地址位

  PC机默认使用小端存储

• 大端->网络字节序

  数据的低位字节存储到内存的高地址位，数据的高位字节存储到内存的低地址位

  套接字通过过程中操作的数据都是大端存储，包括：接收/发送数据、IP地址、端口

  4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit

​ 0x12 34 56 78

​ 小端：78 56 34 12

​ 大端：12 34 56 78

3.2 大小端转换函数

#include <arpa/inet.h>
/*
u:unsigned
16：16位
h:host,主机字节序
n:net，网络字节序
s:short
l:int
*/
uint16_t htons(uint16_t hostshort);
uint32_t htonl(uint32_t hostlong);

uint16_t ntohs(uint16_t netshort);
uint32_t ntohl(uint32_t netlong);

3.3 IP地址转换

• 字符串类型的IP地址转换为大端整型数

  int inet_pton(int af , const char *src, void *dst );
  /*
  af:地址族协议
  AF_INET4:ipv4格式的ip地址
  AF_INET6:ipv6格式的ip地址
  
  src:传入参数，对应要转换的点分十进制的ip地址：192.168.10.27
  dst:传出参数，函数调用完成，转换得到的大端整形IP被写入到这块内存中
  
  返回值:成功1，失败0或-1
  */
  

• 大端整型数转换为小端的点分十进制的IP地址

  #include <arpa/inet.h>
  
  const char *inet_ntop(int af,const void *src,char *dst,socklen_t size);
  /*
  src:传入参数，指向大端整形数的地址
  dst:传出参数，指向小端点分十进制的IP地址字符串
  size:dst的内存大小
  返回值：成功返回a non-null pointer to dst
  	   失败返回NULL  with errno set to indicate the error
  */
  

• 只能用于IPV4大小端转换的函数(一般不用)

  //IP->大端整形
  in_addr_t inet_addr(const char *cp);
  
  // 大端整形 -> 点分十进制ip
  char *inet_ntoa(struct in_addr in);
  

4. TCP 通信流程

TCP报文长度

TCP是一个面向连接的，安全的，流式传输协议，这个协议是传输层协议

• 面向连接：是一个双线连接，通过三次握手完成，断开连接需要通过四次挥手
• 安全：tcp通信过程中，会对发送的每一数据包都会进行校验，如果发现数据丢失会自动重传
• 流式传输：发送端和接收端处理数据的速度，数据的量都可以不一致

4.1 服务器端通信流程

int lfd = socket(int domain, int type, int protocol); //创建用于监听的socket，lfd是一个文件描述符
bind();             //将得到的监听的文件描述符和本地的IP端口进行绑定
listen();           //设置监听(成功之后开始监听，监听的是客户端的连接)
int cfd = accept(); //等待并接受客户端的连接请求，建立新的连接，会得到一个新的文件描述符(通信的)
read(); /recv();//通信读写默认都是阻塞的
write();/send();
close();//断开连接，关闭套接字  **调用一次挥手两次**

4.2 客户端通信流程

在单线程的情况下客户端通信的文件描述符有一个，没有监听的文件描述符

int cfd = socket();//创建一个通信的套接字
connect(); //连接服务器，需要知道服务器绑定的IP和端口
// 接收数据
read();/recv();
//发送数据
write();/send();

close(); //断开连接，关闭文件描述符(套接字)

4.3 socket函数

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
/*
domain 用于指定一个通信域；这将选择将用于通信的协议族。
TCP/IP协议来说，AF_INET\AF_INET6\AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE

type 指定套接字的类型

protocol 通常设置为 0，表示为给定的通信域和套接字类型选择默认协议。
当对同一域和套接字类型支持多个协议时，可以使用 protocol 参数选择一个
特定协议。在 AF_INET 通信域中，套接字类型为SOCK_STREAM 的默认协议是
传输控制协议（Transmission Control Protocol，TCP 协议）。
在 AF_INET 通信域中，套接字类型为 SOCK_DGRAM 的默认协议时 UDP。
*/

*注意*：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

4.4 bind函数

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//bind()函数用于将一个 IP 地址或端口号与一个套接字进行绑定（将套接字与地址进行关联）。

struct sockaddr{
    sa_family_t sa_family;
    char sa_data[14];
};
/*sa_data 是一个 char 类型数组，一共 14 个字节，在这 14 个字节中就包括了 IP 地址、端口
号等信息*/
typedef uint32_t in_addr_t;
struct in_addr{
    in_addr_t s_addr;
};
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];
};
/*
sin_port,sin_addr,会组成sa_data,然后传递给bind
*/

//`````````````````````````使用示例```````````````````````````````````````````

int socket_fd = socket(AF_INET, SOCK_STREAM, 0);//打开套接字
if (0 > socket_fd) {
 perror("socket error");
 exit(-1);
}

struct sockaddr_in socket_addr;
memset(&socket_addr, 0x0, sizeof(socket_addr)); //清零
//填充变量
socket_addr.sin_family = AF_INET;
socket_addr.sin_addr.s_addr = htonl(INADDR_ANY);
socket_addr.sin_port = htons(5555);
bind(socket_fd, (struct sockaddr *)&socket_addr, sizeof(socket_addr));

·····
    
close(socket_fd);

4.5 listen函数

int listen(int sockfd, int backlog);
//可以看作有一个任务队列，只能最多排128个请求
//参数 backlog 用来描述 sockfd 的等待连接队列能够达到的最大值。

4.6 accept函数

为了能够正常让客户端能正常连接到服务器，服务器必须遵循以下处理流程：

①、调用 socket()函数打开套接字；

②、调用 bind()函数将套接字与一个端口号以及 IP 地址进行绑定；

③、调用 listen()函数让服务器进程进入监听状态，监听客户端的连接请求；

④、调用 accept()函数处理到来的连接请求。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//没有连接请求时会阻塞
/*
当有客户端连接请求到达时，accept()函数与远程客户端之间建立连接，accept()函数返回一个新的套接字。这个套接字与 socket()函数返回的套接字并不同，socket()函数返回的是服务器的套接字（以服务器为例），而accept()函数返回的套接字连接到调用 connect()的客户端，服务器通过该套接字与客户端进行数据交互，譬如向客户端发送数据、或从客户端接收数据。
*/

/*
参数 addr 是一个传出参数，参数 addr 用来返回已连接的客户端的 IP 地址与端口号等这些信息。参数addrlen 应设置为 addr 所指向的对象的字节长度，如果我们对客户端的 IP 地址与端口号这些信息不感兴趣，可以把 arrd 和 addrlen 均置为空指针 NULL。
*/

关键理解新的套接字描述符，代表了服务器与客户端建立的一个连接

4.7 客户端连接服务器connect函数

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/*
参数 addr 指定了待连接的服务器的 IP 地址以及端口号等信息
参数 addrlen 指定了 addr 指向的 struct sockaddr对象的字节大小
成功返回0，失败返回-1，并设置errno
*/

客户端通过 connect()函数请求与服务器建立连接，对于 TCP 连接来说，调用该函数将发生 TCP 连接的握手过程，并最终建立一个 TCP 连接，而对于 UDP 协议来说，调用这个函数只是在 sockfd 中记录服务器IP 地址与端口号，而不发送任何数据.

4.8 客户端与服务器通信函数

通过套接字描述符来收发数据了（对于客户端使用socket()返回的套接字描述符，而对于服务器来说，需要使用 accept()返回的套接字描述符）

ssize_t read(int sockfd,void *buf,size_t size);
/*
read()函数从一个文件描述符中读取指定字节大小的数据并放入到指定的缓冲区中，read()调用成功将返回读取到的字节数，此返回值受文件剩余字节数限制，当返回值小于指定的字节数时并不意味着错误；这可能是因为当前可读取的字节数小于指定的字节数（比如已经接近文件结尾，或者正在从管道或者终端读取数据，或者 read()函数被信号中断等），出错返回-1 并设置 errno，如果在调 read 之前已到达文件末尾，则这次 read 返回 0。
*/
ssize_t recv(int sockfd,void *buf,size_t size,int flags);
/*
参数：
sockfd:用于通信的文件描述符，accept函数的返回值
buf：指向一块有效内存，用于存储接收数据
size：参数buf指向的内存的容量
flags：特殊的属性，一般不使用，0，控制如何接收数据

返回值：
大于0：实际接收的字节数
等于0：对方断开连接
-1：接收数据失败
*/

flags属性：

ssize_t write(int fd,const void *buf,size_t len);

ssize_t send(int fd,const void *buf,size_t len,int flags);
/*
参数
fd： 通信的文件描述符，服务器就是accpet的返回值，客户端就是socket的返回值
buf：传入参数，要发送的字符串
len：要发送的字符串长度
flags：属性

返回值：
大于0：实际发送的字节数，和参数len是相等的
-1：发送数据失败
*/

4.9 文件描述符在socket通信中的作用

服务器的文件描述符的作用：

1. 监听新的客户端连接

2. 接受已建立连接的客户端数据

[!CAUTION]

在服务器端用于监听的文件描述符只有一个，用于通信的文件描述符有n个，建立几个连接就有几个；客户端也是只有一类

服务端示例程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(){
    char ip_s[16] = "192.168.23.139";
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);

    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    //绑定端口
    struct sockaddr_in sever_addr;
    memset(&sever_addr, 0x0, sizeof(sever_addr));
    sever_addr.sin_family = AF_INET;
    sever_addr.sin_port = htons(8080);
    inet_pton(AF_INET,ip_s,&sever_addr.sin_addr.s_addr);
    //sever_addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*)&sever_addr,sizeof(sever_addr));
    if(ret == -1){
        perror("bind error\n");
        close(fd);
        exit(-1);
    }
  
    printf("sever ip:%s,port:%d\n",ip_s,8080);
    //监听
    ret = listen(fd, 128);
    if(ret == -1){
        perror("listen error\n");
        close(fd);
        exit(-1);
    }
    
    //处理连接请求
    struct sockaddr_in accept_addr;
    memset(&accept_addr, 0, sizeof(accept_addr));
    int addrlen = sizeof(accept_addr);
    int cfd = accept(fd, (struct sockaddr *)&accept_addr, &addrlen);
    if(ret == -1){
        perror("accept error\n");
        close(fd);
        exit(-1);
    }

    char ip[32];
    printf("建立新连接客户端IP地址:%s,端口:%d\n",inet_ntop(AF_INET,&accept_addr.sin_addr.s_addr,ip,sizeof(ip)),ntohs(accept_addr.sin_port));

    while(1)
    {

        char buf[1024];
        //读数据，没有数据就阻塞等待
        int len = recv(cfd, buf, sizeof(buf),0);
        if(len  > 0){
            printf("client say: %s\n",buf);
            send(cfd, buf, sizeof(buf),0);
        }else if(len == 0){
            perror("client end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
    }
    close(fd);
    close(cfd);

    exit(0);
}

客户端示例程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(int argc, char **argv){
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    
    //连接请求
    struct sockaddr_in client_addr;
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(8080);
    //client_addr.sin_addr.s_addr = INADDR_ANY;
    inet_pton(AF_INET,"192.168.23.139",&client_addr.sin_addr.s_addr);
    int ret = connect(fd, (struct sockaddr*)&client_addr, sizeof(client_addr));
    if(ret == -1){
        perror("connect error\n");
        exit(-1);
    }

    char ip[32];
    printf("与服务器建立连接服务器IP地址:%s,\
           端口:%d\n",inet_ntop(AF_INET,&client_addr.sin_addr.s_addr,ip,sizeof(ip)),
           ntohs(client_addr.sin_port));

    int number = 0;
    while(1)
    {
        char buff[1024];
        sprintf(buff,"你好，hello world %d...\n",number++);
        send(fd, buff ,strlen(buff)+1,0);
     
        memset(buff,0,sizeof(buff));
        int len = recv(fd, buff, sizeof(buff),0);
        if(len  > 0){
            printf("sever say: %s\n",buff);
        }else if(len == 0){
            perror("sever end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
        sleep(1);
     
    }
    close(fd);
    exit(0);
}

5. 基于多线程实现服务器并发分析

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>

struct addrInfo{
    struct sockaddr_in addr;
    int cfd;
    int number;
};

struct addrInfo addrInFos[50];
static void *working(void *arg){

    struct addrInfo *addrINFO = (struct addrInfo *)arg;
    char ip[32];
    printf("建立新连接客户端IP地址:%s,端口:%d\n",inet_ntop(AF_INET,&addrINFO->addr.sin_addr.s_addr,ip,sizeof(ip)),ntohs(addrINFO->addr.sin_port));

    while(1)
    {

        char buf[1024];
        int len = recv(addrINFO->cfd, buf, sizeof(buf),0);
        if(len  > 0){
            printf("client %d say: %s\n",addrINFO->number,buf);
            send(addrINFO->cfd, buf, sizeof(buf),0);
        }else if(len == 0){
            perror("client end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
    }

    close(addrINFO->cfd);
    addrINFO->cfd = -1;
    return (void *)0;

}
int main(){
    char ip_s[16] = "192.168.23.139";
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    int count = 0;
    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    //绑定端口
    struct sockaddr_in sever_addr;
    memset(&sever_addr, 0x0, sizeof(sever_addr));
    sever_addr.sin_family = AF_INET;
    sever_addr.sin_port = htons(8080);
    inet_pton(AF_INET,ip_s,&sever_addr.sin_addr.s_addr);
    //sever_addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*)&sever_addr,sizeof(sever_addr));
    
    if(ret == -1){
        perror("bind error\n");
        close(fd);
        exit(-1);
    }
    printf("sever ip:%s,port:%d\n",ip_s,8080);
    ret = listen(fd, 128);
    if(ret == -1){
        perror("listen error\n");
        close(fd);
        exit(-1);
    }

    int max = sizeof(addrInFos) / sizeof(addrInFos[0]);
    for(int i = 0; i < max; i++){
        memset(&addrInFos[i],0,sizeof(addrInFos[i]));
        addrInFos[i].cfd = -1; 
        addrInFos[i].number = 0;  
    }

    socklen_t addrlen = sizeof(struct sockaddr_in);
    while(1){
        struct addrInfo *pinInfo;
        for(int i=0;i<max;i++){
            if(addrInFos[i].cfd == -1){
                pinInfo = &addrInFos[i];
                break;
            }
        }
   
        int cfd = accept(fd, (struct sockaddr *)&pinInfo->addr, &addrlen);
        pinInfo->cfd = cfd;
        count++;
        pinInfo->number =count;
        if(ret == -1){
            perror("accept error\n");
            break;
        }

        pthread_t tid;
        pthread_create(&tid, NULL, working, pinInfo);
        pthread_detach(tid);
    }
    
    close(fd);
    exit(0);
}
    

6. TCP连接三次握手四次挥手

为什么不是二次而是三次？

• 为了实现可靠数据传输， TCP 协议的通信双方， 都必须维护一个序列号， 以标识发送出去的数据包中， 哪些是已经被对方收到的。 三次握手的过程即是通信双方相互告知序列号起始值， 并确认对方已经收到了序列号起始值的必经步骤

• 如果只是两次握手， 至多只有连接发起方的起始序列号能被确认， 另一方选择的序列号则得不到确认

⚫ 第一次握手

客户端将 TCP 报文标志位 SYN(同步序列编号) 置为 1，随机产生一个序号值 seq=J，保存在 TCP 首部的序列号(Sequence Number)字段里，指明客户端打算连接的服务器的端口，并将该数据包发送给服务器端，发送完毕后，客户端进入 SYN_SENT 状态，等待服务器端确认。

⚫ 第二次握手

服务器端收到数据包后由标志位 SYN=1 知道客户端请求建立连接，服务器端将 TCP 报文标志位 SYN和 ACK 都置为 1，ack=J+1，随机产生一个序号值 seq=K，并将该数据包发送给客户端以确认连接请求，服务器端进入 SYN_RCVD 状态。

⚫ 第三次握手

客户端收到确认后，检查 ack 是否为 J+1，ACK 是否为 1，如果正确则将标志位 ACK 置为 1，ack=K+1，并将该数据包发送给服务器端，服务器端检查 ack 是否为 K+1，ACK 是否为 1，如果正确则连接建立成功，客户端和服务器端进入 ESTABLISHED 状态，完成三次握手，随后客户端与服务器端之间可以开始传输数据了。

TCP连接是全双工的，因此每个方向都必须单独进行关闭。

⚫ 第一次挥手

Client 端发起挥手请求，向 Server 端发出一个 FIN 报文段主动进行关闭连接，此时报文段的 FIN 标志位被设置为 1。此时，Client 端进入 FIN_WAIT_1 状态，这表示 Client 端没有数据要发送给 Server 端了。

⚫ 第二次挥手

Server 端收到了 Client 端发送的 FIN 报文段，向 Client 端返回一个 ACK 报文段，此时报文段的 ACK标志位被设置为 1。ack 设为 seq 加 1，Client 端进入 FIN_WAIT_2 状态，Server 端告诉 Client 端，我确认并同意你的关闭请求。

⚫ 第三次挥手

Server 端向 Client 端发送一个 FIN 报文段请求关闭连接，此时报文段的 FIN 标志位被设置为 1，同时sever端进入 LAST_ACK 状态。

⚫ 第四次挥手

Client 端收到 Server 端发送的 FIN 报文段后，向 Server 端发送 ACK 报文段（此时报文段的 ACK 标志位被设置为 1），然后 Client 端进入 TIME_WAIT 状态。Server 端收到 Client 端的 ACK 报文段以后，就关闭连接。此时，Client 端等待 2MSL 的时间后依然没有收到回复，则证明 Server 端已正常关闭，那好，Client端也可以关闭连接了。这就是关闭 TCP 连接的四次挥手

7. 线程池

7.1 线程池概念

为了避免频繁创建线程进而频繁申请内存，给操作系统带来更大的压力，影响性能，所以一次申请好一定数量的线程，然后将线程的管理操作交给线程池，避免短时间内不断创建与销毁。

7.2 优势

1. 节省创建线程时间，有任务就立刻执行
2. 防止系统过载问题
3. 线程池资源占用少

7.3 应用

1. web服务器
2. 对性能苛刻的应用，要求服务器迅速响应
3. 突发性的大量请求

7.4 组成

线程池的组成主要分为3个部分，这三部分配合工作就可以得到一个完整的线程池：

• 任务队列，存储需要处理的任务，由工作的线程来处理这些任务

  通过线程池提供的API函数，将一个待处理的任务添加到任务队列，或者从任务队列中删除

  已处理的任务会被从任务队列中删除

  线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程

• 工作的线程（任务队列任务的消费者） ，N个

  线程池中维护了一定数量的工作线程, 他们的作用是是不停的读任务队列, 从里边取出任务并处理

  工作的线程相当于是任务队列的消费者角色，

  如果任务队列为空, 工作的线程将会被阻塞 (使用条件变量/信号量阻塞)

  如果阻塞之后有了新的任务, 由生产者将阻塞解除, 工作线程开始工作

• 管理者线程（不处理任务队列中的任务），1个

  它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测

  当任务过多的时候, 可以适当的创建一些新的工作线程

  当任务过少的时候, 可以适当的销毁一些工作的线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include "threadpool.h"

struct addrInfo{
    struct sockaddr_in addr;
    int cfd;
    int number;
};

typedef  struct poolInfo{
    ThreadPool *p;
    int fd;
}poolInfo;


void acceptConn(void *arg){
    int count = 0;
    poolInfo *info = (poolInfo*)arg;
    socklen_t addrlen = sizeof(struct sockaddr_in);
    while(1){
        struct addrInfo *pinInfo;
        pinInfo = (struct addrInfo*)malloc(sizeof(struct addrInfo));

        pinInfo->cfd = accept(info->fd, (struct sockaddr *)&pinInfo->addr, &addrlen);
        count++;
        pinInfo->number =count;
        if(pinInfo->cfd == -1){
            perror("accept error\n");
            break;
        }
        threadPoolAdd(info->p, working, pinInfo);
    }
    
    close(info->fd);

}
   
static void working(void *arg){

    struct addrInfo *addrINFO = (struct addrInfo *)arg;
    char ip[32];
    printf("建立新连接客户端IP地址:%s,端口:%d\n",inet_ntop(AF_INET,&addrINFO->addr.sin_addr.s_addr,ip,sizeof(ip)),ntohs(addrINFO->addr.sin_port));

    while(1)
    {

        char buf[1024];
        int len = recv(addrINFO->cfd, buf, sizeof(buf),0);
        if(len  > 0){
            printf("client %d say: %s\n",addrINFO->number,buf);
            send(addrINFO->cfd, buf, sizeof(buf),0);
        }else if(len == 0){
            perror("client end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
    }

    close(addrINFO->cfd);
    addrINFO->cfd = -1;
}
int main(){
    char ip_s[16] = "192.168.23.140";
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    //绑定端口
    struct sockaddr_in sever_addr;
    memset(&sever_addr, 0x0, sizeof(sever_addr));
    sever_addr.sin_family = AF_INET;
    sever_addr.sin_port = htons(8080);
    inet_pton(AF_INET,ip_s,&sever_addr.sin_addr.s_addr);
    //sever_addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*)&sever_addr,sizeof(sever_addr));
    if(ret == -1){
        perror("bind error\n");
        close(fd);
        exit(-1);
    }
    printf("sever ip:%s,port:%d\n",ip_s,8080);
    
    //监听
    ret = listen(fd, 128);
    if(ret == -1){
        perror("listen error\n");
        close(fd);
        exit(-1);
    }
	//创建线程池
    ThreadPool *pool = threadPoolCreate(3, 8, 100);
    poolInfo *info = (poolInfo*)malloc(sizeof(poolInfo));
    info->fd = fd;
    info->p = pool;
    //添加任务
    threadPoolAdd(pool, acceptConn, info);

    pthread_exit(NULL);

    return 0;
}