C语言之网络编程（必背知识点）

三、UDP编程

1.通信流程

udp流程：(类似发短信)
server:
创建数据报套接字（socket(,SOCK_DGRAM,)）----->有手机
绑定网络信息（bind()）---------------------->绑定号码（发短信知道发给谁）
接收信息（recvfrom()）--------------------->接收短信
关闭套接字（close()）----------------------->接收完毕

client:
创建数据报套接字(socket())----------------------->有手机
指定服务器的网络信息------------------------------>有对方号码
发送信息（sendto()）---------------------------->发送短信
关闭套接字（close()）--------------------------->发送完

2.函数接口

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
					struct sockaddr *src_addr, socklen_t*addrlen);
功能：接收数据
参数：
	sockfd：套接字描述符
	buf:接收缓存区的首地址
	len：接收缓存区的大小
	flags：0
	src_addr:发送端的网络信息结构体的指针
	addrlen：发送端的网络信息结构体的大小的指针
  
返回值：
	成功接收的字节个数
	失败：-1
	0:客户端退出

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                  const struct sockaddr *dest_addr, socklen_t addrlen);
功能：发送数据

参数：
	sockfd：套接字描述符
	buf:发送缓存区的首地址
	len：发送缓存区的大小
	flags：0
	src_addr:接收端的网络信息结构体的指针
	addrlen：接收端的网络信息结构体的大小

返回值： 
	成功发送的字节个数
	失败：-1

3.实现

 server.c代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    //1.创建数据报套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //填充结构体
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    //2绑定
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    //3.循环收消息
    char buf[64];
    while (1)
    {
        if (recvfrom(sockfd, buf, sizeof(buf), 0,
                     (struct sockaddr *)&caddr, &len) < 0)
        {
            perror("recv err.");
            return -1;
        }
        printf("%s %d:%s\n", inet_ntoa(caddr.sin_addr),
               ntohs(caddr.sin_port), buf);
    }
    close(sockfd);
    return 0;
}

client.c代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    //1.创建数据报套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //填充结构体
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr(argv[1]);

    socklen_t len = sizeof(caddr);

    //3.循环发消息
    char buf[64];
    while (1)
    {
        fgets(buf,sizeof(buf),stdin);
        if(buf[strlen(buf)-1]=='\n')
           buf[strlen(buf)-1]='\0';
        sendto(sockfd,buf,sizeof(buf),0,\
        (struct sockaddr *)&saddr,sizeof(saddr));
    }
    close(sockfd);
    return 0;
}

4.  练习：实现如客户端发送"hello"给服务器端，服务器接着给客户端回，"recv:hello!!!!!"。

注意：
1、对于TCP是先运行服务器，客户端才能运行。
2、对于UDP来说，服务器和客户端运行顺序没有先后，因为是无连接，所以服务器和客户端谁先开始，没有关系，
3、一个服务器可以同时连接多个客户端。想知道是哪个客户端登录，可以在服务器代码里面打印IP和端口号。
4、UDP，客户端当使用send的时候，上面需要加connect，这个connect不是代表连接的作用，而是指定客户端即将要发送给谁数据。这样就不需要使用sendto而用send就可以。
5、在TCP里面，也可以使用recvfrom和sendto，使用的时候将后面的两个参数都写为NULL就OK。

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    //saddr.sin_addr.s_addr = inet_addr(argv[1]);
    // saddr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY   0.0.0.0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    while (1)
    {
        // 4.阻塞等待客户端连接accept .返回通信文件描述符
        int acceptfd = accept(sockfd,(struct sockaddr *)&caddr,&len);
        if (acceptfd < 0)
        {
            perror("accept err.");
            return -1;
        }
        printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
        printf("client:ip=%s port=%d\n",inet_ntoa(caddr.sin_addr),\
        ntohs(caddr.sin_port));//inet_ntoa
        // 5.收发消息
        char buf[64];
        int recvbyte;
        while (1)
        {
            recvbyte = recv(acceptfd, buf, sizeof(buf), MSG_DONTWAIT);
            if (recvbyte < 0)
            {
                perror("recv err.");
               // return -1;
            }
            else if (recvbyte == 0)
            {
                printf("client exit.\n");
                break;
            }
            else
            {
                printf("buf:%s\n", buf);
            }
        }
        // 6.关闭套接字
       close(acceptfd);
    }
    close(sockfd);
    return 0;
}

5.项目-网络聊天室

5.1 项目要求

利用UDP协议，实现一套聊天室软件。服务器端记录客户端的地址，客户端发送消息后，服务器群发给各个客户端软件。

问题思考

• 客户端会不会知道其它客户端地址？

UDP客户端不会直接互连，所以不会获知其它客户端地址，所有客户端地址存储在服务器端。

• 有几种消息类型？
• 登录：服务器存储新的客户端的地址。把某个客户端登录的消息发给其它客户端。
• 聊天：服务器只需要把某个客户端的聊天消息转发给所有其它客户端。
• 退出：服务器删除退出客户端的地址，并把退出消息发送给其它客户端。
• 服务器如何存储客户端的地址？

数据结构可以选择线性数据结构

链表节点结构体：
struct node{
	struct sockaddr_in addr;//data   memcmp
	struct node *next;
};

消息对应的结构体(同一个协议)
typedef struct msg_t
{
    int type;//'L' C  Q    enum un{login,chat,quit};
    char name[32];//用户名
    char text[128];//消息正文
}MSG_t;

int memcmp(void *s1,void *s2,int size)

• 客户端如何同时处理发送和接收？

客户端不仅需要读取服务器消息，而且需要发送消息。读取需要调用recvfrom，发送需要先调用gets，两个都是阻塞函数。所以必须使用多任务来同时处理，可以使用多进程或者多线程来处理。

5.2 程序流程图

服务器端

客户端

客户端

server.c代码

#include<stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>
#include<stdlib.h>
#include <sys/wait.h>
#include<dirent.h>
#include<sys/stat.h>
#include<signal.h>
#include <pthread.h>

struct sockaddr_in serveraddr,caddr;
enum type_t//枚举
{
    Login,
    Chat,
    Quit,
};
typedef struct MSG
{
    char type;//L C Q
    char name[32];//
    char text[128];//
}msg_t;

typedef struct NODE//链表
{
    struct sockaddr_in caddr;
    struct NODE *next;
}node_t;

node_t *create_node(void)//建头节点
{
    node_t *p=(node_t *)malloc(sizeof(node_t));
    if(p==NULL)
    {
        perror("malloc err");
        return NULL;
    }
    p->next=NULL;
    return p;

}
void do_login(int ,msg_t ,node_t *,struct sockaddr_in);//登录的函数
void do_chat(int ,msg_t ,node_t *,struct sockaddr_in);//群聊的函数
void do_quit(int ,msg_t ,node_t *,struct sockaddr_in);//退出函数
int main(int argc, char const *argv[])
{
    if(argc !=3)
    {
        printf("Usage:./a.out <port>\n");
        return -1;
    }
    //创建UDP套接字
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd<0)
    {
        perror("socket err");
        exit(-1);
    }
    //填充服务器网络信息结构体
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr=inet_addr(argv[1]);
    socklen_t len = sizeof(caddr);
    //定义保存客户端网络信息的结构体
    //绑定套接字和服务器网络信息的结构体
    bind(sockfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
    printf("bind ok!\n");
    msg_t msg;
    node_t *p=create_node();
    while(1)
   {
        if(recvfrom(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&caddr,&len)<0)
        {
            perror("recvfrom err");
            return -1;
        }
            if(msg.type==Login)
        {
            strcpy(msg.text,"以上线");
            printf("ip:%s pord:%d name:%s\n",inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port),msg.name);
            printf("状态:%s\n",msg.text);
            do_login(sockfd,msg,p,caddr);
        }
            else if(msg.type==Chat)
        {
            do_chat(sockfd,msg,p,caddr);    
        }
        else if(msg.type==Quit)
        {
            strcpy(msg.text,"以下线");
            printf("ip:%s pord:%d name:%s\n",inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port),msg.name);
            printf("状态:%s\n",msg.text);
            do_quit(sockfd,msg,p,caddr);        
        }
    }
    close(sockfd);
    return 0;
}
//登录的函数
//功能：
//1》将新登录的用户转发给所有已经登录的用户（遍历链表发送谁登录的消息）
//2》创建新节点来保存新登录用户的信息，链接到链表尾就可以
void do_login(int sockfd,msg_t msg,node_t *p,struct sockaddr_in caddr)
{
    
    sprintf(msg.text,"%s 以上线",msg.name);
    while(p->next != NULL)
    {
        p= p->next;
        sendto(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&(p->caddr),sizeof(p->caddr));
        //printf("%s\n",msg.text);
    }
    node_t *new=(node_t *)malloc(sizeof(node_t));
    //初始化
    new->caddr=caddr;
    new->next=NULL;
    //链接到链表尾
    p->next=new;
    return;
}
//群聊的函数
//功能：将客户端发来的聊天内容转发给所有已登录的用户，除了发送聊天内容的用户以外
void do_chat(int sockfd,msg_t msg,node_t *p,struct sockaddr_in caddr)
{
    //遍历链表
    while(p->next != NULL)
    {
        p=p->next;
        
        if(memcmp(&(p->caddr),&caddr,sizeof(caddr)) != 0)
        {
           sendto(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&(p->caddr),sizeof(p->caddr));
        }
    }
    return;
}
//退出函数
//功能：
//1》将谁退出的消息转发给i所有用户
//2》将链表中保存这个推出的用户信息的节点删除
void do_quit(int sockfd,msg_t msg,node_t *p,struct sockaddr_in caddr)
{
    sprintf(msg.text,"%s 以下线",msg.name);
    while(p->next != NULL)
    {
        if((memcmp(&(p->next->caddr),&caddr,sizeof(caddr)))==0)
        { 
            node_t *dele=NULL;
            dele = p->next;
            p->next=dele->next;
            free(dele);
            dele=NULL;
        }
      else
      {
          p=p->next;
          sendto(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&(p->caddr),sizeof(p->caddr));
      }  
    }
    return;
}

client.c代码

#include<stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>
#include<stdlib.h>
#include <sys/wait.h>
#include<dirent.h>
#include<sys/stat.h>

enum type_t
{
    Login,
    Chat,
    Quit,
};
typedef struct 
{
    char type;//L C Q
    char name[32];//
    char text[128];//
}msg_t;

int main(int argc, char const *argv[])
{
     if(argc !=3)
    {
        printf("Usage ./a.out <ip> <port>\n");
        return -1;
    }
   
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd<0)
    {
        perror("socket err");
        exit(-1);
    }
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr=inet_addr(argv[1]);
    socklen_t len = sizeof(serveraddr);
    msg_t msg;
    //先执行登录操作 
    printf("请登录:\n");
    msg.type=Login;
    printf("请输入用户名:");
    fgets(msg.name,32,stdin);
    if(msg.name[strlen(msg.name)-1]=='\n')
       msg.name[strlen(msg.name)-1]='\0';
    //发送登录消息
    if(sendto(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&serveraddr,len)<0)
       {
         perror("sendto err");
         exit(-1);
       }
    pid_t pid=fork();
     if(pid<0)
    {
        perror("fork err");
        exit(-1);
    }
    else if(pid==0)
    {
        while(1)
        {
            if(recvfrom(sockfd,&msg,sizeof(msg),0,NULL,NULL)<0)
            {
                perror("recvfrom err");
                return -1;
            }
            printf("[%s]:%s\n",msg.name,msg.text);
        } 
    }    
    else 
    {
        while(1)
        {
            fgets(msg.text,sizeof(msg.text),stdin);
            if(msg.text[strlen(msg.text)-1]=='\n')
               msg.text[strlen(msg.text)-1]='\0';
            if(strcmp(msg.text,"quit")==0)
            {
                msg.type=Quit; 
                sendto(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&serveraddr,len);
                kill(pid,SIGKILL);
                wait(NULL);
                exit(-1);
            }else
        {
            msg.type=Chat;
        }
        //发送消息
        sendto(sockfd,&msg,sizeof(msg),0,(struct sockaddr *)&serveraddr,len);
        }
    }
    close(sockfd);
    return 0;
}

四、linux下I/O模及特点

1.阻塞式IO  

 特点：最简单、最常用；效率低

阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。
缺省情况下（及系统默认状态），套接字建立后所处于的模式就是阻塞I/O 模式。
学习的读写函数在调用过程中会发生阻塞相关函数如下：
•读操作中的read、recv、recvfrom
     读阻塞--》需要读缓冲区中有数据可读，读阻塞解除
•写操作中的write、send
     写阻塞--》阻塞情况比较少，主要发生在写入的缓冲区的大小小于要写入的数据量的情况下，写操作不进行任何拷贝工作，将发生阻塞，一旦缓冲区有足够的空间，内核将唤醒进程，将数据从用户缓冲区拷贝到相应的发送数据缓冲区。 
注意：sendto没有写阻塞
 1）无sendto函数的原因：
sendto不是阻塞函数，本身udp通信不是面向链接的，udp无发送缓冲区，即sendto没有发送缓冲区，send是有发送缓存区的，即sendto不是阻塞函数。
 2）UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在缓冲区满的情况，在UDP套接字上进行写操作永远不会阻塞。
•其他操作：accept、connect

 2. 非阻塞式IO 

     特点：可以处理多路IO；需要轮询，浪费CPU资源

•当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”
•当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。
•应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
•这种模式使用中不普遍。

2.１ 通过函数自带的参数设置非阻塞

２.2 通过设置文件描述符属性设置非阻塞（fcntl）

int fcntl(int fd, int cmd, ... /* arg */ );
功能：设置文件描述符属性
参数：
   fd:文件描述符
   cmd：设置方式 - 功能选择
        F_GETFL  获取文件描述符的状态信息     第三个参数化忽略
        F_SETFL  设置文件描述符的状态信息     通过第三个参数设置
                O_NONBLOCK  非阻塞
                O_ASYNC      异步
                O_SYNC      同步
  arg:设置的值  in
返回值：
      特殊选择返回特殊值 - F_GETFL  返回的状态值(int)
        其他：成功0  失败-1，更新errno
        
使用：0为例
  0-原本：阻塞、读权限  修改或添加非阻塞
  int flags=fcntl(0,F_GETFL);//1.获取文件描述符原有的属性信息
  flags = flags | O_NONBLOCK;//2.修改添加权限
  fcntl(0,F_SETFL,flags);    //3.将修改好的权限设置回去

#include 
#include 
#include 
#include 

int main(int argc, char const *argv[])
{
    //设置0文件描述符的非阻塞
    //1.获取原属性
    int flags;
    flags = fcntl(0, F_GETFL);
    //2.修改属性
    flags = flags | O_NONBLOCK;
    //3.设置回去
    fcntl(0, F_SETFL, flags);

    char buf[32];
    while (1)
    {
        sleep(1);
        if (fgets(buf, sizeof(buf), stdin) == NULL)
        {
            perror("fgets err.");
        }
        printf("buf:%s\n", buf);
    }
    return 0;
}

3.信号驱动IO (异步IO模型 非重点)

特点：异步通知模式，需要底层驱动的支持

•  通过信号方式，当内核检测到设备数据后，会主动给应用发送信号SIGIO。
• 应用程序收到信号后做异步处理即可。
• 应用程序需要把自己的进程号告诉内核，并打开异步通知机制。

标准模板

//将APP进程号告诉驱动程序
fcntl(fd, F_SETOWN, getpid());

//使能异步通知
int flag;
flag = fcntl(fd, F_GETFL);
flag |= O_ASYNC;  //也可以用FASYNC标志
fcntl(fd, F_SETFL, flag);

signal(SIGIO, handler);

示例：用非阻塞方式监听鼠标的数据（操作鼠标需要增加sudo权限

查看自己使用的鼠标：/dev/input    

 检查鼠标设备：sudo cat /dev/input/mouse0

#include 
#include 
#include 
#include 
#include 

int fd;
void handler(int sig)
{
    char buf[32] = "";
    int ret = read(fd, buf, sizeof(buf) - 1);
    buf[ret] = '\0';
    printf("mouse:%s\n", buf);
}

int main(int argc, char const *argv[])
{
    fd = open("/dev/input/mouse0", O_RDONLY);
    if (fd < 0)
    {
        perror("open mouse err.");
        return -1;
    }
    //1.将文件描述符、进程ID告诉底层驱动
    fcntl(fd, F_SETOWN, getpid());

    //2.设置fd文件描述符的异步通知属性
    int flags;
    flags = fcntl(fd, F_GETFL);
    flags |= O_ASYNC;
    fcntl(fd, F_SETFL, flags);
    //3.捕捉信号
    signal(SIGIO, handler);
    while (1)
    {
        sleep(1);
        printf("hello world.\n");
    }
    return 0;
}

前三种使用场景假设总结：

假设妈妈有一个孩子，孩子在房间里睡觉，妈妈需要及时获知孩子是否醒了，如何做？

1. 进到房间陪着孩子一起睡觉，孩子醒了会吵醒妈妈：不累，但是不能干别的了
2. 时不时进房间看一下：简单，空闲时间还能干点别的，但是很累
3. 妈妈在客厅干活，小孩醒了他会自己走出房门告诉妈妈：互不耽误

4. IO多路复用

4.1 IO多路复用场景假设

假设妈妈有三个孩子，分别不同的房间里睡觉，需要及时获知每个孩子是否醒了，如何做？

1. 不停进每个房间看一下：简单，空闲时间还能干点别的，但是很累
2. 把三个房间的门都打开，在客厅睡觉，同时监听所有房间的哭声，如果被哭声吵醒，那么能准确定位某个房间，及时处理即可：既能得到休息，也能及时获知每个孩子的状态。

4.2 IO多路复用机制

• 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
• 若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
• 若设置多个进程/线程，分别处理一条数据通路，将新产生进程/线程间的同步与通信问题，使程序变得更加复杂；
• 比较好的方法是使用I/O多路复用技术。其基本思想是：
  • 先构造一张有关描述符的表，然后调用一个函数。
  • 当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
  • 函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。

基本流程：
1. 先构造一张有关文件描述符的表(集合、数组); 
2. 将你关心的文件描述符加入到这个表中;
3. 然后调用一个函数。 select / poll 
4. 当这些文件描述符中的一个或多个已准备好进行I/O操作的时候
该函数才返回(阻塞)。
5. 判断是哪一个或哪些文件描述符产生了事件(IO操作);
6. 做对应的逻辑处理;

5. 实现IO多路复用的方式

5.1 select

 int select(int nfds, fd_set *readfds, fd_set *writefds,
            fd_set *exceptfds, struct timeval *timeout);
   功能：select用于监测是哪个或哪些文件描述符产生事件;
   参数：nfds：    监测的最大文件描述个数
        （这里是个数，使用的时候注意，与文件中最后一次打开的文件
          描述符所对应的值的关系是什么？）
    readfds：  读事件集合; //读（用的多）
     writefds： 写事件集合;  //NULL表示不关心
     exceptfds：异常事件集合;  
     timeout：超时检测 1
   如果不做超时检测：传 NULL 
   select返回值：  <0 出错
               >0 表示有事件产生;
   如果设置了超时检测时间：&tv
      select返回值：
         <0 出错
        >0 表示有事件产生;
        ==0 表示超时时间已到;

     struct timeval {
               long    tv_sec;         /* seconds */
               long    tv_usec;        /* microseconds */
           };
 void FD_CLR(int fd, fd_set *set);//将fd从表中清除
 int  FD_ISSET(int fd, fd_set *set);//判断fd是否在表中
 void FD_SET(int fd, fd_set *set);//将fd添加到表中
 void FD_ZERO(fd_set *set);//清空表1

总结select实现IO多路复用特点*

1. 一个进程最多只能监听1024个文件描述符 （千级别）
2. select被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低（消耗CPU资源）;
3. select每次会清空表，每次都需要拷贝用户空间的表到内核空间，效率低（一个进程0~4G，0~3G是用户态，3G~4G是内核态，拷贝是非常耗时的）;

练习1：检测终端输入事件(键盘 0)，鼠标输入事件。

//鼠标设备的路径：/dev/input/mouse0  

#include 
#include 
#include 
#include 
#include 
#include 

/* According to earlier standards */
#include 
#include 
#include 

int main(int argc, char const *argv[])
{
    //鼠标 /dev/input/mouse0
    //键盘：0 - stdin
    int fd_mouse = open("/dev/input/mouse0", O_RDONLY);
    if (fd_mouse < 0)
    {
        perror("open mouse err.");
        return -1;
    }
    //引入IO多路复用机制 select  0 fd_mouse-检测读事件
    //1.创建表
    fd_set readfds, tempfds;
    FD_ZERO(&readfds); //清空表
    //2.将关心文件描述符添加到表中
    FD_SET(0, &readfds);
    FD_SET(fd_mouse, &readfds);
    
    int maxfd = fd_mouse;
    char buf[32] = "";
    while (1)
    {
        tempfds = readfds;
        //3.调用select函数检测
        int ret = select(maxfd + 1, &tempfds, NULL, NULL, NULL);
        if (ret < 0)
        {
            perror("select err.");
            return -1;
        }
        //4.当有一个或多个事件产生select函数返回
        //5.判断是那个或那几个产生事件
        if (FD_ISSET(0, &tempfds))
        {
            //6.处理事件
            //键盘
            fgets(buf, sizeof(buf), stdin);
            printf("key:%s\n", buf);
        }
        //鼠标
        if (FD_ISSET(fd_mouse, &tempfds))
        {
            int ret = read(fd_mouse, buf, sizeof(buf) - 1);
            buf[ret] = '\0';
            printf("mouse:%s\n", buf);
        }
    }
    close(fd_mouse);
    return 0;
}

练习：尝试用select检测0 和sockfd (TCP)，实现一个服务器响应多个客户端的连接，写完的提交群里一下。

server.c代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    //1.创建套接字   socket  TCP
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1])); //"8888"
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);
    //2.绑定bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    //listen监听 将主动套接字变被动
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    //引入select 0 sockfd  - >读事件
    //1.创建表
    fd_set readfds, tempfds;
    FD_ZERO(&readfds);
    //2.添加关心文件描述符
    FD_SET(0, &readfds);
    FD_SET(sockfd, &readfds);

    int maxfd = sockfd;
    char buf[128];
    while (1)
    {
        tempfds = readfds;
        int ret = select(maxfd + 1, &tempfds, NULL, NULL, NULL);
        if (ret < 0)
        {
            perror("select err.");
            return -1;
        }
        if (FD_ISSET(0, &tempfds))
        {
            fgets(buf, sizeof(buf), stdin);
            printf("key:%s\n", buf);
            for(int i=4;i<=maxfd;i++)
            {
                if(FD_ISSET(i,&readfds))
                 send(i,buf,sizeof(buf),0);
            }
        }
        if (FD_ISSET(sockfd, &tempfds))
        {
            int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
            if (acceptfd < 0)
            {
                perror("accept err.");
                return -1;
            }
            printf("client: ip:%s port:%d\n", inet_ntoa(caddr.sin_addr),
                   ntohs(caddr.sin_port));
            FD_SET(acceptfd, &readfds);
            if (maxfd < acceptfd)
                maxfd = acceptfd;
        }
        for (int i = 4; i <= maxfd; i++)
        {
            if (FD_ISSET(i, &tempfds))
            {
                int ret=recv(i, buf, sizeof(buf), 0);
                if(ret < 0)
                {
                    perror("recv err.");
                    return -1;
                }else if(ret == 0)
                {
                    printf("%d client exit.\n",i);
                    FD_CLR(i,&readfds);//5
                    close(i);
                    if(maxfd==i)
                      maxfd--;
                }else 
                {
                    printf("%d :%s\n",i,buf);
                }
            }
        }
    }
    return 0;
}

client.c代码

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

   参数：

   struct pollfd *fds

     关心的文件描述符数组struct pollfd fds[N];

   nfds:个数

   timeout： 超时检测

    毫秒级的：如果填1000，1秒

     如果-1，阻塞

 struct pollfd {

     int   fd;         /* 检测的文件描述符 */

     short events;     /* 检测事件 */

     short revents;    /* 调用poll函数返回填充的事件，poll函数一旦返回，将对应事件自动填充结构体这个成员。只需要判断这个成员的值就可以确定是否产生事件 */

 };

    事件： POLLIN ：读事件

                POLLOUT : 写事件

               POLLERR：异常事件

poll实现IO多路复用的特点

1. 优化文件描述符个数的限制;(根据poll函数第一个函数的参数来定，如果监听的事件为1个，则结构体数组元素个数为1，如果想监听100个，那么这个结构体数组的元素个数就为100，由程序员自己来决定)
2. poll被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低
3. poll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可

实现代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s \n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    //poll：0 sockfd acceptfd ->读事件
    //1.创建表
    struct pollfd fds[200] = {};
    //2.将关心文件描述符添加到表中
    fds[0].fd = 0;
    fds[0].events = POLLIN;

    fds[1].fd = sockfd;
    fds[1].events = POLLIN;

    int last = 1;

    char buf[64];
    while (1)
    {
        //调用poll监测
        int ret = poll(fds, last + 1, -1); //阻塞
        if (ret < 0)
        {
            perror("poll err.");
            return -1;
        }
        for (int i = 0; i <= last; i++)
        {
            if (fds[i].revents == POLLIN)
            {
                if (fds[i].fd == 0)
                {
                    fgets(buf, sizeof(buf), stdin);
                    printf("key:%s\n", buf);
                    for(int j=2;i<=last;j++)
                    {
                        send(fds[j].fd,buf,sizeof(buf),0);
                    }
                }
                else if (fds[i].fd == sockfd)
                {
                    // 4.阻塞等待客户端连接accept .返回通信文件描述符
                    int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
                    if (acceptfd < 0)
                    {
                        perror("accept err.");
                        return -1;
                    }
                    printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
                    printf("client:ip=%s port=%d\n", inet_ntoa(caddr.sin_addr),
                           ntohs(caddr.sin_port)); //inet_ntoa
                    //将acceptfd添加到表
                    last++;
                    fds[last].fd = acceptfd;
                    fds[last].events = POLLIN;
                }
                else
                {
                    int recvbyte = recv(fds[i].fd, buf, sizeof(buf), 0);
                    if (recvbyte < 0)
                    {
                        perror("recv err.");
                        return -1;
                    }
                    else if (recvbyte == 0)
                    {
                        printf("%d client exit\n", fds[i].fd);
                        close(fds[i].fd);
                        fds[i] = fds[last];
                        last--;
                        i--;
                    }
                    else
                    {
                        printf("%d :%s\n", fds[i].fd, buf);
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

5.3 epoll实现 (异步)

epoll实现机制：(了解)

epoll的提出--》它所支持的文件描述符上限是系统可以最大打开的文件的数目；eg：1GB机器上，这个上限10万个左右。
每个fd上面有callback(回调函数)函数，只有活跃的fd才有主动调用callback，不需要轮询。

注意：
   Epoll处理高并发，百万级，不关心底层怎样实现，只需要会调用就可以。

函数接口

#include <sys/epoll.h>
int epoll_create(int size); 
功能：创建红黑树根节点
 参数：size：不作为实际意义值 >0 即可
返回值：成功时返回epoll文件描述符，失败时返回-1。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
功能：控制epoll属性
    epfd:epoll_create函数的返回句柄。
    op:表示动作类型。有三个宏 来表示：
            EPOLL_CTL_ADD：注册新的fd到epfd中
            EPOLL_CTL_MOD：修改已注册fd的监听事件
            EPOLL_CTL_DEL：从epfd中删除一个fd
    Fd:需要监听的fd。
            event:告诉内核需要监听什么事件
            EPOLLIN:表示对应文件描述符可读
            EPOLLOUT:可写
            EPOLLPRI：有紧急数据可读；
            EPOLLERR：错误；
            EPOLLHUP：被挂断；
            EPOLLET：触发方式，边缘触发；(默认使用边缘触发)
             ET模式：表示状态的变化；
返回值：成功时返回0，失败时返回-1

typedef union epoll_data {
               void* ptr;(无效)
               int fd;
               uint32_t u32;
               uint64_t u64;
           } epoll_data_t;
           struct epoll_event {
               uint32_t events； / * Epoll事件* /
               epoll_data_t data； / *用户数据变量* /
};
//等待事件到来
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
功能：等待事件的产生，类似于select的用法
     epfd:句柄；
     events：用来保存从内核得到事件的集合；
     maxevents:表示每次能处理事件最大个数；
     timeout：超时时间，毫秒，0立即返回，-1阻塞
成功时返回发生事件的文件描述个数，失败时返回-1

帮助理解：
1.epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。
2.epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时， 返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中 依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
 3.另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()
来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制， 迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

epoll实现IO多路复用的特点

•监听的最大的文件描述符没有个数限制（理论上，取决与你自己的系统）
•异步I/O，Epoll当有事件产生被唤醒之后，文件描述符主动调用callback(回调函数)函数直接拿到唤醒的文件描述符，不需要轮询，效率高
•epoll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可.

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/epoll.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    //epoll：0 sockfd acceptfd ->读事件
    struct epoll_event event;      //暂时保存添加的事件
    struct epoll_event revent[10]; //暂时保存从链表中拿出来的事件
        //1.创建树
        int epfd = epoll_create(1);
    //2.将关心文件描述符添加到数上
    event.data.fd = 0;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);

    event.data.fd = sockfd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &event);

    int last = 1;

    char buf[64];
    while (1)
    {
        //拿事件处理,ret实际拿到的个数
        int ret = epoll_wait(epfd, revent, 10, -1);
        if (ret < 0)
        {
            perror("epoll err.");
            return -1;
        } 
        for (int i = 0; i < ret; i++)
        {
            if (revent[i].data.fd == 0)
            {
                fgets(buf, sizeof(buf), stdin);
                printf("key:%s\n", buf);
            }
            else if (revent[i].data.fd == sockfd)
            {
                // 4.阻塞等待客户端连接accept .返回通信文件描述符
                int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
                if (acceptfd < 0)
                {
                    perror("accept err.");
                    return -1;
                }
                printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
                printf("client:ip=%s port=%d\n", inet_ntoa(caddr.sin_addr),
                       ntohs(caddr.sin_port)); //inet_ntoa
                //将acceptfd添加到表树上
                event.data.fd=acceptfd;
                event.events=EPOLLIN|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_ADD,acceptfd,&event);               
            }
            else
            {
                int recvbyte = recv(revent[i].data.fd, buf, sizeof(buf), 0);
                if (recvbyte < 0)
                {
                    perror("recv err.");
                    return -1;
                }
                else if (recvbyte == 0)
                {
                    printf("%d client exit\n", revent[i].data.fd);
                    close(revent[i].data.fd);
                    epoll_ctl(epfd,EPOLL_CTL_DEL,revent[i].data.fd,NULL); 
                }
                else
                {
                    printf("%d :%s\n",revent[i].data.fd, buf);
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

socket()
bind();
listen();
while(1)
{
	accept();
	while(1)
	{
		process(); //处理
	}
	close();
}

socket()
bind();
listen();
while(1)
{
	accept();	if(fork() == 0)  //子进程
	{
		while(1)
		{
			process();
		}
		close(client_fd);
		exit();
	}
}

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int main(int argc, char const *argv[])
{
	int a=100;
	char buf[32];
	int ret;
	printf("88888888888888888888888\n");

	int fd=open("./fork.c",O_RDONLY);

	pid_t pid=fork();
	if(pid < 0)
	{
		perror("fork err.");
		return -1;
	}else if(pid == 0)
	{
		a=10000;
		printf("my child. %d %d\n",a,fd);
		ret=read(fd,buf,sizeof(buf)-1);
		buf[ret]='\0';
		printf("buf:%s\n",buf);
		close(fd);

	}else
	{
		sleep(1);
		printf("my father %d %d\n",a,fd);
		ret=read(fd,buf,sizeof(buf)-1);
		buf[ret]='\0';
		printf("buf:%s\n",buf);

    }

    printf("------------------------%d\n",a);
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>

void handler(int sig)
{
    waitpid(-1, NULL, WNOHANG);
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    //注册信号
    signal(SIGCHLD, handler); //void (*handler)(int )
    while (1)
    {
        // 4.阻塞等待客户端连接accept .返回通信文件描述符
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accept err.");
            return -1;
        }
        printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
        printf("client:ip=%s port=%d\n", inet_ntoa(caddr.sin_addr),
               ntohs(caddr.sin_port)); //inet_ntoa

        pid_t pid = fork();
        if (pid < 0)
        {
            perror("fork err.");
            return -1;
        }
        else if (pid == 0)
        {
            close(sockfd);
            // 5.收发消息
            char buf[64];
            int recvbyte;
            while (1)
            {
                recvbyte = recv(acceptfd, buf, sizeof(buf), 0);
                if (recvbyte < 0)
                {
                    perror("recv err.");
                    return -1;
                }
                else if (recvbyte == 0)
                {
                    printf("client exit.\n");
                    break;
                }
                else
                {
                    printf("buf:%s\n", buf);
                }
            }
            close(acceptfd);
            exit(-1); //结束子进程
        }
        // 6.关闭套接字
        close(acceptfd);
    }
    close(sockfd);
    return 0;
}

socket()
bind();
listen();
while(1)
{
	accept();
	pthread_create();
}

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>

void handler(int sig)
{
	printf("--------------ctrt+c\n");
}

int main(int argc, const char *argv[])
{

    signal(SIGINT,handler);

	while(1)
	{
		sleep(5);
		printf("hello world.\n");
	}
	return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h> 

//void *(*thread)(void *)
void *pthread(void *arg)
{
    int acceptfd = *((int *)arg);
    char buf[64];
    int recvbyte;
    while (1)
    {
        recvbyte = recv(acceptfd, buf, sizeof(buf), 0);
        if (recvbyte < 0)
        {
            perror("recv err.");
            return NULL;
        }
        else if (recvbyte == 0)
        {
            printf("client exit.\n");
            break;
        }
        else
        {
            printf("%d buf:%s\n", acceptfd, buf);
        }
    }
    close(acceptfd);
    return NULL; //pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    while (1)
    {
        // 4.阻塞等待客户端连接accept .返回通信文件描述符
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accept err.");
            return -1;
        }
        printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
        printf("client:ip=%s port=%d\n", inet_ntoa(caddr.sin_addr),
               ntohs(caddr.sin_port)); //inet_ntoa

        pthread_t tid;
        pthread_create(&tid, NULL, pthread, &acceptfd);
        pthread_detach(tid);
    }
    close(sockfd);
    return 0;
}

1.select设置超时
struct timeval tm = {2, 0};//设置2s打算阻塞
sret = select(maxfd + 1, &tempfds, NULL, NULL, &tm);
第五个参数：
 struct timeval {
     long    tv_sec;         /*秒*/
     long    tv_usec;        /*微秒*/
 };
 
 2.poll
 int poll(struct pollfd *fds, nfds_t nfds, int timeout);
   第三个参数：时间单位是毫秒 -1阻塞， 2000=2s
   ret = poll(event, num, 2000);//超时检测时间为2s

3.epoll 设置的是epoll_wait
 int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);
  第四个参数：时间单位是毫秒 -1阻塞， 2000=2s
  ret = epoll_wait(epfd, events, 20, 2000);

设置超时后的返回值都为：<0  error
                        =0   超时
                        >0   正确

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    //鼠标 /dev/input/mouse0
    //键盘：0 - stdin
    int fd_mouse = open("/dev/input/mouse0", O_RDONLY);
    if (fd_mouse < 0)
    {
        perror("open mouse err.");
        return -1;
    }
    //引入IO多路复用机制 select  0 fd_mouse-检测读事件
    //1.创建表
    fd_set readfds, tempfds;
    FD_ZERO(&readfds); //清空表

    //2.将关心文件描述符添加到表中
    FD_SET(0, &readfds);
    FD_SET(fd_mouse, &readfds);

    int maxfd = fd_mouse;

    char buf[32] = "";
    while (1)
    {
        tempfds = readfds;
        //3.调用select函数检测
		struct timeval tv={2,0};
        int ret = select(maxfd + 1, &tempfds, NULL, NULL, &tv);
        if (ret < 0)
        {
            perror("select err.");
            return -1;
        }else if(ret == 0)
		{
			printf("time out --------------------\n");
			continue;

		}
        //4.当有一个或多个事件产生select函数返回
        //5.判断是那个或那几个产生事件
        if (FD_ISSET(0, &tempfds))
        {
            //6.处理事件
            //键盘
            fgets(buf, sizeof(buf), stdin);
            printf("key:%s\n", buf);
        }
        //鼠标
        if (FD_ISSET(fd_mouse, &tempfds))
        {
            int ret = read(fd_mouse, buf, sizeof(buf) - 1);
            buf[ret] = '\0';
            printf("mouse:%s\n", buf);
        }
    }

    close(fd_mouse);
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <poll.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    //poll：0 sockfd acceptfd ->读事件
    //1.创建表
    struct pollfd fds[200] = {};
    //2.将关心文件描述符添加到表中
    fds[0].fd = 0;
    fds[0].events = POLLIN;

    fds[1].fd = sockfd;
    fds[1].events = POLLIN;

    int last = 1;

    char buf[64];
    while (1)
    {
        //调用poll监测
        int ret = poll(fds, last + 1,2000); //阻塞
		if (ret < 0)
		{
			perror("poll err.");
			return -1;
		}//当事件产生，将这个结构体元素中第二个成员的值赋值给第三个成员。
		//没有事件第三个成员为0
		else if(ret == 0)
		{
			printf("time out -----------------\n");
			continue;	
		}
		for (int i = 0; i <= last; i++)
		{
			if (fds[i].revents == POLLIN)
			{
                if (fds[i].fd == 0)
                {
                    fgets(buf, sizeof(buf), stdin);
                    printf("key:%s\n", buf);
                    for(int j=2;j<=last;j++)
                    {
                        send(fds[j].fd,buf,sizeof(buf),0);
                    }
                }
                else if (fds[i].fd == sockfd)
                {
                    // 4.阻塞等待客户端连接accept .返回通信文件描述符
                    int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
                    if (acceptfd < 0)
                    {
                        perror("accept err.");
                        return -1;
                    }
                    printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
                    printf("client:ip=%s port=%d\n", inet_ntoa(caddr.sin_addr),
                           ntohs(caddr.sin_port)); //inet_ntoa
                    //将acceptfd添加到表
                    last++;
                    fds[last].fd = acceptfd;
                    fds[last].events = POLLIN;
                }
                else
                {
                    int recvbyte = recv(fds[i].fd, buf, sizeof(buf), 0);
                    if (recvbyte < 0)
                    {
                        perror("recv err.");
                        return -1;
                    }
                    else if (recvbyte == 0)
                    {
                        printf("%d client exit\n", fds[i].fd);
                        close(fds[i].fd);
                        fds[i] = fds[last];
                        last--;
                        i--;
                    }
                    else
                    {
                        printf("%d :%s\n", fds[i].fd, buf);
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/epoll.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    //epoll：0 sockfd acceptfd ->读事件
    struct epoll_event event;      //暂时保存添加的事件
    struct epoll_event revent[10]; //暂时保存从链表中拿出来的事件
    //1.创建树
    int epfd = epoll_create(1);
    //2.将关心文件描述符添加到数上
    event.data.fd = 0;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);

    event.data.fd = sockfd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &event);

    char buf[64];
    while (1)
    {
        //拿事件处理,ret实际拿到的个数
        int ret = epoll_wait(epfd, revent, 10, 2000);
        if (ret < 0)
        {
            perror("epoll err.");
            return -1;
        }else if(ret == 0)
		{
			printf("timeout -----------------\n");
			continue;
		}
        for (int i = 0; i < ret; i++)
        {
            if (revent[i].data.fd == 0)
            {
                fgets(buf, sizeof(buf), stdin);
                printf("key:%s\n", buf);
            }
            else if (revent[i].data.fd == sockfd)
            {
                // 4.阻塞等待客户端连接accept .返回通信文件描述符
                int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
                if (acceptfd < 0)
                {
                    perror("accept err.");
                    return -1;
                }
                printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
                printf("client:ip=%s port=%d\n", inet_ntoa(caddr.sin_addr),
                       ntohs(caddr.sin_port)); //inet_ntoa
                //将acceptfd添加到表树上
                event.data.fd = acceptfd;
                event.events = EPOLLIN | EPOLLET;
                epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &event);
            }
            else
            {
                int recvbyte = recv(revent[i].data.fd, buf, sizeof(buf), 0);
                if (recvbyte < 0)
                {
                    perror("recv err.");
                    return -1;
                }
                else if (recvbyte == 0)
                {
                    printf("%d client exit\n", revent[i].data.fd);
                    close(revent[i].data.fd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, revent[i].data.fd, NULL);
                }
                else
                {
                    printf("%d :%s\n", revent[i].data.fd, buf);
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

选项名称        说明                  数据类型 
======================================================================== 
SOL_SOCKET  应用层
------------------------------------------------------------------------ 
SO_BROADCAST     允许发送广播数据              int 
SO_DEBUG       允许调试                  int 
SO_DONTROUTE     不查找路由                int 
SO_ERROR       获得套接字错误               int 
SO_KEEPALIVE     保持连接                  int 
SO_LINGER       延迟关闭连接               struct linger 
SO_OOBINLINE     带外数据放入正常数据流           int 
SO_RCVBUF       接收缓冲区大小               int 
SO_SNDBUF       发送缓冲区大小               int 
SO_RCVLOWAT      接收缓冲区下限               int 
SO_SNDLOWAT      发送缓冲区下限              int 
SO_RCVTIMEO      接收超时                 struct timeval 
SO_SNDTIMEO      发送超时                 struct timeval 
SO_REUSEADDR      允许重用本地地址和端口          int 
SO_TYPE        获得套接字类型              int 
SO_BSDCOMPAT     与BSD系统兼容               int 
==========================================================================             
         IPPROTO_IP  IP层/网络层
----------------------------------------------------------------------------
IP_HDRINCL       在数据包中包含IP首部          int 
IP_OPTINOS       IP首部选项               int 
IP_TOS          服务类型 
IP_TTL         生存时间                int 
IP_ADD_MEMBERSHIP       将指定的IP加入多播组                    struct ip_mreq
==========================================================================            
		IPPRO_TCP  传输层
-----------------------------------------------------------------------------
TCP_MAXSEG       TCP最大数据段的大小            int 
TCP_NODELAY       不使用Nagle算法             int  

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

功能：获得/设置套接字属性
参数：
	sockfd：套接字描述符
	level：协议层
		SOL_SOCKET（应用层）
		IPPROTO_TCP（传输层）
		IPPROTO_IP（网络层） 
	optname：选项名
		SO_BROADCAST     允许发送广播数据             int 
		SO_RCVBUF       接收缓冲区大小              int 
		SO_SNDBUF       发送缓冲区大小              int 
		SO_RCVTIMEO      接收超时                struct timeval 
		SO_SNDTIMEO      发送超时                 struct timeval
		
	optval:选项值
	optlen:选项值大小指针

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //ipv4
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    //设置端口重用
    int optval=1;
    setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(optval));

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    while (1)
    {
        // 4.阻塞等待客户端连接accept .返回通信文件描述符
        int acceptfd = accept(sockfd,(struct sockaddr *)&caddr,&len);
        if (acceptfd < 0)
        {
            perror("accept err.");
            return -1;
        }
        printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);
        printf("client:ip=%s port=%d\n",inet_ntoa(caddr.sin_addr),\
        ntohs(caddr.sin_port));//inet_ntoa
        // 5.收发消息
        char buf[64];
        int recvbyte;
        while (1)
        {
            //设置接收超时
            struct timeval tv={2,0};
            setsockopt(acceptfd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv));

            recvbyte = recv(acceptfd, buf, sizeof(buf), 0);
            if (recvbyte < 0)
            {
                perror("recv err.");
               //  return -1;
            }
            else if (recvbyte == 0)
            {
                printf("client exit.\n");
                break;
            }
            else
            {
                printf("buf:%s\n", buf);
            }
        }
        // 6.关闭套接字
       close(acceptfd);
    }
    close(sockfd);
    return 0;
}

struct timeval {
     long    tv_sec;         /*秒*/
     long    tv_usec;        /*微秒*/
 };
//设置接收超时
 struct timeval tm={2,0};    
 setsockopt(acceptfd,SOL_SOCKET,SO_RCVTIMEO,&tm,sizeof(tm));
 //设置超时之后时间到打断接下来的阻塞在这个文件描述符的函数，直接错误返回

补充：
//设置端口和地址重用
int optval=1;  
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(optval));

alarm(5) 闹钟   定时器
//5秒之后会，会有一个信号产生(SIGALRM)
int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);
 功能：对接收到的指定信号处理
	signum  信号		 
    struct sigaction {
               void     (*sa_handler)(int);
     };
     
    //设置信号属性
    struct sigaction act;
    sigaction(SIGALRM,NULL,&act);//获取原属性
    act.sa_handler=handler;//修改属性
    sigaction(SIGALRM,&act,NULL);//将修改的属性设置回去
   
注：在recv前调用alarm函数
   alarm的 SIGALRM信号产生后会打断(终端)下面的系统调用recv;
   打断后相当于recv错误返回。

#include <stdio.h>
#include <signal.h>

void handler(int sig)
{
    printf("time out -----------------\n");
}

int main(int argc, char const *argv[])
{
    //SIGALRM
    struct sigaction act;
    //1.获取原属性
    sigaction(SIGALRM,NULL,&act);
    //2.修改
    act.sa_handler=handler;
    //3.设置
    sigaction(SIGALRM,&act,NULL);

    char buf[32];
    while(1)
    {
        alarm(2);
        if(fgets(buf,sizeof(buf),stdin)== NULL)
        {
            perror("fgets err.");
        }
        printf("buf:%s\n",buf);
    }
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>

int main(int argc, char const *argv[])
{
    //1.创建数据报套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //2.设置发送广播属性
    int optval = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval));
    //3.填充广播IP和端口
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr(argv[1]);

    char buf[128];
    //4.发送广播消息
    while (1)
    {
        fgets(buf, sizeof(buf), stdin);
        if (buf[strlen(buf) - 1] == '\n')
            buf[strlen(buf) - 1] = '\0';
        sendto(sockfd, buf, sizeof(buf), 0,
               (struct sockaddr *)&saddr, sizeof(saddr));
    }
    close(sockfd);
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>

int main(int argc, char const *argv[])
{
    //1.创建数据报套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }

    //2.填充广播IP和端口
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);
    //3.绑定
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    char buf[128];
    //4.收广播消息
    while (1)
    {
        if (recvfrom(sockfd, buf, sizeof(buf), 0,
                     (struct sockaddr *)&caddr, &len) < 0)
        {
            perror("recvfrom err.");
            return -1;
        }
        printf("ip=%s port=%d ： %s\n", inet_ntoa(caddr.sin_addr),
               ntohs(caddr.sin_port), buf);
    }
    close(sockfd);
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>

int main(int argc, char const *argv[])
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    //将ip地址加入多播组
    struct ip_mreq mreq;
    mreq.imr_multiaddr.s_addr=inet_addr(argv[1]); 
    mreq.imr_interface.s_addr=inet_addr("0.0.0.0"); 

    setsockopt(sockfd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq));

    //填充结构体 组ip
    struct sockaddr_in gaddr;
    gaddr.sin_family = AF_INET;
    gaddr.sin_port = htons(atoi(argv[2]));
    gaddr.sin_addr.s_addr = inet_addr(argv[1]); //组ip

    //绑定
    if(bind(sockfd,(struct sockaddr *)&gaddr,sizeof(gaddr))<0)
    {
        perror("bind err.");
        return -1;
    }

    char buf[128];
    while (1)
    {
        recvfrom(sockfd,buf,sizeof(buf),0,NULL,NULL);
        printf("buf:%s\n",buf);
    }
    close(sockfd);
    return 0;
}

struct ip_mreq
{
	struct  in_addr  imr_multiaddr;   /* 指定多播组IP */
	struct  in_addr  imr_interface;   /* 本地网卡地址，通常指定为 INADDR_ANY--0.0.0.0*/};
}
struct ip_mreq mreq;
bzero(&mreq, sizeof(mreq));
mreq.imr_multiaddr.s_addr = inet_addr("224.10.10.1");
mreq.imr_interface.s_addr = INADDR_ANY;
setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));

#include 
#include 

unix_socket = socket(AF_UNIX, type, 0);

struct sockaddr_un {
   sa_family_t sun_family;               /* AF_UNIX */
   char        sun_path[UNIX_PATH_MAX];  /* 本地路径 */
};

struct sockaddr_un myaddr;
bzero(&myaddr,  sizeof(myaddr));
myaddr.sun_family = AF_UNIX; 
strcpy(myaddr.sun_path,  "mysocket");  //可以指定路径

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    struct sockaddr_un saddr;
    saddr.sun_family = AF_UNIX;
    strcpy(saddr.sun_path, "./myunix");

  //  system("rm ./myunix -f");
    unlink("./myunix");

    // 2.绑定(填充通信结构体)bind
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    // 3.监听。主动套接字变为被动套接字listen
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    while (1)
    {
        // 4.阻塞等待客户端连接accept .返回通信文件描述符
        int acceptfd = accept(sockfd, NULL, NULL);
        if (acceptfd < 0)
        {
            perror("accept err.");
            return -1;
        }
        printf("sockfd:%d acceptfd:%d\n", sockfd, acceptfd);

        // 5.收发消息
        char buf[64];
        int recvbyte;
        while (1)
        {
            recvbyte = recv(acceptfd, buf, sizeof(buf), 0);
            if (recvbyte < 0)
            {
                perror("recv err.");
                return -1;
            }
            else if (recvbyte == 0)
            {
                printf("client exit.\n");
                break;
            }
            else
            {
                printf("buf:%s\n", buf);
            }
        }
        // 6.关闭套接字
        close(acceptfd);
    }
    close(sockfd);
    return 0;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>

int main(int argc, char const *argv[])
{
    // 1.创建流式套接字socket .返回连接文件描述符
    int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    struct sockaddr_un saddr;
    saddr.sun_family = AF_UNIX;
    strcpy(saddr.sun_path, "./myunix");

    if (connect(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }

    char buf[64];
    while (1)
    {
        fgets(buf, sizeof(buf), stdin); //10  20
        //最多读size-1,自动补'\0',读到'\n'
        if (buf[strlen(buf) - 1] == '\n')
            buf[strlen(buf) - 1] = '\0';
        send(sockfd, buf, sizeof(buf), 0);
    }
    // 6.关闭套接字
    close(sockfd);
    return 0;
}

粘包、拆包发生原因: 1000 - 800+200 400  200   
    发生TCP粘包或拆包有很多原因，常见的几点： 600   1000   400
   1、要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。 
   2、待发送数据大于MSS（最大报文长度），TCP在传输前将进行拆包。 
   3、要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包。 
   4、接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。
   
粘包、拆包解决办法: 
   解决问题的关键在于如何给每个数据包添加边界信息，常用的方法有如下：
   1、发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。 
   2、发送端将每个数据包封装为固定长度（不够的可以通过补0填充），这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。 
   3、可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。 等等。
   4.延时、效率低

	    1. 安装  sudo apt-get update
		sudo apt-get install wireshark
		2. 运行
			sudo wireshark
		3. 过滤
			tcp.port == 8888
		4. 抓的是流经eth0网卡的数据
			服务器端代码运行在ubuntu
			客户端代码运行在windows下
			
		ip.addr == 192.168.1.31

注：抓包的过程，就是抓网卡流经的一些数据。启动时不加sudo找不到网卡，没有办法找到内容。
 如何抓包：1.启动wireshark 。//filter-》过滤器
	    2.想抓流经eth0网卡的数据，就点击一下eth0.
		3.想找到我想抓的数据，需要用到filter
    //在这之前，需要将ubuntu的ip修改固定ip和windows在同一网段。
		4.在filter，输入：tcp port==8888，回车查找端口号为8888的流经的数据。
		//通过端口号进行的过滤，也可通过ip(通过Expression按键可以查看过滤方式)

常用的数据库
大型数据库 ：Oracle

中型数据库 ：Server是微软开发的数据库产品，主要支持windows平台 
小型数据库 : mySQL是一个小型关系型数据库管理系统。开放源码 

SQLite基础
 SQLite的源代码是C，其源代码完全开放。它是一个轻量级的嵌入式数据库。
 SQLite有以下特性： 
     	零配置一无需安装和管理配置； 
     	储存在单一磁盘文件中的一个完整的数据库； 
     	数据库文件可以在不同字节顺序的机器间自由共享； 
     	支持数据库大小至2TB（1024G = 1TB）；足够小，全部源码大致3万行c代码，250KB； 
        比目前流行的大多数数据库对数据的操作要快；

创建SQLite数据库：
手工创建 
     使用sqlite3工具，通过手工输入SQL命令行完成数据库创建. 
     用户在Linux的命令行界面中输入sqlite3可启动sqlite3工具 
代码创建 
在代码中常动态创建数据库 在程序运行过程中，当需要进行数据库操作时，应用程序会首先尝试打开数据库，此时如果数据库并不存在，程序则会自动建立数据库，然后再打开数据库 

sqlite3 安装：
1. sudo dpkg -i *.deb  离线安装		
2. 在线安装
 1、设置能够上网
 2、更新更新源
	#apt-get update
		
 3、安装软件及开发环境
   # apt-get install sqlite3		--->sqlite3数据库软件
   # apt-get install libsqlite3-dev	--->sqlite3数据库开发支持库
   # apt-get install sqlite3-doc		--->sqlite3数据库说明文档
	--------------------------------		
   #apt-get install sqlitebrowser		
			--->sqlite3数据库操作软件

tar xf sqlite-autoconf-3140100.tar.gz
./configure
make
sudo make install

$ sqlite3 -version 
3.14.1 2016-08-11

头文件：#include <sqlite3.h>
编译：gcc sqlite1.c -lsqlite3

1.int sqlite3_open(char  *path, sqlite3 **db);

功能：打开sqlite数据库，如果数据库不存在则创建它
path： 数据库文件路径
db： 指向sqlite句柄的指针
返回值：成功返回SQLITE_OK，失败返回错误码(非零值)

2.int sqlite3_close(sqlite3 *db);

功能：关闭sqlite数据库
返回值：成功返回SQLITE_OK，失败返回错误码

返回值：返回错误信息

3.执行sql语句接口
int sqlite3_exec(
  sqlite3 *db,                                  /* An open database */
  const char *sql,                           /* SQL to be evaluated */
  int (*callback)(void*,int,char**,char**),  /* Callback function */
  void *arg,                      /* 1st argument to callback */
  char **errmsg                              /* Error msg written here */
);

功能：执行SQL操作
db：数据库句柄
sql：要执行SQL语句
callback：回调函数(满足一次条件，调用一次函数，用于查询)
    再调用查询sql语句的时候使用回调函数打印查询到的数据
arg:传递给回调函数的参数
errmsg：错误信息指针的地址
返回值：成功返回SQLITE_OK，失败返回错误码

回调函数：
typedef int (*sqlite3_callback)(void *para, int f_num, 
         char **f_value, char **f_name);

功能：select:每找到一条记录自动执行一次回调函数
para：传递给回调函数的参数（由 sqlite3_exec() 的第四个参数传递而来）
f_num：记录中包含的字段数目
f_value：包含每个字段值的指针数组（列值）
f_name：包含每个字段名称的指针数组（列名）
返回值：成功返回SQLITE_OK，失败返回-1，每次回调必须返回0后才能继续下次回调

4.不使用回调函数执行SQL语句(只用于查询)
int sqlite3_get_table(sqlite3 *db, const  char  *sql, 
   char ***resultp,  int *nrow,  int *ncolumn, char **errmsg);

功能：执行SQL操作
db：数据库句柄
sql：SQL语句
resultp：用来指向sql执行结果的指针
nrow：满足条件的记录的数目(但是不包含字段名(表头 id name score))
ncolumn：每条记录包含的字段数目
errmsg：错误信息指针的地址

返回值：成功返回SQLITE_OK，失败返回错误码

5.返回sqlite3定义的错误信息
char *sqlite3_errmsg(sqlite3 *db);

#include <stdio.h>
#include <sqlite3.h>

int callback(void *arg, int f_num, char **f_value, char **f_name)
{
    printf("%s\n", (char *)arg);
    for (int i = 0; i < f_num; i++)
    {
        printf("%s ", f_name[i]);
    }
    putchar(10);
    for (int i = 0; i < f_num; i++)
    {
        printf("%s ", f_value[i]);
    }
    putchar(10);
    return 0;
}
int main(int argc, char const *argv[])
{
    //1.打开或新建一个数据库
    sqlite3 *db;
    if (sqlite3_open("./stu.db", &db) != 0)
    {
        fprintf(stderr, "sqlite3_open:%s", sqlite3_errmsg(db));
        return -1;
    }
    printf("open ok.\n");
    //2.创建表
    char *errmsg = NULL;
    if (sqlite3_exec(db, "create table stu1(id int primary key,name char,score float);",
                     NULL, NULL, &errmsg) != 0)
    {
        fprintf(stderr, "create table err:%s", errmsg);
        //  return -1;
    }
    printf("create table ok.\n");
    //3.向表中插入数据
    int id, num;
    char name[32];
    float score;
    char sql[128];
    printf("please input student number:");
    scanf("%d", &num);
    for (int i = 0; i < num; i++)
    {
        scanf("%d %s %f", &id, name, &score);
        sprintf(sql, "insert into stu1 values(%d,\"%s\",%f);", id, name, score);
        if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != 0)
        {
            fprintf(stderr, "insert err:%s", errmsg);
            return -1;
        }
    }
    //4.查询表
    // if (sqlite3_exec(db, "select id,score from stu1 where id=1;", callback, "hello", &errmsg) != 0)
    // {
    //     fprintf(stderr, "select err:%s", errmsg);
    //     return -1;
    // }

    //只用于查询的函数 sqlite3_get_table
    char **rstp = NULL;
    int hang, lie;
    if (sqlite3_get_table(db, "select * from stu1 where id=1;", &rstp, &hang, &lie, &errmsg) != 0)
    {
        fprintf(stderr, "select err:%s", errmsg);
        return -1;
    }
    int k = 0;
    for (int i = 0; i < hang + 1; i++)
    {
        for (int j = 0; j < lie; j++)
        {
            printf("%s ", rstp[k++]);
        }
        putchar(10);
    }

    //5.关闭数据库
    sqlite3_close(db);
    return 0;
}

#include <stdio.h>
//(a+b) * c
//(a-b) * c
//(a*b) * c
//(a/b) * c
//a+b a-b a*b a/b

int add(int a,int b)
{
	return a+b;
}
int sub(int a,int b)
{
	return a-b;
}
int mul(int a,int b)
{
	return a*b;
}
int chu(int a,int b)
{
	return a/b;
}
//int (* fun_p)(int,int);
//fun_p=add;    fun_p = mul;
int fun(int c,int (*fun_p)(int ,int ), int a,int b)
{
	return fun_p(a,b)*c;
}
//想通过一个函数更改一个变量的值：
//两种- 参数(传变量地址)，返回值
#if 0
int func(void)
{
	return 1000;
}
void func1(int *sp)
{
	*sp=1000;
}
#endif

int *func(void)
{
	static int a=1000;
	return &a;
}
void func1(int **sp)
{
	static int a=1000;
	*sp=&a;
}

int main(int argc, const char *argv[])
{
    printf("%d\n",fun(10,add,2,3));
    printf("%d\n",fun(10,sub,2,3));
    printf("%d\n",fun(10,mul,2,3));
    printf("%d\n",fun(10,chu,2,3));

 //   int a;//1000;
//	a=fun();//fun1(&a);

	int *p;
	int **q;


	return 0;
}