11/22作业

select

1.服务器端

#include<myhead.h>

#define PORT 8888              //端口号
#define IP "192.168.114.142"       //IP地址


int main(int argc, const char *argv[])
{
    //1、创建用于接受连接的套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }

    printf("socket success sfd = %d\n", sfd);    //4


    //设置端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("设置端口快速重用成功 _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);

    



    //2、绑定IP地址和端口号
    //2.1、填充要绑定的地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family     = AF_INET;         //表明是ipv4
    sin.sin_port     = htons(PORT);        //端口号
    sin.sin_addr.s_addr = inet_addr(IP);     //IP地址

    //2.2、绑定
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);

    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128) == -1)
    {
        perror("listen error");
        return -1;
    }

    printf("listen success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);

    //4、阻塞等待客户端连接请求，如果有新的客户端连接，则创建一个新的用于通信的套接字
    //4.1、定义客户端地址信息结构体
    struct sockaddr_in cin;             //客户端地址信息结构体
    cin.sin_family     = AF_INET;
    socklen_t socklen = sizeof(cin);          //客户端地址信息的大小


    定义一个用于检测文件描述符的集合
    fd_set readfds, tempfds;                          //在栈区定义

    清空容器中的内容
    FD_ZERO(&readfds);
    将要检测的文件描述符放入集合中
    FD_SET(sfd, &readfds);           //将sfd文件描述符放入
    FD_SET(0, &readfds);             //将0号文件描述符放入



    //定义一个容器
    char buf[128] = "";
    int res = 0;             //接收select的返回值
    int newfd = -1;          //存放用于最新连接客户端的套接字
    int maxfd = sfd;          //定义控制select函数中最大文件描述符

    struct sockaddr_in saveCin[1024];       //用于存放客户端地址信息结构体


    while(1)
    {
        将集合内容复制一份
        tempfds = readfds;

        使用select阻塞等待集合中的文件描述符有事件产生
        res = select(maxfd+1, &tempfds, NULL, NULL, NULL);
        if(res == -1)
        {
            perror("select error");
            return -1;
        }else if(res == 0)
        {
            printf("time out\n");
            return -1;
        }


        //遍历所有集合中文件描述符
        for(int i=0; i<=maxfd; i++)
        {
            //判断当前i是否在集合中，如果不在，直接判断下一个
            if(!FD_ISSET(i, &tempfds))
            {
                continue;
            }

            判断sfd是否还在集合中
            if( i == sfd)
            {
                //4.2、阻塞接收客户端的链接请求，并且获取客户端的地址信息
                newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
                if(newfd == -1)
                {
                    perror("accept error");
                    return -1;
                }
                printf("accept success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);

                将newfd放入readfds中
                FD_SET(newfd , &readfds);

                //更新maxfd
                if(newfd > maxfd)
                {
                    maxfd = newfd;
                }

                //将最新的客户端套接字放入数组的下标为new的位置
                saveCin[newfd] = cin;
                printf("newfd = %d\n", newfd);

            }else if(i == 0 )    //判断是否是终端输入

            {
                char buf1[128] = "";

                bzero(buf, sizeof(buf));
                //从终端获取数据
                fgets(buf, sizeof(buf), stdin);       //从终端获取数据
                buf[strlen(buf)-1]='\0';
                printf("触发终端输入事件:%s\n", buf);

                sprintf(buf1, "%s%s", "系统消息：", buf);

                //将数据发送给所有客户端
                for(int j=4; j<=maxfd; j++)
                {
                    send(j, buf1,sizeof(buf1), 0);
                }


            }else
            {
                //5、收发数据使用newfd完成通信
                char buf[128] = "";
                //清空字符串
                bzero(buf, sizeof(buf));
                int ret = recv(i, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息

                //判断收到的结果
                if(ret == 0)
                {
                    printf("客户端已经下线\n");    
                    close(i);             //关闭通信的套接字

                    将当前的文件描述符从集合中删除
                    FD_CLR(i, &readfds);

                    更新maxfd
                    for(int j=maxfd; j>=0; j--)
                    {
                        //判断当前的j是否在集合中，如果在，则为maxfd
                        if(FD_ISSET(j, &readfds))
                        {
                            maxfd = j;
                            break;
                        }
                    }

                    continue;           //继续判断下一个
                }else if(ret < 0)
                {
                    perror("recv error");
                    return -1;
                }

                printf("[%s:%d]：%s\n", inet_ntoa(saveCin[i].sin_addr), ntohs(saveCin[i].sin_port), buf);

                //将读取的信息，加上一些字符发送回去
                strcat(buf, "*_*");
                send(i, buf, sizeof(buf), 0); 


            }
        }

    }



    //6、关闭所有套接字
    close(sfd);               //关闭监听

    return 0;
}

2.客户端

#include<myhead.h>
#define SERIP "192.168.114.142"
#define SERPORT 8888
#define CLIIP "192.168.114.142"
#define CLIPORT 7777
 
int main(int argc, const char *argv[])
{
	//1、创建客户端用于通信的套接字
	int cfd = socket(AF_INET,SOCK_STREAM,0);
	if(cfd==-1)
	{
		perror("socket error");
		return -1;
	}
	printf("cfd=%d\n",cfd);
 
	//2、绑定(可选)
	//2.1填充地址信息结构体
	struct sockaddr_in cin;
	cin.sin_family = AF_INET;    //使用的是IPV4通信
	cin.sin_port = htons(CLIPORT);   //服务器端口号
	cin.sin_addr.s_addr = inet_addr(CLIIP);    //服务器IP地址
	//2.2绑定工作
	if(bind(cfd,(struct sockaddr*)&cin,sizeof(cin))==-1)
	{
		perror("bind error");
		return -1;
	}
	//3.连接服务器
	//3.1、填充服务器地址信息结构体
	struct sockaddr_in sin;
	sin.sin_family = AF_INET;    //使用的是IPV4通信
	sin.sin_port = htons(SERPORT);   //服务器端口号
	sin.sin_addr.s_addr = inet_addr(SERIP);    //服务器IP地址
	//3.2、连接服务器
	if(connect(cfd,(struct sockaddr*)&sin,sizeof(sin))==-1)
	{
		perror("connect error");
		return -1;
	}
	printf("connect success\n");
 
	定义一个用来检测文件描述符的集合
	fd_set readfds;
 
	清空容器中的内容
	FD_ZERO(&readfds);
	将要检测的文件描述符放入集合中
	FD_SET(cfd,&readfds);
	FD_SET(0,&readfds);
 
	int res=0;//接收select的返回值
	//4.收发数据
	char buf[128]="";
	char rbuf[128]="";
 
	while(1)
	{
		res=select(cfd+1,&readfds,NULL,NULL,NULL);
		if(res==-1)
		{
			perror("select error");
			return -1;
		}else if(res==0)
		{
			printf("time out\n");
			return -1;
		}else
		{
			bzero(buf,sizeof(buf));
			bzero(rbuf,sizeof(rbuf));
 
				fgets(buf,sizeof(buf),stdin);    //从标准输入中读取数据
				buf[strlen(buf)-1]='\0';
				//将数据发送给服务器
				send(cfd,buf,sizeof(buf),0);
				if(strcmp(buf,"quit")==0)
				{
					break;
				}
				//接收服务器发送来的消息
				int res=recv(cfd,rbuf,sizeof(rbuf),0);
				if(res==0)
				{
					printf("服务器已经关闭\n");
					break;
				}
				printf("rbuf=%s\n",rbuf);
		}
	}
		//5、关闭客户端
		close(cfd);
		return 0;
}
————————————————
版权声明：本文为CSDN博主「47不乖」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_65427718/article/details/134561987

POLL

1.客户端

2.服务器端

#include<myhead.h>
#define SERIP "192.168.114.142"
#define SERPORT 8888
#define CLIIP "192.168.114.142"
#define CLIPORT 6666

int main(int argc, const char *argv[])
{
    //1、创建客户端用于通信的套接字
    int cfd = socket(AF_INET, SOCK_STREAM, 0);
    if(cfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("cfd = %d\n", cfd);                //3


    //2、绑定（可选）
    //2.1、填充地址信息结构体
    struct sockaddr_in cin;
    cin.sin_family     = AF_INET;            //使用的是ipv4通信
    cin.sin_port     = htons(CLIPORT);       //服务器端口号
    cin.sin_addr.s_addr     = inet_addr(CLIIP);       //服务器IP地址
    //2.2、绑定工作
    if(bind(cfd, (struct sockaddr*)&cin, sizeof(cin)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");


    //3、连接服务器
    //3.1、填充服务器地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family     = AF_INET;            //使用的是ipv4通信
    sin.sin_port     = htons(SERPORT);       //服务器端口号
    sin.sin_addr.s_addr     = inet_addr(SERIP);       //服务器IP地址

    //3.2、连接服务器
    if(connect(cfd, (struct sockaddr*)&sin, sizeof(sin)) ==-1)
    {
        perror("connect error");
        return -1;
    }
    printf("connect success\n");

    //4、收发数据（send、recv、read、write）
    char buf[128] = "";
    char rbuf[128] = "";

    定义一个集合管理0号文件描述符和cfd
    struct pollfd fds[2];

    //将0号文件描述符放入
    fds[0].fd = 0;
    fds[0].events = POLLIN;          //表明要进行读事件

    //将cfd放入集合
    fds[1].fd = cfd;
    fds[1].events = POLLIN;

    int res = 0;     //接收poll返回的结果


    while(1)
    {
        res = poll(fds, 2, -1);          //第三个参数如果是负数，表明一直等待
        if(res == -1)
        {
            perror("poll error");
            return -1;
        }else if(res == 0)
        {
            printf("time out\n");
            return -1;
        }


        bzero(buf, sizeof(buf));
        bzero(rbuf, sizeof(rbuf));



        //判断是否是发送数据满足条件
        if(fds[0].revents == POLLIN)
        {
            fgets(buf, sizeof(buf), stdin);       //从标准输入中读取数据
            buf[strlen(buf)-1] = '\0';

            //将数据发送给服务器
            send(cfd, buf, sizeof(buf), 0);

            //如果输入的是quit则退出
            if(strcmp(buf,"quit") == 0)
            {
                break;
            }
        }



        //判断是否为接收数据满足条件
        if(fds[1].revents == POLLIN)
        {

            //接收服务器发送来的消息
            int res = recv(cfd, rbuf, sizeof(rbuf), 0);
            if(res == 0)
            {
                printf("服务器已经关闭\n");
                break;
            }
            printf("rbuf = %s\n", rbuf);
        }

    }

    //5、关闭客户端套接字
    close(cfd);
    

    return 0;
}