Linux下select函数实现的聊天服务器

最新推荐文章于 2023-11-01 18:23:27 发布

freezgw1985

最新推荐文章于 2023-11-01 18:23:27 发布

阅读量929

点赞数

分类专栏： linux 文章标签： linux 聊天 null include search cmd

本文链接：https://blog.csdn.net/freezgw1985/article/details/5647835

版权

linux 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

消息缓冲区类MessageBuffer，接收线程将受到的消息放入缓冲区，发送线程从缓冲区中取出消息

MessageBuffer.h

//MessageBuffer.h
#ifndef _MESSAGE_BUF_INCLUDE_
#define _MESSAGE_BUF_INCLUDE_
#include <pthread.h>
#define MESSAGE_COUNT 16
#define MESSAGE_LENGTH 2048
class MessageBuffer{
private:
pthread_mutex_t mutex;//访问缓冲的互斥量
pthread_cond_t condition;//访问缓冲区的条件变量
//消息缓冲区，循环队列
char buf[MESSAGE_COUNT][MESSAGE_LENGTH];
int rear; //循环队列的队尾
int front; //循环队列的队首
public:
bool toStop;
//构造函数
MessageBuffer();
//析构函数
virtual ~MessageBuffer();
//将消息放入消息缓冲区，当缓冲区满时阻塞，toStop=true时返回-1
int PutMessage(const char *message);
//从消息缓冲区中获得消息，当缓冲区空时阻塞，toStop=true时返回-1
int GetMessage(char *mbuf, int buflen);
};
#endif

MessageBuffer.cpp

//MessageBuffer.cpp
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
#include "MessageBuffer.h"
MessageBuffer::MessageBuffer() {
toStop = false;
pthread_mutex_init(&mutex,NULL);//初始化互斥量
pthread_cond_init(&condition,NULL);//初始化条件变量
rear = 0; //队尾指针指向0
front = 0; //队首指针指向0
printf("A MessageBuffer intance created./n");
}
MessageBuffer::~MessageBuffer(){
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&condition);
printf("A MessageBuffer instance destroyed./n");
}
//将消息放入消息缓冲区
int MessageBuffer::PutMessage(const char *message){
struct timespec t;
//等待互斥量
pthread_mutex_lock(&mutex);
while(!toStop && (rear+1)%MESSAGE_COUNT==front){
t.tv_sec = time(NULL)+1;
t.tv_nsec = 0;
pthread_cond_timedwait(&condition,&mutex,&t);
}
if(toStop){
pthread_cond_broadcast(&condition);
pthread_mutex_unlock(&mutex);
return -1;
}
int messageLen = strlen(message);
int copyLen = messageLen>=MESSAGE_LENGTH?MESSAGE_LENGTH-1:messageLen;
memcpy(buf[rear],message,copyLen);
buf[rear][copyLen]='/0';
rear = (rear+1)%MESSAGE_COUNT;
pthread_cond_signal(&condition);
pthread_mutex_unlock(&mutex);
return 0;
}
//从消息缓冲区中获得消息
int MessageBuffer::GetMessage(char *mbuf, int buflen){
struct timespec t;
pthread_mutex_lock(&mutex);
while(!toStop && rear==front){
t.tv_sec = time(NULL)+1;
t.tv_nsec = 0;
pthread_cond_timedwait(&condition,&mutex,&t);
}
if(toStop){
pthread_cond_broadcast(&condition);
pthread_mutex_unlock(&mutex);
return -1;
}
int messageLen = strlen(buf[front]);
int copyLen = messageLen>=buflen ? buflen-1 : messageLen;
memcpy(mbuf,buf[front],copyLen);
mbuf[copyLen]='/0';
front = (front+1)%MESSAGE_COUNT;
pthread_cond_signal(&condition);
pthread_mutex_unlock(&mutex);
return 0;
}

客户类Clients，用于维护套接字socket和套接字地址struct sockaddr_in之间的对应关系，并维护用户的姓名。

Clients.h

//Clients.h
#ifndef _CLIENTS_INCLUDE_
#define _CLIENTS_INCLUDE_
#include <sys/types.h>
#include <netinet/in.h>
#include <pthread.h>
#define NAME_LEN 50
#define MAX_CLIENT 30
typedef struct client_info{
int sock;
struct sockaddr_in clientAddr;
char name[NAME_LEN];
}CLIENT_INFO;
class Clients{
private:
pthread_mutex_t mutex;
CLIENT_INFO client[MAX_CLIENT];
int clientCount;
int IPtoString(unsigned long ip, char *buf, int buflen);
int Search(int sock);
public:
Clients();//构造函数
virtual ~Clients();//析构函数
int GetClientCount();
bool PutClient(int sock,const struct sockaddr_in &clientAddr);
void RemoveClient(int sock);
bool GetAddrBySocket(int sock,struct sockaddr_in *addr);
bool PutName(int sock,const char *name, int namelen);
bool GetName(int sock, char *name, int namelen);
int GetAllSocket(int* sockArray, int arrayLen );
};
#endif

Clients.cpp

//Clients.cpp
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include "Clients.h"
Clients::Clients() {
pthread_mutex_init(&mutex, NULL);
clientCount = 0;
printf("Clients created./n");
}
Clients::~Clients() {
pthread_mutex_destroy(&mutex);
printf("Clients destroyed./n");
}
int Clients::Search(int sock){
int index = -1;
for(int i=0; i<clientCount; i++) {
if(client[i].sock==sock){
index = i;
break;
}
}
return index;
}
int Clients::IPtoString(unsigned long ip,char *buf,int buflen){
unsigned char *p = (unsigned char*)&ip;
if(buflen<16){
return -1;
}
sprintf(buf,"%u.%u.%u.%u",*p,*(p+1),*(p+2),*(p+3));
return strlen(buf);
}
int Clients::GetClientCount(){
return clientCount;
}
bool Clients::PutClient(int sock,const struct sockaddr_in &clientAddr) {
if(clientCount==MAX_CLIENT){
return false;
}
pthread_mutex_lock(&mutex);
client[clientCount].sock = sock;
client[clientCount].clientAddr = clientAddr;
int buflen = sizeof(client[clientCount].name);
int pos = IPtoString(clientAddr.sin_addr.s_addr,client[clientCount].name,buflen);
sprintf(&client[clientCount].name[pos],":%d",ntohs(clientAddr.sin_port));
clientCount++;
pthread_mutex_unlock(&mutex);
return true;
}
void Clients::RemoveClient(int sock){
pthread_mutex_lock(&mutex);
int index = Search(sock);
if(index!=-1){
for(int i=index; i<clientCount-1; i++){
client[i] = client[i+1];
}
clientCount--;
}
pthread_mutex_unlock(&mutex);
}
bool Clients::GetAddrBySocket(int sock,struct sockaddr_in *addr){
pthread_mutex_lock(&mutex);
int index = Search(sock);
if(index!=-1){
memcpy(addr,&client[index].clientAddr,sizeof(struct sockaddr_in));
}
pthread_mutex_unlock(&mutex);
return index!=-1;
}
bool Clients::PutName(int sock,const char *name,int namelen) {
pthread_mutex_lock(&mutex);
int index = Search(sock);
if(index!=-1){
int copyLen = namelen>=NAME_LEN ? NAME_LEN-1:namelen;
memcpy(client[index].name,name,copyLen);
client[index].name[copyLen]='/0';
}
pthread_mutex_unlock(&mutex);
return index!=-1;
}
bool Clients::GetName(int sock, char *name, int namelen) {
pthread_mutex_lock(&mutex);
int index = Search(sock);
if(index!=-1){
int msgLen = strlen(client[index].name);
int copyLen = (msgLen<namelen)? msgLen:(namelen-1);
memcpy(name,client[index].name,copyLen);
name[copyLen]='/0';
}
pthread_mutex_unlock(&mutex);
return index!=-1;
}
int Clients::GetAllSocket(int* sockArray, int arrayLen ) {
pthread_mutex_lock(&mutex);
int copyCount = arrayLen>clientCount ? clientCount : arrayLen;
for(int i=0; i<copyCount; i++){
sockArray[i] = client[i].sock;
}
pthread_mutex_unlock(&mutex);
return copyCount;
}