网络编程学习日记-----UDP协议、IO模型、阻塞IO

一、网络编程通信协议。 -- UDP协议。

1、UDP协议特性是什么？ UDP协议全称"User Data Protocol/用户数据包协议"，这种协议特点基于无连接的通信，所以UDP协议的代码中是没有connect()和accept()。

2、UDP协议设计步骤？ 详细参考： UDP协议的设计流程.jpg

客户端：

#include "head.h"

int main(int argc,char *argv[]) // ./Jack 192.168.19.3 50001

{ //1. 创建UDP协议套接字。

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

//2. 直接写信。
struct sockaddr_in srvaddr;
socklen_t len = sizeof(srvaddr);
bzero(&srvaddr,len);
​
srvaddr.sin_family = AF_INET;
srvaddr.sin_port = htons(atoi(argv[2]));
inet_pton(AF_INET,argv[1],&srvaddr.sin_addr);
​
char buf[100];
while(1)
{
    bzero(buf,sizeof(buf));
    fgets(buf,sizeof(buf),stdin);
    sendto(sockfd,buf,strlen(buf),0,(struct sockaddr *)&srvaddr,len);
​
    if(strncmp(buf,"quit",4) == 0)
    {
        break;
    }
}
​
//3. 销毁信箱
close(sockfd);
​
return 0;

}

服务器：

 

#include "head.h"

int main(int argc,char *argv[]) // ./Rose 50001

{ //1. 创建UDP协议套接字。

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

//2. 绑定IP地址到套接字上。
struct sockaddr_in srvaddr;
socklen_t len = sizeof(srvaddr);
bzero(&srvaddr,len);
​
srvaddr.sin_family = AF_INET;
srvaddr.sin_port = htons(atoi(argv[1]));
srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);
​
bind(sockfd,(struct sockaddr *)&srvaddr,len);
​
//3. 不断等待对方写信给我。
char buf[100];
struct sockaddr_in cliaddr;
bzero(&cliaddr,sizeof(cliaddr));
​
while(1)
{
    bzero(buf,sizeof(buf));
    recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&cliaddr,&len);
​
    printf("%s:%s",inet_ntoa(cliaddr.sin_addr),buf);
​
    if(strncmp(buf,"quit",4) == 0)
    {
        break;
    }
}
​
//4. 销毁信箱
close(sockfd);
​
return 0;

}

二、IO模型。

1、什么是IO模型？

在网络编程中，对于套接字，我们可以进行读写的操作，例如connfd，那么我们可以recv(connfd)，也可以send(connfd)。

当进程在读取套接字时，revc（connfd），那么当这个套接字上没有数据时，这个函数就会阻塞等待。

如果需要读取多个套接字的数据时，就不能阻塞等待，就要使用IO模型

 

2.IO模型有哪些：？

一共有四种IO模型分别是，阻塞IO、非阻塞IO、多路复用、信号驱动、

三、非阻塞IO模型

 1.    阻塞IO：当多个套接字给我发送数据时，我会先询问第一个套接字 有没有数据到达，如果有则读取，则阻塞等待以一个套接字的数据

     非阻塞IO：当多个套接字给我发送数据时，我会先询问第一个套接字 有没有数据到达，如果有则读取，没有则读取下一个。   

2.如何设置非阻塞

      正常情况下我们使用用一个函数去读取数据时，默认都是阻塞的。例如：read（fd）accept、recv、recvfrom。实际上这些函数并不是造成阻塞的原因，而是这些函数中的套接字/文件描述符阻塞。

 1）创建一个新的文件描述符/套接字   ----------》默认为时阻塞的

2）添加非阻塞属性给套接字 /文件描述符 ------------》这时就不是阻塞了

3）那么再调用read（fd）accept（）等就不会阻塞了

3.如何添加非阻塞给套接字/文件描述符？  --------fcntl（）------man 2 fcntl

使用方法：

       #include <unistd.h>
       #include <fcntl.h>

       int fcntl(int fd, int cmd, ... /* arg */ );
 

参数：

     fd：  需要设置属性的套接字/文件描述符

     cmd： F_GETFL (void)   -------代表后面那个参数不用填

                F_SETFL (int)      --------代表后面那个参数需要填

     arg：   O_RDONLY, O_WRONLY, O_RDWR

                 O_NONBLOCK    ----非阻塞属性

 

返回值    成功： 

                          F_GETFL   //返回文件属性

                          F_SETFL  //返回0

                失败：

                         -1

4.假设有一个文件描述符叫fd，那么如何给这个fd添加非阻塞属性？

     ①获取fd原来的属性

              int state=fcntl （fd,F_GETFL）;

     ②在原来的属性上添加非阻塞的属性

              state=state | O_NONBLOCK   

      ③将state设置到fd上

              fcntl（fd，F_SETFL,state）；

 

非阻塞eg：

client 

#include "head.h"

int main(int argc,char *argv[])   //  ./Jack 192.168.19.5 50001
								  //  ./Jack 服务器的IP地址 端口号
{
	//1. 创建TCP协议套接字。
	int sockfd;
	sockfd = socket(AF_INET,SOCK_STREAM,0);

	//2. 打电话。
	struct sockaddr_in srvaddr;
	socklen_t len = sizeof(srvaddr);
	bzero(&srvaddr,len);

	srvaddr.sin_family = AF_INET;
	srvaddr.sin_port = htons(atoi(argv[2]));
	inet_pton(AF_INET,argv[1],&srvaddr.sin_addr);

	int ret = connect(sockfd,(struct sockaddr *)&srvaddr,len);
	if(ret == -1)
	{
		printf("connect error!\n");
	}

	//3. 不断发送数据给服务器。
	char buf[100] = {0};
	while(1)
	{
		bzero(buf,sizeof(buf));
		fgets(buf,sizeof(buf),stdin);
		send(sockfd,buf,strlen(buf),0);

		if(strncmp(buf,"quit",4) == 0)
		{
			break;
		}
	}

	//4. 挂断。
	close(sockfd);

	return 0;
}

sever

#include "head.h"

int main(int argc, char *argv[])
{
	//1. 创建TCP套接字
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);

	//2. 绑定IP地址
	struct sockaddr_in srvaddr;
	socklen_t len = sizeof(srvaddr);
	bzero(&srvaddr, len);

	srvaddr.sin_family = AF_INET;
	srvaddr.sin_port = htons(atoi(argv[1]));
	srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	bind(sockfd, (struct sockaddr *)&srvaddr, len);

	//3. 设置监听套接字。
	listen(sockfd, 20); //sockfd -> 阻塞(监听套接字)

	//4. 添加非阻塞到监听套接字上。
	int state;
	state = fcntl(sockfd, F_GETFL);
	state |= O_NONBLOCK;
	fcntl(sockfd, F_SETFL, state); //sockfd -> 非阻塞(监听套接字)

	//5. 等待连接
	struct sockaddr_in cliaddr;
	bzero(&cliaddr, sizeof(cliaddr));

	int connfd;
	char buf[100] = {0};
	while (1)
	{
		
		connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);
		if (connfd >= 0)
		{
			while (1)
			{
				bzero(buf, sizeof(buf));
				recv(connfd, buf, sizeof(buf), 0);
				printf("from:%s", buf);
				if (strncmp(buf, "quit", 4) == 0)
				{
					exit(0);
				}
			}
		}

	}

	//6. 关闭套接字。
	close(connfd);
	close(sockfd);

	return 0;
}

 

 

使用非阻塞IO、内核链表实现聊天室

sever

#include "head.h"
#include "kernel_list.h"
struct list_node
{
    int connfd;            //存放连接到服务器上的已连接套接字。
    struct list_head list; //统计当前连接到服务器中的人数。
};

struct list_node *init_list_head()
{

    struct list_node *head = malloc(sizeof(struct list_node));
    INIT_LIST_HEAD(&(head->list));
    return head;
}

void insert_data_to_list(struct list_node *head, int connfd)
{
    struct list_node *new = malloc(sizeof(struct list_node));
    new->connfd = connfd;
    list_add_tail(&(new->list), &(head->list));
    return;
}

int delete_list_node(struct list_node *head, int connfd)
{
    struct list_node *p = NULL;
    struct list_node *q = NULL;

    list_for_each_entry_safe(p, q, &(head->list), list)
    {
        if (p->connfd == connfd)
        {
            list_del(&(p->list));

            free(p);
            return 0;
        }
    }
    return -1;
}

void client_quest(struct list_node *head)
{   
    char buf[100] = {0};
    //遍历整个链表

    struct list_node *p = NULL;

    list_for_each_entry(p, &(head->list), list)
    {

        bzero(buf, sizeof(buf));

        if (recv(p->connfd, buf, sizeof(buf), 0) >= 0)
        {
            //说明者为顾客说话了
            printf("from %dclient:%s", p->connfd, buf);

            //如果该用户选择退出聊天室

            if (strncmp(buf, "quit", 4) == 0)
            {
                //让用户结束，将自己从链表中删除
                delete_list_node(head, p->connfd);
                return ;

            }
        }
    }

    return;
}

void delete_list(struct list_node *head)
{
    struct list_node *p = NULL;
    struct list_node *q = NULL;
    list_for_each_entry_safe(p, q, &(head->list), list)
    {
        //1. 从链表中将节点脱离了
        list_del(&(p->list));

        //2. 释放空间。
        free(p);
    }

    free(head);
    return;
}

int main(int argc, char *argv[]) // ./server 50001
{
    //0. 初始头节点。
    struct list_node *head = NULL;
    head = init_list_head();

    //1. 创建TCP套接字。
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);

    //2. 绑定IP地址。
    struct sockaddr_in srvaddr;
    socklen_t len = sizeof(srvaddr);
    bzero(&srvaddr, len);

    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(atoi(argv[1]));
    srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sockfd, (struct sockaddr *)&srvaddr, len);

    //3. 设置监听套接字。
    listen(sockfd, 5);

    //4. 设置非阻塞给监听套接字
    int state;
    state = fcntl(sockfd, F_GETFL);
    state |= O_NONBLOCK;
    fcntl(sockfd, F_SETFL, state);

    //5. 非阻塞地等待客户端的连接
    struct sockaddr_in cliaddr;
    bzero(&cliaddr, sizeof(cliaddr));
    int connfd, ret, i;
    char buf[100];

    while (1)
    {

        sleep(1);
        //6. 老板在门口非阻塞地迎宾。

        connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);

        //7. 如果真的有人进来吃饭，那么就在数组中安排桌位。
        if (connfd > 0)
        {
            //8. 将这个新人设置为非阻塞。
            state = fcntl(connfd, F_GETFL);
            state |= O_NONBLOCK;
            fcntl(connfd, F_SETFL, state);

            //9. 将这个人储存到链表中。
            insert_data_to_list(head, connfd);

            //10.将新连接到服务器的那个人的IP地址打印出来。
            printf("新用户连接进来: %s(%d)\n", inet_ntoa(cliaddr.sin_addr), connfd);
        }

        //11. 如果没有人进来吃饭，那么老板就会开始询问那个链接到服务器的客户端有没有话说。
        client_quest(head);
    }

    delete_list(head);

    return 0;
}