Select 实现网络聊天室功能 (服务器端)

最新推荐文章于 2023-11-01 18:23:27 发布
最新推荐文章于 2023-11-01 18:23:27 发布
阅读量429 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljf_djcrs/article/details/79016741
版权

服务器端：

ChatRoom.h

#ifndef  _CHATROOM_H_H
#define  _CHATROOM_H_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sqlite3.h>
#include <pthread.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>



#define  TRUE     1
#define  FALSE    2
#define  SUCCESS  3
#define  FAILURE  4
#define  PORT     8888

#define  REGISTER               100
#define  REG_SUCCESS            101
#define  LOGIN                  102
#define  LOG_SUCCESS            103
#define  LOG_FAILURE            104
#define  OnLine                 105
#define  NoOnLine               106
#define  Online                 107
#define  PrivateChat            108
#define  OFFLINE                109
#define  GroupChat              110
#define  ChatVip                111
#define  ShutUp                 112
#define  NoShutup               113
#define  SHUTUP                 114
#define  IsChatVip              115
#define  NoChatVip              116
#define  IsGroupShutup          117
#define  NoGroupShutup          118
#define  Kick                   119
#define  KickSuccess            120    
#define  KickFailure            121
#define  KickOk                 122
#define  KickNoOk               123
#define  Expression             124

struct user
{
	char id[20];
	char password[20];
	char username[20];
	char toname[20];
	int Tofd;                             //文件描述符
    int cmd;
    char online[20][20]	;
    int n;	                              //记录在线人数
	char buf[100];                        //聊天内容 
	int vip ;
    int speak;
	int find;
	char ep;                             

};

struct linknode
{
	struct user User;
	struct linknode *next;
};



void Register(struct user *U);
void Login(struct user *U);
int isOnLine(struct linknode *List, struct user *User);
void ListInsert(struct linknode *list, struct user *User);
void TraverList(struct linknode*list, struct user *User);
void ChatRoom(int chatfd, struct user recvbuf, struct user USER);
void DeleteList(struct linknode *list, struct user *User);
void TraverId(struct linknode *list, struct user User, sqlite3 *db);
void TraverFriend(struct linknode *list, struct user User, sqlite3 *db);
void gettime();
void DealVip(struct user User, sqlite3 *db);
void Shut_up(struct user User, sqlite3 *db);
void DealKick(struct linknode *list, struct user User, sqlite3 *db);
char *nowtime();
void ExpressionShow();
void des_ep(struct user User);

#endif


Server.c 

#include <stdio.h>
#include "ChatRoom.h"

struct linknode *UserList;

struct user RecvBuf = {0};

int isOnLine(struct linknode *list, struct user *User)
{

		struct linknode *p =list->next;
		while (p != NULL && strcmp(p->User.id, User->id) != 0 )
		{
			
			p = p->next;
		}
		if (p == NULL)
		{
			return NoOnLine;
		}
		return OnLine;

}

void ListInsert(struct linknode *list, struct user *User)
{
	    struct linknode *p = list;
		struct linknode*node = (struct linknode*)malloc(sizeof(struct linknode));
		
		strcpy(node->User.id, User->id); 
		strcpy(node->User.username, User->username);
		node->User.Tofd = User->Tofd;
		
		node->next = p->next;
		p->next = node;
		
}

/*void copyUser(struct user *User1, struct user *User2)
{
	strcpy((*User1).username, (*User2).username);
}*/

 void TraverList(struct linknode *list, struct user *User)
{
    
	int j = 0;
	if (list == NULL)
	{
		return ;
	}
	struct linknode *p  = list->next;
	while (p)
	{
		
	    strcpy(RecvBuf.online[j], p->User.username);
		j++;
		p = p->next;
	}
    RecvBuf.n = j; 
	send(User->Tofd, &RecvBuf, sizeof(RecvBuf), 0);

	memset(&RecvBuf, 0 , sizeof(RecvBuf));
    
	
}

void TraverId(struct linknode *list, struct user User, sqlite3 *db)
{
	int ret;
	char sql[300] = {0};
	char *errmsg = NULL;
	char **dbResult = NULL;
	int nRow, nCol;
	

	if (list == NULL)
	{
		return ;
	}
	struct linknode *p = list->next;
	
	while(p)
	{
		if (User.Tofd == p->User.Tofd)
		{
			strcpy(User.username, p->User.username);             //拷贝自己的名字
			break;
		}
		p = p->next;
	}
	
	sprintf(sql, "select speak from message where username = '%s';", User.username);
	ret  = sqlite3_get_table(db, sql, &dbResult, &nRow, &nCol, &errmsg);
	if (ret != SQLITE_OK)
	{
		perror("sqlite3_get_table");
		exit(1);
	}

	if (*dbResult[1]-48 == 1)
	{	User.find = SHUTUP;
		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}
	}
	else
	{
		p = list->next;
		while(p)
		{	
			if (!strcmp(p->User.username, User.toname ))
			{	
				User.find = NoShutup;
				ret = send(p->User.Tofd, &User, sizeof(User), 0);     //从链表中找出你想发送人的文件描述符
				if (ret < 0)
				{
					perror("send");
					exit(1);
				}
		
				break;		
			}
	
			p = p->next;

		}


	}
}

void DeleteList(struct linknode*list, struct user *User)
{
	struct linknode *p = list;
	struct linknode *tmp  ;

	if (p == NULL)
	{
		return;
	}

	while(p->next != NULL)
	{
		
		if (strcmp(p->next->User.id, User->id) == 0)       //根据帐号判断是否下线
		{
			tmp = p->next;
	        p->next = tmp->next;
	        free(tmp);
			break;
		}
		p = p->next;
	}


}




int main()
{
	struct user User;
	int sockfd,ret,fd[100] = {0};
	int length,j,i = 0;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	fd_set ReadFd, TmpFd;
	int MaxFd;
	int Tem;
	

	sqlite3 *ppdb;
	char sql[300] = {0};
	char **dbResult = NULL;
	int nRow, nCol;
	char *errmsg = NULL;

	UserList = (struct linknode*)malloc(sizeof(struct linknode));
	UserList->next = NULL;
    

	ret = sqlite3_open("message.db", &ppdb);                //打开或创建数据库
    if (ret != SQLITE_OK)
	{
		perror("sqlite3_open");
		exit(1);

	}
	sprintf(sql,"create table if not exists message (id text, password text, username text, vip integer, speak integer);");
	ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
	if (ret != SQLITE_OK)
	{
		perror("sqlite3_execl");
		exit(1);
	}

	sockfd = socket(PF_INET, SOCK_STREAM, 0);              // socket 建立连接，不用于发送消息
	if (sockfd < 0)
	{
		perror("sockfd");
		exit(1);
	}

	int opt = 1;
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));    //允许重复使用地址

	bzero(&server_addr, sizeof(server_addr));
	server_addr.sin_family = PF_INET;
	server_addr.sin_port = htons(PORT);
	server_addr.sin_addr.s_addr = inet_addr("192.168.0.128");

	ret = bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));    //绑定信息
	if (ret < 0)
	{
		perror("bind");
		exit(1);
	}

	
	ret = listen(sockfd, 20);                  //监听
	if (ret < 0)
	{
		perror("listen");
		exit(1);
	}

	FD_ZERO(&ReadFd);                          //初始化
	FD_ZERO(&TmpFd);
	FD_SET(sockfd, &ReadFd);                   //添加
	MaxFd = sockfd;

	while(1)
	{
		TmpFd = ReadFd;
		ret = select(MaxFd + 1, &TmpFd, NULL, NULL, NULL);
		if (-1 == ret)
		{
			perror("select");
			exit(1);
		}

		if(FD_ISSET(sockfd, &TmpFd))                            //检测
		{
			length = sizeof(client_addr);
			fd[i] = accept(sockfd, (struct sockaddr *)&client_addr, &length);
			if (fd[i] < 0)
			{
				perror("accept");
				exit(1);
			}

			printf("Accept  %d  Port  %d\n",fd[i], client_addr.sin_port);          //打印客户端端口号

			FD_SET(fd[i], &ReadFd);
			j = 0;
			Tem = fd[0];
			while(fd[j])
			{
				if (Tem < fd[j])
				{
					Tem = fd[j];
				}
				j++;
			}
			MaxFd = Tem;
			i++;
		}
		else
		{
			for(j = 0; j < i; j++)
			{
				if (FD_ISSET(fd[j], &TmpFd))
				{
					ret = recv(fd[j], &RecvBuf, sizeof(RecvBuf), 0);            //接收客户端的请求
					
					if (ret < 0)
					{
						perror("recv");
						exit(1);
					}
                        
					switch(RecvBuf.cmd)
					{

    
						case REGISTER:                        //注册用户信息
						{
							RecvBuf.Tofd = fd[j];
							
							memset(sql, 0, sizeof(sql));
                                                
							sprintf(sql, "insert into message (id, password, username, vip, speak) values ('%s', '%s', '%s', %d, %d);", RecvBuf.id, RecvBuf.password, RecvBuf.username, RecvBuf.vip,RecvBuf.speak);

							ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
							if (ret != SQLITE_OK)
							{			
								perror("sqlite3_exec2");
								exit(1);
							}
							RecvBuf.cmd = REG_SUCCESS;
                            send(RecvBuf.Tofd, &RecvBuf, sizeof(RecvBuf), 0);
						    memset(&RecvBuf, 0 , sizeof(RecvBuf));
							break;
						}

						case LOGIN:                                                //登录信息
						{
							RecvBuf.Tofd = fd[j];
						    memset(sql, 0, sizeof(sql));	
							sprintf(sql, "select * from message where id = '%s' and password = '%s';", RecvBuf.id, RecvBuf.password);
							ret = sqlite3_get_table(ppdb, sql,&dbResult, &nRow, &nCol, &errmsg);
							if (ret != SQLITE_OK)
							{
								perror("sqlite3_get_table");
							 	exit(1);
							} 
							
							
							int i;
							for (i = 0; i < (nRow + 1) * nCol; i++)
							{
								if (strcmp(dbResult[i],RecvBuf.id) == 0 && strcmp(dbResult[i+1], RecvBuf.password) == 0)
								{   
									ret = isOnLine(UserList, &RecvBuf);
									if (ret == OnLine)
									{
										RecvBuf.cmd = OnLine;
										break;
									}
									strcpy(RecvBuf.username,dbResult[i+2]);                        
									ListInsert(UserList, &RecvBuf);
									RecvBuf.cmd = LOG_SUCCESS;

									break;
								}

							}
	                         	send(RecvBuf.Tofd, &RecvBuf, sizeof(RecvBuf), 0);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
						}

						case Online:
							{
								RecvBuf.Tofd = fd[j];
								TraverList(UserList, &RecvBuf);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
					    case PrivateChat:
							{
								RecvBuf.Tofd = fd[j];
								TraverId(UserList, RecvBuf, ppdb);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
						case GroupChat:
							{
								RecvBuf.Tofd = fd[j];
								TraverFriend(UserList, RecvBuf, ppdb);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
						
						case ChatVip:
							{
								RecvBuf.Tofd = fd[j];
								DealVip(RecvBuf, ppdb);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
						case Kick:
							{
								RecvBuf.Tofd = fd[j];
								DealKick(UserList, RecvBuf, ppdb);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
						case ShutUp:
							{
								RecvBuf.Tofd = fd[j];
								Shut_up(RecvBuf, ppdb);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
						case Expression:
							{
								RecvBuf.Tofd = fd[j];
								Send_expression(UserList, RecvBuf, ppdb);
								memset(&RecvBuf, 0, sizeof(RecvBuf));
								break;
							}
						case OFFLINE:
							{
								RecvBuf.Tofd = fd[j];
								DeleteList(UserList, &RecvBuf);
								memset(&RecvBuf, 0, sizeof(RecvBuf));

								FD_CLR(fd[j], &ReadFd);
								close(fd[j]);
								break;
							}
					}	
				}
			}
		}

	}



	return 0;
}

TestServer.c 

#include <stdio.h>
#include "ChatRoom.h"

void TraverFriend(struct linknode *list, struct user User, sqlite3 *db)
{
	int ret;
	char sql[300] = {0};
	char *errmsg = NULL;
	char **dbResult = NULL;
	int nRow, nCol;

	if (NULL == list)
	{
		return;
	}

	struct linknode *p = list->next;

	while(p)
	{
		if (p->User.Tofd == User.Tofd)
		{
			strcpy(User.username, p->User.username);
			break;
		}
		p = p->next;
	}
	sprintf(sql, "select speak from message where username = '%s';", User.username);
	ret = sqlite3_get_table(db, sql, &dbResult, &nRow, &nCol, &errmsg);
	if (ret != SQLITE_OK)
	{
		perror("sqlite3_get_table");
		exit(1);
	}

	if (*dbResult[1] - 48 == 1)
	{   User.find = IsGroupShutup;
		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}
	}
	else
	{
		p = list->next;
		while(p)
		{
			if (strcmp(p->User.username, User.username) != 0)
			{	
				User.find = NoGroupShutup;
				ret = send(p->User.Tofd, &User, sizeof(User), 0);
				if (ret < 0)
				{
					perror("send");
					exit(1);
				}

			}
			p = p->next;
		}

	}

}


void DealVip(struct user User, sqlite3 *db)
{
	int ret;
	char sql[300] = {0};
	char *errmsg = NULL;
    char **dbResult = NULL;
	int nRow, nCol;

	sprintf(sql, "select vip from message where username = '%s';",User.username);
	ret = sqlite3_get_table(db, sql, &dbResult, &nRow, &nCol, &errmsg);
	if (ret != SQLITE_OK)
	{
		perror("sqlite3_get_table");
		exit(1);
	}

	if (*dbResult[1]-48 == 0)
	{
		User.vip = 1;
		memset(sql, 0, sizeof(sql));
		sprintf(sql, "update message set vip = %d where username = '%s';", User.vip, User.username);
		ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
		if (ret != SQLITE_OK)
		{
			perror("sqlite3_exec");
			exit(1);
		}

		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}
		
	}
	else
	{
		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}

	}


}

void Shut_up(struct user User, sqlite3 *db)
{
	int ret;
	char sql[300] = {0};
	char *errmsg = NULL;
    char **dbResult = NULL;
	int nRow, nCol;

	sprintf(sql, "select vip from message where username = '%s';", User.username);
	ret = sqlite3_get_table(db, sql, &dbResult, &nRow, &nCol, &errmsg);
	if (ret != SQLITE_OK)
	{
		perror("sqlite3_get_table");
		exit(1);
	}

	if (*dbResult[1] -  48 == 0)
	{
		User.find = NoChatVip;
		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}
	}
	else
	{
		User.speak = 1;
		User.find = IsChatVip;
		memset(sql, 0, sizeof(sql));
		sprintf(sql, "update message set speak = %d where username = '%s';", User.speak, User.toname);
		ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
		if (ret != SQLITE_OK)
		{
			perror("sqlite3_exec");
			exit(1);
		}

		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}

	}	

}

void DealKick(struct linknode *list, struct user User, sqlite3 *db)
{
		int ret;
		struct linknode *p = list;
		struct linknode *tmp;
		
		char sql[200] = {0};
		char *errmsg = NULL;
		char **dbResult = NULL;
		int nRow, nCol;

		if (p == NULL)
		{
			return ;
		}

		sprintf(sql, "select vip from message where username = '%s';", User.username);
		ret = sqlite3_get_table(db, sql, &dbResult, &nRow, &nCol, &errmsg);
		if (ret != SQLITE_OK)
		{
			perror("sqlite3_get_table");
			exit(1);
		}

		if (*dbResult[1] - 48 == 0)
		{
			User.find = KickFailure;
			ret = send(User.Tofd, &User, sizeof(User), 0);
			if (ret < 0)
			{
				perror("send");
				exit(1);
			}
		}
		else
		{
			while(p->next)
			{
				if (!strcmp(p->next->User.username, User.toname))    //要特别注意条件里的p->next是否成立
				{
					User.find = KickSuccess;
					ret = send(User.Tofd, &User, sizeof(User), 0);
					if (ret < 0)
					{
					perror("send");
					exit(1);
					}

					User.find = KickOk;
					User.Tofd = p->next->User.Tofd;
					ret = send(User.Tofd, &User, sizeof(User), 0);
					if (ret < 0)
					{
						perror("send");
						exit(1);
					}

					tmp = p->next;
					p->next = tmp->next;
					free(tmp);
					break;
				}
				p = p->next;
			}
			if (p->next == NULL)
			{
				User.find = KickNoOk;
				ret = send(User.Tofd, &User, sizeof(User), 0);
				if (ret < 0)
				{
					perror("send");
					exit(1);
				}
			}

		}

	

}

void Send_expression(struct linknode *list, struct user User, sqlite3 *db)
{
	int ret;
	char sql[200] = {0};
	char *errmsg = NULL;
    char **dbResult = NULL;
	int nRow, nCol;

	if (list == NULL)
	{
		return ;
	}
	struct linknode *p = list->next;

	sprintf(sql, "select speak from message where username = '%s';", User.username);
	ret = sqlite3_get_table(db, sql, &dbResult, &nRow, &nCol, &errmsg);
	if (ret != SQLITE_OK)
	{
		perror("sqlite3_get_table");
		exit(1);
	}
	if(*dbResult[1] - 48 == 1)
	{
		User.find = SHUTUP;
		ret = send(User.Tofd, &User, sizeof(User), 0);
		if (ret < 0)
		{
			perror("send");
			exit(1);
		}
	}
	else
	{
		p = list->next;
		while(p)
		{
			if (!strcmp(p->User.username, User.toname))
			{
				User.find = NoShutup;
				ret = send(p->User.Tofd, &User, sizeof(User), 0);
				if (ret < 0)
				{
					perror("send");
					exit(1);
				}
				break;
			}
			p = p->next;
		}
	}

}


ljf_djcrs
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
菜鸟学习历程【24】select 实现 聊天室（ Server / Client 模式）
leessang_bo的博客
01-05 728
聊天室项目实战 项目要求： 采用client/server架构 client A登录聊天服务器前，需要注册自己的ID和密码 注册成功后，client A就可以通过自己的ID和密码登录聊天服务器 多个 Client X 可以同时登陆聊天服务器之后,与其他用户进行通讯聊天 Client A 成功登陆后可以查看当前聊天室内其他在线用户 Client x Client A 可以选择发消息给某个特定的
select实现tcp并发服务器
weixin_52741083的博客
04-20 397
select实现tcp并发服务器，
基于WSAAsyncSelect模型的服务端和客户端设计（MFC）
weixin_45984283的博客
04-27 3669
目录1 效果展示1.1 服务器和客户端界面展示1.2 一对一之间通信的功能展示1.3 一对多之间通信的功能展示2 知识预备2.1 WSAAsyncSelect模型介绍2.2 WSAAsyncSelect模型的过程图2.3 与SELECT模型比较2.4 套接字WSAAsyncSelect模型实现2.5 网络事件种类2.6 WSAAsyncSelect模型的优势和不足3 代码展示3.1 服务端3.1.1 定义变量3.1.2 初始化界面3.1.3 启动服务器3.1.4 消息响应3.1.5 发送消息3.1.5 断开
利用select函数在Linux环境下实现一个聊天室程序
最新发布
bfbshs_ddd的博客
11-01 111
利用select函数实现linux环境下的简易聊天室程序
select函数实现一个服务器与多个客户端的通信
12-06
利用select函数实现I/O复用，可进行一个服务器与多个客户端的通信。-CSU某课内作业
计算机公共实验-linux下基于多线程的网络聊天室
11-26
本实验是一个Linux下的聊天工具，是一个基于多线程的并发程序。程序实现分客户端和服务端，其中客户端采用界面形式，服务端无界面，用于可以通过客户端登录、注册、聊天、查看聊天记录等。
linux网络聊天室(select服务器)
08-14
【描述】：“基于Linux的网络聊天室，在多线程版本下修改为select版本，其中线程部分未删除，不影响功能使用” 这个描述暗示了该聊天室程序曾经采用多线程模型，每个客户端连接都有一个独立的线程来处理。然而，...
linux系统下实现聊天室
06-20
要创建一个聊天室服务器，我们需要使用`socket()`函数创建一个套接字，然后用`bind()`函数绑定一个本地IP地址和端口号，再用`listen()`函数设置最大连接队列长度，例如5个，表示服务器最多可以同时处理5个客户端的...
linux下c实现的聊天室
01-06
在聊天室中，服务器端需要管理多个客户端的连接，这就涉及到了多路复用技术，如select、poll或epoll等。 接着，客户端也需要创建socket并使用`connect()`函数与服务器建立连接。一旦连接成功，客户端和服务器端都...
基于QT和select的多人网络聊天室 Qt(客户端) Socket(服务端)
11-02
本项目“基于QT和select的多人网络聊天室”是一个实现客户端-服务器通信的经典案例，它利用了QT库的强大功能以及socket编程中的select模型来处理多个并发连接。以下是这个项目中涉及的重要知识点： 1. **QT库**：QT...
聊天室服务器端改进版 多线程
03-30
4. **网络编程基础**：聊天室服务器端通常基于TCP/IP协议栈进行网络通信，使用Socket接口实现客户端与服务器间的连接建立、数据传输和断开。TCP协议提供可靠的数据传输，保证数据的顺序和不丢失。 5. **事件驱动...
使用socket实现基于select模型的网络聊天室
weixin_30736301的博客
09-27 547
假期闲来无事，便写了个小小的网络聊天室程序。以前一直都是写MFC的有界面的程序，时间长了，便失去了兴趣，感觉有些东西经过MFC的封装，反而失去了意义，让人学不到东西，所以，丢开MFC那层的东西，直接使用socket来实现，要知道直接在黑白屏下实现有界面的那种效果，难度还是有的，喜欢挑战自我，是我的个性。 网络程序，有一些I/O模型的，阻塞的，就是你什么也不做的，就是直接开始写的recv...
基于select模型的多人聊天程序(C++)
_ACME_的博客
11-18 3115
原理参考该博文： http://blog.csdn.net/qq_18297675/article/details/53224494该程序采用select模型设计（只是服务器采用），服务器端只有四个线程。 1.接受请求线程 2.接收数据线程 3.发送数据线程 4.管理client状态线程优势显而易见，只用了四个线程，不用给每个client开辟一个新的线程管理。select模型的核心就是“轮
基于select模型的TCP服务器
如风
07-29 8988
之前的一篇博文是基于TCP的服务器和客户机程序，今天在这我要实现一个基于select模型的TCP服务器（仅实现了服务器）。 socket套接字编程提供了很多模型来使服务器高效的接受客户端的请求，select就是其中之一。 了解select模型我们先来看一下的代码： int iResult = recv(s, buffer,1024); 这 是用来接收数据的，在默认的阻塞模式下的套接字里，r
基于select函数的单进程并发服务器程序----TCP
曹绍坚(嵌入式学生)
04-12 895
下面是一个简单的时间服务器程序。 #include #include #include #include #include #include #include #include #include #define MAX_LISTEN 5 #define PORT 1234 i
IO多路复用--select系统调用+基于select实现并发服务器
偶然i的博客
08-04 499
多路转接模型 作用 针对大量描述符的I0进行就绪事件监控, 能够让进程在对大量描述符的IO操作中，仅仅针对就绪了指定IO事件的描述符进行操作，避免了对于没有就绪的描述进行操作，进而提高了IO效率,并且避免了对未就绪描述进行的阻塞操作导致程序流程无法推进示例:tcp服务器 tcp服务端程序会为每一个客户端的连接创建一个新的套接字,并使用新的套接字描述符与客户端进行通信，但是并不是每个客户端都会一直给服务器发送数据, 并且一直有新连接到来，在固定的流程中会因为对没有新连接到来进行的...
IO多路复用（select）多线程实现点对点聊天
Xinspace
04-05 1984
在网络编程中，IO操作不止本地的read或write，还会有网络套接字上的read和write。这样的话就容易出现这个问题： 当你用fgets函数在等待本地的标准输入，这时IO输入操作会阻塞在这里等待输入。如果此时网络套接字上传来了数据（比如说关闭连接命令），由于你的IO被阻塞在fgets处，无法及时知道网络套接字上传来的关闭命令。当你从fgets处获得数据后，再处理网络套接字发来的关闭命令
计算机网络课设_基于TCP协议编程的网络聊天室.docx
07-07
"基于TCP协议的网络聊天室设计与实现" 设计一个基于TCP协议的网络聊天室是一项典型的计算机网络课程设计任务，它涉及到客户端-服务器（C/S）架构、网络通信以及多用户交互等多个核心概念。以下是这个项目的主要知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值