evapacketmanager.cpp

linux下的eva源代码

void EvaPacketManager::processGetUserInfoReply( const InPacket * in )
{
	GetUserInfoReplyPacket *packet = new GetUserInfoReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	ContactInfo info = packet->contactInfo();
	std::string strID = info.at(ContactInfo::Info_qqID);
	unsigned int id = atoi(strID.c_str());
	if( id == user->getQQ()){
		user->setDetails(info);
		user->loginManager()->finishedCommand(QQ_CMD_GET_USER_INFO);
		emit myInfoReady();
	}else{
		user->getFriendList().addContactInfoTo(id, info);
	}
	delete packet;
	user->saveGroupedBuddyList();
	emit userInfoReady(convertDetails(info));
}

void EvaPacketManager::doChangeStatus( EvaUser::UserStatus newStatus )
{
	user->setStatus( newStatus );
	connecter->append(new ChangeStatusPacket(EvaUser::getStatusCode(newStatus)));
}

void EvaPacketManager::processChangeStatusReply( const InPacket * in )
{
	ChangeStatusReplyPacket *packet = new ChangeStatusReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->isAccepted()){  // if change status failed,  in most cases it's because of connection problem, 
		user->loginManager()->finishedCommand(QQ_CMD_CHANGE_STATUS);    // so we simply emit a offline signal
		switch(user->getStatus()){
		case EvaUser::Eva_Online:
			emit onlineReady();
			break;
		case EvaUser::Eva_Offline:
			if(timer->isActive())
				timer->stop();
			connecter->stop();
			Packet::clearAllKeys();
			emit offlineReady();
			break;	
		case EvaUser::Eva_Invisible:
			emit invisibleReady();
			break;
		case EvaUser::Eva_Leave:
			emit leaveReady();
			break; 
		}
	}else{
		if(timer->isActive())
			timer->stop();
		connecter->stop();
		emit offlineReady();    // if we meet any problem, just emit offline signal
	}
	delete packet;
}

void EvaPacketManager::doGetAllFriends( )
{
	user->getFriendList().clearFriendList();
	connecter->append(new GetFriendListPacket());
}

void EvaPacketManager::processGetFriendListReply( const InPacket * in )
{
	GetFriendListReplyPacket *packet = new GetFriendListReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	friendItemList gotList = packet->getFriendList();
	friendItemList::iterator iter;
	for(iter = gotList.begin(); iter!= gotList.end(); ++iter){
		QQFriend frd;
		frd.setFriendItem(*iter);
		user->getFriendList().addFriend(frd);
	}
	if(packet->getPosition()!=QQ_FRIEND_LIST_POSITION_END){
		connecter->append(new GetFriendListPacket(packet->getPosition()));
	}else{
		emit friendListReady(); // EvaMain class will set the loginManager
	}
	delete packet;
}

void EvaPacketManager::doSendMessage( const unsigned int receiver, const bool isNormal, QString & message, const char fontSize, 
					const bool u, const bool i, const bool b, 
					const char blue, const char green, const char red )
{	
	if(!user->loginManager()->isReady()) {
		printf("Client Not ready, ignore sending request!\n");
		emit sentMessageResult(receiver, false);
		return;
	}
	QQFriend * frd = user->getFriendList().getFriend(receiver);
	if(!frd){
		printf("Friend \"%d\" not in list, sending ignored\n", receiver);
		emit sentMessageResult(receiver, false);
		return;
	}
	QString rNick = codec->toUnicode( frd->getNick().c_str());
	QString sNick = codec->toUnicode(user->getDetails().at(ContactInfo::Info_nick).c_str());
	QDateTime time = QDateTime::currentDateTime(Qt::LocalTime);	
	user->getSetting()->saveMessage(receiver,  user->getQQ(), sNick, receiver, rNick,
				isNormal, message, time, fontSize, u, i, b, blue, green, red);
	
	QCString str = codec->fromUnicode(message);
	unsigned short pcs = strlen(str.data()) / 700;
	SendTextIMPacket *firstPacket = 0;
	int lastSeq = -1;
	for (unsigned short pcsn=0; pcsn<=pcs; pcsn++)
	{
		SendTextIMPacket *packet = new SendTextIMPacket();
		packet->setNumFragments(pcs + 1);
		packet->setSeqOfFragments(pcsn);	
		
		packet->setReceiver(receiver);
		//packet->setMsgSequence(frd->getNextSequence());
		packet->setFontSize(fontSize);
		packet->setUnderline(u);
		packet->setItalic(i);
		packet->setBold(b);
		packet->setBlue(blue);
		packet->setGreen(green);
		packet->setRed(red);
		packet->setAutoReply(isNormal);
		packet->setMessage(str.mid(pcsn * 700, 700).data());
		if(!pcsn) {
			firstPacket = packet;
			lastSeq = firstPacket->getSequence();
		} else {
			longMsgPacketQueue[lastSeq] = packet; // record the next packet
			lastSeq = packet->getSequence();
			if(pcsn == (pcs - 1))  // the last sent packet points to NULL
				longMsgPacketQueue[lastSeq] = NULL;
		}
		//qApp->processEvents();
	}
	saveBuddyQQ(receiver, firstPacket->getSequence());
	connecter->append(firstPacket);
}

void EvaPacketManager::processSendIMReply( const InPacket * in )
{
	SendIMReplyPacket *packet = new SendIMReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	int id = getSavedBuddyQQ(packet->getSequence());
	if(id==-1) return;
	removeSequence(packet->getSequence());

	// check if there are more sub packets to send
	std::map<int, SendTextIMPacket*>::iterator iter = longMsgPacketQueue.find(packet->getSequence());
	if(iter == longMsgPacketQueue.end()){
		// should be one-shot message
		emit sentMessageResult(id, packet->isSentOK());
	} else {
		// got it in the long message queue
		SendTextIMPacket *next = iter->second;  // next packet
		
		// erase the last sent sequence entry
		longMsgPacketQueue.erase(packet->getSequence());

		if(packet->isSentOK()){
			// if sent ok, try to send next
			int receiver = next->getReceiver();
			saveBuddyQQ(receiver, next->getSequence());
			connecter->append(next);
			printf("next fragment sent!\n");
		}else{
			// if one of the long message got error back, chuck all fragments
			int nextSeq = next->getSequence();
			while(next){
				longMsgPacketQueue.erase(next->getSequence());
				next = longMsgPacketQueue[nextSeq];
				nextSeq = next->getSequence();
			}
			emit sentMessageResult(id, false);
		}
	}

	delete packet;
}

void EvaPacketManager::processKeepAliveReply( const InPacket * in )
{
	KeepAliveReplyPacket *packet = new KeepAliveReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	numOnlineUsers = packet->numOnlineUsers();
	delete packet;
	connecter->append(new GetOnlineFriendsPacket());
}

void EvaPacketManager::processGetOnlineFriendReply( const InPacket * in )
{
	GetOnlineFriendReplyPacket *packet = new GetOnlineFriendReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	onlineList list = packet->getOnlineFriendList();
	onlineList::iterator iter;
	for(iter = list.begin(); iter!=list.end(); ++iter){
		user->getFriendList().addOnlineFriendEntryTo(iter->getQQ(), *iter);
	}
	if(packet->getPosition() != QQ_FRIEND_ONLINE_LIST_POSITION_END){
		connecter->append(new GetOnlineFriendsPacket(packet->getPosition()));
	}
	delete packet;
}

void EvaPacketManager::processFriendChangeStatus( const InPacket * in )
{
	FriendChangeStatusPacket *packet = new FriendChangeStatusPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	
	//user->getFriendList().updateFriendIP(packet->getQQ(), packet->getIP());
	//user->getFriendList().updateFriendPort(packet->getQQ(), packet->getPort());
	
	const QQFriend *frd = (user->getFriendList()).getFriend(packet->getQQ());
	
	if( frd && (frd->getStatus() != packet->getStatus()) ){
		user->getFriendList().updateFriendStatus(packet->getQQ(), packet->getStatus());
		emit friendStatusChanged(packet->getQQ());
	}
	delete packet;
}

void EvaPacketManager::processReceiveIM( const InPacket * in )
{
	ReceiveIMPacket *packet = new ReceiveIMPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		printf(" ----- parse error!\n");
		delete packet;
		return;
	}
	printf("IM: seq: %d ----- msg seq: %d\n", packet->getIntSequence(), packet->getSequence());
	ReceiveIMReplyPacket *packetReply = new ReceiveIMReplyPacket(packet->getReplyKey());
	packetReply->setSequence(packet->getSequence());
	connecter->append(packetReply);
	
	int index = receivedCacheList.findIndex(packet->hashCode());
	if(index != -1 ){
		printf("Duplicated message, ignore\n");
		delete packet;
		return;
	}
	
	receivedCacheList.append(packet->hashCode());

	switch(packet->getIMType()){
	case 0x0010:{
		int len = packet->getBodyLength();
		const unsigned char *buf = packet->getBodyData();
		printf("COMMAND: 0X0010s\n");
		for(int i=0; i<len; i++){
			if(!(i%8)) printf("\n");
			char t = buf[i];
			printf("%2x ", (uint8_t)t);
		}
		printf("\n");
		}
		break;
	case QQ_RECV_IM_NEWS:{
		ReceivedQQNews *news = new ReceivedQQNews(packet->getBodyData(), packet->getBodyLength());
		emit receivedQQNews(codec->toUnicode(news->getTitle().c_str()),
					codec->toUnicode(news->getBrief().c_str()),
					codec->toUnicode(news->getURL().c_str()));
		}
		break;
	case QQ_RECV_IM_TO_BUDDY_2006:
	case QQ_RECV_IM_TO_BUDDY:
	case QQ_RECV_IM_TO_UNKNOWN:{
		NormalIMBase *base = new NormalIMBase(packet->getBodyData(), packet->getBodyLength());	
		base->parseData();
		printf("sender version: 0x%4x\n", base->getSenderVersion());
		switch(base->getNormalIMType())
		{
		case QQ_IM_NORMAL_TEXT:{
			for(int i=0; i<packet->getLength(); i++){
				if(!(i%8)) printf("\n%d: ",i);
				char t = packet->getBody()[i];
				printf("%2x ", (uint8_t)t);
			}
			printf("\n----====== Normal Text Finished ======----\n\n");
			ReceivedNormalIM * received = new ReceivedNormalIM();
			received->setNormalIMBase(base);
			received->parseData();
			const QQFriend *frd = user->getFriendList().getFriend(received->getSender());
			if(frd==NULL){
				QQFriend f(received->getSender(),received->getSenderFace());
				f.setGroupIndex(EvaUser::getAnonymousIndex());
				user->getFriendList().addFriend(f);
				user->saveGroupedBuddyList();
				emit addAnonymous(received->getSender(),received->getSenderFace());
			}else	if(frd->getGroupIndex() == EvaUser::getBlackIndex()){
					delete received;
					delete packet;
					return;
				}
			
			//check fragments
			if (received->getNumFragments()>1)
			{
				unsigned short ropID = received->getMessageID();
				
				//push fragment inormation into map
				unsigned short total = received->getNumFragments();
				pcMsgCache[ropID].total = total;
				pcMsgCache[ropID].content[received->getSeqOfFragments()] = received->getMessage().c_str();
				
				if (total == pcMsgCache[ropID].content.size())
				{
					//all fragments received
					QString allText = "";
					for (int idx=0; idx<total; idx++) 
						allText += pcMsgCache[ropID].content[idx];
					pcMsgCache.erase(ropID);
					received->setMessage(allText);
				} else
				{
					delete received;
					delete packet;
					return;
				}
				
			}
			//user->getFriendList().updateFriendIP(packet->getSender(), packet->getSenderIP());
			//user->getFriendList().updateFriendPort(packet->getSender(), packet->getSenderPort());
			user->getFriendList().updateFriendFileSessionKey(packet->getSender(),received->getBuddyFileSessionKey());
			user->getFriendList().getFriend(received->getSender())->setSequence(base->getSequence());
			QString msg = codec->toUnicode(received->getMessage().c_str());
			QDateTime time;
			time.setTime_t(received->getSendTime());
			
			int sender = received->getSender();
			bool isNormal = received->isNormalReply();
			char fontSize = received->getFontSize();
			bool u = received->isUnderline();
			bool i = received->isItalic();
			bool b = received->isBold();
			char blue = received->getBlue();
			char green = received->getGreen();
			char red = received->getRed();
			if(received->getReplyType() == QQ_IM_IMAGE_REPLY) isNormal = true;
			QString sNick = codec->toUnicode(user->getFriendList().getFriend(sender)->getNick().c_str());
			QString rNick = codec->toUnicode(user->getDetails().at(ContactInfo::Info_nick).c_str());
			user->getSetting()->saveMessage(sender, sender, sNick, user->getQQ(), rNick, 
						isNormal, msg, time, fontSize, u, i, b, blue, green, red);
			printf("From Buddy -- %s (%d)  : %s\n", sNick.local8Bit().data(), sender, msg.local8Bit().data());
			emit txtMessage(sender, isNormal, msg, time, fontSize, 
					u, i, b, blue, green, red);
			delete received;
			}
			break;
		case QQ_IM_UDP_REQUEST:
			printf("EvaPacketManager::processReceiveIM -- QQ_IM_UDP_REQUEST <- old version used\n");
			for(int i=0; i<packet->getLength(); i++){
				if(!(i%8)) printf("\n%d: ",i);
				char t = packet->getBody()[i];
				printf("%2x ", (uint8_t)t);
			}
			printf("\n----====== QQ_IM_UDP_REQUEST Finished ======----\n\n");
			break;
		case QQ_IM_TCP_REQUEST:
		case QQ_IM_ACCEPT_UDP_REQUEST:
		case QQ_IM_NOTIFY_IP:
		case QQ_IM_REQUEST_CANCELED:
			fprintf(stderr, "Received file command from \"%d\"(v:%d). Command not supported, Buddy might use a client earlier than QQ2005 beta1!\n",
					packet->getSender(), 0xffff&packet->getVersion());
			break;
		case QQ_IM_NOTIFY_FILE_AGENT_INFO:
		case QQ_IM_EX_UDP_REQUEST:
		case QQ_IM_EX_REQUEST_CANCELLED: