/////////// for server
void CFileHandler::HandleFileHasOfflineRes(CImPduFileHasOfflineRes* pPdu)
{
uint32_t req_user_id = pPdu->GetReqUserId();
uint32_t file_cnt = pPdu->GetFileCnt();
offline_file_t* file_list = pPdu->GetFileList();
CDbAttachData attach(pPdu->GetAttachData(), pPdu->GetAttachLen());
log("HandleFileHasOfflineRes, req_id=%u, file_cnt=%u\n", req_user_id, file_cnt);
CMsgConn* pConn = CImUserManager::GetInstance()->GetMsgConnByHandle(req_user_id,
attach.GetHandle());
CFileServConn* pFileConn = get_random_file_serv_conn();
const list<ip_addr_t>* ip_list = NULL;
if (pFileConn)
{
ip_list = pFileConn->GetFileServerIPList();
}
else
{
log("HandleFileHasOfflineRes, no file server.\n");
}
if (pConn) {
CImPduClientFileHasOfflineRes pdu(file_cnt, file_list, ip_list);
pdu.SetReserved(pPdu->GetReserved());
pConn->SendPdu(&pdu);
}
}
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 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);
}
}
}
nsresult
BluetoothDaemonAvrcpModule::RegisterNotificationRspCmd(
BluetoothAvrcpEvent aEvent, BluetoothAvrcpNotification aType,
const BluetoothAvrcpNotificationParam& aParam,
BluetoothAvrcpResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<BluetoothDaemonPDU> pdu(
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_REGISTER_NOTIFICATION_RSP,
1 + // Event
1 + // Type
1 + // Data length
256)); // Maximum data length
nsresult rv = PackPDU(aEvent, aType,
BluetoothAvrcpEventParamPair(aEvent, aParam), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonAvrcpModule::ListPlayerAppAttrRspCmd(
int aNumAttr, const BluetoothAvrcpPlayerAttribute* aPAttrs,
BluetoothAvrcpResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<BluetoothDaemonPDU> pdu(
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_LIST_PLAYER_APP_ATTR_RSP,
1 + // # Attributes
aNumAttr)); // Player attributes
nsresult rv = PackPDU(
PackConversion<int, uint8_t>(aNumAttr),
PackArray<BluetoothAvrcpPlayerAttribute>(aPAttrs, aNumAttr), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
// 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);
}
}
}
}
HCIACLPDU AclEngine::Implementation::ChannelList::Channel::Send::getPdu(bool &isSendablePdu)
{
CriticalSection::Lock lock(mCs);
HCIACLPDU pdu(null_pdu);
while (true)
{
fillQueue();
if (queue.empty())
{
isSendablePdu = false;
return pdu;
}
else if (queue.front()->getPdu(pdu))
{
++tokensUsed;
isSendablePdu = true;
return pdu;
}
else
{
queue.pop_front();
}
}
}
// Fill remaining unused seats. These seats will have the
// same amount of tournament chips and they will be blinded off
void CTable::fillSeats(const CChips& chips)
{
printf("CTable::fillSeats\n");
SingleLock l(&tableMutex_);
l.lock();
int numPlayers = tableMax_ - countPlayersRaw();
for (int i = 0; (i < MaxPlayers) && (numPlayers > 0); i++)
{
if (players_[i]->matchState(PLAYER_STATE_UNUSED))
{
char buf[32];
sprintf(buf, "Open Seat %i", i + 1);
players_[i]->setPlayer(0,
buf,
buf,
chips,
0);
players_[i]->stateChange(PLAYER_STATE_BOUGHTIN);
players_[i]->setIsZombie(true);
players_[i]->setIsFreeSeat(true);
CpduPlayerInfo pdu(this);
pdu.sendPlayerInfo(players_[i]);
numPlayers--;
}
}
}
void Cplm::allIn(CPlayer* player, const CChips& pay)
{
/*
* 1) set player->state(ALLIN)
* 2) create a new side pot
* 3) move excess chips from the original pot to the side pot, and
* 4) make players eligible for active pot (besides all-in player) eligible
* for side pot
* 5) send allin pdu
*/
CpduAllIn pdu(table_);
player->stateChange(PLAYER_STATE_ALLIN);
splitPot(player, pay);
pdu.sendAllIn(player, pay);
#ifdef DEBUG_POT_
int i = 0;
for (Cpot* p = table_->getMainPot(); p != NULL; p = p->getNext())
{
printf("Pot %d ", i++);
p->print();
}
#endif
}
void CRouteConn::_HandleUserClientType(CImPduUserClientTypeRequest *pPdu)
{
uint32_t user_id = pPdu->GetUserId();
uint32_t attach_len = pPdu->GetAttachLen();
uchar_t* attach_data = pPdu->GetAttachData();
log("HandleUserClientType, user_id = %u\n", user_id);
RouteConnMap_t* pConnMap = get_route_conns(user_id);
uint32_t client_type_flag = 0x00;
if (pConnMap != NULL)
{
RouteConnMap_t::iterator it = pConnMap->begin();
for (; it != pConnMap->end(); it++)
{
if (it->first != this)
{
uint32_t client_type_flag_tmp = it->second;
client_type_flag |= client_type_flag_tmp;
}
}
}
CImPduUserClientTypeResponse pdu(user_id, client_type_flag, attach_len, attach_data);
pdu.SetReserved(pPdu->GetReserved());
SendPdu(&pdu);
}
void CRouteConn::_HandleUsersStatusRequest(CImPduUsersStatusRequest* pPdu)
{
uint32_t request_id = pPdu->GetRequestId();
uint32_t query_count = pPdu->GetQueryCount();
log("HandleUserStatusReq, req_id=%u, query_count=%u\n", request_id, query_count);
const list<uint32_t>& query_list = pPdu->GetQueryList();
list<user_stat_t> result_list;
user_stat_t status;
for(list<uint32_t>::const_iterator itQ=query_list.begin(); itQ!=query_list.end(); ++itQ)
{
UserStatMap_t::iterator it = g_rs_user_map.find(*itQ);
if (it != g_rs_user_map.end()) {
status.status = it->second.status;
}
else
{
status.status = USER_STATUS_OFFLINE;
}
status.user_id = *itQ;
result_list.push_back(status);
}
// send back query user status
CImPduUsersStatusResponse pdu(request_id, result_list);
pdu.SetReserved(pPdu->GetReserved());
SendPdu(&pdu);
}
void CDBServConn::_HandleDBQueryResponse(CImPduDBQueryResponse* pPdu)
{
uint32_t user_id = pPdu->GetUserid();
uint32_t seq_no = pPdu->GetSeqNo();
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
uint32_t handle = attach_data.GetHandle();
CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(user_id, handle);
log("HandleDBQueryResp, user_id=%u, seq_no=%u\n", user_id, seq_no);
if (pMsgConn && pMsgConn->IsOpen()) {
CImPduClientDBQueryResponse pdu(seq_no, pPdu->GetResultLen(), pPdu->GetResultData());
pMsgConn->SendPdu(&pdu);
}
}
/**
* @brief Creates an instance of Normal traffic event.
*
* @param pduSize Size of PDU to generate.
* @param pduContents Reference to Entity object that will be carried by the token.
* @param recordRoute True if this generated token should record the route it follows. False otherwise. Default is false.
*
* @return PDU that was generated, per the class constructor parameters and if generator is On. Otherwise, returns nullptr.
*/
std::shared_ptr<ProtocolDataUnit> NormalTrafficGenerator::createInstanceTrafficEventPdu(unsigned int pduSize, std::shared_ptr<Entity> pduContents,
bool recordRoute) {
// Creates a PDU and assigns it class member values and a unique ID obtained from simulatorGlobals.
std::shared_ptr<Token> token = TrafficGenerator::createInstanceTrafficEvent(pduContents, recordRoute);
if (token == nullptr) {
return nullptr;
}
std::shared_ptr<ProtocolDataUnit> pdu(new ProtocolDataUnit(token, pduSize));
//std::shared_ptr<ProtocolDataUnit> pdu(new ProtocolDataUnit(TrafficGenerator::createInstanceTrafficEvent(pduContents, recordRoute), pduSize));
if (pdu != nullptr) {
scheduler.schedule(Event(generateNormalVariate(), eventType, pdu));
}
return pdu;
}
/**
* @brief Creates an instance of constant rate traffic event.
*
* @param pduSize Size of PDU to generate.
* @param explicitRoute Vector containing a list of Entity objects representing the route to be followed by a token/PDU.
* @param recordRoute True if this generated token should record the route it follows. False otherwise. Default is false.
*
* @return PDU that was generated, per the class constructor parameters and if generator is On. Otherwise, returns nullptr.
*/
std::shared_ptr<ProtocolDataUnit> ConstantRateTrafficGenerator::createInstanceTrafficEventPdu(unsigned int pduSize, std::vector<std::shared_ptr<Entity>> explicitRoute,
bool recordRoute) {
// Creates a PDU and assigns it class member values and a unique ID obtained from simulatorGlobals.
std::shared_ptr<Token> token = TrafficGenerator::createInstanceTrafficEvent(explicitRoute, recordRoute);
if (token == nullptr) {
return nullptr;
}
//std::shared_ptr<ProtocolDataUnit> pdu(new ProtocolDataUnit(TrafficGenerator::createInstanceTrafficEvent(explicitRoute, recordRoute), pduSize));
std::shared_ptr<ProtocolDataUnit> pdu(new ProtocolDataUnit(token, pduSize));
if (pdu != nullptr) {
scheduler.schedule(Event(interval, eventType, pdu));
}
return pdu;
}
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 CRouteServConn::_HandleUsersStatusResponse(CImPduUsersStatusResponse* pPdu)
{
uint32_t request_id = pPdu->GetRequestId();
uint32_t result_count = pPdu->GetResultCount();
const list<user_stat_t>& result_list = pPdu->GetQueryResult();
log("HandleUsersStatusResp, req_id=%u, query_count=%u\n", request_id, result_count);
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
uint32_t handle = attach_data.GetHandle();
CMsgConn* pToConn = CImUserManager::GetInstance()->GetMsgConnByHandle(request_id,handle);
if (pToConn) {
CImPduClientUsersStatusResponse pdu(result_list);
pToConn->SendPdu(&pdu);
}
}
/**
* @brief Creates an instance of constant rate traffic event with PDU.
*
* @param pduSize Size of PDU to generate.
* @param recordRoute True if this generated token should record the route it follows. False otherwise. Default is false.
*
* @return PDU that was generated, per the class constructor parameters and if generator is On. Otherwise, returns nullptr.
*/
std::shared_ptr<ProtocolDataUnit> ConstantRateTrafficGenerator::createInstanceTrafficEventPdu(unsigned int pduSize, bool recordRoute) {
// Creates a PDU and assigns it class member values and a unique ID obtained from simulatorGlobals.
// Notice that the base class member function "createInstance..." is used here instead of the derived override:
// the derived override schedules an event, and that is undesired here, since an event can only be scheduled "after" the PDU is created.
std::shared_ptr<Token> token = TrafficGenerator::createInstanceTrafficEvent(recordRoute);
if (token == nullptr) {
return nullptr;
}
//std::shared_ptr<ProtocolDataUnit> pdu(new ProtocolDataUnit(TrafficGenerator::createInstanceTrafficEvent(recordRoute), pduSize));
std::shared_ptr<ProtocolDataUnit> pdu(new ProtocolDataUnit(token, pduSize));
if (pdu != nullptr) {
scheduler.schedule(Event(interval, eventType, pdu));
}
return pdu;
}
void CFileHandler::HandleClientFileDelOfflineReq(CImPduClientFileDelOfflineReq* pPdu)
{
string from_id_url(pPdu->GetFromId(), pPdu->GetFromIdLen());
string to_id_url(pPdu->GetToId(), pPdu->GetToIdLen());
uint32_t from_id = urltoid(from_id_url.c_str());
uint32_t to_id = urltoid(to_id_url.c_str());
string task_id(pPdu->GetTaskId(), pPdu->GetTaskIdLen());
log("HandleClientFileDelOfflineReq, %u->%u, task_id=%s\n", from_id, to_id, task_id.c_str());
CDBServConn* pDbConn = get_db_serv_conn();
if (pDbConn) {
CImPduFileDelOfflineReq pdu(to_id, from_id, to_id, task_id.c_str());
pDbConn->SendPdu(&pdu);
}
}
void CDBServConn::_HandleDepartmentResponse(CImPduDepartmentResponse *pPdu)
{
uint32_t req_user_id = pPdu->GetReqUserId();
uint32_t depart_cnt = pPdu->GetDepartCnt();
department_info_t* depart_list = pPdu->GetDepartList();
log("HandleDepartmentResp, req_user_id=%u, depart_cnt=%u\n", req_user_id, depart_cnt);
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
uint32_t handle = attach_data.GetHandle();
CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(req_user_id, handle);
if (pMsgConn && pMsgConn->IsOpen()) {
CImPduClientDepartmentResponse pdu(depart_cnt, depart_list);
pdu.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pdu);
}
}
void CRouteServConn::OnConfirm()
{
log("connect to route server success\n");
m_bOpen = true;
m_connect_time = get_tick_count();
g_route_server_list[m_serv_idx].reconnect_cnt = MIN_RECONNECT_CNT / 2;
if (g_master_rs_conn == NULL) {
update_master_route_serv_conn();
}
list<user_conn_stat_t> online_user_list;
CImUserManager::GetInstance()->GetOnlineUserInfo(&online_user_list);
CImPduOnlineUserInfo pdu(&online_user_list);
SendPdu(&pdu);
}
void CRouteServConn::_HandleUserStatusResponse(CImPduUserStatusResponse* pPdu)
{
uint32_t request_id = pPdu->GetRequestId();
uint32_t query_id = pPdu->GetQueryId();
uint32_t status = pPdu->GetStatus();
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
uint32_t handle = attach_data.GetHandle();
log("HandleUserStatusResp, req_id=%u, query_id=%u, status=%u\n", request_id, query_id, status);
CMsgConn* pToConn = CImUserManager::GetInstance()->GetMsgConnByHandle(request_id,handle);
if (pToConn) {
char* query_id_url = idtourl(query_id);
CImPduClientUserStatusResponse pdu(query_id_url, status);
pToConn->SendPdu(&pdu);
}
}
void CDBServConn::_HandleUnreadMsgCountResponse(CImPduUnreadMsgCountResponse* pPdu)
{
uint32_t to_user_id = pPdu->GetToUserId();
UserUnreadMsgCnt_t* user_unread_list = pPdu->GetUserUnreadList();
uint32_t user_unread_cnt = pPdu->GetUserUnreadCnt();
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
uint32_t handle = attach_data.GetHandle();
log("HandleUnreadMsgCntResp, userId=%u, cnt=%u\n", to_user_id, user_unread_cnt);
CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(to_user_id, handle);
if (pMsgConn && pMsgConn->IsOpen()) {
CImPduClientUnreadMsgCntResponse pdu(user_unread_cnt, user_unread_list);
pdu.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pdu);
}
}
void CRouteServConn::_HandleUserClientTypeResponse(CImPduUserClientTypeResponse *pPdu)
{
uint32_t client_type_flag = pPdu->GetClientTypeFlag();
uint32_t attach_len = pPdu->GetAttachLen();
uchar_t* attach_data = pPdu->GetAttachData();
CPduAttachData pduAttachData(attach_data, attach_len);
CImPduClientFileRequest pdu(pduAttachData.GetPdu(), pduAttachData.GetPduLength());
string from_id_url(pdu.GetFromId(), pdu.GetFromIdLen());
uint32_t from_id = urltoid(from_id_url.c_str());
string to_id_url(pdu.GetToId(), pdu.GetToIdLen());
uint32_t to_id = urltoid(to_id_url.c_str());
string file_name(pdu.GetFileName(), pdu.GetFileNameLen());
uint32_t file_size = pdu.GetFileSize();
uint32_t handle = pduAttachData.GetHandle();
log("HandleUserClientTypeResponse, from_user_id: %u, to_user_id: %u, file_name: %s\n",
from_id, to_id, file_name.c_str());
uint32_t trans_mode = FILE_TYPE_OFFLINE;
if ((client_type_flag & CLIENT_TYPE_FLAG_BOTH) == CLIENT_TYPE_FLAG_PC)
{
trans_mode = FILE_TYPE_ONLINE;
}
CPduAttachData attach(ATTACH_TYPE_HANDLE, handle, 0, NULL, 0);
CImPduMsgFileTransferReq pdu2(from_id, to_id, file_name.c_str(), file_size,
trans_mode, attach.GetLength(), attach.GetBuffer());
pdu2.SetReserved(pPdu->GetReserved());
CFileServConn* pConn = get_random_file_serv_conn();
if (pConn) {
pConn->SendPdu(&pdu2);
}
else
{
log("HandleUserClientTypeResponse, no file server\n");
CImPduClientFileResponse pdu3(REFUSE_REASON_NO_FILE_SERVER, from_id_url.c_str(), to_id_url.c_str(), file_name.c_str(), NULL, NULL, 0);
pdu3.SetReserved(pPdu->GetReserved());
CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(from_id,handle);
if (pMsgConn)
{
pMsgConn->SendPdu(&pdu3);
}
}
}
void CFileHandler::HandleClientFileHasOfflineReq(CMsgConn* pMsgConn, CImPduClientFileHasOfflineReq* pPdu)
{
uint32_t req_user_id = pMsgConn->GetUserId();
log("HandleClientFileHasOfflineReq, req_id=%u\n", req_user_id);
CDbAttachData attach_data(ATTACH_TYPE_HANDLE, pMsgConn->GetHandle(), 0);
CDBServConn* pDbConn = get_db_serv_conn();
if (pDbConn) {
CImPduFileHasOfflineReq pdu(req_user_id, attach_data.GetLength(), attach_data.GetBuffer());
pdu.SetReserved(pPdu->GetReserved());
pDbConn->SendPdu(&pdu);
} else {
log("warning no DB connection available\n");
CImPduClientFileHasOfflineRes pdu;
pdu.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pdu);
}
}
void CFileHandler::HandleClientFileAddOfflineReq(CImPduClientFileAddOfflineReq* pPdu)
{
string from_id_url(pPdu->GetFromId(), pPdu->GetFromIdLen());
string to_id_url(pPdu->GetToId(), pPdu->GetToIdLen());
string task_id(pPdu->GetTaskId(), pPdu->GetTaskIdLen());
string file_name(pPdu->GetFileName(), pPdu->GetFileNameLen());
uint32_t file_size = pPdu->GetFileSize();
uint32_t from_id = urltoid(from_id_url.c_str());
uint32_t to_id = urltoid(to_id_url.c_str());
log("HandleClientFileAddOfflineReq, %u->%u, task_id: %s, file_name: %s, size: %u \n",
from_id, to_id, task_id.c_str(), file_name.c_str(), file_size);
CDBServConn* pDbConn = get_db_serv_conn();
if (pDbConn) {
CImPduFileAddOfflineReq pdu(from_id, from_id, to_id, task_id.c_str(), file_name.c_str(), file_size);
pDbConn->SendPdu(&pdu);
}
}
void CRouteConn::_HandleUserStatusRequest(CImPduUserStatusRequest* pPdu)
{
uint32_t request_id = pPdu->GetRequestId();
uint32_t query_id = pPdu->GetQueryId();
uint32_t attach_len = pPdu->GetAttachLen();
uchar_t* attach_data = pPdu->GetAttachData();
log("HandleUserStatusReq, req_id=%u, query_id=%u\n", request_id, query_id);
uint32_t status = USER_STATUS_OFFLINE;
UserStatMap_t::iterator it = g_rs_user_map.find(query_id);
if (it != g_rs_user_map.end()) {
status = it->second.status;
}
// send back query user status
CImPduUserStatusResponse pdu(request_id, query_id, status, attach_len, attach_data);
pdu.SetReserved(pPdu->GetReserved());
SendPdu(&pdu);
}
int main()
{
char *data = const_cast<char *>("hello 0world");
uint32_t data_len = strlen(data);
CImPduClientData pdu(data, data_len);
printf("pdu lenght: %d\n", pdu.GetLength());
uchar_t *buf = pdu.GetBuffer();
int i = 0;
for (i = 0; i < pdu.GetLength(); i++) {
printf("%X\n", buf[i]);
}
cout << endl;
return 0;
}
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 CDBServConn::_HandleRemoveSessionResponse(CImPduRemoveSessionResponse* pPdu)
{
uint32_t req_user_id = pPdu->GetReqUserId();
uint32_t result = pPdu->GetResult();
uint32_t session_type = pPdu->GetSessionType();
uint32_t session_id = pPdu->GetSessionId();
log("HandleRemoveSessionResp, req_user_id=%u, result=%u, session_id=%u, type=%u\n",
req_user_id, result, session_id, session_type);
CDbAttachData attach_data(pPdu->GetAttachData(), pPdu->GetAttachLen());
uint32_t handle = attach_data.GetHandle();
CMsgConn* pMsgConn = CImUserManager::GetInstance()->GetMsgConnByHandle(req_user_id, handle);
if (pMsgConn && pMsgConn->IsOpen()) {
char* session_id_url = idtourl(session_id);
CImPduClientRemoveSessionResponse pdu(result, session_type, session_id_url);
pdu.SetReserved(pPdu->GetReserved());
pMsgConn->SendPdu(&pdu);
}
}
