1.服务端
创建一个聊天室，以ip和端口号来标识用户的唯一性，通过哈希表将IP与套接字联系起来。当有服务端收到一个消息，就将其IP地址与表内的数据进行比对，若不在表内，就在服务端发送新用户上线，IP为x.x.x.x。在发送消息时对表内所存储的所有客户端套接字进行发送，实现群聊效果。
2.客户端
由于客户端此前是单进程的，收消息前需要先发送消息，先getline/sendkto，才走到recvfrom收消息，若不进行消息的发送，就一直阻塞在getlline，无法获取服务端群聊发送的消息。
因此，将客服端修改为多线程，一个线程发送消息，一个线程接收消息。
但此时，客户端发送和接收的消息混淆在一个终端，我们可以开两个终端，将发送消息的输出描述符改为标准错误，用cerr输出，再将cerr输出重定向到标准输出外的另一个终端，就可以实现收到的消息和发送的消息分别出现在不同的终端。
3.实现
客户端：
#pragma once
#include <iostream>
#include <string>
#include <strings.h>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include <unistd.h>
#include <errno.h>
#include <unordered_map>
typedef std::function <std::string(const std::string& )> func_t; //回调函数，用于处理服务端接收到的数据
uint16_t defaultport=8080; //设置的默认端口号
std::string defaultip="0.0.0.0"; //设置的默认ip
const int size=1024; //用去从网络中读取数据的缓冲区的默认大小
class UdpServer{
public:
UdpServer(const uint16_t &port=defaultport,const std::string &ip=defaultip):sockfd_(0),port_(port),ip_(ip),isrunning_(false)
{}
void Init()//服务端初始化，创建套接字，并对套接字进行绑定
{
//1.先进行udp套接字的创建
sockfd_=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd_<0)
{
std::cout<<"socket error"<<std::endl;
exit(0);
}
else
{
std::cout<<"socket creat success"<<std::endl;
}
//2.绑定套接字,先创建一个栈上的套接字，并对其相关成员变量赋值
struct sockaddr_in local;
bzero(&local,sizeof(local));
local.sin_family=AF_INET;
local.sin_port=htons(port_);//端口号和ip都需要转换成网络序列的存储方式
local.sin_addr.s_addr=htonl(INADDR_ANY);//inet_addr是一个库函数，作用是将一个char类型ipv4的地址转换成32位的网络序列的整数
//c_str()的作用是将string转化成char类型
socklen_t len=sizeof(local);
int res=bind(sockfd_,(const struct sockaddr*)&local,len); //为了适应通用接口需要将我们的sockaddr_in变量进行强转
if(res<0)
{
std::cout<<"bind erro"<<std::endl;
std::cout<<strerror(errno)<<std::endl;
exit(1);
}
else
{
std::cout<<"socket bind success"<<std::endl;
}
}
void CheakUser(const struct sockaddr_in &client,const std::string clientip,uint16_t clientport)
{
auto iterator=online_user_.find(clientip);
if(iterator ==online_user_.end())
{
online_user_.insert({clientip,client}); //若不在哈希表中就将新用户插入表内
std::cout<<"["<<clientip<<":"<<clientport<<"]"<<"用户上线"<<std::endl;
}
}
void Broadcast(std::string info,std::string clientip,uint16_t clientport)
{
for(const auto &user:online_user_)//将服务器收到的消息广播给表内全部用户
{
std::string message="[";
message+=clientip;
message+=":";
message+=clientport;
message+="]---";
message+=info;
socklen_t len=sizeof(sizeof(user.second));
sendto(sockfd_,message.c_str(),message.size(),0,(struct sockaddr*)&(user.second),len);
}
}
void Run()//服务端运行，就是从套接字中接收消息，并对消息进行处理，
{ //再将处理后的消息发送回给客户端(func是回调函数，将处理数据交给外部函数，对代码进行分层)
isrunning_=true;
char inbuffer[size]; //用于从套接字文件中读取消息的缓冲区
std::cout<<"进入whilerun"<<std::endl;
while(isrunning_) //一般服务器启动后就一直进行运行，等待客户的消息
{
memset(inbuffer,0,sizeof(inbuffer));
struct sockaddr_in client;
socklen_t len=sizeof(client);
ssize_t n=recvfrom(sockfd_,inbuffer,sizeof(inbuffer)-1,0,(struct sockaddr*)&client,&len);//读取客户端的消息并写入缓冲区
if(n<0)
{
std::cout<<"recvfrom error"<<std::endl;
continue;
}
std::cout<<"revufrom:"<<"["<<inet_ntoa(client.sin_addr)<<"]"<<"："<<inbuffer<<std::endl;
uint16_t clientport=ntohs(client.sin_port);
std::string clientip=inet_ntoa(client.sin_addr);//保存用户端的ip和端口号，用于检测是否为新用户
CheakUser(client,clientip,clientport);
std::string info=inbuffer;
Broadcast(info,clientip,clientport);
}
}
~UdpServer()
{
if(sockfd_>0)
{
close(sockfd_);
}
}
private:
int sockfd_; //网络文件的描述符
std::string ip_; //任意ip地址
uint16_t port_; //表明服务器进程的端口号
bool isrunning_;
std::unordered_map<std::string ,struct sockaddr_in> online_user_;
};服务端：
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cerrno>
#include <string.h>
#include <pthread.h>
using namespace std;
void Usage(std::string proc)//客户端启动后用于提示用于传输消息,proc为所运行程序
{
std::cout<<"\n\rUsage: "<<proc<<"serveip serveport\n"<<std::endl;
}
struct ThreadDate
{
struct sockaddr_in server;
int sockfd;
std::string serveip;
};
void *recv_message(void* args)
{
ThreadDate *td=static_cast<ThreadDate*>(args);//将可变参数强转后接收
char buffer[1024]; //接收服务端处理后的消息的缓冲区
while(true)
{
memset(buffer,0,sizeof(buffer));
//创建一个套接字用于接收服务器处理后的消息
struct sockaddr_in temp;
socklen_t len=sizeof(temp);
memset(buffer,0,sizeof(buffer));
ssize_t s=recvfrom((*td).sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&temp,&len);
if(s>0)
{
buffer[s]=0;
cerr<<buffer<<endl; //将从服务器接收到的消息以标准错误的方式输出
}
}
}
void *send_message(void* args)
{
ThreadDate* td=static_cast<ThreadDate*>(args);
string message; //向服务端发送的消息
socklen_t len=sizeof(td->server);
std::string welcome=td->serveip;
welcome+="comming...";
sendto(td->sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&(td->server),len);
while(true)
{
cout<<"Please Enter@:";
getline(cin,message);
if(-1==sendto(td->sockfd,message.c_str(),message.size(),0,(struct sockaddr *)&(td->server),len))
{
cout<<"sendto error"<<strerror(errno);
}
}
}
int main(int argc,char* argv[])//用命令行参数来接收ip和端口号
{
if(argc != 3) //./udpclient ip 端口号
{
Usage(argv[0]);
exit(0);
}
std::string serverip=argv[1];
uint16_t serverport=std::stoi(argv[2]); //将端口号转为uint16_t
struct ThreadDate td; //创建服务端套接字将相关变量赋值，使用户知道服务端的ip和端口号，便于向服务端发送消息
bzero(&(td.server),sizeof(td.server));
td.server.sin_family=AF_INET;
td.server.sin_port=htons(serverport);
td.server.sin_addr.s_addr=inet_addr(serverip.c_str());
td.serveip=serverip;
socklen_t len=sizeof(td.server);
td.sockfd=socket(AF_INET,SOCK_DGRAM,0); //创建客服端套接字向服务端发送消息
if(td.sockfd<0)
{
cout<<"socket error"<<endl;
return 1;
}
pthread_t recvr,sender; //创建两个线程，一个用于向服务器发送消息，一个用于向服务器接收消息
pthread_create(&recvr,nullptr,recv_message,&td); //recv_message就是接收消息线程的入口函数
pthread_create(&sender,nullptr,send_message,&td);
pthread_join(recvr,nullptr);
pthread_join(sender,nullptr);
close(td.sockfd);
return 0;
}Makeflie文件和Main调用文件在之前发送的博客，无需进行修改。
启动客户端程序时通过指令进行标准错误输出重定向：./udpclient x.x.x.x xxxx 2>/dev/pts/x
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
