本文主要是介绍TeamTalk源码之用户登录验证流程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1. 用户登录验证流程图：

/*
登录流程：

	client   --->               msg_server                                 --->         db_proxy_server 							route_server
	【client】 --->         【CMsgConn --> (msg_server) --> CDBServConn】       ---> 【CProxyConn ---> (db_proxy_server)】				|
		|						|							|							|												|
		|						|							|							|												|
		IM::Login::IMLoginReq	
		pdu.CID = CID_LOGIN_REQ_USERLOGIN;
				        		
				        CMsgConn::HandlePdu()
					        case CID_LOGIN_REQ_USERLOGIN:
					        _HandleLoginRequest(pPdu);
												
							IM::Server::IMValidateReq									|
							pdu.CID = CID_OTHER_VALIDATE_REQ;  -----------------------> |
																			
																				CProxyConn::HandlePdu()
																				DB_PROXY::doLogin();
												
															|					IM::Server::IMValidateRsp
															| <---------------	pdu.CID = CID_OTHER_VALIDATE_RSP;							

													CDBServConn::HandlePdu()
														case CID_OTHER_VALIDATE_RSP:
														_HandleValidateResponse(pPdu);

														if(UserValidateFail)
		|												IM::Login::IMLoginRes
		| <-------------------------------------------	pdu.CID = CID_LOGIN_RES_USERLOGIN;

														if(UserValidateSucc)
														IM::Server::IMServerKickUser												   |
														pdu.CID = CID_OTHER_SERVER_KICK_USER ----------------------------------------> |



*/

2. 详细过程：

2.1 msg_server：（CMsgConn）

void CMsgConn::_HandleLoginRequest(CImPdu* pPdu) {
	//step 1. 从所有的db_proxy_server列表中找出一个可用的连接：
	CDBServConn* pDbConn = get_db_serv_conn_for_login();	
	if(!pDbConn) {
		result = IM::BaseDefine::REFUSE_REASON_NO_DB_SERVER;
		reslt_string = "服务器异常";
	}
	if(result) {	//如果服务器异常，例如没有可用的 msg_server到proxy_server的连接，则直接给客户端返回异常
		IM::Login::IMLoginRes msg;
		SendPdu(&pdu);
		Close();
		return;
	}

	//step 2. 正常找到连接，对收到的msg反序列化，准备给proxy_server发登录请求消息：
	IM::Login::IMLoginReq msg;
	msg.ParseFromArray(pdu->GetBodyData(), pdu->GetBodyLength());	//反序列化
	m_login_name = msg.user_name();		//CMsgConn对应一个登录的端，CMsgConn.m_login_name 保存登录的用户名。（一个 msg_server 上会同时维护无数个 CMsgConn）
	string password = msg.password();
	m_online_status = IM::BaseDefine::USER_STATUS_ONLINE;	//连接状态为在线

	//step 3. CImUser:	根据用户名去找CImUser实例
	CImUser* pImUser = CImUserManager::getInstance()->GetImUserByLoginName(m_login_name);
	if(!pImUser) {	//如果没有找到，则是首个端登录，新创建一个实例：
		pImUser = new CImUser(m_login_name);
		CImUserManager::getInstance()->AddImUserByLoginName(m_login_name, pImUser);	//将新建的CImUser实例加入到CImUserManager中：map<string(user_name), CImUser*> ImUserMapByName_t;
	}

	pImUser->AddUnValidateMsgConn(this);	//加入到 m_unvalidate_conn_set 未鉴权set中

	//step 4. 构造消息发给 db_proxy_server：
	CDBAttachData attach_data(ATTACH_TYPE_HANDLE, m_handle, 0);	//附加上connfd
	IM::Server::IMValidateReq  msg2;
	msg2.set_user_name();
	msg2.set_password();
	msg2.set_attach_data();

	CImPdu pdu;
	pdu.SetPBMsg(&msg2);
	pdu.SetServiceId(SID_OTHER);
	pdu.SetCommandId(CID_OTHER_VALIDATE_REQ);
	pdu.SetSeqNum();

	pDbConn->SendPdu(&pdu);
}



//关键点： CImUserManager ---> CImUser ---> CMsgConn :
		//msg_server上维护一个 CImUserManager, 用于维护此msg_server上登录的所有用户（CImUser），
		//CImUserManager的实现也比较简单，数据成员是两个map，分别对应 user_id 和 user_name到 CImUser实例指针的索引，成员函数是向其中添加成员和删除成员
		//每个 CImUser 对应一个登录用户，CMsgConn 对应一个端的登录，CImUser和CMsgConn是 1：n 的关系
		//对应的包含关系如下：
		// CImUserManager --> CImUser --> CMsgConn

class CImUserManager {
private:
	ImUserMap_t 		m_im_user_map;			//map<uint32_t(user_id), CImUser*>
	ImUserMapByName_t 	m_im_user_map_by_name;	//map<string(login_name), CImUser*>

	static CImUserManager*  s_manager;
};

class CImUser {
private:
	uint32_t 		m_user_id;
	string 			m_login_name;
	uint32_t		m_pc_login_status;

	bool 			m_bValidate;

	map<uint32_t, CMsgConn*>	m_conn_map;		//<connfd, CMsgConn*>
	set<CMsgConn*>				m_unvalidate_conn_set;		//刚刚连接到msg_server上，还未经过proxy_server密码验证的CMsgConn。等验证通过后就会转入到上面的m_conn_map中。
	//我认为这里用map代替set会更好，因为后面的是在for循环遍历整个set找到匹配的CMsgConn，不如直接connfd--->CMsgConn索引更快
};

class CMsgConn : public CImConn {
private:
	string 			m_login_name;	//用于标识本连接属于哪个user
	uint32_t 		m_user_id;	
	uint32_t 		m_client_type;	//端类型（mobile/pc）
	uint32_t 		m_online_status;//连接状态（OFFLINE/ONLINE）

	//属于 CImConn中的：
	net_handle_t	m_handle;
};



static CDBServConn* get_db_serv_conn_for_login(uint32_t start_pos, uint32_t stop_pos) {
	uint32_t i = 0;
	CDBServConn* pDbConn = NULL;

	//determine if there is a valid DB server connection:
	for(i = start_pos; i < stop_pos; i++) {
		pDbConn = (CDBServConn*)g_db_server_list[i].serv_conn;	//g_db_server_list 是从原始conf配置文件中界消息出来的所有db_server列表
		if(pDbConn && pDbConn->IsOpen()) {
			break;
		}
	}

	if(i == stop_pos) {
		return NULL;
	}

	while(true) {
		int i = rand() % (stop_pos - start_pos) + start_pos;
		pDbConn = (CDBServConn*)g_db_server_list[i].serv_conn;
		if(pDbConn && pDbConn->IsOpen()) {
			break;
		}
	}
	return pDbConn;
}

2.2 db_proxy_server：（CProxyConn）

namespace DB_PROXY {

void doLogin(CImPdu* pPdu, uint32_t conn_uuid) {	//conn_uuid是一个保持单调递增的uint32_t整型值，在CProxyConn新建时赋值 m_uuid
	CImPdu *pPduResp = new CImPdu;		//用于给msg_server回复消息的pdu
	IM::Server::IMValidateRsp msgResp;	//用于给msg_server回复消息的pb

	//step 0. 反序列化msg：

	IM::Server::IMValidateReq msg;
	if(!msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength())) {
		//如果反序列化失败，则直接回复错误：
		msgResp.set_result_code(2);
		msgResp.ser_result_string("服务器内部错误");

	} else {
		//正常情况，对收到的msg_server的pb消息反序列化成功后：

		//step 1. 检验是否已在30分钟内连续密码错误10次，如是，则禁止登录，直接给msg_server回复异常响应并return返回：
		if(!VerifyFailTimesIn30min()) {
			return ;
		}

		//step 2. 进行登录验证：
		IM::BaseDefine::UserInfo cUser;		//如果检验成功，则将用户的各个信息存储在cUser中，返回给msg_server
		int ret = g_loginStrategy.doLogin(msg.user_name(), msg.password(), cUser);
		if(ret == fail) {   
			//如果验证失败，则记录一次：
			lsErrorTime.push_front(time(NULL));
			
			msgResp.set_result_code(1);
			msgResp.ser_result_string("用户名/密码错误");

		} else {
			//登录验证成功：
			IM::BaseDefine::UserInfo* pUser = msgResp.mutable_user_info();	//填充pdu中的pb内容
			pUser->set_user_id();	pUser->set_user_name(); pUser->set_dapartment_id(); ......

			msgResp->set_result_code(0);
			msgResp->set_result_string("成功");

			lsErrorTime.clear();		//已经登录成功了，就清空失败记录
		}
	}


	//step 3. 无论成功失败，统一给msg_server回复结果：(注意这里只是加入到发送列表)
    pPduResp->SetPBMsg(&msgResp);
    pPduResp->SetSeqNum(pPdu->GetSeqNum());
    pPduResp->SetServiceId(IM::BaseDefine::SID_OTHER);
    pPduResp->SetCommandId(IM::BaseDefine::CID_OTHER_VALIDATE_RSP);

	CProxyConn::AddResponsePdu(conn_uuid, pPduResp);

}

};

//校验是否在30分钟内失败了10次，如是，则禁止登录，即使这次带的密码是正确的：
int VerifyFailTimesIn30min() {
	uint32_t tmNow = time(NULL);
	auto itTime = lsErrorTime.begin();		//list<uint32_t>& lsErrorTime = g_hmLimits[msg.user_name()]; //g_hmLimits = unordered_map<string user_name, list<uint32_t> error_time>; 用于记录该user_names上历次的密码失败时刻
	for(; itTime != lsErrorTime.end(); ++itTime) {
		if(tmNow - *itTime > 30*60) {
			break;
		}
	}
	if(itTime != lsErrorTime.end()) {
		lsErrorTime.erase(itTime, lsErrorTime.end());	//lsErrorTime链表中存储的格式是 (60,50,40,30,20,10...) 新元素会push_front插入到链表头部，删除时则删除后面的老时间
	}
	if(lsErrorTime.size() > 30) {
		msgResp.set_result_code(6);
		msgResp.ser_result_string("用户名/密码错误次数过多");

		pPduResp->SetPBMsg(msgResp);
		pPduResp->SetSeqNum();
		pPduResp->SetServiceId(IM::BaseDefine::SID_OTHER);
		pPduResp->SetCommandId(IM::BaseDefine::CID_OTHER_VALIDATE_RSP);

		CProxyConn::AddResponsePdu(conn_uuid, pPduResp);
		return 1;	//fail
	}
	return 0;	//succ
}


//查询MySQL数据库，进行用户名密码验证：
bool CInterLoginStrategy::doLogin(const std::string &strName, const std::string &strPass, IM::BaseDefine::UserInfo& user) {
	CDBConn* pDbConn = CDBManager::getInstance()->GetDBConn("teamtalk_slave");
	if(pDbConn) {
		string strSql = "select * from IMUser where name = '" + strName + "' and status = 0";
		CResultSet* pResultSet = pDbConn->ExcueteQuery(strSql.c_str);
		if(pResultSet) {
			while(pResultSet->Next()) {

			}
			if(strOutPass == strResult) {
				user.set......	//user是引用&类型，密码验证通过后，把查询到的用户信息都拷贝出去
			}
		} 
	}
}

//ResponseList中的消息的发送：
//关键点在于 db_proxy_server 上会维护一个map，保存 uuid 到 CProxyConn 之间的索引，这样需要从ResponseList中统一发送消息时，就可以通过uuid知道发送给哪个msg_server（一个CProxyConn对应一个连接的msg_server）
//另外注意CProxyConn中的两个static静态成员的写法，所有CProxyConn实例都共享同一个 s_uuid_allocator 和 s_response_list
tpepdef unordered_map<uint32_t, CImConn*>  UserMap_t;	//map<uuid, CProxyConn*>
static UserMap_t  g_uuid_conn_map;

class CProxyConn : public CImConn {
public:
	CProxyConn();
	static void AddResponsePdu(uint32_t conn_uuid, CImPdu* pPdu);
	static void SendResponsePduList();
private:
	static uint32_t 	s_uuid_allocator;			//注意s_uuid_allocator是static静态对象，所有CProxyConn实例共享一个，保证单调递增
	uint32_t 			m_uuid;						//这个才是每个CProxyConn对应的专属 conn_uuid

	static list<ResponsePdu_t*> 	s_response_pdu_list;	//同样是static静态对象，所有CProxyConn的Response消息都会插入到这里list链表中，因此会产生互斥，需要对其加锁访问
	static CLock					s_list_clock;
};

CProxyConn::CProxyConn() {
	m_uuid = ++CProxyConn::s_uuid_allocator;
	if(m_uuid == 0) {
		m_uuid = ++CProxyConn::s_uuid_allocator;
	}

	g_uuid_conn_map.insert( make_pair(m_uuid, this) );	//新建的CProxyConn及其对应的m_uuid 插入到map中
}

void CProxyConn::AddResponsePdu(uint32_t conn_uuid, CImPdu* pPdu) {
	ResponsePdu_t* pPduResp = new ResponsePdu_t(conn_uuid, pPdu);

	s_list_clock.lock();
	s_response_pdu_list.push_back(pPduResp);
	s_list_clock.unlock();
}

void CProxyConn::SendResponsePduList() {
	s_list_clock.lock();
	while(!s_response_pdu_list.empty()) {
		ResponsePdu_t* pResp = s_response_list.font();
		s_response_list.pop_font();
		s_list_clock.unlock();

		CProxyConn* pConn = get_proxy_conn_by_uuid(pResp->conn_uuid);	//g_uuid_conn_map.find();
		if(pConn) {
			if(pResp->pPdu) {
				pConn->SendPdu(pResp->pPdu);
			}
		} 

		s_response_pdu_list.lock();
	}
	s_list_clock.unlock();
}

2.3 msg_server：（CDBServConn）

void CDBServConn::_HandleValidateResponse(CImPdu* pPdu) {
	//step 0. 对收到的返回结果消息反序列化：
	IM::Server::IMValidateRsp msg;
	msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength());

	CImUser* pImUser = CImUserManager::GetInstance()->GetImUserByLoginName(msg.user_name());
	if(pImUser) {
		CMsgConn* pConn = pImUser->GetUnvalidateMsgConn(msg.attach_data().GetHandle());	//根据attach_data中保存的用户的connfd，从CIMUser::m_unvalidate_conn_set中找到未鉴权的CMsgConn
	}

	//step 1. 检查密码校验的结果是成功还是失败：
	if(result != 0) {	
		//step 1.1 : 如果密码校验失败，则只需要返回结果给客户端，无需做其他处理
		result = IM::BaseDefine::REFUSE_REASON_DB_VALIDATE_FAILED;

		IM::Login::IMLoginRes msg4;
		msg4.set_server_time();
		msg4.set_result_code();
		msg4.set_result_string();

		CImPdu pdu3;
		pdu3.SetPBMsg(&msg4);
		pdu3.SetServiceId(SID_LOGIN);
		pdu3.SetCommandId(CID_LOGIN_RES_USERLOGIN);
		pdu3.SetSeqNum();

		pMsgConn->SendPdu(pdu3);
		pMsgConn->Close();		//注意发送会失败的校验结果后要close关闭连接，因为后面不会再有聊天报文上来

	} else {	//result = 0, 说明密码校验成功
		//step 1.2 : 如果登录成功，则需要发送route_server去踢掉此用户的其他同类型的登录端：
		CImUserManager::GetInstance()->AddImUserById(user_id, pUser);	//维护user_id到CImUser的映射关系

		//step 2. 在本msg_server上踢掉同类型登录端 + 通知route_server踢掉其他msg_server上的同类型登录端：
		pUser->KickOutSameClientType(pMsgConn->GetClientType(), IM::BaseDefine::KICK_REASON_DUPLICATE_USER, pMsgConn);
		CRouteServConn* pRouteConn = get_route_serv_conn();
		if(pRouteConn) {
			IM::Server::IMServerKickUser msg2;
			msg2.set_user_id();

			CImPdu pdu;
			pdu.SetCommandId(CID_OTHER_SERVER_KICK_USER);
			pRouteConn->SendPdu(&pdu);
		}

		//step 3. 通知所有 route_server 更新用户的登录状态：
		pMsgConn->SendUserStatusUpdate(IM::BaseDefine::USER_STATUS_ONLINE);

		pUser->ValidateMsgConn();	//将这个CMsgConn 从CImUser的未完成鉴权set集合中转移到 已完成鉴权map中

		//step 4. 给客户端回复成功登录响应：
		IM::Login::IMLoginRes msg3;
		CImPdu pdu2;
		pdu2.SetCommandId(CID_LOGIN_RES_USERLOGIN);
		pMsgConn->SendPdu(&pdu2);
	}

}

3. 登录过程涉及到的MySQL表：

3.1 IMUser :

功能：用户表

字段说明：

id 			:	用户ID，自增，唯一 （主键）
password 	: 	密码，规则： ( md5(password) + salt )
salt  		:	密码混淆
sex 		: 	性别
name 		: 	用户名
domain 		:	拼音 
nick 		:	昵称
phone  		: 	电话号码
email 		: 	邮箱
avatar  	:	头像
departId  	: 	部门
status  	: 	状态

create  	: 	创建时间
update  	: 	更新时间

这篇关于TeamTalk源码之用户登录验证流程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！