697 lines
27 KiB
C++
697 lines
27 KiB
C++
#include "MsgHandle.h"
|
||
#include "common.h"
|
||
|
||
Session::Session(int socket)
|
||
{
|
||
m_isLogin = -1;
|
||
m_account = -1;
|
||
m_socket = socket;
|
||
m_type = RECV_HEAD;
|
||
m_head = NULL;
|
||
m_bufLen = 0;
|
||
m_readPos = 0;
|
||
m_body = NULL;
|
||
m_isFinish = false;
|
||
m_head = new char[sizeof(DeMessageHead)];
|
||
m_bufLen = sizeof(DeMessageHead);
|
||
}
|
||
|
||
Session::~Session(){
|
||
if (m_head != NULL)
|
||
delete[] m_head;
|
||
if (m_body != NULL)
|
||
delete[] m_body;
|
||
if (m_socket != -1){
|
||
close(m_socket);
|
||
m_socket = -1;
|
||
}
|
||
if(m_isLogin == 1){
|
||
cleanSession();
|
||
m_isLogin = -1;
|
||
}
|
||
};
|
||
|
||
int Session::readEvent()
|
||
{
|
||
int ret = 0;
|
||
switch (m_type)
|
||
{
|
||
case RECV_HEAD:
|
||
ret = recvHead();
|
||
break;
|
||
case RECV_BODY:
|
||
ret = recvBody();
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
if (ret == RET_AGAIN)
|
||
return readEvent();
|
||
return ret;
|
||
}
|
||
|
||
int Session::recvHead()
|
||
{
|
||
if (m_head == NULL)
|
||
{
|
||
m_head = new char[sizeof(DeMessageHead)];
|
||
assert(m_head != NULL);
|
||
m_bufLen = sizeof(DeMessageHead);
|
||
m_readPos = 0;
|
||
}
|
||
|
||
int len = read(m_socket, m_head + m_readPos, m_bufLen - m_readPos);
|
||
if (len < 0)
|
||
return RET_ERROR;
|
||
if (len == 0)
|
||
return RET_EXIT;
|
||
m_readPos += len;
|
||
if (m_readPos == m_bufLen)
|
||
{
|
||
m_type = RECV_BODY;
|
||
int bufLen = ((DeMessageHead *)m_head)->length;
|
||
m_body = new char[bufLen];
|
||
|
||
assert(m_body != NULL);
|
||
m_bufLen = bufLen;
|
||
m_readPos = 0; //读取的位置置零
|
||
return RET_AGAIN;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int Session::recvBody()
|
||
{
|
||
/* 先判断读取的位置是否是 ((DeMessageHead*)m_head)->length 接收头指定的长度 */
|
||
if (m_readPos == m_bufLen)
|
||
{
|
||
m_type = RECV_HEAD;
|
||
handleMsgBase();
|
||
m_isFinish = true;
|
||
return RET_AGAIN;
|
||
}
|
||
/*读取指定 Body 大小的数据*/
|
||
int len = read(m_socket, m_body + m_readPos, m_bufLen - m_readPos);
|
||
|
||
if (len < 0)
|
||
return RET_ERROR;
|
||
|
||
m_readPos += len;
|
||
|
||
/* 判断读取的位置是否是 ((DeMessageHead*)m_head)->length 接收头指定的长度 */
|
||
if (m_readPos == m_bufLen)
|
||
{
|
||
m_type = RECV_HEAD;
|
||
handleMsgBase();
|
||
m_bufLen = 0;
|
||
m_isFinish = true;
|
||
return RET_AGAIN;
|
||
}
|
||
return RET_OK;
|
||
}
|
||
|
||
int Session::handleMsgBase(){
|
||
recvMsg *rMsg = new recvMsg();
|
||
rMsg->head = m_head;
|
||
rMsg->body = m_body;
|
||
rMsg->bodyLen = m_bufLen;
|
||
handleMsg(rMsg);
|
||
m_head = NULL;
|
||
m_body = NULL;
|
||
return RET_OK;
|
||
}
|
||
|
||
int Session::handleMsg(recvMsg *rMsg)
|
||
{
|
||
DeMessagePacket *packet = (DeMessagePacket *)(rMsg->body);
|
||
DeMessageHead *head = (DeMessageHead *)(rMsg->head);
|
||
// LOGINFO("mark:%s,encoded:%d,length:%d,version:%d\n", head->mark, head->encoded, head->length, head->version);
|
||
// LOGINFO("command:%d,error:%d,,mode:%d,sequence:%d\n", packet->command, packet->error, packet->mode, packet->sequence);
|
||
void *reqData = NULL;
|
||
int reqDataLen = -1;
|
||
short ret = RET_OK;
|
||
LOGINFO("handleMsg command:%d\n",packet->command);
|
||
switch (packet->command)
|
||
{
|
||
case CommandEnum_Registe:
|
||
handleRegiste(this,rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_Login:
|
||
handleLogin(this, rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_Logout:
|
||
handleLogout(this, rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_GroupChat:
|
||
handleGroupChat(this, rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_AddFriend:
|
||
if(packet->mode == 1){
|
||
handleAddFriendReq(rMsg->body + sizeof(DeMessagePacket));
|
||
}else if(packet->mode == 2){
|
||
handleAddFriendResp(rMsg->body + sizeof(DeMessagePacket));
|
||
}
|
||
break;
|
||
case CommandEnum_delFriend:
|
||
break;
|
||
case CommandEnum_PrivateChat:
|
||
handlePrivateChat(rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_CreateGroup:
|
||
break;
|
||
case CommandEnum_GetGroupList:
|
||
handleGetGroupList(rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_GetGroupInfo:
|
||
handleGetGroupInfo(rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
case CommandEnum_GetFriendInfo:
|
||
handleGetFriendInfo(rMsg->body + sizeof(DeMessagePacket));
|
||
break;
|
||
}
|
||
delete rMsg;
|
||
}
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
* @param socket
|
||
* @param buf
|
||
* @param bufLen
|
||
* @param type
|
||
* @param error 0为正常 其他为错误码
|
||
* @param mode 消息模式 请求/响应 1/2
|
||
*/
|
||
void Session::sendMsg(int socket,void*buf,int bufLen,int type,int error,int mode){
|
||
DeMessageHead header;
|
||
memcpy(header.mark, "DE", sizeof(header.mark));
|
||
header.encoded = '0';
|
||
header.version = '0';
|
||
header.length = sizeof(DeMessagePacket) + bufLen;
|
||
|
||
char *p = (char *)malloc(header.length);
|
||
DeMessagePacket *pPacket = (DeMessagePacket *)p;
|
||
pPacket->mode = mode;
|
||
pPacket->sequence = getSeqNum();
|
||
pPacket->command = type;
|
||
pPacket->error = error;
|
||
if(buf)
|
||
memcpy(p + sizeof(DeMessagePacket), buf, bufLen);
|
||
|
||
char *sendMsg = new char[sizeof(DeMessageHead) + header.length];
|
||
memset(sendMsg, 0, sizeof(DeMessageHead) + header.length);
|
||
memcpy(sendMsg, &header, sizeof(DeMessageHead));
|
||
memcpy(sendMsg + sizeof(DeMessageHead), p, header.length);
|
||
free(p);
|
||
write(socket, sendMsg, sizeof(DeMessageHead) + header.length);
|
||
}
|
||
|
||
void Session::cleanSession(){
|
||
mapUserInfo::iterator iter = g_UserInfoMap.find(m_account);
|
||
if (iter == g_UserInfoMap.end())
|
||
{
|
||
LOGINFO("出错了..\n");
|
||
}
|
||
else
|
||
{
|
||
UserInfo* delUserInfo = iter->second;
|
||
g_UserInfoMap.erase(iter);
|
||
if(delUserInfo!=NULL){
|
||
free(delUserInfo);
|
||
delUserInfo =NULL;
|
||
}
|
||
LOGINFO("会话关闭成功..\n在线用户数量:%d\n",g_UserInfoMap.size());
|
||
}
|
||
}
|
||
|
||
void Session::noticeUserLogin(UserInfo*userInfo)
|
||
{
|
||
GroupUserInfo* groupUserInfo = (GroupUserInfo*)malloc(sizeof(GroupUserInfo));
|
||
groupUserInfo->m_account = userInfo->m_account;
|
||
groupUserInfo->m_right = 0;
|
||
strncpy(groupUserInfo->m_userName,userInfo->m_userName,sizeof(userInfo->m_userName));
|
||
LOGINFO("=======//%s\n",groupUserInfo->m_userName);
|
||
mapUserInfo::iterator iter = g_UserInfoMap.begin();
|
||
for (; iter != g_UserInfoMap.end(); iter++)
|
||
{
|
||
if(iter->first == m_account)
|
||
{
|
||
LOGINFO("不给自己发..\n");
|
||
continue;
|
||
}
|
||
sendMsg(iter->second->m_socket, groupUserInfo, sizeof(GroupUserInfo), CommandEnum_Login,0,3); //发送用户上线通知
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 未添加存储功能时，注册信息申请的RegistInfoReq*一直存在
|
||
*/
|
||
int Session::handleRegiste(void*arg,void* msg){
|
||
Session* pthis = (Session*)arg;
|
||
RegistInfoReq* registInfo = (RegistInfoReq*)malloc(sizeof(RegistInfoReq));
|
||
memmove(registInfo,msg,sizeof(RegistInfoReq));
|
||
LOGINFO("username:%s,password:%s\n",registInfo->m_userName,registInfo->m_password);
|
||
RegistInfoResp registInfoResp;
|
||
registInfoResp.m_account = g_idIndex++;
|
||
|
||
g_AccountInfoMap.insert(std::make_pair(registInfoResp.m_account,registInfo));
|
||
LOGINFO("account:%d,注册成功..\n",registInfoResp.m_account);
|
||
sendMsg(pthis->m_socket,®istInfoResp,sizeof(RegistInfoResp),CommandEnum_Registe);
|
||
}
|
||
|
||
int Session::handleLogin(void*arg,void*msg){
|
||
Session* pthis = (Session*)arg;
|
||
LoginInfoReq* loginInfo = (LoginInfoReq*)msg;
|
||
LOGINFO("account:%d,password:%s\n",loginInfo->m_account,loginInfo->m_password);
|
||
|
||
mapAccountInfo::iterator iter = g_AccountInfoMap.find(loginInfo->m_account);
|
||
if (iter == g_AccountInfoMap.end())
|
||
{
|
||
sendMsg(pthis->m_socket,NULL,0,CommandEnum_Login,RET_ERROR);
|
||
LOGINFO("请先注册..\n");
|
||
}
|
||
else
|
||
{
|
||
mapUserInfo::iterator ite = g_UserInfoMap.find(loginInfo->m_account);
|
||
if(ite!=g_UserInfoMap.end()){
|
||
sendMsg(pthis->m_socket,NULL,0,CommandEnum_Login,RET_ERROR);
|
||
LOGINFO("已登录，重复登录\n");
|
||
return -1;
|
||
}
|
||
//匹配账号密码
|
||
RegistInfoReq* pRegistInfoReq = iter->second;
|
||
if (strcmp(loginInfo->m_password, iter->second->m_password) == 0)
|
||
{
|
||
// 给当前会话保存账号信息
|
||
pthis->m_account = loginInfo->m_account;
|
||
pthis->m_isLogin = 1;
|
||
strncpy(pthis->m_userName,pRegistInfoReq->m_userName,sizeof(pRegistInfoReq->m_userName));
|
||
// 添加用户信息
|
||
UserInfo* userInfo = (UserInfo*)malloc(sizeof(UserInfo));
|
||
userInfo->m_account = loginInfo->m_account;
|
||
userInfo->m_socket = pthis->m_socket;
|
||
strncpy(userInfo->m_password,loginInfo->m_password,sizeof(loginInfo->m_password));
|
||
strncpy(userInfo->m_userName,pRegistInfoReq->m_userName,sizeof(pRegistInfoReq->m_userName));
|
||
|
||
g_UserInfoMap.insert(std::make_pair(userInfo->m_account,userInfo));
|
||
// 给用户添加一个公共群聊 （后续程序完善后会删除公共群聊）
|
||
mapGroupChatInfo::iterator iter = g_GroupCharInfoMap.find(0);
|
||
if( iter!= g_GroupCharInfoMap.end()){
|
||
GroupChatInfo* info = iter->second;
|
||
info->m_size++;
|
||
LOGINFO("current group size:%d\n",g_GroupCharInfoMap.size());
|
||
}
|
||
else{
|
||
//第一次添加往群信息表中插入群信息
|
||
GroupChatInfo *groupChatinfo = (GroupChatInfo *)malloc(sizeof(GroupChatInfo));
|
||
groupChatinfo->m_account = 0;
|
||
groupChatinfo->m_size = 1; //服务启动后新用户登录时初始化公共聊天群 公共聊天群成员大小为1
|
||
strncpy(groupChatinfo->m_groupName, "C/C++学习交流群", strlen("C/C++学习交流群"));
|
||
std::pair<mapGroupChatInfo::iterator, bool> Insert_Pair = g_GroupCharInfoMap.insert(std::make_pair(groupChatinfo->m_account, groupChatinfo));
|
||
if (Insert_Pair.second == true)
|
||
{
|
||
ChatLog << "Insert Successfully:" << g_GroupCharInfoMap.size() << endl;
|
||
}
|
||
else
|
||
{
|
||
ChatLog << "Insert fail" << endl;
|
||
}
|
||
}
|
||
//发送响应,告诉客户端你登录成功了
|
||
sendMsg(pthis->m_socket,NULL, 0, CommandEnum_Login, RET_OK);
|
||
LOGINFO("登录成功..\n在线用户数量:%d\n",g_UserInfoMap.size());
|
||
pthis->noticeUserLogin(userInfo);
|
||
}
|
||
else
|
||
{
|
||
sendMsg(pthis->m_socket,NULL,0,CommandEnum_Login,RET_ERROR);
|
||
LOGINFO("密码错误.. password:%s\n",iter->second->m_password);
|
||
}
|
||
}
|
||
}
|
||
|
||
int Session::handleLogout(void*arg,void*msg){
|
||
Session* pthis = (Session*)arg;
|
||
if (pthis->m_isLogin == 1){
|
||
pthis->cleanSession();
|
||
pthis->m_isLogin = -1;
|
||
}
|
||
}
|
||
|
||
int Session::handleGroupChat(void *arg, void *msg){
|
||
Session* pthis = (Session*)arg;
|
||
GroupChatReq* groupChatReq = (GroupChatReq*)msg;
|
||
|
||
if(!pthis->m_isLogin)
|
||
return -1;
|
||
|
||
LOGINFO("account:%d,msgLen:%d,group:%d,type:%d\n",groupChatReq->m_UserAccount,groupChatReq->m_msgLen,groupChatReq->m_GroupAccount,groupChatReq->m_type);
|
||
char*buf = (char*)malloc(groupChatReq->m_msgLen);
|
||
memmove(buf,(char*)msg + sizeof(GroupChatReq),groupChatReq->m_msgLen);
|
||
LOGINFO("recv msg:%s\n",buf);
|
||
if(groupChatReq->m_GroupAccount == 0){
|
||
//广播
|
||
mapUserInfo::iterator iter = g_UserInfoMap.begin();
|
||
for(;iter!=g_UserInfoMap.end();iter++){
|
||
if(iter->first == pthis->m_account)
|
||
{
|
||
LOGINFO("不给自己发..\n");
|
||
continue;
|
||
}
|
||
sendMsg(iter->second->m_socket,msg,sizeof(GroupChatReq) + groupChatReq->m_msgLen, CommandEnum_GroupChat);
|
||
}
|
||
}
|
||
}
|
||
|
||
int Session::handlePrivateChat(void*msg){
|
||
PrivateChatReq* privateChatReq = (PrivateChatReq*)msg;
|
||
|
||
if(!m_isLogin)
|
||
return -1;
|
||
LOGINFO("account:%d,msgLen:%d,friendAccount:%d,type:%d\n",privateChatReq->m_UserAccount,privateChatReq->m_msgLen,privateChatReq->m_FriendAccount,privateChatReq->m_type);
|
||
char*buf = (char*)malloc(privateChatReq->m_msgLen);
|
||
memmove(buf,(char*)msg + sizeof(PrivateChatReq),privateChatReq->m_msgLen);
|
||
LOGINFO("recv msg:%s\n",buf);
|
||
|
||
mapUserFriendInfo::iterator iter = g_UserFriendInfoMap.find(m_account);
|
||
if (iter != g_UserFriendInfoMap.end())
|
||
{
|
||
//用户存在好友表
|
||
mapFriendInfo::iterator ite = iter->second.find(privateChatReq->m_FriendAccount);
|
||
if(ite!=iter->second.end()){
|
||
//找到好友
|
||
FriendInfo* friendInfo = ite->second;
|
||
//给好友发消息
|
||
mapUserInfo::iterator it = g_UserInfoMap.find(friendInfo->m_account);
|
||
if(it!=g_UserInfoMap.end()){
|
||
sendMsg(it->second->m_socket,msg,sizeof(PrivateChatReq) + privateChatReq->m_msgLen, CommandEnum_PrivateChat);
|
||
}
|
||
else{
|
||
LOGINFO("用户不在线，请稍后发送..\n");
|
||
}
|
||
}
|
||
else{
|
||
LOGINFO("没有找到好友\n");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
LOGINFO("不存在好友表\n");
|
||
}
|
||
|
||
if(buf!=NULL)
|
||
free(buf);
|
||
}
|
||
/**
|
||
* @brief 获取群列表，这里需要修改，具体获取那个人的群聊列表
|
||
*/
|
||
int Session::handleGetGroupList(void*msg){
|
||
//申请一块内存用于保存 群列表大小 以及 群信息
|
||
int size = sizeof(GetGroupListResp) + sizeof(GroupChatInfo)*g_GroupCharInfoMap.size();
|
||
char*p = (char*)malloc(size);
|
||
GetGroupListResp* pResp = (GetGroupListResp*)p;
|
||
pResp->m_size = g_GroupCharInfoMap.size();
|
||
mapGroupChatInfo::iterator iter = g_GroupCharInfoMap.begin();
|
||
for (int index = 0; iter != g_GroupCharInfoMap.end(); iter++, index++){
|
||
//获取当前群聊信息
|
||
GroupChatInfo *curGroupChatInfo = iter->second;
|
||
//申请新的群聊信息
|
||
GroupChatInfo *pGroupChatInfo = (GroupChatInfo *)(p + sizeof(GetGroupListResp) + sizeof(GroupChatInfo) * index);
|
||
pGroupChatInfo->m_account = curGroupChatInfo->m_account;
|
||
pGroupChatInfo->m_size = curGroupChatInfo->m_size;
|
||
memmove(pGroupChatInfo->m_groupName, curGroupChatInfo->m_groupName, sizeof(curGroupChatInfo->m_groupName));
|
||
}
|
||
sendMsg(m_socket, p, size, CommandEnum_GetGroupList);
|
||
}
|
||
|
||
/**
|
||
* @brief 获取群信息
|
||
*/
|
||
int Session::handleGetGroupInfo(void *msg)
|
||
{
|
||
GetGroupInfoReq* pReq = (GetGroupInfoReq*)msg;
|
||
if(pReq->m_GroupAccount == 0){
|
||
// 全部用户 申请一块内存用于保存 群信息 以及 群成员信息
|
||
int size = sizeof(GetGroupInfoResp) + sizeof(GroupUserInfo)*g_UserInfoMap.size();
|
||
char*p = (char*)malloc(size);
|
||
GetGroupInfoResp* pResp = (GetGroupInfoResp*)p;
|
||
pResp->m_GroupAccount = pReq->m_GroupAccount;
|
||
pResp->m_size = g_UserInfoMap.size();
|
||
strncpy(pResp->m_groupName,"C/C++学习交流群",strlen("C/C++学习交流群"));
|
||
//遍历保存所有群用户信息（仅在线用户在公共聊天群里面）
|
||
mapUserInfo::iterator iter = g_UserInfoMap.begin();
|
||
for (int index = 0; iter != g_UserInfoMap.end(); iter++, index++){
|
||
UserInfo* curUserInfo = iter->second;
|
||
GroupUserInfo *pUserInfo = (GroupUserInfo *)(p + sizeof(GetGroupInfoResp) + sizeof(GroupUserInfo) * index);
|
||
pUserInfo->m_account = curUserInfo->m_account;
|
||
pUserInfo->m_right = 0;
|
||
strncpy(pUserInfo->m_userName,curUserInfo->m_userName,sizeof(curUserInfo->m_userName));
|
||
}
|
||
sendMsg(m_socket, p, size, CommandEnum_GetGroupInfo);
|
||
free(p);
|
||
p = NULL;
|
||
}
|
||
}
|
||
|
||
int Session::handleGetFriendInfo(void* msg){
|
||
// 全部用户 申请一块内存用于保存 群信息 以及 群成员信息
|
||
//1.从用户好友表找到好友表
|
||
mapUserFriendInfo::iterator iter = g_UserFriendInfoMap.find(m_account);
|
||
if(iter!=g_UserFriendInfoMap.end()){
|
||
|
||
int size = sizeof(GetFriendInfoResp) + sizeof(FriendInfo) * iter->second.size();
|
||
char *p = (char *)malloc(size);
|
||
GetFriendInfoResp *pResp = (GetFriendInfoResp *)p;
|
||
pResp->m_size = iter->second.size();
|
||
//用户存在好友表
|
||
mapFriendInfo::iterator ite = iter->second.begin();
|
||
for(int index = 0;ite!=iter->second.end();ite++,index++){
|
||
FriendInfo* pFriendInfo = ite->second;
|
||
FriendInfo* pFriendInfoResp = (FriendInfo *)(p + sizeof(GetFriendInfoResp) + sizeof(FriendInfo) * index);
|
||
strncpy(pFriendInfoResp->m_userName, pFriendInfo->m_userName, sizeof(pFriendInfo->m_userName));
|
||
pFriendInfoResp->m_account = pFriendInfo->m_account;
|
||
pFriendInfoResp->m_status = pFriendInfo->m_status;
|
||
}
|
||
sendMsg(m_socket, p, size, CommandEnum_GetFriendInfo);
|
||
}
|
||
else{
|
||
//没有好友信息
|
||
int size = sizeof(GetFriendInfoResp) + sizeof(FriendInfo) * 0;
|
||
char *p = (char *)malloc(size);
|
||
GetFriendInfoResp *pResp = (GetFriendInfoResp *)p;
|
||
pResp->m_size = 0;
|
||
LOGINFO("account:%d not has friends\n");
|
||
sendMsg(m_socket, p, size, CommandEnum_GetFriendInfo);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief A:发送好友请求的客户端
|
||
* B:接收好友请求的客户端
|
||
*/
|
||
int Session::handleAddFriendReq(void*msg){
|
||
AddFriendInfoReq* pReq = (AddFriendInfoReq*)msg;
|
||
LOGINFO("recv addFriendReq:{\n\tfriendAccount:%d;\n\tsenderAccount:%d;\n\tmsg:%s;\n}\n",pReq->m_friendAccount,pReq->m_senderAccount,pReq->m_reqInfo);
|
||
//A.找到 B 的用户信息
|
||
UserInfo *pUserInfo = NULL;
|
||
mapUserInfo::iterator UserInfoiter = g_UserInfoMap.find(pReq->m_friendAccount);
|
||
if (UserInfoiter != g_UserInfoMap.end())
|
||
{
|
||
pUserInfo = UserInfoiter->second;
|
||
}
|
||
else{
|
||
//没找到B用户信息，添加好友请求失败
|
||
//给客户端发送请求失败的响应信息
|
||
LOGINFO("not find account:%d\n",pReq->m_friendAccount);
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, -1);
|
||
return -1;
|
||
}
|
||
|
||
//C 1.从用户好友表找到 A 对应的好友表
|
||
mapUserFriendInfo::iterator iter = g_UserFriendInfoMap.find(m_account);
|
||
if(iter!=g_UserFriendInfoMap.end()){
|
||
//A用户存在好友表
|
||
//2.用户好友表中查找B的账号是否在表中
|
||
mapFriendInfo::iterator ite = iter->second.find(pReq->m_friendAccount);
|
||
if(ite!=iter->second.end()){
|
||
//找到了
|
||
FriendInfo* pFriendInfo = ite->second;
|
||
if(pFriendInfo->m_status == 1){
|
||
//已经是好友了，重复添加 不应该出现的情况
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, -1);
|
||
return -1;
|
||
}
|
||
else if(pFriendInfo->m_status == -1){
|
||
//B还未同意，暂时不给B发请求了
|
||
//给客户端发送请求成功的信息,防止重复添加
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, 0);
|
||
}
|
||
}
|
||
else{
|
||
//没有好友信息，需要添加好友信息
|
||
//将B添加到A的好友表中
|
||
FriendInfo *pFriendInfo = (FriendInfo *)malloc(sizeof(FriendInfo));
|
||
pFriendInfo->m_account = pUserInfo->m_account;
|
||
pFriendInfo->m_status = 0; //未同意的好友，当拒绝时删除这条信息
|
||
strncpy(pFriendInfo->m_userName, pUserInfo->m_userName, sizeof(pUserInfo->m_userName));
|
||
|
||
std::pair<mapFriendInfo::iterator, bool> Insert_Pair = iter->second.insert(std::make_pair(pReq->m_friendAccount, pFriendInfo));
|
||
if (Insert_Pair.second == true)
|
||
{
|
||
ChatLog << "A friend map Insert Successfully:" << iter->second.size() << endl;
|
||
}
|
||
else
|
||
{
|
||
ChatLog << "A friend map Insert fail" << endl;
|
||
}
|
||
//给其 B 用户 转发 A 添加好友的请求
|
||
sendMsg(pUserInfo->m_socket, msg, sizeof(AddFriendInfoReq), CommandEnum_AddFriend, 0, 1);
|
||
//给客户端发送请求成功的信息,告诉客户端请求被受理了
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, 0);
|
||
}
|
||
}
|
||
else{
|
||
//A用户不存在好友表
|
||
mapFriendInfo curFriendInfoMap;
|
||
//将B添加到A的好友表中
|
||
FriendInfo *pFriendInfo = (FriendInfo *)malloc(sizeof(FriendInfo));
|
||
pFriendInfo->m_account = pReq->m_friendAccount;
|
||
pFriendInfo->m_status = 0; //未同意的好友，当拒绝时删除这条信息
|
||
strncpy(pFriendInfo->m_userName, pUserInfo->m_userName, sizeof(pUserInfo->m_userName));
|
||
std::pair<mapFriendInfo::iterator, bool> Insert_Pair = curFriendInfoMap.insert(std::make_pair(pReq->m_friendAccount, pFriendInfo));
|
||
if (Insert_Pair.second == true)
|
||
{
|
||
ChatLog << "A friend map Insert Successfully,user:"<<m_account<<" friend size:" << iter->second.size() <<",friend account:"<<pReq->m_friendAccount<< endl;
|
||
}
|
||
else
|
||
{
|
||
ChatLog << "A friend map Insert fail" << endl;
|
||
}
|
||
|
||
g_UserFriendInfoMap.insert(std::make_pair(m_account, curFriendInfoMap));
|
||
//给其 B 用户 转发 A 添加好友的请求
|
||
sendMsg(pUserInfo->m_socket, msg, sizeof(AddFriendInfoReq), CommandEnum_AddFriend,0,1);
|
||
//给客户端发送请求成功的信息,告诉客户端请求被受理了
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, 0);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief A:发送好友请求的客户端
|
||
* B:接收好友请求的客户端
|
||
*/
|
||
int Session::handleAddFriendResp(void*msg){
|
||
AddFriendInfoResp* pResp = (AddFriendInfoResp*)msg;
|
||
LOGINFO("recv a AddFriendResp msg,status:%d\n",pResp->status);
|
||
//A.找到 A 的用户信息
|
||
UserInfo *pUserInfo = NULL;
|
||
mapUserInfo::iterator UserInfoiter = g_UserInfoMap.find(pResp->m_senderAccount);
|
||
if (UserInfoiter != g_UserInfoMap.end())
|
||
{
|
||
pUserInfo = UserInfoiter->second;
|
||
}
|
||
else{
|
||
//没找到A用户信息，添加好友请求失败
|
||
//给客户端发送响应失败的响应信息(不应该出现的情况)
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, -1);
|
||
return -1;
|
||
}
|
||
|
||
|
||
//C 1.从用户好友表找到 B 对应的好友表
|
||
mapUserFriendInfo::iterator iter = g_UserFriendInfoMap.find(m_account);
|
||
if(iter!=g_UserFriendInfoMap.end()){
|
||
//B用户存在好友表
|
||
//2.用户好友表中查找A的账号是否在表中
|
||
mapFriendInfo::iterator ite = iter->second.find(pResp->m_senderAccount);
|
||
if(ite!=iter->second.end()){
|
||
LOGINFO("-----------error-----------\n");
|
||
//找到了,这不应该出现的情况
|
||
FriendInfo* pFriendInfo = ite->second;
|
||
if(pFriendInfo->m_status == 1){
|
||
//已经是好友了，重复添加 不应该出现的情况
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, -1);
|
||
return -1;
|
||
}
|
||
else if(pFriendInfo->m_status == -1){
|
||
//B还未同意，暂时不给B发请求了
|
||
//给客户端发送请求成功的信息
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, 0);
|
||
}
|
||
}
|
||
else{
|
||
//没有好友信息，需要添加好友信息
|
||
//将B添加到A的好友表中
|
||
FriendInfo *pFriendInfo = (FriendInfo *)malloc(sizeof(FriendInfo));
|
||
pFriendInfo->m_account = pResp->m_senderAccount;
|
||
pFriendInfo->m_status = 1; //未同意的好友，当拒绝时删除这条信息
|
||
strncpy(pFriendInfo->m_userName, pUserInfo->m_userName, sizeof(pUserInfo->m_userName));
|
||
LOGINFO("[%d][%s]userName：%s,account:%d,status:%d\n",m_account,m_userName,pFriendInfo->m_userName,pFriendInfo->m_account,pFriendInfo->m_status);
|
||
|
||
std::pair<mapFriendInfo::iterator, bool> Insert_Pair = iter->second.insert(std::make_pair(pResp->m_senderAccount, pFriendInfo));
|
||
if (Insert_Pair.second == true)
|
||
{
|
||
ChatLog << "B friend map Insert Successfully,user:" << m_account << " friend size:" << iter->second.size() << ",friend account:" << pResp->m_senderAccount << endl;
|
||
}
|
||
else
|
||
{
|
||
ChatLog << "B friend map Insert fail" << endl;
|
||
}
|
||
|
||
//给其 A 用户 转发 B 添加好友的成功的响应
|
||
sendMsg(pUserInfo->m_socket, pResp, sizeof(AddFriendInfoResp), CommandEnum_AddFriend);
|
||
//给客户端发送请求成功的信息,告诉客户端请求被受理了
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, 0);
|
||
}
|
||
}
|
||
else{
|
||
//B用户不存在好友表
|
||
mapFriendInfo curFriendInfoMap;
|
||
//将A添加到B的好友表中
|
||
FriendInfo *pFriendInfo = (FriendInfo *)malloc(sizeof(FriendInfo));
|
||
pFriendInfo->m_account = pResp->m_senderAccount;
|
||
pFriendInfo->m_status = 1; //未同意的好友，当拒绝时删除这条信息
|
||
strncpy(pFriendInfo->m_userName, pUserInfo->m_userName, sizeof(pUserInfo->m_userName));
|
||
LOGINFO("[%d][%s]userName：%s,account:%d,status:%d\n",m_account,m_userName,pFriendInfo->m_userName,pFriendInfo->m_account,pFriendInfo->m_status);
|
||
|
||
std::pair<mapFriendInfo::iterator, bool> Insert_Pair = curFriendInfoMap.insert(std::make_pair(pResp->m_senderAccount, pFriendInfo));
|
||
if (Insert_Pair.second == true)
|
||
{
|
||
ChatLog << "B friend map Insert Successfully,user:" << m_account << " friend size:" << iter->second.size() << ",friend account:" << pResp->m_senderAccount << endl;
|
||
}
|
||
else
|
||
{
|
||
ChatLog << "B friend map Insert fail" << endl;
|
||
}
|
||
|
||
g_UserFriendInfoMap.insert(std::make_pair(m_account, curFriendInfoMap));
|
||
//给其 A 用户 转发 B 添加好友的成功的响应
|
||
sendMsg(pUserInfo->m_socket, pResp, sizeof(AddFriendInfoResp), CommandEnum_AddFriend);
|
||
//给客户端发送请求成功的信息,告诉客户端请求被受理了
|
||
sendMsg(m_socket, NULL, 0, CommandEnum_AddFriend, 0);
|
||
}
|
||
|
||
//将A用户的好友标志置位
|
||
//C 1.从用户好友表找到 A 对应的好友表
|
||
mapUserFriendInfo::iterator iter2 = g_UserFriendInfoMap.find(pResp->m_senderAccount);
|
||
if(iter2!=g_UserFriendInfoMap.end()){
|
||
//A用户存在好友表
|
||
//2.用户好友表中查找B的账号是否在表中
|
||
mapFriendInfo::iterator ite2 = iter2->second.find(pResp->m_friendAccount);
|
||
if(ite2!=iter2->second.end()){
|
||
//找到了
|
||
FriendInfo* pFriendInfo = ite2->second;
|
||
pFriendInfo->m_status = 1; //同意
|
||
LOGINFO("[%d]userName：%s,account:%d,status:%d\n",pResp->m_senderAccount,pFriendInfo->m_userName,pFriendInfo->m_account,pFriendInfo->m_status);
|
||
}
|
||
else{
|
||
LOGINFO("==========出错了==========\n");
|
||
}
|
||
}
|
||
else{
|
||
LOGINFO("==========出错了==========\n");
|
||
}
|
||
}
|
||
|
||
|