12.20

1tcp客户端

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include<netinet/in.h>
 
//打印错误信息
#define ERR_MSG(msg) do{\
    fprintf(stderr,"__%d__",__LINE__); \
    perror(msg);}while(0)
 
#define PORT 3333     //1024——49151
#define IP "192.168.10.57"   //本机IP
 
int updateMaxfd(int maxfd,fd_set readfds)
{
    int i = maxfd;
    for(;i>0;i--)
    {
        if(FD_ISSET(i,&readfds))
            return i;
    }
    return 0;
}
 
int main(int argc, const char *argv[])
{
    //创建流式套接字
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
 
    //绑定客户端的地址信息结构体（非必须绑定)
    //填充要连接的服务器的地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
 
    //连接服务器
    if(connect(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0)
    {
        ERR_MSG("connect");
        return -1;
    }
    printf("connect server success\n");
 
    //创建一个集合
    fd_set readfds,tempfds;
 
    //将集合清空
    FD_ZERO(&readfds);
    FD_ZERO(&tempfds);
 
    //将0号文件描述符添加到集合
    FD_SET(0,&readfds);
 
    //将sfd文件描述符添加到集合
    FD_SET(sfd,&readfds);
 
    //设置最大文件描述符
    int maxfd = sfd;
    int s_res = 0;
 
    char buf[128] = "";
    ssize_t res = 0;
 
    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    int i;
    while(1)
    {
        tempfds = readfds;
        //调用select,让内核去监测文件描述符集合
        res = select(maxfd+1,&tempfds,NULL,NULL,NULL);
        if(s_res < 0)
        {
            ERR_MSG("select");
            return -1;
        }
 
        //判断集合中剩下哪个文件描述符，走对应函数即可
        for(i=0;i<=maxfd;i++)
        {
            if(FD_ISSET(i,&tempfds) == 0)
            {
                continue;
            }
 
            if(0 == i)
            {
                bzero(buf,sizeof(buf));
                printf("请输入>>>");
                fgets(buf,sizeof(buf),stdin);
                buf[strlen(buf)-1] = 0;
 
                if(send(sfd,buf,sizeof(buf),0) < 0)
                {
                    ERR_MSG("send");
                    return -1;
                }
                printf("send success\n");
            }
            if(sfd == i)
            {
                bzero(buf,sizeof(buf));
 
                res = recv(i,buf,sizeof(buf),0);
 
                if(res < 0)
                {
                    ERR_MSG("recv");
                    return -1;
                }
                else if(0 == res)
                {
                    printf("服务器断开连接\n");
                    close(i);
                    FD_CLR(i,&readfds);
                    maxfd = updateMaxfd(maxfd,readfds);
                    break;
                }
                else
                {
 
                    printf("%s\n",buf);
                }
            }
 
        }
    }
    close(sfd);
    return 0;
}
 

2tcp并发服务器

#include<myhead.h>
#define PORT 8888              //端口号
#define IP "192.168.115.162"       //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);          //客户端地址信息的大小
 
	//定义一个容器
	char buf[128] = "";
	int maxfd = sfd;
	///定义一个集合管理sfd和newfd
	struct pollfd fds[maxfd-2];
	///将sfd文件描述符放入
	fds[0].fd = sfd;
	fds[0].events = POLLIN;  //表明要进行读事件
	
	int rct = 0; //接收poll返回的结果
 
 
	while(1){
		rct = poll(fds,maxfd+1,-1);    //第三个参数如果是负数，表明一直等待
		if(rct == -1){
			perror("poll error");
			return -1;
		}else if(rct == 0){
			printf("time out\n");
			return -1;
		}
		if(fds[0].revents == POLLIN){
			//4.2、阻塞接收客户端的链接请求，并且获取客户端的地址信息
			int 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__);
			fds[newfd].fd = newfd;
			fds[newfd].events = POLLIN;
			if(newfd>maxfd){
				maxfd = newfd;
			}
		}
		for(int i = 1;i<=maxfd;i++){
			if(fds[i].revents == POLLIN){
				//清空字符串
				bzero(buf, sizeof(buf));
				int res = recv(i, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息
 
				//判断收到的结果
				if(res == 0)
				{
					printf("客户端已经下线\n");
					close(i);
					break;
				}else if(res < 0)
				{
					perror("recv error");
					return -1;
				}
 
				printf("[%s:%d]：%s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
 
				//将读取的信息，加上一些字符发送回去
				strcat(buf, "*_*");
				send(i, buf, sizeof(buf), 0);
 
			}
		}
 
	}
	close(sfd);
}