Linux网络编程

#include <sys/socket.h>
int shutdown(int sockfd, int how);
参数：
    sockfd:需要关闭的socket的描述符
    how:允许为shutdown操作选择以下几种方式：
        SHUT_RD(0):关闭sockfd上的读功能，此选项将不允许sockfd进行读操作。该套接字不再接收数据，任何当前在套接字接受缓冲区的数据将被丢弃。
        SHUT_WR(1):关闭sockfd上的写功能，此选项将不允许sockfd进行写操作。进程不能再对此套接字发出写操作
        SHUT_RDWR(2):关闭sockfd的读写功能。相当于调用shutdown两次：首先是SHUT_RD,然后是SHUT_WR。

keepAlive=1;
setsockopt(listenfd,SOL_SOCKET,SO_KEEPALIVE,(void *)&keepAlive,sizeof(keepAlive));

在server代码的socket()和bind()调用之间插入如下代码：
int opt=1;
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

#include <sys/socket.h>

ssize_t recv(int sockfd, void buf[.len], size_t len,
  int flags);
flags==MSG_PEEK 读数据不会删除缓冲区的数据 一般填0

#include <sys/socket.h>
ssize_t send(int sockfd,
  const void buf[.len], size_t len, int flags);//flags=1表示紧急数据 一般填0

#include <sys/socket.h>
ssize_t sendto(int sockfd,
  const void buf[.len], size_t len, int flags,
    const struct sockaddr * dest_addr, socklen_t addrlen);
dest_addr:目的地的地址信息
addrlen:结构体大小

#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void buf[restrict.len], size_t len,
  int flags,
  struct sockaddr * _Nullable restrict src_addr,
  socklen_t * _Nullable restrict addrlen);
src_addr：对方的地址信息
addrlen：结构体大小地址    

int socket(int domain,int type,int protocol);
参数：
    domain:AF_INET
    type:SOCK_DGRAM
    protocol:0

#include<stdio.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
int main(int argc,char *argv[]){
    //创建套接字
    int fd=socket(AF_INET,SOCK_DGRAM,0);
    //绑定
    struct sockaddr_in myaddr;
    myaddr.sin_family=AF_INET;
    myaddr.sin_port=htons(8000);
    myaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    int ret=bind(fd,(struct sockaddr*)&myaddr,sizeof(myaddr));
    if(ret<0){
        perror("bind");
        return 0;
    }
    //读写
    char buf[1500]="";
    struct sockaddr_in cliaddr;
    socklen_t len=sizeof(cliaddr);
    while(1){
        int n=recvfrom(fd,buf,sizeof(buf),0,(struct sockaddr*)&cliaddr,&len);
        if(n<0){
            perror("");
            break;
        }
        else{
            printf("%s\n",buf);
            sendto(fd,buf,n,0,(struct sockaddr*)&cliaddr,len);
        }
    }
    //关闭
    close(fd);
}

#include<stdio.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>
int main(int argc,char *argv[]){
    //创建套接字
    int fd=socket(AF_INET,SOCK_DGRAM,0);
    //绑定
    struct sockaddr_in myaddr;
    myaddr.sin_family=AF_INET;
    myaddr.sin_port=htons(9000);
    myaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    int ret=bind(fd,(struct sockaddr*)&myaddr,sizeof(myaddr));
    if(ret<0){
        perror("bind");
        return 0;
    }
    //读写
    char buf[1500]="";
    struct sockaddr_in dstaddr;
    dstaddr.sin_family=AF_INET;
    dstaddr.sin_port=htons(8000);
    dstaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    int n=0;
    while(1){
        n=read(STDIN_FILENO,buf,sizeof(buf));
        sendto(fd,buf,n,0,(struct sockaddr*)&dstaddr,sizeof(dstaddr));
        memset(buf,0,sizeof(buf));
        int n=recvfrom(fd,buf,sizeof(buf),0,NULL,NULL);
        if(n<0){
            perror("");
            break;
        }
        else{
            printf("%s\n",buf);
        }
    }
    //关闭
    close(fd);
}

int socket(int domain,int type,int protocol);
参数：
    domain:AF_UNIX
    type:SOCK_STREAM
    protocol:0

#include <sys/socket.h>

int bind(int sockfd,
  const struct sockaddr * addr,
    socklen_t addrlen);
参数:
	sockfd：本地套接字
    addr：本地套接字结构体地址
struct sockaddr_un {
  sa_family_t sun_family; /* AF_UNIX */
  char sun_path[108]; /* Pathname */
};   
	addrlen:sockaddr_un大小

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr * _Nullable restrict addr,
  socklen_t * _Nullable restrict addrlen);
addr:struct sockaddr_un结构体来接

#include<stdio.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/un.h>
int main(int argc,char *argv[]){
    //删除文件，文件如果先前存在会通信不了
    unlink("sock.s");
    //创建unix流式套接
    int lfd=socket(AF_UNIX,SOCK_STREAM,0);
    //绑定
    struct sockaddr_un myaddr;
    myaddr.sun_family=AF_UNIX;
    strcpy(myaddr.sun_path,"sock.s");

    bind(lfd,(struct sockaddr*)&myaddr,sizeof(myaddr));
    //监听
    listen(lfd,128);
    //提取
    struct sockaddr_un cliaddr;
    socklen_t len=sizeof(cliaddr);
    int cfd=accept(lfd,(struct sockaddr*)&cliaddr,&len);
    printf("new client file=%s\n",cliaddr.sun_path);
    //读写
    char buf[1500]="";
    while(1){
        int n=recv(cfd,buf,sizeof(buf),0);
        if(n<=0){
            break;
        }else{
            printf("%s\n",buf);
            send(cfd,buf,n,0);
        }
    }
    close(cfd);
    close(lfd);
}

#include<stdio.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main(int argc,char *argv[]){
    unlink("sock.c");
    //创建unix流式套接字
    int cfd=socket(AF_UNIX,SOCK_STREAM,0);
    //如果不绑定就会隐式绑定
    struct sockaddr_un myaddr;
    myaddr.sun_family=AF_UNIX;
    strcpy(myaddr.sun_path,"sock.c");
    if(bind(cfd,(struct sockaddr*)&myaddr,sizeof(myaddr))<0){
        perror("");
        return 0;
    }    
    //连接
    struct sockaddr_un seraddr;
    seraddr.sun_family=AF_UNIX;
    strcpy(seraddr.sun_path,"sock.s");
    connect(cfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    //读写
    char buf[1500]="";
    while(1){
        char buf[1500]="";
        int n=read(STDIN_FILENO,buf,sizeof(buf));
        send(cfd,buf,n,0);
        memset(buf,0,sizeof(buf));
        n=recv(cfd,buf,sizeof(buf),0);
        if(n<=0){
            break;
        }
        else{
            printf("%s\n",buf);
        }
    }
    //关闭
    close(cfd);
    return 0;
}

#include<arpa/inet.h>

uint32_t htonl(uint32_t hostlong);//主机字节序转网络字节序（4个字节）转ip
uint16_t htons(uint16_t hostshort);//主机字节序转网络字节序（2个字节）转port
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

#include<arpa/inet.h>
#include<stdio.h>
int main(int argc,char *argv[]){
    char buf[4]={192,168,1,2};
    int num=*(int *)buf;
    int sum=htonl(num);
    unsigned char *p=&sum;
    printf("%d %d %d %d\n",*p,*(p+1),*(p+2),*(p+3));

    unsigned short a=0x0102;
    unsigned short b=htons(a);
    printf("%x\n",b);
    return 0;
}

#include<arpa/inet.h>

int inet_pton(int af,const char *src,void *dst);
功能：将点分十进制串转成32位网络大端的数据
参数：af:
		AF_INET IPV4
        AF_INET6 IPV6
   	 src：点分十进制串的首地址
   	 dst:32位网络数据的首地址
返回值：
     成功：返回1
     失败：返回0
const char *inet_ntop(int af,const void *src,char *dst,socklen_t size);
功能：将32位大端的网络数据转成点分十进制串
参数：af:
		AF_INET IPV4
        AF_INET6 IPV6
   	 src：32位网络数据的首地址
   	 dst: 点分十进制串的首地址
     size:存储点分制串数组的大小 通常写16
返回值：
     存储点分制串数组的首地址。
支持IPV4和IPV6。

#include<stdio.h>
#include<arpa/inet.h>

int main(int argc,char *argv[]){
    char buf[]="192.168.1.4";
    unsigned int num=0;
    inet_pton(AF_INET,buf,&num);
    unsigned char *p=(unsigned char *)&num;
    printf("%d %d %d %d\n",*p,*(p+1),*(p+2),*(p+3));
    char ip[16]="";
    inet_ntop(AF_INET,&num,ip,16);
    printf("%s\n",ip);
    return 0;
}

struct sockaddr_in {
  sa_family_t sin_family; /* address family: AF_INET */ 对应的协议（ipv4）
  in_port_t sin_port; /* port in network byte order */ 端口
  struct in_addr sin_addr; /* internet address */ ip地址
};

/* Internet address */
struct in_addr {
  uint32_t s_addr; /* address in network byte order */ ip地址
};

struct sockaddr{
    sa_family_t sa_family; /* address family,AF_xxx*/
    char sa_data[14]; /*14 bytes of protocol address*/
};

#include <sys/socket.h>
int socket(int domain,int type,int protocol);
功能：创建套接字
参数：domain:AF_INET
     type:SOCK_STREAM 流式套接字 用于TCP通信
     protocol:0
返回值：
     成功：返回文件描述符
     失败：返回-1

#include <sys/socket.h>

int connect(int sockfd,
  const struct sockaddr * addr,
    socklen_t addrlen);
功能：连接服务器
参数：
    sockfd:socket套接字
    addr:ipv4套接字结构体地址
    addrlen:ipv4套接字结构体的长度

#include<arpa/inet.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<unistd.h>
int main(int argc,char *argv[]){
    //创建套接字
    int sock_fd;
    sock_fd=socket(AF_INET,SOCK_STREAM,0);
    if(sock_fd==-1){
        printf("连接失败");
    }else{
        printf("连接成功");
    }
    //连接服务器
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(8000);
    inet_pton(AF_INET,"127.0.0.1",&addr.sin_addr.s_addr);  
    connect(sock_fd,(struct sockaddr *)&addr,sizeof(addr));
    //读写数据
    char buf[1024]="";
    while(1){
        int n=read(STDIN_FILENO,buf,sizeof(buf));
        write(sock_fd,buf,n);//发送数据给服务器
        n=read(sock_fd,buf,sizeof(buf));
        write(STDOUT_FILENO,buf,n);

    }
    //关闭
    close(sock_fd);
    return 0;
}

#include <sys/socket.h>

int bind(int sockfd,
  const struct sockaddr * addr,
    socklen_t addrlen);
功能：给套接字绑定固定的端口和ip
参数：
    sockfd:套接字
    addr:ipv4套接字结构体地址
    addrlen:ipv4结构体的大小
返回值：
    成功：返回0
    失败：返回-1

#include <sys/socket.h>

int listen(int sockfd, int backlog);
功能：
    监听套接字
参数：
    sockfd:套接字
    backlog:已完成连接队列和未完成连接队列之和的最大值 一般写128

#include <sys/socket.h>

int accept(int sockfd, struct sockaddr * _Nullable restrict addr,
  socklen_t * _Nullable restrict addrlen);
功能：
    从已完成连接队列提取新的连接，如果没有新的连接，accept会阻塞。
参数：
    sockfd:套接字
    addr:获取的客户端的ip和端口信息 ipv4套接字结构体
    addrlen:ipv4套接字结构体的大小的地址
返回值：
    新的已连接套接字的文件描述符

#include<stdio.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<unistd.h>

int main(int argc,char *argv[]){
    //创建套接字
    int lfd=socket(AF_INET,SOCK_STREAM,0);
    //绑定
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(8000);
    //addr.sin_addr.s_addr=INADDR_ANY;//绑定的是通配地址，当前主机的所有ip
    inet_pton(AF_INET,"127.0.0.1",&addr.sin_addr.s_addr);
    int ret=bind(lfd,(struct sockaddr *)&addr,sizeof(addr));
    if(ret<0){
        perror("bind");
        exit(0);
    }
    //监听
    listen(lfd,128);
    //提取
    struct sockaddr_in cliaddr;
    socklen_t len=sizeof(cliaddr);
    int cfd=accept(lfd,(struct sockaddr *)&cliaddr,&len);
    char ip[16]="";
    printf("new client ip=%s port=%d\n",inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,ip,16),ntohs(cliaddr.sin_port));
    //读写
    char buf[1024]="";
    while(1){
        bzero(buf,sizeof(buf));
        int n=read(STDIN_FILENO,buf,sizeof(buf));
        write(cfd,buf,n);
        int readn=read(cfd,buf,sizeof(buf));
        if(readn==0){
            printf("客户端关闭");
        }
        printf("%s\n",buf);
    }
    //关闭
    close(lfd);
    close(cfd);
    return 0;
}

#include <stdio.h>
#include<stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/wait.h>
#include "wrap.h"
void free_process(int sig){
    pid_t pid;
    while(1){
        pid=waitpid(-1,NULL,WNOHANG);
        if(pid<=0){//小于0 子进程全部退出 =0没有子进程退出
            break;
            printf("haha");
        }else{
            printf("child pid =%d",pid);
        }
    }
    
}
int main(int argc, char *argv[])
{
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set,SIGCHLD);
    sigprocmask(SIG_BLOCK,&set,NULL);
    // 创建套接字
    int lfd = tcp4bind(8000, NULL);
    // 监听
    Listen(lfd, 128);
    // 提取
    // 回射
    struct sockaddr_in cliaddr;
    socklen_t len = sizeof(cliaddr);
    while (1)
    {
        char ip[16] = "";
        // 提取连接
        int cfd = Accept(lfd, (struct sockaddr *)&cliaddr, &len);
        printf("new client ip=%s port=%d\n", inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, ip, 16), ntohs(cliaddr.sin_port));
        // fork创建子进程
        pid_t pid;
        pid = fork();
        if (pid < 0)
        {
            perror("fork:");
            exit(0);
        }
        else if (pid == 0)
        { // 子进程
            // 关闭lfd
            close(lfd);
            while (1)
            {
                char buf[1024] = "";
                int n = read(cfd, buf, sizeof(buf));
                if (n < 0)
                {
                    perror("read:");
                    close(cfd);
                    exit(0);
                }
                else if (n == 0)
                { // 对方关闭
                    printf("client close\n");
                    close(cfd);
                    exit(0);
                }
                else
                {
                    printf("%s\n", buf);
                    write(cfd, buf, n);
                }
            }
        }
        else
        { // 父进程
            close(cfd);
            // 回收
            //注册信号回调
            struct sigaction act;
            act.sa_flags=0;
            act.sa_handler=free_process;
            sigemptyset(&act.sa_mask);
            sigaction(SIGCHLD,&act,NULL);
            sigprocmask(SIG_UNBLOCK,&set,NULL);
        }
    }
    // 关闭
    return 0;
}

#include<stdio.h>
#include<pthread.h>
#include"wrap.h"
typedef struct c_info{
    int cfd;
    struct sockaddr_in cliaddr;
}CINFO;
void *client_fun(void *arg);
int main(int argc,char *argv[]){
    if(argc<2){
        printf("argc<2\n");
        return 0;
    }
    //如果使用pthread_join或pthread_detach()回收资源要具体的线程id,太繁琐，
    //所以在创建线程时赋予detach属性
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
    short port=atoi(argv[1]);
    int lfd=tcp4bind(port,NULL);//创建套接字 绑定
    Listen(lfd,128);
    struct sockaddr_in cliaddr;
    socklen_t len=sizeof(cliaddr);
    CINFO *info;
    while(1){
        int cfd=Accept(lfd,(struct sockaddr *)&cliaddr,&len);
        
        //printf("new client ip=%s port=%d\n",inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,buf,16),ntohs(cliaddr.sin_port));
        pthread_t pthid;
        //这里如果CINFO info来用是不可以的，在多线程环境下，可能info里面的信息被覆盖，就不是原来的信息，所以放在堆区。
        info=malloc(sizeof(CINFO));
        info->cfd=cfd;
        info->cliaddr=cliaddr;
        pthread_create(&pthid,NULL,client_fun,info);
    }

    return 0;
}
void *client_fun(void *arg){
    CINFO *info=(CINFO *)arg;
    char buf[16]="";
    printf("new client ip=%s port=%d\n",inet_ntop(AF_INET,&(info->cliaddr.sin_addr.s_addr),buf,16),ntohs(info->cliaddr.sin_port));
    while(1){
        char buf[1024]="";
        int count=0;
        count=read(info->cfd,buf,sizeof(buf));
        if(count<0){
            perror("read:");
            break;
        }else if(count==0){
            printf("client close\n");
            break;
        }else{
            printf("%s\n",buf);
            write(info->cfd,buf,count);
        }
    }
    close(info->cfd);
    free(info);
}

#include <sys/select.h>

typedef /* ... */ fd_set;

int select(int nfds, fd_set * _Nullable restrict readfds,
  fd_set * _Nullable restrict writefds,
  fd_set * _Nullable restrict exceptfds,
  struct timeval * _Nullable restrict timeout);
功能：监听多个文件描述符的属性变化（读，写，异常）
参数：nfds:最大文件描述符+1
    readfds:需要监听的读的文件描述符存放集合
    writefds:需要监听的写的文件描述符存放集合 NULL
    exceptfds:需要监听的异常的文件描述符存放集合 NULL
    timeout：多长时间监听一次 固定的时间，限时等待 NULL 永久监听
返回值：返回的是变化的文件描述符的个数，变化的文件描述符会在readfds保存，但是没有变化的文件描述符会被删掉。
struct timeval {
  time_t tv_sec; /* seconds */
  suseconds_t tv_usec; /* microseconds */
};
void FD_CLR(int fd, fd_set * set);//从集合删除指定文件描述符
int FD_ISSET(int fd, fd_set * set);//文件描述符是否在集合，在就返回1
void FD_SET(int fd, fd_set * set);//向集合添加文件描述符
void FD_ZERO(fd_set * set);//清空文件描述符集

#include<stdio.h>
#include<sys/select.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/time.h>
#define PORT 8888
int main(int argc,char *argv[]){
    //创建套接字，绑定
    int lfd=tcp4bind(PORT,NULL);
    //监听
    Listen(lfd,128);
    int maxfd=lfd;//最大的文件描述符
    fd_set oldset,rset;
    //清空集合
    FD_ZERO(&oldset);
    FD_ZERO(&rset);
    //将lfd添加到oldset集合中
    FD_SET(lfd,&oldset);
    while(1){
        rset=oldset;
        int n=select(maxfd+1,&rset,NULL,NULL,NULL);
        if(n<0){
            perror("select:");
            break;
        }else if(n==0){
            continue;
        }else{
            //监听到了文件描述符的变化
            //lfd 代表有新的连接到来
            if(FD_ISSET(lfd,&rset)){
                struct sockaddr_in cliaddr;
                socklen_t len=sizeof(cliaddr);
                char ip[16]="";
                //提取新的连接
                int cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&len);
                printf("new client ip=%s port=%d\n",inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,ip,16),ntohs(cliaddr.sin_port));
                //将cfd添加至oldset集合中，以下次监听
                FD_SET(cfd,&oldset);
                //更新maxfd
                if(cfd>maxfd){
                    maxfd=cfd;
                }
                //如果只有lfd变化，continue
                if(--n==0){
                    continue;
                }
            }
            //cfd  遍历lfd之后的文件描述符是否在rset集合中，如果在则cfd变化
            for(int i=lfd+1;i<=maxfd;i++){
                if(FD_ISSET(i,&rset)){
                    char buf[1500]="";
                    int ret=Read(i,buf,sizeof(buf));
                    if(ret<0){//出错，将cfd关闭，从oldset删除cfd;
                        perror("Read");
                        close(i);
                        FD_CLR(i,&oldset);
                        continue;
                    }else if(ret==0){
                        printf("client close\n");
                        close(i);
                        FD_CLR(i,&oldset);
                    }else{
                        printf("%s\n",buf);
                        Write(i,buf,ret);
                    }
                }
            }
        }
    }
}

#include <poll.h>
int poll(struct pollfd * fds, nfds_t nfds, int timeout);
功能：监听多个文件描述符的属性变化
参数:
	fds:监听的数组首元素地址
    nfds:数组有效元素的最大下标+1
    timeout:超时时间 -1是永久监听 >=0限时等待
数组元素：struct pollfd
struct pollfd {
  int fd; /* file descriptor */ 需要监听的文件描述符
  short events; /* requested events */ 需要监听的文件描述符什么事件 POLLIN 读事件 POLLOUT 写事件
  short revents; /* returned events */ 返回监听到的事件
};        

#include <sys/epoll.h>
int epoll_create(int size);
参数：
    size:监听的文件描述符上限，2.6版本之后写1即可会自动扩展
返回值：
    返回树的句柄

#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd,
  struct epoll_event * _Nullable event);
参数：
    epfd:树的句柄
    op:选项：EPOLL_CTL_ADD 上树 EPOLL_CTL_MOD 修改节点 EPOLL_CTL_DEL 下树
    fd:上树下树的文件描述符
    event:上树的节点
 struct epoll_event {
   uint32_t events; /* Epoll events */ 需要监听的事件 EPOLLIN　读事件　EPOLLOUT 写事件
   epoll_data_t data; /* User data variable */ 需要监听的文件描述符
 };

 union epoll_data {
   void * ptr;
   int fd;
   uint32_t u32;
   uint64_t u64;
 };

 typedef union epoll_data epoll_data_t;

#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event * events,
  int maxevents, int timeout);
功能：监听树上文件描述符的变化
参数：
	epfd:树的句柄
    events：接收变化节点的数组的首地址
    maxevents：数组元素的个数
    timeout：-1 永久监听 大于等于0限时等待
返回值：
    返回的是变化的文件描述符个数

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/epoll.h>
#include <sys/types.h> 
int main(int argc,char *argv[]){
    int fd[2];
    pipe(fd);
    //创建子进程
    pid_t pid;
    pid=fork();
    if(pid<0){
        perror("fork:");
        return 1;
    }else if(pid==0){
        close(fd[0]);
        char buf[5];
        char ch='a';
        while(1){
            sleep(3);
            memset(buf,ch++,sizeof(buf));
            write(fd[1],buf,5);
        }
    }else{
        close(fd[1]);
        //创建树
        int epfd=epoll_create(1);
        //上树
        struct epoll_event ev,evs[1];
        ev.data.fd=fd[0];
        ev.events=EPOLLIN;
        epoll_ctl(epfd,EPOLL_CTL_ADD,fd[0],&ev);
        //监听
        while(1){
            int n=epoll_wait(epfd,evs,1,-1);
            if(n==1){
                char buf[128]="";
                int ret=read(fd[0],buf,sizeof(buf));
                if(ret<=0){
                    close(fd[0]);
                    epoll_ctl(epfd,EPOLL_CTL_DEL,fd[0],&ev);
                    break;
                }else{
                    printf("%s\n",buf);
                }
            }
        }
    }
    return 0;
}

#include<stdio.h>
#include"wrap.h"
#include<sys/epoll.h>

int main(int argc,char *argv[]){
    //创建套接字 绑定
    int lfd=tcp4bind(8000,NULL);
    //监听
    Listen(lfd,128);
    //创建树
    int epfd=epoll_create(1);
    //将lfd上树
    struct epoll_event ev,evs[1024];
    ev.data.fd=lfd;
    ev.events=EPOLLIN;
    epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&ev);
    //while监听
    while(1){
        int nready=epoll_wait(epfd,evs,1024,-1);
        if(nready<0){
            perror("epoll_wait:");
            break;
        }else if(nready==0){
            continue;
        }else{
            for(int i=0;i<nready;i++){
                //判断lfd变化，并且是读事件变化
                if(evs[i].data.fd==lfd&&evs[i].events & EPOLLIN){
                    struct sockaddr_in cliaddr;
                    char ip[16]="";
                    socklen_t len=sizeof(cliaddr);
                    //提取新的连接
                    int cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&len);
                    printf("new client ip=%s port=%d\n",inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,ip,16),ntohs(cliaddr.sin_port));
                    //将cfd上树
                    ev.data.fd=cfd;
                    ev.events=EPOLLIN;
                    epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&ev);
                }else if(evs[i].events & EPOLLIN)//cfd变化,而且是读事件变化
                {
                    char buf[1024]="";
                    int n=read(evs[i].data.fd,buf,sizeof(buf));
                    if(n<0){
                        perror("read:");
                        epoll_ctl(epfd,EPOLL_CTL_DEL,evs[i].data.fd,&evs[i]);
                    }else if(n==0){//客户端关闭
                        printf("client close");
                        close(evs[i].data.fd);
                        epoll_ctl(epfd,EPOLL_CTL_DEL,evs[i].data.fd,&evs[i]);
                    }else{
                        printf("%s\n",buf);
                        write(evs[i].data.fd,buf,n);
                    }
                }
            }
        }
    }
    return 0;
}

ev.events=EPOLLIN | EPOLLET

#include <stdio.h>
#include "wrap.h"
#include <sys/epoll.h>
#include <sys/fcntl.h>
int main(int argc, char *argv[])
{
    // 创建套接字 绑定
    int lfd = tcp4bind(8000, NULL);
    // 监听
    Listen(lfd, 128);
    // 创建树
    int epfd = epoll_create(1);
    // 将lfd上树
    struct epoll_event ev, evs[1024];
    ev.data.fd = lfd;
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
    // while监听
    while (1)
    {
        int nready = epoll_wait(epfd, evs, 1024, -1);
        printf("epoll_wait .........................\n");
        if (nready < 0)
        {
            perror("epoll_wait:\n");
            break;
        }
        else if (nready == 0)
        {
            continue;
        }
        else
        {
            for (int i = 0; i < nready; i++)
            {
                // 判断lfd变化，并且是读事件变化
                if (evs[i].data.fd == lfd && evs[i].events & EPOLLIN)
                {
                    struct sockaddr_in cliaddr;
                    char ip[16] = "";
                    socklen_t len = sizeof(cliaddr);
                    // 提取新的连接
                    int cfd = Accept(lfd, (struct sockaddr *)&cliaddr, &len);
                    printf("new client ip=%s port=%d\n", inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, ip, 16), ntohs(cliaddr.sin_port));
                    // 设置cfd为非阻塞
                    int flags = fcntl(cfd, F_GETFL); // 获取cfd的标志位
                    flags |= O_NONBLOCK;
                    fcntl(cfd, F_SETFL, flags);
                    // 将cfd上树
                    ev.data.fd = cfd;
                    ev.events = EPOLLIN | EPOLLET;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
                }
                else if (evs[i].events & EPOLLIN) // cfd变化,而且是读事件变化
                {
                    while (1)
                    {   //使用循环读，因为cfd采用的边沿模式读，一次可能读不完需要循环读保证读完
                        //但是read循环读的话会产生阻塞，这个程序就无法监听了，所以设置cfd为非阻塞
                        char buf[4] = "";
                        //如果读一个缓冲区，缓冲区没有数据，如果是带阻塞，就阻塞等待
                        //如果是非阻塞，返回值就等于-1,并且会将errno的值置为EAGAIN
                        //所以在非阻塞这里就出现问题了，n<0,可能是出错或者没有数据，没有数据不必下树，退出循环读。出错下树
                        int n = read(evs[i].data.fd, buf, sizeof(buf));
                        if (n < 0)
                        {
                            //缓冲区读干净了，跳出读循环
                            if(errno==EAGAIN){
                                break;
                            }
                            //普通错误
                            perror("read:");
                            epoll_ctl(epfd, EPOLL_CTL_DEL, evs[i].data.fd, &evs[i]);
                            close(evs[i].data.fd);
                            break;
                        }
                        else if (n == 0)
                        { // 客户端关闭
                            printf("client close");
                            close(evs[i].data.fd);
                            epoll_ctl(epfd, EPOLL_CTL_DEL, evs[i].data.fd, &evs[i]);
                            break;
                        }
                        else
                        {
                            //这里为什么不用printf了呢，因为printf输出字符串时，会去找字符串结束的\0但是网络传输收到的是没有\0(需要主动方手动添加)
                            //没有\0,printf就会出错，但是使用write函数就不会
                            write(STDOUT_FILENO,buf,n);
                            write(evs[i].data.fd, buf, n);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

创建event_base根节点
struct event_base *event_base_new(void);
返回值就是event_base根节点，因为libevent底层默认使用epoll,所以定义了一个自己封装的节点
释放根节点
void event_base_free(struct event_base *);
循环监听
int event_base_dispatch(struct event_base *base);
相当于while(1){epoll_wait()}//循环监听
退出循环监听
int event_base_loopexit(struct event_base *base,const struct timeval*tv);//等待固定时间退出
int event_base_loopbreak(struct event_base *base);//立即退出

初始化上树节点
struct event*event_new(struct event_base *base,evutil_socket_t fd,
                       short events,event_callback_fn cb,void *arg);
参数：
    base:event_base根节点
    fd:上树的文件描述符
    events:监听的事件 EV_TIMEOUT 超时事件 EV_READ 读事件 EV_WRITE 写事件 EV_SIGNAL 信号事件 EV_PERSIST 周期性触发
   	cb:回调函数
       typedef void (*event_callback_fn)(evutil_socket_t fd,short events,void *arg);
返回值:初始化好的节点的地址        

节点上树
int event_add(struct event*ev,const struct timeval *timeout);
参数:
	ev:上树节点的地址
    timeout:NULL 永久监听 固定时间 限时等待

节点下树
int event_del(struct event *ev);
参数：
    ev:下树节点的地址

释放节点
void event_free(struct event *ev);

#include<stdio.h>
#include"wrap.h"
#include<event.h>
void cfdcb(int cfd,short event,void *arg){
    char buf[1500]="";
    int n=Read(cfd,buf,sizeof(buf));
    if(n<=0){
        perror("err or close");
       // event_del()
    }
    else{
        printf("%s\n",buf);
        Write(cfd,buf,n);
    }
}
void lfdcb(int lfd,short event,void *arg){
    struct event_base *base=(struct event_base *)arg;
    //提取新的cfd
    int cfd=Accept(lfd,NULL,NULL);
    //cfd初始化
    struct event *ev=event_new(base,cfd,EV_READ|EV_PERSIST,cfdcb,NULL);
    //cfd上树
    event_add(ev,NULL);
}
int main(){
    //创建套接字
    //邦定
    int lfd=tcp4bind(8000,NULL);
    //监听
    Listen(lfd,128);
    //创建event_base根节点
    struct event_base *base=event_base_new();
    //初始化lfd上树节点
    struct event *ev=event_new(base,lfd,EV_READ|EV_PERSIST,lfdcb,base);
    //上树
    event_add(ev,NULL);
    //监听
    event_base_dispatch(base);//阻塞
    //收尾
    event_free(ev);
    close(lfd);
    return 0;
}

创建新的节点
struct bufferevent *bufferevent_socket_new(
    struct event_base *base,
    evutil_socket_t fd,
    int options
);
参数：
    base:event_base 根节点
    fd:要初始化上树的文件描述符
    options:BEV_OPT_CLOSE_ON_FREE	在 bufferevent_free() 时自动关闭 socket（常用）
        	BEV_OPT_THREADSAFE	让 bufferevent 在多线程中线程安全
返回值：新建节点的地址

设置节点的回调
void bufferevent_setcb(
    struct bufferevent *bev,
    bufferevent_data_cb readcb,
    bufferevent_data_cb writecb,
    bufferevent_event_cb eventcb,
    void *cbarg
);
参数:
	bev:新建的节点的地址
    readcb:读回调
    writecb:写回调
    eventcb：异常回调
    cbarg：传给回调函数的参数
    回调函数：
    typedef void (*bufferevent_data_cb)(struct bufferevent *bev, void *ctx);//读写回调
	typedef void (*bufferevent_event_cb)(struct bufferevent *bev, short events, void *ctx);//事件回调
	事件回调 events会写明触发回调的原因

让事件使能
int bufferevent_enable(struct bufferevent *bev, short events);
int bufferevent_disable(struct bufferevent *bev, short events);
参数：
    bev:新建的节点的地址
    events:使生效或使失效的事件 EV_READ EV_WRITE

发送数据
将数据写入 bufferevent 的输出缓冲区，异步发送（不会立即写到 socket 上）发送后会触发回调
int bufferevent_write(struct bufferevent *bev, const void *data, size_t size);

接受数据
size_t bufferevent_read(struct bufferevent *bev, void *data, size_t size);
将从 bev 的读缓冲区中读取最多 size 字节的数据，复制到 data。同时将读到的数据从bufferevent的读缓冲区清除
返回实际读取的字节数。    

连接侦听器
创建套接字 绑定 监听 提取
struct evconnlistener *evconnlistener_new_bind(
    struct event_base *base,
    evconnlistener_cb cb,
    void *ctx,
    unsigned flags,
    int backlog,
    const struct sockaddr *sa,
    int socklen
);
参数：
    base：根节点
    cb:提取套接字cfd（连接到来）调用的回调
        回调函数：
        typedef void evconnlistener_cb(
            struct evconnlistener *listener,
            evutil_socket_t fd,
            struct sockaddr *addr,
            int socklen,
            void *ctx
        );
		参数：
            listener：连接侦听器的地址
            fd：提取后的新文件描述符cfd
            addr:客户端的地址信息
            socklen：addr的大小
            ctx：evconnlistener_new_bind传给回调函数的参数
    ctx:传给回调函数的参数
    flags:
        LEV_OPT_CLOSE_ON_FREE	关闭时自动释放（推荐）
        LEV_OPT_REUSEABLE	设置 SO_REUSEADDR 端口复用（推荐）
        LEV_OPT_THREADSAFE	线程安全
        LEV_OPT_LEAVE_SOCKETS_BLOCKING  文件描述符为阻塞的
    backlog:-1 监听队列长度自动填充
    sa：绑定的地址信息
    socklen：sa的大小     
返回值：连接侦听器的地址

这个是用来写tcp客户端的
创建套接字 连接服务器
但是要先有节点
struct bufferevent *bufferevent_socket_new(
    struct event_base *base,
    evutil_socket_t fd,
    int options
);这里fd为-1.    
int bufferevent_socket_connect(
    struct bufferevent *bev,
    const struct sockaddr *address,
    int addrlen
);
参数：
    bev:新建的节点
    address:服务器的地址信息
    addrlen：address长度

/*
  This example program provides a trivial server program that listens for TCP
  connections on port 9995.  When they arrive, it writes a short message to
  each client connection, and closes each connection once it is flushed.

  Where possible, it exits cleanly in response to a SIGINT (ctrl-c).
*/


#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#ifndef _WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
#  include <arpa/inet.h>
# endif
#include <sys/socket.h>
#endif

#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <event2/event.h>

static const char MESSAGE[] = "Hello, World!\n";

static const int PORT = 9995;

static void listener_cb(struct evconnlistener *, evutil_socket_t,
    struct sockaddr *, int socklen, void *);
static void conn_writecb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void conn_readcb(struct bufferevent *, void *);
static void signal_cb(evutil_socket_t, short, void *);

int
main(int argc, char **argv)
{
	struct event_base *base;//创建根节点
	struct evconnlistener *listener;
	struct event *signal_event;

	struct sockaddr_in sin = {0};
#ifdef _WIN32
	WSADATA wsa_data;
	WSAStartup(0x0201, &wsa_data);
#endif

	base = event_base_new();
	if (!base) {
		fprintf(stderr, "Could not initialize libevent!\n");
		return 1;
	}

	sin.sin_family = AF_INET;
	sin.sin_port = htons(PORT);

	//创建连接侦听器
	listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
	    (struct sockaddr*)&sin,
	    sizeof(sin));

	if (!listener) {
		fprintf(stderr, "Could not create a listener!\n");
		return 1;
	}
	//创建信号触发的节点
	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
	//将信号节点上树
	if (!signal_event || event_add(signal_event, NULL)<0) {
		fprintf(stderr, "Could not create/add a signal event!\n");
		return 1;
	}

	event_base_dispatch(base);//循环监听

	evconnlistener_free(listener);//释放连接侦听器
	event_free(signal_event);//释放信号节点
	event_base_free(base);//释放event_base根节点

	printf("done\n");
	return 0;
}

static void
listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
    struct sockaddr *sa, int socklen, void *user_data)
{
	struct event_base *base = user_data;
	struct bufferevent *bev;
	//将fd上树
	//新建一个bufferevent节点
	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
	if (!bev) {
		fprintf(stderr, "Error constructing bufferevent!");
		event_base_loopbreak(base);
		return;
	}
	//设置回调
	bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, NULL);
	bufferevent_enable(bev, EV_WRITE | EV_READ);//设置读写事件使能
	//bufferevent_disable(bev, EV_READ);//设置读事件非使能

	//bufferevent_write(bev, MESSAGE, strlen(MESSAGE));//给cfd发送消息 hello world
}
static void
conn_readcb(struct bufferevent *bev, void *user_data){
	char buf[1500]="";
	int n=bufferevent_read(bev,buf,sizeof(buf));
	//不用担心出错，出错会触发事件回调
	printf("%s\n",buf);
	bufferevent_write(bev, buf,n);//给cfd发送消息
}
static void
conn_writecb(struct bufferevent *bev, void *user_data)
{
	struct evbuffer *output = bufferevent_get_output(bev);//获取缓冲区类型
	if (evbuffer_get_length(output) == 0) {//判断==0则应用层缓冲区为空，发送完毕
		//printf("flushed answer\n");
		//bufferevent_free(bev);//释放节点 自动关闭连接
	}
}

static void
conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
	if (events & BEV_EVENT_EOF) {
		printf("Connection closed.\n");
	} else if (events & BEV_EVENT_ERROR) {
		printf("Got an error on the connection: %s\n",
		    strerror(errno));/*XXX win32*/
	}
	/* None of the other events can happen here, since we haven't enabled
	 * timeouts */
	bufferevent_free(bev);
}

static void
signal_cb(evutil_socket_t sig, short events, void *user_data)
{
	struct event_base *base = user_data;
	struct timeval delay = { 2, 0 };

	printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");

	event_base_loopexit(base, &delay);//退出循环监听
}