void CRouteServConn::_HandleClientDelFriendNotify(CImPdu* pPdu)
{
IM::Buddy::IMCommonOperFriendRes msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
log(" user_id=%d friend_id=%d.", msg.user_id(), msg.friend_id());
//send to other client
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(msg.user_id());
if (pFromImUser)
{
pPdu->SetCommandId(DFFX_CID_BUDDY_LIST_DELFRIEND_RES);
pFromImUser->BroadcastPdu(pPdu);
}
// 2.send notify to myfriend
uint32_t to_user_id = msg.friend_id();
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pToImUser)
{
pPdu->SetCommandId(DFFX_CID_BUDDY_LIST_DELFRIEND_NOTIFY);
pToImUser->BroadcastPdu(pPdu);
}
}
void CRouteServConn::_HandlePCLoginStatusNotify(CImPdu *pPdu)
{
IM::Server::IMServerPCLoginStatusNotify msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t user_id = msg.user_id();
uint32_t login_status = msg.login_status();
log("HandlePCLoginStatusNotify, user_id=%u, login_status=%u ", user_id, login_status);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (pUser)
{
pUser->SetPCLoginStatus(login_status);
IM::Buddy::IMPCLoginStatusNotify msg2;
msg2.set_user_id(user_id);
if (IM_PC_LOGIN_STATUS_ON == login_status)
{
msg2.set_login_stat(::IM::BaseDefine::USER_STATUS_ONLINE);
}
else
{
msg2.set_login_stat(::IM::BaseDefine::USER_STATUS_OFFLINE);
}
CImPdu pdu;
pdu.SetPBMsg(&msg2);
pdu.SetServiceId(IM::BaseDefine::SID_BUDDY_LIST);
pdu.SetCommandId(IM::BaseDefine::CID_BUDDY_LIST_PC_LOGIN_STATUS_NOTIFY);
pUser->BroadcastPduToMobile(&pdu);
}
}
// friend online/off-line notify
void CRouteServConn::_HandleFriendStatusNotify(CImPduFriendStatusNotify* pPdu)
{
uint32_t user_id = pPdu->GetFromUserId();
uint32_t user_status = pPdu->GetFromUserStatus();
uint32_t friend_cnt = pPdu->GetFriendCnt();
uint32_t* friend_id_list = pPdu->GetFriendIdList();
string user_id_url = idtourl(user_id);
log("HandleFriendStatusNotify, from_id=%u, status=%u\n", user_id, user_status);
// send friend online message to client
CImPduClientFriendNotify pdu(user_id_url.c_str(), user_status);
for (uint32_t i = 0; i < friend_cnt; ++i) {
CImUser* pImUser = CImUserManager::GetInstance()->GetImUserById(friend_id_list[i]);
if (pImUser) {
pImUser->BroadcastPdu(&pdu);
if (user_status == USER_STATUS_ONLINE) {
pImUser->AddOnlineFriend(user_id);
} else if (user_status == USER_STATUS_OFFLINE){
pImUser->RemoveOnlineFriend(user_id);
}
}
}
}
void CRouteServConn::_HandleMsgData(CImPdu* pPdu)
{
IM::Message::IMMsgData msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
if (CHECK_MSG_TYPE_GROUP(msg.msg_type())) {
s_group_chat->HandleGroupMessageBroadcast(pPdu);
return;
}
uint32_t from_user_id = msg.from_user_id();
uint32_t to_user_id = msg.to_session_id();
uint32_t msg_id = msg.msg_id();
log("HandleMsgData, %u->%u, msg_id=%u. ", from_user_id, to_user_id, msg_id);
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(from_user_id);
if (pFromImUser)
{
pFromImUser->BroadcastClientMsgData(pPdu, msg_id, NULL, from_user_id);
}
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pToImUser)
{
pToImUser->BroadcastClientMsgData(pPdu, msg_id, NULL, from_user_id);
}
}
void CRouteServConn::_HandleGroupP2PMsg(CImPduGroupP2PMessageResponse* pPdu)
{
uint32_t result = pPdu->GetResult();
uint32_t from_user_id = pPdu->GetReqUserId();
uint32_t* toUserList = pPdu->GetUserList();
log("_HandleGroupP2PMsg, from_user_id = %u, result = %u, to_user_cnt = %u.\n", from_user_id, result, pPdu->GetUserCnt());
if(result != 0 || !toUserList)
return;
for (int i = 0; i < pPdu->GetUserCnt(); ++i) {
uint32_t to_user_id = toUserList[i];
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pToImUser) {
uint32_t seq_no = 0;
string from_id_url = idtourl(from_user_id);
string to_id_url = idtourl(to_user_id);
CImPduClientP2PCmdMsg pdu(seq_no, from_id_url.c_str(), to_id_url.c_str(), pPdu->GetMsgDataLen(),
pPdu->GetMsgData());
pToImUser->BroadcastPdu(&pdu);
}
}
}
void CDBServConn::_HandleMsgData(CImPdu *pPdu)
{
IM::Message::IMMsgData msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
if (CHECK_MSG_TYPE_GROUP(msg.msg_type())) {
s_group_chat->HandleGroupMessage(pPdu);
return;
}
uint32_t from_user_id = msg.from_user_id();
uint32_t to_user_id = msg.to_session_id();
uint32_t msg_id = msg.msg_id();
if (msg_id == 0) {
log("HandleMsgData, write db failed, %u->%u.", from_user_id, to_user_id);
return;
}
uint8_t msg_type = msg.msg_type();
CDbAttachData attach_data((uchar_t*)msg.attach_data().c_str(), msg.attach_data().length());
uint32_t handle = attach_data.GetHandle();
log("HandleMsgData, from_user_id=%u, to_user_id=%u, msg_id=%u.", from_user_id, to_user_id, msg_id);
CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(from_user_id, attach_data.GetHandle());
if (pMsgConn)
{
IM::Message::IMMsgDataAck msg2;
msg2.set_user_id(from_user_id);
msg2.set_msg_id(msg_id);
msg2.set_session_id(to_user_id);
msg2.set_session_type(::IM::BaseDefine::SESSION_TYPE_SINGLE);
pMsgConn->SendPdu(SID_MSG, CID_MSG_DATA_ACK, msg2);
}
CRouteServConn* pRouteConn = get_route_serv_conn();
if (pRouteConn) {
pRouteConn->SendPdu(pPdu);
}
msg.clear_attach_data();
pPdu->SetPBMsg(&msg);
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(from_user_id);
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
pPdu->SetSeqNum(0);
if (pFromImUser) {
pFromImUser->BroadcastClientMsgData(pPdu, msg_id, pMsgConn, from_user_id);
}
if (pToImUser) {
pToImUser->BroadcastClientMsgData(pPdu, msg_id, NULL, from_user_id);
}
IM::Server::IMGetDeviceTokenReq msg3;
msg3.add_user_id(to_user_id);
msg3.set_attach_data(pPdu->GetBodyData(), pPdu->GetBodyLength());
SendPdu(SID_OTHER, CID_OTHER_GET_DEVICE_TOKEN_REQ, msg3);
}
CMsgConn* CImUserManager::GetMsgConnByHandle(uint32_t user_id, uint32_t handle)
{
CMsgConn* pMsgConn = NULL;
CImUser* pImUser = GetImUserById(user_id);
if (pImUser) {
pMsgConn = pImUser->GetMsgConn(handle);
}
return pMsgConn;
}
void CGroupChat::_SendPduToUser(CImPdu* pPdu, uint32_t user_id, CMsgConn* pReqConn)
{
if(!pPdu) {
return;
}
CImUser* pToUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if(pToUser) {
pToUser->BroadcastPdu(pPdu, pReqConn);
}
}
void CRouteServConn::_HandleKickUser(CImPduServerKickUser* pPdu)
{
uint32_t to_user_id = pPdu->GetUserId();
uint32_t client_type = pPdu->GetClientType();
log("HandleKickUser, user_id=%u\n", to_user_id);
//TODO
CImUser* pImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pImUser) {
pImUser->KickOutSameClientType(client_type);
}
}
void CRouteServConn::_HandleClientFriendNotifyRequest(CImPdu* pPdu)
{
IM::Buddy::IMFriendNotifyReq msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
log(" from_user_id=%d to_user_id=%d.", msg.from_user_id(), msg.to_user_id());
uint32_t to_user_id = msg.to_user_id();
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pToImUser)
{
pToImUser->BroadcastPdu(pPdu);
}
}
void CRouteServConn::_HandleRemoveSessionNotify(CImPdu *pPdu)
{
IM::Buddy::IMRemoveSessionNotify msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t user_id = msg.user_id();
uint32_t session_id = msg.session_id();
log("HandleRemoveSessionNotify, user_id=%u, session_id=%u ", user_id, session_id);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (pUser)
{
pUser->BroadcastPdu(pPdu);
}
}
void CFileHandler::HandleClientFileRequest(CMsgConn* pMsgConn, CImPduClientFileRequest* pPdu)
{
string from_id_url(pPdu->GetFromId(), pPdu->GetFromIdLen());
uint32_t from_id = urltoid(from_id_url.c_str());
string to_id_url(pPdu->GetToId(), pPdu->GetToIdLen());
uint32_t to_id = urltoid(to_id_url.c_str());
string file_name(pPdu->GetFileName(), pPdu->GetFileNameLen());
uint32_t file_size = pPdu->GetFileSize();
log("HandleClientFileRequest, %u->%u, fileName: %s\n", from_id, to_id, file_name.c_str());
CPduAttachData attach(ATTACH_TYPE_HANDLE, pMsgConn->GetHandle(), 0, NULL, 0);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(to_id);
if (pUser)
{
uint32_t client_type_flag = pUser->GetClientTypeFlag();
//to_user has pc_client in this msg_server
if ((client_type_flag & CLIENT_TYPE_FLAG_BOTH) == CLIENT_TYPE_FLAG_PC)
{
CFileServConn* pFileConn = get_random_file_serv_conn();
if (pFileConn)
{
CImPduMsgFileTransferReq pdu(from_id, to_id, file_name.c_str(), file_size,
FILE_TYPE_ONLINE, attach.GetLength(), attach.GetBuffer());
pdu.SetReserved(pPdu->GetReserved());
pFileConn->SendPdu(&pdu);
}
else
{
log("HandleClientFileRequest, no file server.\n");
CImPduClientFileResponse pdu2(REFUSE_REASON_NO_FILE_SERVER, from_id_url.c_str(),
to_id_url.c_str(), file_name.c_str(), NULL, NULL, 0);
pdu2.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pdu2);
}
return;
}
}
else
{
//no pc_client in this msg_server, check it from route_server
CRouteServConn* pConn = get_route_serv_conn();
CPduAttachData pduAttachData(ATTACH_TYPE_HANDLE_AND_PDU, pMsgConn->GetHandle(),
pPdu->GetLength(), pPdu->GetBuffer());
CImPduUserClientTypeRequest pdu3(to_id, pduAttachData.GetLength(), pduAttachData.GetBuffer());
pdu3.SetReserved(pPdu->GetReserved());
pConn->SendPdu(&pdu3);
}
}
void CImUserManager::GetUserConnCnt(list<user_conn_t>* user_conn_list, uint32_t& total_conn_cnt)
{
total_conn_cnt = 0;
CImUser* pImUser = NULL;
for (ImUserMap_t::iterator it = m_im_user_map.begin(); it != m_im_user_map.end(); it++)
{
pImUser = (CImUser*)it->second;
if (pImUser->IsValidate())
{
user_conn_t user_conn_cnt = pImUser->GetUserConn();
user_conn_list->push_back(user_conn_cnt);
total_conn_cnt += user_conn_cnt.conn_cnt;
}
}
}
void CRouteServConn::_HanddleClientOrderStatusReadMsgBraodcast(CImPdu* pPdu)
{
IM::Message::IMOrderStatusRead msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
log("CRouteServConn user_id = %d order_id = %d orderlist_is_null = %d", msg.user_id(), msg.order_id(), msg.orderlist_is_null());
//send to other client
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(msg.user_id());
if (pFromImUser)
{
pFromImUser->BroadcastPdu(pPdu);
}
}
void CRouteServConn::_HandleDBReverseAddFriendRes(CImPdu* pPdu)
{
IM::Buddy::IMCommonOperFriendRes msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
log(" user_id=%d friend_id=%d.", msg.user_id(), msg.friend_id());
//send to other client
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(msg.user_id());
if (pFromImUser)
{
pFromImUser->BroadcastPdu(pPdu);
}
}
void CRouteServConn::_HandleKickUser(CImPdu* pPdu)
{
IM::Server::IMServerKickUser msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t user_id = msg.user_id();
uint32_t client_type = msg.client_type();
uint32_t reason = msg.reason();
log("HandleKickUser, user_id=%u, client_type=%u, reason=%u. ", user_id, client_type, reason);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (pUser) {
pUser->KickOutSameClientType(client_type, reason);
}
}
void CRouteServConn::_HandleMsgReadNotify(CImPdu *pPdu)
{
IM::Message::IMMsgDataReadNotify msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t req_id = msg.user_id();
uint32_t session_id = msg.session_id();
uint32_t msg_id = msg.msg_id();
uint32_t session_type = msg.session_type();
log("HandleMsgReadNotify, user_id=%u, session_id=%u, session_type=%u, msg_id=%u. ", req_id, session_id, session_type, msg_id);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(req_id);
if (pUser)
{
pUser->BroadcastPdu(pPdu);
}
}
void CDBServConn::_HandleChangeAvatarResponse(CImPdu* pPdu)
{
IM::Buddy::IMChangeAvatarRsp msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t user_id = msg.user_id();
uint32_t result = msg.result_code();
log("HandleChangeAvatarResp, user_id=%u, result=%u.", user_id, result);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (NULL != pUser) {
msg.clear_attach_data();
pPdu->SetPBMsg(&msg);
pUser->BroadcastPdu(pPdu);
}
}
void CFileHandler::HandleFileNotify(CImPduFileNotify *pPdu)
{
uint32_t from_user_id = pPdu->GetFromId();
uint32_t to_user_id = pPdu->GetToId();
string file_name(pPdu->GetFileName(), pPdu->GetFileNameLen());
uint32_t file_size = pPdu->GetFileSize();
string task_id(pPdu->GetTaskId(), pPdu->GetTaskIdLen());
string listen_ip(pPdu->GetListenIp(), pPdu->GetListenIpLen());
uint32_t listen_port = pPdu->GetListenPort();
log("HandleFileNotify, from_id: %u, to_id: %u, file_name: %s, task_id: %s, file_server_ip: %s,\
file_server_port: %u.\n", from_user_id, to_user_id, file_name.c_str(), task_id.c_str(),
listen_ip.c_str(), listen_port);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pUser) {
CImPduClientFileNotify pdu(idtourl(from_user_id), idtourl(to_user_id), file_name.c_str(),
file_size, task_id.c_str(), listen_ip.c_str(), listen_port);
pUser->BroadcastPdu(&pdu);
}
}
void CRouteServConn::_HandleP2PMsg(CImPduP2PMsg* pPdu)
{
uint32_t from_user_id = pPdu->GetFromUserId();
uint32_t to_user_id = pPdu->GetToUserId();
uint32_t seq_no = pPdu->GetSeqNo();
string from_id_url = idtourl(from_user_id);
string to_id_url = idtourl(to_user_id);
CImPduClientP2PCmdMsg pdu(seq_no, from_id_url.c_str(), to_id_url.c_str(), pPdu->GetMsgLen(), pPdu->GetMsgData());
log("HandleP2PMsg, %u->%u\n", from_user_id, to_user_id);
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(from_user_id);
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pFromImUser) {
pFromImUser->BroadcastPdu(&pdu);
}
if (pToImUser) {
pToImUser->BroadcastPdu(&pdu);
}
}
void CRouteServConn::_HandleP2PMsg(CImPdu* pPdu)
{
IM::SwitchService::IMP2PCmdMsg msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t from_user_id = msg.from_user_id();
uint32_t to_user_id = msg.to_user_id();
log("HandleP2PMsg, %u->%u ", from_user_id, to_user_id);
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(from_user_id);
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pFromImUser) {
pFromImUser->BroadcastPdu(pPdu);
}
if (pToImUser) {
pToImUser->BroadcastPdu(pPdu);
}
}
void CRouteServConn::_HandleMsgData(CImPduMsgData* pPdu)
{
uint32_t from_user_id = pPdu->GetFromUserId();
uint32_t to_user_id = pPdu->GetToUserId();
log("HandleMsgData, %u->%u\n", from_user_id, to_user_id);
uint32_t seq_no = pPdu->GetRequestId();
string from_id_url = idtourl(from_user_id);
string to_id_url = idtourl(to_user_id);
uint8_t msg_type = pPdu->GetMsgType();
CImPduClientMsgData pdu(seq_no, from_id_url.c_str(), to_id_url.c_str(), pPdu->GetCreateTime(),
msg_type, pPdu->GetMsgLen(), pPdu->GetMsgData(), pPdu->GetAttachLen(), pPdu->GetAttachData());
CImUser* pFromImUser = CImUserManager::GetInstance()->GetImUserById(from_user_id);
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(to_user_id);
if (pFromImUser) {
pFromImUser->BroadcastClientMsgData(&pdu, NULL, from_user_id);
pFromImUser->AddOnlineFriend(to_user_id); // 聊过天就通知上下线消息
}
if (pToImUser) {
pToImUser->BroadcastClientMsgData(&pdu, NULL, from_user_id);
pToImUser->AddOnlineFriend(from_user_id);
}
}
void CImUserManager::GetOnlineUserInfo(list<user_stat_t>* online_user_info)
{
user_stat_t status;
CImUser* pImUser = NULL;
for (ImUserMap_t::iterator it = m_im_user_map.begin(); it != m_im_user_map.end(); it++) {
pImUser = (CImUser*)it->second;
if (pImUser->IsValidate()) {
map<uint32_t, CMsgConn*>& ConnMap = pImUser->GetMsgConnMap();
for (map<uint32_t, CMsgConn*>::iterator it = ConnMap.begin(); it != ConnMap.end(); it++)
{
CMsgConn* pConn = it->second;
if (pConn->IsOpen())
{
status.user_id = pImUser->GetUserId();
status.client_type = pConn->GetClientType();
status.status = pConn->GetOnlineStatus();
online_user_info->push_back(status);
}
}
}
}
}
void CImUserManager::BroadcastPdu(CImPdu* pdu, uint32_t client_type_flag)
{
CImUser* pImUser = NULL;
for (ImUserMap_t::iterator it = m_im_user_map.begin(); it != m_im_user_map.end(); it++)
{
pImUser = (CImUser*)it->second;
if (pImUser->IsValidate())
{
switch (client_type_flag) {
case CLIENT_TYPE_FLAG_PC:
pImUser->BroadcastPduWithOutMobile(pdu);
break;
case CLIENT_TYPE_FLAG_MOBILE:
pImUser->BroadcastPduToMobile(pdu);
break;
case CLIENT_TYPE_FLAG_BOTH:
pImUser->BroadcastPdu(pdu);
break;
default:
break;
}
}
}
}
void CRouteServConn::_HandleFriendStatusList(CImPduFriendStatusList* pPdu)
{
uint32_t user_id = pPdu->GetFromUserId();
uint32_t friend_cnt = pPdu->GetFriendCnt();
user_stat_t* friend_status_list = pPdu->GetFriendStatList();
string user_id_url = idtourl(user_id);
log("HandleOnlineFriendList, from_id=%d\n", user_id);
CImUser* pImUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (!pImUser) {
return;
}
// send online friend status list to client
CImPduClientOnlineFriendList pduCOFL(pPdu->GetRequestType(), friend_cnt, friend_status_list);
pImUser->BroadcastPdu(&pduCOFL);
// user don't need to send self status to friend list
if (pPdu->GetRequestType() == ONLINE_LIST_TYPE_FRIEND_LIST) {
return;
}
// send online friend notify packet to the client in the same message server
CImPduClientFriendNotify pduCFN(user_id_url.c_str(), pImUser->GetIMOnlineStatus());
for (uint32_t i = 0; i < friend_cnt; i++) {
pImUser->AddOnlineFriend(friend_status_list[i].user_id);
CImUser* pFriendUser = CImUserManager::GetInstance()->GetImUserById(friend_status_list[i].user_id);
if (pFriendUser) {
//log("notify %u online to %u\n", user_id, friend_status_list[i].user_id);
pFriendUser->BroadcastPdu(&pduCFN);
pFriendUser->AddOnlineFriend(user_id);
}
}
}
void CDBServConn::_HandleGetDeviceTokenResponse(CImPdu *pPdu)
{
IM::Server::IMGetDeviceTokenRsp msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
IM::Message::IMMsgData msg2;
CHECK_PB_PARSE_MSG(msg2.ParseFromArray(msg.attach_data().c_str(), msg.attach_data().length()));
string msg_data = msg2.msg_data();
uint32_t msg_type = msg2.msg_type();
uint32_t from_id = msg2.from_user_id();
uint32_t to_id = msg2.to_session_id();
if (msg_type == IM::BaseDefine::MSG_TYPE_SINGLE_TEXT || msg_type == IM::BaseDefine::MSG_TYPE_GROUP_TEXT)
{
//msg_data =
char* msg_out = NULL;
uint32_t msg_out_len = 0;
if (pAes->Decrypt(msg_data.c_str(), msg_data.length(), &msg_out, msg_out_len) == 0)
{
msg_data = string(msg_out, msg_out_len);
}
else
{
log("HandleGetDeviceTokenResponse, decrypt msg failed, from_id: %u, to_id: %u, msg_type: %u.", from_id, to_id, msg_type);
return;
}
pAes->Free(msg_out);
}
build_ios_push_flash(msg_data, msg2.msg_type(), from_id);
//{
// "msg_type": 1,
// "from_id": "1345232",
// "group_type": "12353",
//}
jsonxx::Object json_obj;
json_obj << "msg_type" << (uint32_t)msg2.msg_type();
json_obj << "from_id" << from_id;
if (CHECK_MSG_TYPE_GROUP(msg2.msg_type())) {
json_obj << "group_id" << to_id;
}
uint32_t user_token_cnt = msg.user_token_info_size();
log("HandleGetDeviceTokenResponse, user_token_cnt = %u.", user_token_cnt);
IM::Server::IMPushToUserReq msg3;
for (uint32_t i = 0; i < user_token_cnt; i++)
{
IM::BaseDefine::UserTokenInfo user_token = msg.user_token_info(i);
uint32_t user_id = user_token.user_id();
string device_token = user_token.token();
uint32_t push_cnt = user_token.push_count();
uint32_t client_type = user_token.user_type();
//自己发得消息不给自己发推送
if (from_id == user_id) {
continue;
}
log("HandleGetDeviceTokenResponse, user_id = %u, device_token = %s, push_cnt = %u, client_type = %u.",
user_id, device_token.c_str(), push_cnt, client_type);
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (pUser)
{
msg3.set_flash(msg_data);
msg3.set_data(json_obj.json());
IM::BaseDefine::UserTokenInfo* user_token_tmp = msg3.add_user_token_list();
user_token_tmp->set_user_id(user_id);
user_token_tmp->set_user_type((IM::BaseDefine::ClientType)client_type);
user_token_tmp->set_token(device_token);
user_token_tmp->set_push_count(push_cnt);
//pc client登录，则为勿打扰式推送
if (pUser->GetPCLoginStatus() == IM_PC_LOGIN_STATUS_ON)
{
user_token_tmp->set_push_type(IM_PUSH_TYPE_SILENT);
log("HandleGetDeviceTokenResponse, user id: %d, push type: silent.", user_id);
}
else
{
user_token_tmp->set_push_type(IM_PUSH_TYPE_NORMAL);
log("HandleGetDeviceTokenResponse, user id: %d, push type: normal.", user_id);
}
}
else
{
IM::Server::IMPushToUserReq msg4;
msg4.set_flash(msg_data);
msg4.set_data(json_obj.json());
IM::BaseDefine::UserTokenInfo* user_token_tmp = msg4.add_user_token_list();
user_token_tmp->set_user_id(user_id);
user_token_tmp->set_user_type((IM::BaseDefine::ClientType)client_type);
user_token_tmp->set_token(device_token);
user_token_tmp->set_push_count(push_cnt);
user_token_tmp->set_push_type(IM_PUSH_TYPE_NORMAL);
CImPdu pdu;
pdu.SetPBMsg(&msg4);
pdu.SetServiceId(SID_OTHER);
pdu.SetCommandId(CID_OTHER_PUSH_TO_USER_REQ);
CPduAttachData attach_data(ATTACH_TYPE_PDU_FOR_PUSH, 0, pdu.GetBodyLength(), pdu.GetBodyData());
IM::Buddy::IMUsersStatReq msg5;
msg5.set_user_id(0);
msg5.add_user_id_list(user_id);
msg5.set_attach_data(attach_data.GetBuffer(), attach_data.GetLength());
CImPdu pdu2;
pdu2.SetPBMsg(&msg5);
pdu2.SetServiceId(SID_BUDDY_LIST);
pdu2.SetCommandId(CID_BUDDY_LIST_USERS_STATUS_REQUEST);
auto route_conn = get_route_serv_conn();
if (route_conn)
{
route_conn->SendPdu(&pdu2);
}
}
}
if (msg3.user_token_list_size() > 0)
{
CImPdu pdu3;
pdu3.SetPBMsg(&msg3);
pdu3.SetServiceId(SID_OTHER);
pdu3.SetCommandId(CID_OTHER_PUSH_TO_USER_REQ);
auto PushConn = get_push_serv_conn();
if (PushConn) {
PushConn->SendPdu(&pdu3);
}
}
}
void CGroupChat::HandleGroupInfoResponse(CImPdu* pPdu)
{
IM::Group::IMGroupInfoListRsp msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
uint32_t user_id = msg.user_id();
uint32_t group_cnt = msg.group_info_list_size();
CPduAttachData pduAttachData((uchar_t*)msg.attach_data().c_str(), msg.attach_data().length());
log("HandleGroupInfoResponse, user_id=%u, group_cnt=%u. ", user_id, group_cnt);
//此处是查询成员时使用，主要用于群消息从数据库获得msg_id后进行发送,一般此时group_cnt = 1
if (pduAttachData.GetPduLength() > 0 && group_cnt > 0)
{
IM::BaseDefine::GroupInfo group_info = msg.group_info_list(0);
uint32_t group_id = group_info.group_id();
log("GroupInfoRequest is send by server, group_id=%u ", group_id);
std::set<uint32_t> group_member_set;
for (uint32_t i = 0; i < group_info.group_member_list_size(); i++)
{
uint32_t member_user_id = group_info.group_member_list(i);
group_member_set.insert(member_user_id);
}
if (group_member_set.find(user_id) == group_member_set.end())
{
log("user_id=%u is not in group, group_id=%u. ", user_id, group_id);
return;
}
IM::Message::IMMsgData msg2;
CHECK_PB_PARSE_MSG(msg2.ParseFromArray(pduAttachData.GetPdu(), pduAttachData.GetPduLength()));
CImPdu pdu;
pdu.SetPBMsg(&msg2);
pdu.SetServiceId(SID_MSG);
pdu.SetCommandId(CID_MSG_DATA);
//Push相关
IM::Server::IMGroupGetShieldReq msg3;
msg3.set_group_id(group_id);
msg3.set_attach_data(pdu.GetBodyData(), pdu.GetBodyLength());
for (uint32_t i = 0; i < group_info.group_member_list_size(); i++)
{
uint32_t member_user_id = group_info.group_member_list(i);
msg3.add_user_id(member_user_id);
CImUser* pToImUser = CImUserManager::GetInstance()->GetImUserById(member_user_id);
if (pToImUser)
{
CMsgConn* pFromConn = NULL;
if( member_user_id == user_id )
{
uint32_t reqHandle = pduAttachData.GetHandle();
if(reqHandle != 0)
pFromConn = CImUserManager::GetInstance()->GetMsgConnByHandle(user_id, reqHandle);
}
pToImUser->BroadcastData(pdu.GetBuffer(), pdu.GetLength(), pFromConn);
}
}
CImPdu pdu2;
pdu2.SetPBMsg(&msg3);
pdu2.SetServiceId(SID_OTHER);
pdu2.SetCommandId(CID_OTHER_GET_SHIELD_REQ);
CDBServConn* pDbConn = get_db_serv_conn();
if (pDbConn)
{
pDbConn->SendPdu(&pdu2);
}
}
else if (pduAttachData.GetPduLength() == 0)
{
//正常获取群信息的返回
CMsgConn* pConn = CImUserManager::GetInstance()->GetMsgConnByHandle(user_id, pduAttachData.GetHandle());
if (pConn)
{
msg.clear_attach_data();
pPdu->SetPBMsg(&msg);
pConn->SendPdu(pPdu);
}
}
}
void CDBServConn::_HandleValidateResponse(CImPduValidateResponse* pPdu)
{
string user_name(pPdu->GetUserName(), pPdu->GetUserNameLen());
uint32_t result = pPdu->GetResult();
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
log("HandleValidateResp, user_name=%s, result=%d\n", user_name.c_str(), result);
CImUser* pImUser = CImUserManager::GetInstance()->GetImUserByName(user_name);
CMsgConn* pMsgConn = NULL;
if (!pImUser) {
// can not find the client connection,
// maybe the client is closed before the DB response arrived
// do nothing
log("ImUser for user_name=%s not exist\n", user_name.c_str());
return;
} else {
pMsgConn = pImUser->GetUnValidateMsgConn(attach_data.GetHandle());
if (!pMsgConn || pMsgConn->IsOpen()) {
log("no such connection or is validated, user_name=%s\n", user_name.c_str());
return;
}
}
if (result != 0) {
result = REFUSE_REASON_DB_VALIDATE_FAILED;
}
// validate OK, set client validate past, and send FriendListRequest to db storage server
// else close the client connection
if (result == 0) {
user_info_t* user = pPdu->GetUserInfo();
pImUser->SetUser(user);
pImUser->SetValidated();
uint32_t user_id = user->user_id;
CImUserManager::GetInstance()->AddImUserById(user_id, pImUser);
pImUser->KickOutSameClientType(pMsgConn->GetClientType(), pMsgConn);
CRouteServConn* pRouteConn = get_route_serv_conn();
if (pRouteConn) {
CImPduServerKickUser kickPdu(user_id, pMsgConn->GetClientType(), KICK_REASON_DUPLICATE_USER);
pRouteConn->SendPdu(&kickPdu);
}
string token = create_uuid();
log("user_name: %s, uid: %d, token:%s\n", user_name.c_str(), user->user_id, token.c_str());
pMsgConn->SetToken(token);
pMsgConn->SetOpen();
pMsgConn->SendUserActionLog(USER_ACTION_TYPE_LOGIN);
pMsgConn->SendUserStatusUpdate(USER_STATUS_ONLINE);
pImUser->ValidateMsgConn(token, pMsgConn);
CImPduLoginResponse pduLR(result, pImUser->GetIMOnlineStatus(), user, (char*)token.c_str());
pduLR.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pduLR);
} else {
CImPduLoginResponse pduLR(result);
pduLR.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pduLR);
//pMsgConn->Close();
}
}
void CDBServConn::_HandleDbRegisterResponse(CImPdu* pPdu)
{
RUNTIME_TRACE;
IM::Server::IMDbRegRes msgDb;
CHECK_PB_PARSE_MSG(msgDb.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
string login_name = msgDb.user_name();
CImUser* pImUser = CImUserManager::GetInstance()->GetImUserByLoginName(login_name);
if (!pImUser) {
log("ImUser for user_name=%s not exist", login_name.c_str());
return;
}
CDbAttachData attach_data((uchar_t*)msgDb.attach_data().c_str(), msgDb.attach_data().length());
auto pMsgConn = pImUser->GetUnValidateMsgConn(attach_data.GetHandle());
if (!pMsgConn || pMsgConn->IsOpen()) {
log("no such conn, user_name=%s", login_name.c_str());
return;
}
IM::BaseDefine::UserInfo user_info = msgDb.user_info();
uint32_t user_id = user_info.user_id();
pImUser->SetUserId(user_id);
pImUser->SetNickName(user_info.user_nick_name());
pImUser->SetValidated();
CImUserManager::GetInstance()->AddImUserById(user_id, pImUser);
log("user_name: %s, uid: %d", login_name.c_str(), user_id);
pMsgConn->SetUserId(user_id);
pMsgConn->SetOpen();
pMsgConn->SendUserStatusUpdate(IM::BaseDefine::USER_STATUS_ONLINE);
pImUser->ValidateMsgConn(pMsgConn->GetHandle(), pMsgConn);
IM::Login::IMRegisterRes msgRes;
msgRes.set_user_name(login_name);
msgRes.set_server_time(time(NULL));
msgRes.set_result_code((IM::BaseDefine::ResultType)msgDb.result_code());
msgRes.set_online_status((IM::BaseDefine::UserStatType)pMsgConn->GetOnlineStatus());
msgRes.set_result_string(msgDb.result_string());
IM::BaseDefine::UserInfo* user_info_tmp = msgRes.mutable_user_info();
user_info_tmp->set_user_id(user_info.user_id());
user_info_tmp->set_user_gender(user_info.user_gender());
user_info_tmp->set_user_nick_name(user_info.user_nick_name());
user_info_tmp->set_avatar_url(user_info.avatar_url());
user_info_tmp->set_department_id(user_info.department_id());
user_info_tmp->set_email(user_info.email());
user_info_tmp->set_user_real_name(user_info.user_real_name());
user_info_tmp->set_user_tel(user_info.user_tel());
user_info_tmp->set_user_domain(user_info.user_domain());
user_info_tmp->set_status(user_info.status());
CImPdu pdu;
pdu.SetPBMsg(&msgRes);
pdu.SetServiceId(SID_LOGIN);
pdu.SetCommandId(CID_LOGIN_RES_USERREG);
pdu.SetSeqNum(pPdu->GetSeqNum());
pMsgConn->SendPdu(&pdu);
log("send pdu command id = %d", pdu.GetCommandId());
if (msgDb.result_code())
pMsgConn->Close();
}
void CDBServConn::_HandleValidateResponse(CImPdu* pPdu)
{
RUNTIME_TRACE;
IM::Server::IMValidateRsp msg;
CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
string login_name = msg.user_name();
uint32_t result = msg.result_code();
string result_string = msg.result_string();
CDbAttachData attach_data((uchar_t*)msg.attach_data().c_str(), msg.attach_data().length());
log("HandleValidateResp, user_name=%s, result=%d", login_name.c_str(), result);
CImUser* pImUser = CImUserManager::GetInstance()->GetImUserByLoginName(login_name);
SpCMsgConn pMsgConn = NULL;
if (!pImUser) {
log("ImUser for user_name=%s not exist", login_name.c_str());
return;
} else {
pMsgConn = pImUser->GetUnValidateMsgConn(attach_data.GetHandle());
if (!pMsgConn || pMsgConn->IsOpen()) {
log("no such conn is validated, user_name=%s", login_name.c_str());
return;
}
}
if (result != 0) {
result = IM::BaseDefine::REFUSE_REASON_DB_VALIDATE_FAILED;
}
if (result == 0)
{
IM::BaseDefine::UserInfo user_info = msg.user_info();
uint32_t user_id = user_info.user_id();
CImUser* pUser = CImUserManager::GetInstance()->GetImUserById(user_id);
if (pUser)
{
pUser->AddUnValidateMsgConn(pMsgConn);
pImUser->DelUnValidateMsgConn(pMsgConn);
if (pImUser->IsMsgConnEmpty())
{
CImUserManager::GetInstance()->RemoveImUserByLoginName(login_name);
delete pImUser;
}
}
else
{
pUser = pImUser;
}
pUser->SetUserId(user_id);
pUser->SetNickName(user_info.user_nick_name());
pUser->SetValidated();
CImUserManager::GetInstance()->AddImUserById(user_id, pUser);
pUser->KickOutSameClientType(pMsgConn->GetClientType(), IM::BaseDefine::KICK_REASON_DUPLICATE_USER, pMsgConn);
auto pRouteConn = get_route_serv_conn();
if (pRouteConn) {
IM::Server::IMServerKickUser msg2;
msg2.set_user_id(user_id);
msg2.set_client_type((::IM::BaseDefine::ClientType)pMsgConn->GetClientType());
msg2.set_reason(1);
CImPdu pdu;
pdu.SetPBMsg(&msg2);
pdu.SetServiceId(SID_OTHER);
pdu.SetCommandId(CID_OTHER_SERVER_KICK_USER);
pRouteConn->SendPdu(&pdu);
}
log("user_name: %s, uid: %d", login_name.c_str(), user_id);
pMsgConn->SetUserId(user_id);
pMsgConn->SetOpen();
pMsgConn->SendUserStatusUpdate(IM::BaseDefine::USER_STATUS_ONLINE);
pUser->ValidateMsgConn(pMsgConn->GetHandle(), pMsgConn);
IM::Login::IMLoginRes msg3;
msg3.set_server_time(time(NULL));
msg3.set_result_code(IM::BaseDefine::REFUSE_REASON_NONE);
msg3.set_result_string(result_string);
msg3.set_online_status((IM::BaseDefine::UserStatType)pMsgConn->GetOnlineStatus());
IM::BaseDefine::UserInfo* user_info_tmp = msg3.mutable_user_info();
user_info_tmp->set_user_id(user_info.user_id());
user_info_tmp->set_user_gender(user_info.user_gender());
user_info_tmp->set_user_nick_name(user_info.user_nick_name());
user_info_tmp->set_avatar_url(user_info.avatar_url());
user_info_tmp->set_department_id(user_info.department_id());
user_info_tmp->set_email(user_info.email());
user_info_tmp->set_user_real_name(user_info.user_real_name());
user_info_tmp->set_user_tel(user_info.user_tel());
user_info_tmp->set_user_domain(user_info.user_domain());
user_info_tmp->set_status(user_info.status());
CImPdu pdu2;
pdu2.SetPBMsg(&msg3);
pdu2.SetServiceId(SID_LOGIN);
pdu2.SetCommandId(CID_LOGIN_RES_USERLOGIN);
pdu2.SetSeqNum(pPdu->GetSeqNum());
pMsgConn->SendPdu(&pdu2);
}
else
{
IM::Login::IMLoginRes msg4;
msg4.set_server_time(time(NULL));
msg4.set_result_code((IM::BaseDefine::ResultType)result);
msg4.set_result_string(result_string);
CImPdu pdu3;
pdu3.SetPBMsg(&msg4);
pdu3.SetServiceId(SID_LOGIN);
pdu3.SetCommandId(CID_LOGIN_RES_USERLOGIN);
pdu3.SetSeqNum(pPdu->GetSeqNum());
pMsgConn->SendPdu(&pdu3);
pMsgConn->Close();
}
}
