evapacketmanager.cpp

linux下的eva源代码

		case QQ_IM_EX_REQUEST_ACCEPTED:{
			printf("EvaPacketManager::processReceiveIM -- Here we got\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----====== Before parseData ======----\n\n");

			ReceivedFileIM * received = new ReceivedFileIM();
			received->setNormalIMBase(base);
			received->parseData();
			if(received->getTransferType() != QQ_TRANSFER_FILE && 
				received->getTransferType() != QQ_TRANSFER_IMAGE ){
				fprintf(stderr, "EvaPacketManager::processReceiveIM -- unknown transfer type: %2x\n", 0xff & received->getTransferType());
				delete received;
				break;
			}
			printf("EvaPacketManager::processReceiveIM -- TransferType : 0x%2x\n", 
								received->getTransferType());
			printf("EvaPacketManager::processReceiveIM -- ConnectMode : 0x%2x\n", 
								received->getConnectMode());
			printf("EvaPacketManager::processReceiveIM -- WanIp : 0x%8x\n", 
								received->getWanIp());
			printf("EvaPacketManager::processReceiveIM -- WanPort : 0x%8x\n", 
								received->getWanPort());
			printf("EvaPacketManager::processReceiveIM -- file name : %s\n", 
								received->getFileName().c_str());
			printf("EvaPacketManager::processReceiveIM -- file size : %d\n", 
								received->getFileSize());
			printf("EvaPacketManager::processReceiveIM -- file seq : %d\n", 
								0xffff & received->getSequence());
			//printf("EvaPacketManager::processReceiveIM -- MajorPort : 0x%4x\n", 
			//					received->getMajorPort());
			//printf("EvaPacketManager::processReceiveIM -- LanIp : 0x%8x\n", 
			//					received->getLanIp());
			//printf("EvaPacketManager::processReceiveIM -- LanPort : 0x%4x\n", 
			//					received->getLanPort());
			user->getFriendList().updateFriendIP(packet->getSender(), received->getWanIp());
			user->getFriendList().updateFriendPort(packet->getSender(), received->getWanPort());
			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----====== Lots Msg Finished ======----\n\n");
			switch(base->getNormalIMType()){
			case QQ_IM_EX_UDP_REQUEST:
				emit receivedFileRequest(packet->getSender(), received->getSessionId(), 
						codec->toUnicode(received->getFileName().c_str()),
						received->getFileSize(), received->getTransferType());
				break;
			case QQ_IM_EX_REQUEST_ACCEPTED:
				emit receivedFileAccepted(packet->getSender(), received->getSessionId(), 
							received->getWanIp(), true, received->getTransferType());
				break;
			case QQ_IM_EX_REQUEST_CANCELLED:
				printf("EvaPacketManager::processReceiveIM -- cmd canceled\n");
				emit receivedFileAccepted(packet->getSender(), received->getSessionId(), 
							received->getWanIp(), false, received->getTransferType());
				break;
			case QQ_IM_NOTIFY_FILE_AGENT_INFO:{
				emit receivedFileAgentInfo(packet->getSender(), received->getSequence(), received->getSessionId(), 
							received->getWanIp(), received->getWanPort(), received->getAgentServerKey());
				}
				break;
			}
			delete received;
			}
			break;
		case QQ_IM_EX_NOTIFY_IP:{
			printf("EvaPacketManager::processReceiveIM -- QQ_IM_EX_NOTIFY_IP -- \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_EX_NOTIFY_IP Before parseData ======----\n\n");
			ReceivedFileExIpIM * received = new ReceivedFileExIpIM();
			received->setNormalIMBase(base);
			received->parseData();
			printf("EvaPacketManager::processReceiveIM -- TransferType : 0x%2x\n", 
								received->getTransferType());
			printf("EvaPacketManager::processReceiveIM -- ConnectMode : 0x%2x\n", 
								received->getConnectMode());
			printf("EvaPacketManager::processReceiveIM -- WanIp1 : 0x%8x\n", 
								received->getWanIp1());
			printf("EvaPacketManager::processReceiveIM -- WanPort1 : 0x%8x\n", 
								received->getWanPort1());
			printf("EvaPacketManager::processReceiveIM -- syn ip : 0x%8x\n", 
								received->getSyncIp());
			printf("EvaPacketManager::processReceiveIM -- syn port : 0x%8x\n", 
								received->getSyncPort());
			printf("EvaPacketManager::processReceiveIM -- session : 0x%8x\n", 
								received->getSyncSession());
			if(received->isSender()) printf("isSender -- true\n");
			else printf("isSender -- false\n");
			emit receivedFileNotifyIpEx(packet->getSender(), received->isSender(),
						received->getSessionId(), received->getTransferType(),
						received->getWanIp1(), received->getWanPort1(),
						received->getWanIp2(), received->getWanPort2(),
						received->getWanIp3(), received->getWanPort3(),
						received->getLanIp1(), received->getLanPort1(),
						received->getLanIp2(), received->getLanPort2(),
						received->getLanIp3(), received->getLanPort3(),
						received->getSyncIp(), received->getSyncPort(), received->getSyncSession()
						);
			delete received;
			}
			break;
		default:
			printf("Got a non-text msg, can't process it, ignore it\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----====== Unknown Normal IM Finished ======----\n\n");
		}
		delete base;
		}
		break;
	case QQ_RECV_IM_SYS_MESSAGE:{
		ReceivedSystemIM *sys = new ReceivedSystemIM(packet->getBodyData(), packet->getBodyLength());		
		switch(sys->getSystemIMType())
		{
		case QQ_RECV_IM_KICK_OUT:
			printf("this account has logged in somewhere, you are kicked out!\n");
			if(timer->isActive())
				timer->stop();
			connecter->stop();
			emit kickedOut(codec->toUnicode(sys->getMessage().c_str()));
			break;
		default:
			printf("Got a system msg: %s\n", sys->getMessage().c_str());
		}
		delete sys;
		}
		break;
	case QQ_RECV_IM_QUN_IM:
	case QQ_RECV_IM_TEMP_QUN_IM:
	case QQ_RECV_IM_UNKNOWN_QUN_IM:{
		ReceivedQunIM *im = new ReceivedQunIM(packet->getIMType(), packet->getBodyData(), packet->getBodyLength());
		Qun *qun = user->getQunList()->getQun(packet->getSender());
		if(!qun){
			Qun q(packet->getSender());
			user->getQunList()->add(q);
			doRequestQunInfo(packet->getSender());
			qun = user->getQunList()->getQun(packet->getSender());
			emit qunRequestUpdateDisplay();
		}else if( im->getVersionID() != qun->getDetails().getVersionID()){
				printf("Qun version changed to: %d\n", im->getVersionID());
				doRequestQunInfo(packet->getSender());
			}
		if(qun->getMessageType() == Qun::Reject){
			delete im;
			return;
		}
		if(im->getSenderQQ() == user->getQQ()){
			printf("Qun -- my words, ignore\n");
			delete im;
			return;
		}
		
		
		
		//check fragments
		if (im->getNumFragments()>1)
		{
			unsigned short ropID = im->getMessageID();
			
			//push fragment inormation into map
			unsigned short total = im->getNumFragments();
			pcMsgCache[ropID].total = total;
			pcMsgCache[ropID].content[im->getSeqOfFragments()] = im->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);
				im->setMessage(allText);
			} else
			{
				delete im;
				delete packet;
				return;
			}
			
		}
		QString msg = codec->toUnicode(im->getMessage().c_str());
		QDateTime time;
		time.setTime_t(im->getSentTime());
		// we cannot use  im->getQunID() to get qun id, because it's only for tempory qun's id
		int qunId = packet->getSender();
		int sender = im->getSenderQQ();
		char fontSize = im->getFontSize();
		bool u = im->isUnderline();
		bool i = im->isItalic();
		bool b = im->isBold();
		char blue = im->getBlue();
		char green = im->getGreen();
		char red = im->getRed();
		
		qun = user->getQunList()->getQun(qunId);
		QString qName = "";
		QString sNick = QString::number(sender);
		if(qun){
			QunInfo info = qun->getDetails();
			qName = codec->toUnicode(info.getName().c_str());
			const FriendItem *item = qun->getMemberDetails(sender);
			if(item){
				sNick = codec->toUnicode(item->getQunRealName().c_str());
				if(sNick.isEmpty())
					sNick = codec->toUnicode(item->getNick().c_str());
			}
		}
		QString rNick = codec->toUnicode(user->getDetails().at(ContactInfo::Info_nick).c_str());
		user->getSetting()->saveMessage(qunId,  sender, sNick, user->getQQ(), rNick,
					true, msg, time, fontSize, u, i, b, blue, green, red, true);
		QString qunName = qun ? (codec->toUnicode(qun->getDetails().getName().c_str())) : ("Not In List");
		printf("Qun -- %s--%s(%d) : %s\n", qunName.local8Bit().data(), sNick.local8Bit().data(), sender, msg.local8Bit().data());
		if(qun->getMessageType() != Qun::RecordOnly)
			emit qunTxtMessage(qunId, sender, msg, time, fontSize, u, i, b, blue, green, red);

		delete im;
		}
		break;
	case QQ_RECV_IM_CREATE_QUN:
	case QQ_RECV_IM_ADDED_TO_QUN:
	case QQ_RECV_IM_DELETED_FROM_QUN:// these three type of notifications has no messages
	case QQ_RECV_IM_REQUEST_JOIN_QUN:
	case QQ_RECV_IM_APPROVE_JOIN_QUN:
	case QQ_RECV_IM_REJECT_JOIN_QUN:
	case QQ_RECV_IM_SET_QUN_ADMIN:{
		ReceivedQunIMJoinRequest *join = new ReceivedQunIMJoinRequest(packet->getIMType(),
									packet->getBodyData(),
									packet->getBodyLength());
		QString  msg = codec->toUnicode(join->getMessage().c_str());
		if(packet->getIMType() == QQ_RECV_IM_REQUEST_JOIN_QUN){
			if(user->getSetting()->isInQunRejectForever( packet->getSender(), join->getSender())){
				delete join;
				break;
			}
		}

		emit qunSysMessage(packet->getSender(), packet->getIMType(), join->getExtID(), join->getType(),
			join->getSender(), join->getCommander(), msg, join->getCode(), join->getCodeLength(),
			join->getToken(), join->getTokenLength());

		printf(" imtype: 0x%2x, type: %d --- external id: %d, sender: %d,commander: %d, msg:%s\n",
										packet->getIMType(),
										join->getType(),
										join->getExtID(), 
										join->getSender(),
										join->getCommander(),
										join->getMessage().c_str());

		delete join;
		break;
		/////////////TODO: remove following later on =====================
		if( packet->getIMType()== QQ_RECV_IM_APPROVE_JOIN_QUN || packet->getIMType()== QQ_RECV_IM_ADDED_TO_QUN){
			if(join->getSender() == user->getQQ()){
				user->getQunList()->add(Qun(packet->getSender()));
				user->saveQunList();
				emit qunSystemMessageRequest(join->getSender(), msg);
				emit qunRequestUpdateDisplay();
			}else{
				// show information in the Qun chat window
				emit qunJoinEvent(packet->getSender(), packet->getIMType(), join->getSender(), join->getCommander());
			}
			doRequestQunInfo(packet->getSender());
		} else if( packet->getIMType()== QQ_RECV_IM_DELETED_FROM_QUN){
				if( join->getSender() == user->getQQ()) {
					user->getQunList()->remove(packet->getSender());
					user->saveQunList();
					emit qunSystemMessageRequest(join->getSender(), msg);
					emit qunRequestUpdateDisplay();
				}else {
					doRequestQunInfo(packet->getSender());
					// show information in the Qun chat window
					emit qunJoinEvent(packet->getSender(), packet->getIMType(), join->getSender(), join->getCommander());
				}
			} else {
					emit qunSystemMessageRequest(join->getSender(), msg);
				}
		delete join;
		///////// ===============================
		}
		break;
	case QQ_RECV_IM_SIGNATURE_CHANGED:{
		SignatureChangedPacket *sig = new SignatureChangedPacket(packet->getBodyData(), packet->getBodyLength());
		user->getFriendList().setSignature(sig->getQQ(), sig->getSignature(), sig->getTime());
		user->saveGroupedBuddyList();
		QString sigMsg = codec->toUnicode(sig->getSignature().c_str());
		QDateTime time;
		time.setTime_t(sig->getTime());
		emit friendSignatureChanged(sig->getQQ(), time, sigMsg);
		break;
		}
	default:{
		printf("Unknow IM Type: 0x%2x\n", packet->getIMType());
		printf("sender: %d, receiver: %d, sender IP: %s, sender port: %d\n", packet->getSender(), packet->getReceiver(),
								QHostAddress(packet->getSenderIP()).toString().ascii(), packet->getSenderPort());
		short version = packet->getVersion();
		short command = packet->getCommand();
		short sequence = packet->getSequence();
		short bodyLength = packet->getLength();
		printf("version:0x%4x, command: 0x%4x, sequence: 0x%4x\n", version, command, sequence);
		printf("after InPacket headr(7(UDP) or 9(TCP) bytes) plus ReceiveIMPacket header(20 bytes):\n");
		for(int i=0; i<bodyLength; i++){
			if(!(i%8)) printf("\n%d: ",i);
			char t = packet->getBody()[i];
			printf("%2x ", (uint8_t)t);
		}
		printf("\n============================\n");  
		}
	}
	delete packet;
}

void EvaPacketManager::doGetGroups( )
{
	printf("EvaPacketManager::doGetGroups\n");
	connecter->append(new GroupNameOpPacket(QQ_DOWNLOAD_GROUP_NAME));
}

void EvaPacketManager::doUploadGroups()
{
	GroupNameOpPacket *packet = new GroupNameOpPacket(QQ_UPLOAD_GROUP_NAME);
	packet->setGroups(user->getGroupNames());
	connecter->append(packet);
}

void EvaPacketManager::processGroupNameOp( const InPacket * in )
{
	GroupNameOpReplyPacket *packet = new GroupNameOpReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->isDownloadReply()){
		std::list<std::string>::iterator iter;
		std::list<std::string> names = packet->getGroupNames();
		user->clearGroupNames(); // note that the first group won't be deleted
		for(iter = names.begin(); iter != names.end(); ++iter){
			user->newGroup(*iter);
		}
		doGetGroupedFriends();
	}else{
		std::map<unsigned int, QQFriend> srcList = user->getFriendList().getFriendList();
		std::map<unsigned int, QQFriend>::iterator iter;
		std::map<unsigned int, unsigned int> destList;
		for(iter = srcList.begin(); iter!= srcList.end(); ++iter){
			if((iter->second).getGroupIndex() != user->getAnonymousIndex() &&
				(iter->second).getGroupIndex() != user->getBlackIndex()){
				destList[(iter->second).getQQ()] = (iter->second).getGroupIndex();
			}
		}
		UploadGroupFriendPacket *packet = new UploadGroupFriendPacket();
		packet->setGroupedFriends(destList);
		connecter->append(packet);
	}
	delete packet;
}

void EvaPacketManager::doGetGroupedFriends( )
{
	printf("EvaPacketManager::doGetGroupedFriends \n");
	connecter->append(new DownloadGroupFriendPacket());
}

void EvaPacketManager::processDownloadGroupFriendReply( const InPacket * in )
{
	DownloadGroupFriendReplyPacket *packet = new DownloadGroupFriendReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	std::list<DownloadFriendEntry> friends = packet->getGroupedFriends();
	std::list<DownloadFriendEntry>::iterator iter;
	for(iter = friends.begin(); iter!= friends.end(); ++iter){
		if(!iter->isQun()){
			user->getFriendList().updateFriendGroupIndex(iter->getQQ(), iter->getGroupID());
		}else{
			Qun q(iter->getQQ());
			//printf("------------- Qun : %d\n", iter->getQQ());
			user->getQunList()->add(q);
		}
	}
	
	int nextID = packet->getNextStartID();
	if(nextID != 0x0000){
		connecter->append(new DownloadGroupFriendPacket(nextID));