Linux_基于socket的局域网聊天软件的设计与实现

提交日期：2012-06-20 基于socket的局域网聊天软件的设计与实现1.实验目的

《Linux操作系统课程设计B》是一门在课程《Linux操作系统与程序设计B》后独立开设的实验课程。这一门实验课程的开设目的是为了通过学生独立完成一个基于Linux平台的较大型应用程序，巩固课堂上学到的Linux平台上的编程规范、技术和技巧，培养学生的编写较大型程序的能力和提高学生综合应用素质。

本课程设计实验主要围绕Linux平台上主流的基础技术展开，这些技术包括：Linux的进程、线程通信和同步技术；socket网络通信技术等，这些技术可以集中体现并应用在并发程序设计中。通过并发程序的设计与开发，培养学生底层软件开发的能力，并为将来从事UNIX/Linux平台开发、嵌入式开发等相对高端的软件开发工作打下基础。

2.软件功能及模块划分

本软件是一个linux下基于socket的聊天室程序，能让局域网内的用户通过该软件进行简单的文字通信。在此基础上增加了

1.聊天室成员之间的发送私聊信息；

2.当新的成员加入后能自动收取最近一段时间内的聊天上下文；

3.用户能够查看历史聊天记录；

4.软件界面基于Qt实现，图形化界面方便用户操作。

主要模块划分：

服务端：

数据包发送和接受模块，聊天记录数据库读写模块，数据包处理模块，聊天记录查询模块

客户端：

数据包发送和接受模块，数据包处理模块，聊天记录查询模块，用户界面与展示模块

3.设计与实现

3.1系统概述与总体结构

本系统采用CS架构，服务端采用固定的端口通信，每个客户端动态设置端口。客户端启动后向服务端告知自己所使用的端口号，以便可以双向通信，同时服务器负责为每个客户端分配一个唯一的ID（服务器的ID为1）

客户端和服务端以及客户端和客户端之间采用约定的数据格式进行通信，以便接收方可以正确的解析命令和数据。

数据包通用格式定义如下

#define MAX_UDP_SIZE 1000

struct udp_packet{

int type;

int senderId;

long size;

char content[MAX_UDP_SIZE];

};

type：表示该数据包的类型，直接决定content字段的含义

senderId：该数据包的发送者的ID，

size:整个数据包的数据长度

content:数据包的内容，其数据格式由type决定。

服务器和客户端接受到数据包后，根据type字段的值来解析content字段的数据，从而作出正确的处理和响应。

所有的数据包类型以及对应的content字段的数据结构全部定义在define.h文件中

[系统总体结构]

由上图可以看出，服务器和客户端程序在总体结构上相似。服务器和客户端的全部功在数据处理模块中实现，这也是整个程序的核心之处

由于数据包的接受在单独的线程中完成，而界面采用Qt实现。因此在接受线程中采用QCoreApplication::postEvent()方法向界面线程发送通知事件，在界面窗口中通过重载customEvent()方法响应该通知，然后从Server中获取数据并显示。整个过程中涉及到线程同步和多线程安全问题，觉采用信号量和互斥量解决。

3.2服务端的实现

3.2.1服务总体实现与概述

服务端的全部功能在类Server中实现，由于在整个系统中有且只有一个服务端出现，应此该类采用单例模式实现，通过Server::Instance()方法获得Server的一个实例，通过调用Init()函数完成服务端的初始化（包括信号量的初始化、数据库的连接、设置要发送事件通知的界面对象Object*），最后通过Start()方法创建socket，绑定端口，创建数据包接受线程，至此，完成服务器的启动

部分代码:

class Server

{

friend class ServerPacketProcessor;

public:

virtual ~Server();

static Server* Instance();

bool Init(QObject *mainWindow);

bool Start();

void WaitForServerStop();

protected:

Server();

void* ThreadStartRoutine(void* arg);

private:

static void* ThreadRoutineTransponder(void* arg);

void postEvent(QEvent::Type eventType);

static Server* m_server;

sockaddr_in m_localaddr;

int m_sockfd;

pthread_t m_thread;

bool bCancel;

pthread_mutex_t m_mutex_clients;

pthread_mutex_t m_mutex_msgs;

QObject* m_ui;

。。。。。。

Server.cpp

#include "server.h"

Server* Server::m_server=0;

bool Server::Init(QObject* mainWindow)

{

m_ui=mainWindow;

bCancel=false;

pthread_mutex_init(&m_mutex_clients,0);

pthread_mutex_init(&m_mutex_msgs,0);

return true;

}

Server* Server::Instance()

{

if(m_server==0)

m_server=new Server();

return m_server;

}

bool Server::Start()

{

m_sockfd=socket(AF_INET,SOCK_DGRAM,0);

if(m_sockfd==-1)

{

cerr<<"create udp socket failed!"<

return false;

}

m_localaddr.sin_port=htons(SRV_PORT);

m_localaddr.sin_family=AF_INET;

m_localaddr.sin_addr.s_addr=htonl(INADDR_ANY);

if(-1==bind(m_sockfd,(struct sockaddr*)&m_localaddr,sizeof(m_localaddr))) {

cerr<<"bind socket failed!"<

return false;

}

if(!m_chatRecordMgr.ConnectDB("canghai","canghai","chat_record_schema")) {

cerr<<"server connect datebase error!"<

return false;

}

if(0!=pthread_create(&m_thread,0,ThreadRoutineTransponder,0))

{

cerr<<"create thread failed!"<

return false;

}

return true;

}

void* Server::ThreadRoutineTransponder(void* arg)

{

return Server::Instance()->ThreadStartRoutine(arg);

}

。。。。。。。

3.2.2服务器发送数据模块的显示

由于所有的数据包均以udp_packet结构包装，应此发送模块较简单

void Server::SendMsgTo(sockaddr_in clientaddr,const udp_packet* packet)

{

sendto(m_sockfd,packet,packet->size,0,(struct sockaddr*)&clientaddr,sizeof(clientaddr));

}

3.2.3服务器接受线程的实现

服务端的接受线程负责接受客户端发来的数据，并且解析数据包，采取合适的动作。

由于数据包的种类较多（随着功能的增加而增加），处理过程函数较为复杂，因此将数据包的处理过程封装在类ServerPacketProcessor的子类中，GetPacketProcessor()方法根据数据包的类型会创建合适的ServerPacketProcessor对象并返回

线程函数和GetPacketProcessor方法的实现

void* Server::ThreadStartRoutine(void* arg)

{

while(!bCancel)

{

udp_packet packet; //定义缓冲区

memset(&packet,0,sizeof(packet));

sockaddr_in clientaddr;

socklen_t len=sizeof(clientaddr);

size_t res=recvfrom(m_sockfd,&packet,sizeof(packet),0,(struct sockaddr*)&clientaddr,&len);

if(res==-1)

{

cerr<<"recvfrom error..."<

}

//根据数据包的类型获得正确的处理方式

ServerPacketProcessor* processor=GetPacketProcessor(packet.type); if(processor==0)

continue;

//处理数据包

processor->ProcessPacket(&packet,clientaddr);

delete processor;

}

return 0;

}

ServerPacketProcessor* Server::GetPacketProcessor(int packet_type)

{

switch(packet_type)

{

case CLIENT_ONLINE_REQUST: //客户端上线请求

{

return new CltOnlinePacketProcessor(this);

}

case GROUP_MSG_SEND: //客户端发送群聊消息

{

return new GroupMsgPacketProcessor(this);

}

case QUERY_USER_INFO: //客户端查询其它用户信息

{

return new QueryUserInfoPacketProcessor(this);

}

case QUERY_CHAT_RECORD: //客户端查询聊天记录

{

return new QueryRecordPacketProcessor(this);

}

case CLIENT_OFF_LINE: //客户端下线

{

return new CltOfflinePacketProcessor(this);

}

default:

return 0;

}

}

3.2.4服务器数据包处理模块的设计

当接受线程收到数据包后要根据数据包的类型作出正确的处理和响应

对应的消息类型和content字段的数据结构

1.客户端上线请求

#define CLIENT_ONLINE_REQUST 1

struct client_info{

char username[20]; //客户端用户昵称

char hostname[30]; //客户端的主机名

short client_port; //客户端使用的通信端口

};

2.客户端发送群聊信息

#define GROUP_MSG_SEND 4

struct group_msg_send

{

char content[MAX_MSG_SIZE]; //消息内容

};

3.客户端查询其它用户信息

#define QUERY_USER_INFO 6

struct query_user

{

int userId; //可以查询指定的ID的用户，0则表示查询所有的用户信息};

4.客户端查询聊天记录

#define QUERY_CHAT_RECORD 10

struct query_chat_record

{

int by_begin_time; //查询方式，1表示离开始时间点最近的count条记录，0表示离结束时间点最近的count条记录

time_t begintime; //开始时间点

time_t endtime; //结束时间点

int count; //查询记录的条数

};

5.客户端下线

#define CLIENT_OFF_LINE 12

(content内容无含义)

3.3客户端设计概要

本系统在群聊的基础上实现私聊功能，从服务器的设计可看出，群聊消息是由服务器转发的。

私聊消息的实现是通过客户端之间直接点到点的通信完成的。因此每个客户端必须知道其它客户端的地址和端口号。

客户端的启动流程如下

由于客户端和服务端总体结构上相似，应此不再详细叙述

3.4聊天记录存取模块的实现

服务端采用mysql数据库保存群聊记录

数据库表设计

聊天记录读写的实现由ChatRecordManager类实现.

通过接口函数bool InsertRecord(const char *username,const char *content,time_t time,const char *ip);完成插入聊天记录的功能

通过Records QueryRecordsByBeginTime(time_t begintime,time_t endtime,int count);

Records QueryRecordsByEndTime(time_t begintime,time_t endtime,int count);

两种方式查询聊天记录

查询聊天记录时提供开始时间和结束时间、和要查询的记录的数量。两种方式分别查询begintime和endtime时间段内的前count条记录，和后count条记录

具体实现

//chatrecordmanager.h

#ifndef CHATRECORDMANAGER_H

#define CHATRECORDMANAGER_H

#include "mysql/mysql.h"

#include

#include

#include

#include

#include

#include "define.h"

using namespace std;

//聊天记录结构，用于保存和传送

struct chat_record

{

char username[20];

char content[MAX_MSG_SIZE];

time_t time;

char ip[15];

};

typedef queue Records; //用队列来传递返回值

class ChatRecordManager

{

public:

ChatRecordManager();

bool ConnectDB(char* username,char* password,char* db);

void Disconnect();

bool InsertRecord(const char *username,const char *content,time_t time,const char *ip); Records QueryRecordsByBeginTime(time_t begintime,time_t endtime,int count);

Records QueryRecordsByEndTime(time_t begintime,time_t endtime,int count);

private:

void TraceError();

Records QueryRecords(char* sql);

MYSQL* m_conn_ptr;

};

#endif // CHATRECORDMANAGER_H

//chatrecordmanager.cpp

#include "chatrecordmanager.h"

ChatRecordManager::ChatRecordManager()

{

m_conn_ptr=0;

}

//连接数据库

bool ChatRecordManager::ConnectDB(char *username, char *password, char *db)

{

m_conn_ptr=mysql_init(0);

if(!m_conn_ptr)

{

cout<<"mysql_init failed!"<

TraceError();

return false;

}

m_conn_ptr=mysql_real_connect(m_conn_ptr,"localhost",username,password,db,0,0,0);

if(!m_conn_ptr)

{

cerr<<"connect database failed!"<

TraceError();

return false;

}

return true;

}

//断开数据库连接

void ChatRecordManager::Disconnect()

{

mysql_close(m_conn_ptr);

}

void ChatRecordManager::TraceError()

{

cerr<

}

bool ChatRecordManager::InsertRecord(const char* username,const char* content,time_t time,const char* ip)

{

char sql[MAX_MSG_SIZE+200];

memset(sql,0,sizeof(sql));

//准备sql语句

sprintf(sql,"insert into t_chat_record values('%s','%s',from_unixtime(%lu),'%s')",username,content,time,ip);

int res=mysql_query(m_conn_ptr,sql);

if(res)

{

cerr<<"exec sql failed:"<

TraceError();

return false;

}

return true;

}

Records ChatRecordManager::QueryRecordsByBeginTime(time_t begintime, time_t endtime, int count) {

char sql[200];

memset(sql,0,sizeof(sql));

sprintf(sql,"select * from t_chat_record where time>from_unixtime(%lu) and time<=from_unixtime(%lu) order by time limit 0,%d",begintime,endtime,count);

return QueryRecords(sql);

}

//根据sql语句查询，返回查询结果

Records ChatRecordManager::QueryRecords(char *sql)

{

Records r;

int res=mysql_query(m_conn_ptr,sql);

if(res)

{

cerr<<"exec sql failed:"<

TraceError();

return r;

}

MYSQL_RES* res_ptr;

res_ptr=mysql_store_result(m_conn_ptr);

if(res_ptr)

{

MYSQL_ROW sqlrow;

while((sqlrow=mysql_fetch_row(res_ptr)))

{

chat_record record;

strncpy(https://www.360docs.net/doc/3913475001.html,ername,sqlrow[0],20);

strncpy(record.content,sqlrow[1],MAX_MSG_SIZE);

strncpy(record.ip,sqlrow[3],15);

struct tm t;

strptime(sqlrow[2],"%Y-%m-%d %H:%M:%S",&t);

record.time=mktime(&t);

r.push(record);

}

mysql_free_result(res_ptr);

}

return r;

}

Records ChatRecordManager::QueryRecordsByEndTime(time_t begintime,time_t endtime, int count) {

char sql[200];

memset(sql,0,sizeof(sql));

sprintf(sql,"select * from (select * from t_chat_record where time>from_unixtime(%lu) and time<=from_unixtime(%lu) order by time desc limit 0,%d) as t_temp order by time",begintime,endtime,count);

return QueryRecords(sql);

}

4.测试与调试

测试截图

客户端主界面，

客户端启动后，设置昵称和正确的服务器地址，点击上线后连接服务器。

成功连接服务后用户列表中显示当前在线用户

下方按钮显示未读的群聊信息数量，当收到新的私聊消息时用户列表中会出现提示

双击列表项，

弹出与该用户对话的私聊窗

口；单击最下方按钮弹出群聊窗口

点击群聊窗口的历史记录，弹出群聊记录查询窗口，设置查询条件，可以查询对应的群聊记录

服务端界面

显示当前在线客户端的详细信息和群聊消息

经过调试，基本解决了现有功能中的bug

5.总结与感想

通过这次的课程设计的实现，对于linux下的开发有了很大的改变，不再单纯的做window 下的开发。

附录：程序源码

限于篇幅，仅列出服务端非界面部分的代码，chatrecordmanager.h和chatreocordmanager.cpp 代码在之前已完整列出

//define.h 定义数据包的数据结构和一些常量

#ifndef DEFINE_H_INCLUDED

#define DEFINE_H_INCLUDED

#include

#include

#include

using namespace std;

#define SRV_PORT 8118

#define CLT_PORT 8119

#define MAX_UDP_SIZE 1000

#define MAX_MSG_SIZE 150

struct udp_packet{

int type;

int senderId;

long size;

char content[MAX_UDP_SIZE-8];

//客户端上线请求

#define CLIENT_ONLINE_REQUST 1

struct client_info{

char username[20];

char hostname[30];

short client_port;

};

#define CLIENT_ONLINE_ACK 2

struct server_ack

{

int client_id;

};

//客户端发送群聊信息

#define GROUP_MSG_SEND 4

struct group_msg_send

{

char content[MAX_MSG_SIZE];

};

//服务端转发群聊信息

#define GROUP_MSG_BRODCAST 5

struct group_msg_broadcast

{

int userId;

time_t time;

char content[MAX_MSG_SIZE];

};

//客户端请求查询在线用户

#define QUERY_USER_INFO 6

struct query_user

{

int userId;

};

//服务端发送用户信息

#define SEND_USER_INFO 7

struct user_info

{

int user_id;

sockaddr_in useraddr;

char username[20];

char hostname[30];

short port;

};

//服务端用户信息变动通知,用户的上线和下线问题

#define USER_CHANGE 8

#define ACTION_USER_LOGIN 1

#define ACTION_USER_LOGOUT 2

struct user_change_info

{

char action;

user_info user;

};

#define PRIVATE_CHAT_MSG 9

struct private_chat_msg

{

int sender_id;

time_t time;

char content[MAX_MSG_SIZE];

};

//客户端查询聊天记录请求

#define QUERY_CHAT_RECORD 10

struct query_chat_record

{

int by_begin_time; //查询方式，1表示离开始时间点最近的count条记录，0表示离结束时间点最近的count条记录

time_t begintime; //开始时间点

time_t endtime; //结束时间点

int count; //查询记录的条数

};

//服务器发送聊天记录

#define SEND_CHAT_RECORD 11

//聊天记录结构，用于保存和传送

struct chat_record

{

char username[20];

char content[MAX_MSG_SIZE];

time_t time;

char ip[15];

};

typedef queue Records;

#define CLIENT_OFF_LINE 12

#endif // DEFINE_H_INCLUDED

//server.h

#ifndef SERVER_H

#define SERVER_H

#include

#include

#include

#include

#include

#include "define.h"

#include "client.h"

#include

#include

#include

#include

#include

#include "serverpacketprocessor.h"

#include "chatrecordmanager.h"

using namespace std;

typedef map ClientCollection;

class Server

{

friend class ServerPacketProcessor;

public:

virtual ~Server();

static Server* Instance();

bool Init(QObject *mainWindow);

bool Start();

bool Stop();

bool Restart();

void WaitForServerStop();

void SendMsgTo(Client* c,const udp_packet* packet);

void SendMsgTo(sockaddr_in clientaddr,const udp_packet* packet); void GetClients_lock();

map *GetClients();

void GetClients_unlock();

void GetMsgs_lock();

queue* GetMsgs();

void GetMsgs_unlock();

static const QEvent::Type MessageArrival=(QEvent::Type)3000;

static const QEvent::Type ClientListChange=(QEvent::Type)3001; protected:

Server();

void* ThreadStartRoutine(void* arg);

ServerPacketProcessor* GetPacketProcessor(int packet_type);

private:

static void* ThreadRoutineTransponder(void* arg);

void CleanUp();

void postEvent(QEvent::Type eventType);

static Server* m_server;

sockaddr_in m_localaddr;

int m_sockfd;

pthread_t m_thread;

bool bCancel;

ClientCollection m_clients;

queue m_msgQueue;

pthread_mutex_t m_mutex_clients;

pthread_mutex_t m_mutex_msgs;

QObject* m_ui;

ChatRecordManager m_chatRecordMgr; };

#endif // SERVER_H

//server.cpp

#include "server.h"

Server* Server::m_server=0;

Server::Server()

{

//ctor

}

Server::~Server()

{

//dtor

CleanUp();

}

Server* Server::Instance()

{

if(m_server==0)

m_server=new Server();

return m_server;

}

bool Server::Restart()

{

if(!Stop())

return false;

if(!Start())

return false;

return true;

}

bool Server::Start()

{

m_sockfd=socket(AF_INET,SOCK_DGRAM,0); if(m_sockfd==-1)

{