Tinychatserver: 一个简易的命令行群聊程序

这是学习网络编程后写的一个练手的小程序,可以帮助复习socket,I/O复用,非阻塞I/O等知识点。

通过回顾写的过程中遇到的问题的形式记录程序的关键点,最后给出完整程序代码。

0. 功能

编写一个简易群聊程序,程序具备的基本功能:

服务器:支持多个客户端连接,并将每个客户端发过来的消息发给所有其他的客户端

客户端:能够连接服务器,并向服务器发送消息,同时接收服务器发过来的任何消息

1. Server I/O模型

采用事件驱动(I/O复用)+ 非阻塞I/O的模型,即Reactor模式。I/O复用采用linux下的epoll机制。

相关API介绍见最后,先梳理几个写程序的时候想到的问题。

1.1  I/O复用为什么搭配非阻塞I/O?(select/epoll返回可读后还用非阻塞是不是没有意义?)

  select/epoll返回了可读,并不一定代表能读,在返回可读到调用read函数之间,是有时间间隙的。内核可能把数据丢失,也可能存在比如多个线程监听该socket,

数据被别人读走的情况。所以这里使用非阻塞I/O是有意义的。

可以参考知乎这个问题 https://www.zhihu.com/question/37271342

1.2 epoll的条件触发LT(水平触发)和边缘触发ET区别,如何正确地处理ET模式下的读操作?

简单讲,以读取数据操作举例。条件触发,只要输入缓冲中还有数据,就会以事件方式再次注册;

而边缘触发中仅在输入缓冲收到数据时注册一次该事件(你没读完也epoll_wait也不再返回了)。

所以如果使用边缘触发发生输入相关事件,需要读取输入缓冲中的全部数据。方法是一直读,直到read返回-1,并且变量errno中的值为EAGAIN,说明没有数据可读。

所以在这里再次考虑一下1.1中的问题,epoll如果采用边缘触发,更要使用非阻塞I/O,否则可能就因为无数据可读阻塞整个线程了。

1.3  select与epoll的差别

一个老生常谈的问题,select函数效率低主要有以下两个原因,首先是每次调用select函数时需要向操作系统传递监视对象信息,其次是调用后针对所有文件描述符的循环语句。

第一点对效率的影响更大。

此外,epoll还支持ET模式,而select只支持LT模式。

但select也有优点,比如兼容性好(大多数操作系统支持),在服务端介入者少的情况下仍然可以考虑使用select。

1.4 epoll相关API

// 创建一个epoll句柄,参数size向操作系统建议epoll例程大小
int epoll_create(int size) /*
函数功能: epoll事件注册函数
参数epfd为epoll的句柄,即epoll_create返回值
参数op表示动作,用3个宏来表示:
   EPOLL_CTL_ADD(注册新的fd到epfd),
  EPOLL_CTL_MOD(修改已经注册的fd的监听事件),
   EPOLL_CTL_DEL(从epfd删除一个fd);
   其中参数fd为需要监听的标示符;
参数event告诉内核需要监听的事件,event的结构如下:
struct epoll_event {
__uint32_t events; //Epoll events
epoll_data_t data; //User data variable
};
其中介绍events是宏的集合,常用的有:
EPOLLIN:有数据可读
EPOLLONESHOT:发生一次事件后,相应的文件描述符不再收到事件通知。因此需要向第二个参数传递EPOLL_CTL_MOD再次设置事件。 例如在多线程处理时,如果某个线程在处理fd的同时,又有新的一批数据发来,该fd可读,那么该fd会被分给另一个线程,这样两个线程处理同一个fd肯定就不对了,
这时用EPOLLONESHOT可以解决。在fd返回可读后,需要显式地设置一下才能让epoll重新返回这个fd。
*/
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) // 等待事件的产生,函数返回需要处理的事件数目
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)

2. Client怎么处理?

Client采用分割读写的方式,开两个进程。父进程负责负责接受数据,子进程负责发送数据。

      if (pid == ) {
//子进程负责写操作
write_routine(sock);
}
else {
//父进程负责读操作
read_routine(sock);
}

3. 代码

代码中有详细注释

 //utility.h
#ifndef UTILITY_H_
#define UTILITY_H_ #include <iostream>
#include <list>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h> using namespace std; // clients_list save all the clients's socket
list<int> clients_list; /********************** macro defintion **************************/
// server ip
#define SERVER_IP "127.0.0.1" // server port
#define SERVER_PORT 8888 //epoll size
#define EPOLL_SIZE 5000 //message buffer size
#define BUF_SIZE 0xFFFF #define SERVER_WELCOME "Welcome you to join the chatroom! Your chat ID is: Client #%d" #define SERVER_MESSAGE "ClientID %d say >> %s" // exit
#define EXIT "EXIT" #define CAUTION "There is only one int the chatroom!" /********************** some function **************************/
/**
*设置非阻塞IO
**/
int setnonblocking(int sockfd)
{
fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, )| O_NONBLOCK);
return ;
} /**
* 将文件描述符fd添加到epollfd标示的内核事件表中, 并注册EPOLLIN事件,
* EPOOLET表明是ET工作方式,根据enable_et来判定是否设置边缘触发。
* 最后将文件描述符设置非阻塞方式
**/
void addfd( int epollfd, int fd, bool enable_et )
{
struct epoll_event ev;
ev.data.fd = fd;
ev.events = EPOLLIN;
if( enable_et )
ev.events = EPOLLIN | EPOLLET;
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
setnonblocking(fd);
printf("fd added to epoll!\n\n");
} /**
* 群发消息
**/
int sendBroadcastmessage(int clientfd)
{
// buf[BUF_SIZE] receive new chat message
// message[BUF_SIZE] save format message
char buf[BUF_SIZE], message[BUF_SIZE];
bzero(buf, BUF_SIZE);
bzero(message, BUF_SIZE); // receive message
printf("read from client(clientID = %d)\n", clientfd);
int len = recv(clientfd, buf, BUF_SIZE, ); if(len == ) // len = 0 means the client closed connection
{
close(clientfd);
clients_list.remove(clientfd); //server remove the client
printf("ClientID = %d closed.\n now there are %d client in the chatroom\n", clientfd, (int)clients_list.size()); }
else //broadcast message
{
if(clients_list.size() == ) { // this means There is only one int the chatroom
send(clientfd, CAUTION, strlen(CAUTION), );
return len;
}
// format message to broadcast
sprintf(message, SERVER_MESSAGE, clientfd, buf); list<int>::iterator it;
for(it = clients_list.begin(); it != clients_list.end(); ++it) {
if(*it != clientfd){
if( send(*it, message, BUF_SIZE, ) < ) { perror("error"); exit(-);}
}
}
}
return len;
}
#endif // UTILITY_H_
 //Server.cpp

 #include "utility.h"

 int main(int argc, char *argv[])
{
//服务器端口号和IP地址
struct sockaddr_in serverAddr;
serverAddr.sin_family = PF_INET;
serverAddr.sin_port = htons(SERVER_PORT);
serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);
//创建监听套接字
int listener = socket(PF_INET, SOCK_STREAM, );
if(listener < ) {
perror("listener"); exit(-);
}
printf("listen socket created \n");
//绑定地址
if( bind(listener, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < ) {
perror("bind error");
exit(-);
}
//listen
int ret = listen(listener, );
if(ret < ) {
perror("listen error");
exit(-);
}
printf("Start to listen: %s\n", SERVER_IP);
//创建epoll事件表
int epfd = epoll_create(EPOLL_SIZE);
if(epfd < ) {
perror("epfd error");
exit(-);
}
printf("epoll created, epollfd = %d\n", epfd);
static struct epoll_event events[EPOLL_SIZE];
//注册监听套接字到epoll事件表
addfd(epfd, listener, true);
//main loop
while()
{
//epoll_events_count指明待处理事件数
int epoll_events_count = epoll_wait(epfd, events, EPOLL_SIZE, -);
if (epoll_events_count < ) {
perror("epoll failure");
break;
} printf("epoll_events_count = %d\n", epoll_events_count);
//处理事件
for (int i = ; i < epoll_events_count; ++i)
{
int sockfd = events[i].data.fd;
//sockfd == listener表明有新连接
if(sockfd == listener)
{
struct sockaddr_in client_address;
socklen_t client_addrLength = sizeof(struct sockaddr_in);
int clientfd = accept( listener, ( struct sockaddr* )&client_address, &client_addrLength ); printf("client connection from: %s : % d(IP : port), clientfd = %d \n",
inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port), clientfd); //把新连接加入epoll事件表中
addfd(epfd, clientfd, true); // 把clientfd加入客户连接的list内
clients_list.push_back(clientfd);
printf("Add new clientfd = %d to epoll\n", clientfd);
printf("Now there are %d clients int the chat room\n", (int)clients_list.size()); // 想新连接发送欢迎信息
printf("welcome message\n");
char message[BUF_SIZE];
bzero(message, BUF_SIZE);
sprintf(message, SERVER_WELCOME, clientfd);
int ret = send(clientfd, message, BUF_SIZE, );
if(ret < ) {
perror("send error");
exit(-);
}
}
//sockfd != listener表明之前的连接发来数据,将数据群发给所有连接对象
else
{
printf("i got an message");
int ret = sendBroadcastmessage(sockfd);
if(ret < ) { perror("error");exit(-); }
}
}
}
close(listener); //close socket
close(epfd); //close epoll instance
return ;
}
 //Client.cpp

 #include "utility.h"

 void write_routine(int sock);
void read_routine(int sock);
int main(int argc, char *argv[])
{
//服务器IP和端口
struct sockaddr_in serverAddr;
serverAddr.sin_family = PF_INET;
serverAddr.sin_port = htons(SERVER_PORT);
serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP); // create socket
int sock = socket(PF_INET, SOCK_STREAM, );
if(sock < ) { perror("sock error"); exit(-); } // 连接服务器
if(connect(sock, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < ) {
perror("connect error");
exit(-);
}
char buf[BUF_SIZE];
int str_len = read(sock, buf, BUF_SIZE);
if (str_len == ) {
return ;
}
buf[str_len] = ;
printf("%s\n", buf); pid_t pid = fork();
if (pid == ) {
//子进程负责写操作
write_routine(sock);
}
else {
//父进程负责读操作
read_routine(sock);
} return ;
} void read_routine(int sock) {
char buf[BUF_SIZE];
while() {
memset(buf, , sizeof(buf));
int str_len = read(sock, buf, BUF_SIZE);
if (str_len == ) {
return;
}
buf[str_len] = ;
printf("%s", buf);
}
} void write_routine(int sock) {
char buf[BUF_SIZE];
while() {
memset(buf, , sizeof(buf));
fgets(buf, BUF_SIZE, stdin);
if (!strcmp(buf, "exit\n")) {
shutdown(sock, SHUT_WR);
return;
}
write(sock, buf, strlen(buf));
}
}
上一篇:poj 2125 Destroying The Graph 最小割+方案输出


下一篇:冬季实战营学习报告