evafiledownloader.cpp

linux 下最好用的 QQ 客房端。支持传文件

	if(packet->isAskReady()){
		m_State = ENotifyReady;
	} else {
		m_State = EError;
	}
	delete packet;
}

void EvaAgentDownloader::processStartReply( EvaFTAgentStartReply * packet )
{
	if(!parsePacket(packet)){
		m_State = EError;
		delete packet;
		return;
	}
	m_State = ENone;
	delete packet;
}

void EvaAgentDownloader::processTransferInfo( EvaFTAgentTransferReply * packet )
{
	if(!parsePacket(packet)){
		m_State = EError;
		delete packet;
		return;
	}
	m_StartSequence = packet->getSequence();
	m_IsSendingStart = true;
	m_File->setCheckValues( packet->getFileNameMd5(), packet->getFileMd5());
	QTextCodec *codec = QTextCodec::codecForName("GB18030");
	m_FileName = codec->toUnicode(packet->getFileName().c_str());
	m_FileSize = packet->getFileSize();
	printf("EvaAgentDownloader:: -------------------- got info - file: %s, size: %d\n", 
				packet->getFileName().c_str(), m_FileSize);
	
	m_StartTime = QDateTime::currentDateTime();
	if(!(m_File->setFileInfo(m_FileName, m_FileSize))){
		m_State = EError;
		delete packet;
		return;
	};
	if(m_File->loadInfoFile() && m_TransferType == QQ_TRANSFER_FILE){
		notifyNormalStatus(ESResume);
		m_State = ENone;
		delete packet;
		return;
	}
	notifyTransferStatus();
	m_State = EInfoReady;
	delete packet;
}

void EvaAgentDownloader::askResumeLastDownload( const bool rec)
{
	m_IsRecovery = rec;
	if(m_IsRecovery) m_StartOffset = m_File->getNextOffset();
	m_State = EInfoReady;
}

void EvaAgentDownloader::processTransferData( EvaFTAgentTransferReply * packet )
{
	if(!parsePacket(packet)){
		m_State = EError;
		delete packet;
		return;
	}
	processDataBuffer(packet->getSequence(), packet->getData(), packet->getDataLength());
	delete packet;
	// we don't need set m_State here
}

void EvaAgentDownloader::setBufferSize( const unsigned int size )
{
	if(size > EVA_FILE_BUFFER_MAX_FACTOR ) return;
	m_MaxBufferSize = size * 50 * EVA_FILE_BUFFER_UNIT;
}

void EvaAgentDownloader::processDataBuffer( const unsigned short seq, const unsigned char * data, 
					const unsigned int len )
{
	if(len > EVA_FILE_BUFFER_UNIT) {
		m_State = EError;
		return;
	}
	FileItem item;
	item.no = seq;
	item.len = len;
	m_BufferSize += len;
	m_BytesSent += len;
	memcpy(item.data, data, len);
	m_ItemBuffer[seq] = item;
	checkBuffer(seq);
}

void EvaAgentDownloader::checkBuffer(const unsigned short seq)
{
	if(m_BufferSize > m_MaxBufferSize || (m_BytesSent + m_StartOffset) >= m_File->getFileSize()){
		unsigned int offset = (m_ItemBuffer.begin()->second.no - m_StartSequence - 1) * EVA_FILE_BUFFER_UNIT;
		unsigned char *tmp = new unsigned char[m_BufferSize];
		unsigned int cur = 0;
		std::map<unsigned int, FileItem>::iterator iter;
		for(iter=m_ItemBuffer.begin(); iter!=m_ItemBuffer.end(); ++iter){
			memcpy(tmp+cur, iter->second.data, iter->second.len);
			cur += iter->second.len;
		}
		m_File->saveFragment(m_StartOffset + offset, m_BufferSize, tmp);
		if( m_File->isFinished()){
			if(!m_File->generateDestFile()){
				m_State = EError;
				
			}else{
				doDataReply();
				m_State = EFinished;
			}
			delete []tmp;
			m_ItemBuffer.clear();
			m_BufferSize = 0;
			return;	
		}
		delete []tmp;
		m_ItemBuffer.clear();
		m_BufferSize = 0;
		//m_State = EDataReply;
	}
	if( !((seq - 1) %10)) notifyTransferStatus();
	if( !( (seq - 1) % 50 ) ){ // every 50 packets, we send a ack back to server
		m_State = EDataReply;
	}else
		m_State = ENone;
}

const bool EvaAgentDownloader::parsePacket(EvaFTAgentPacket *packet)
{
	packet->setFileAgentKey(m_FileAgentKey);
	return packet->parse();
}


/** ==================================================================== */



EvaUDPThread::EvaUDPThread(QObject *receiver, const int id,const QValueList<QString> &dirList,
			const QValueList<QString> &filenameList, 
			QValueList<unsigned int> sizeList, const bool isSender)
	: EvaFileThread(receiver, id, dirList, filenameList, sizeList, isSender),
	m_State(ENone), m_Token(NULL), m_TokenLength(0),  m_ServerPort(SYN_SERVER_PORT)
{
}

EvaUDPThread::~ EvaUDPThread()
{
	if(m_Token) delete []m_Token;
}

void EvaUDPThread::setFileAgentToken(const unsigned char *token, const int len)
{
	if(!token) return;
	if(m_Token) delete [] m_Token;
	m_Token = new unsigned char[len];
	memcpy(m_Token, token, len);
	m_TokenLength = len;
}

void EvaUDPThread::setFileAgentKey(const unsigned char *key)
{
	memcpy(m_FileAgentKey, key, 16);
}


void EvaUDPThread::setServerAddress(const unsigned int ip, const unsigned short port)
{
	m_HostAddresses.clear();
	m_HostAddresses.append(QHostAddress(ip));
	m_ServerPort = port;
}

void EvaUDPThread::doCreateConnection()
{
	if(m_Connecter){
		m_Connecter->close();
		delete m_Connecter;
	}
	m_Connecter = new EvaNetwork(m_HostAddresses.first(), m_ServerPort, EvaNetwork::UDP);

	QObject::connect(m_Connecter, SIGNAL(isReady()), SLOT(slotNetworkReady()));
	QObject::connect(m_Connecter, SIGNAL(dataComming(int)), SLOT(slotDataComming(int)));
	QObject::connect(m_Connecter, SIGNAL(exceptionEvent(int)), SLOT(slotNetworkException(int)));
	
	m_State = ENone;
	m_Connecter->connect();
}

void EvaUDPThread::sendSynPacket(EvaFTSynPacket *packet)
{
	if(! m_Connecter ){
		fprintf(stderr, "EvaUDPThread::send -- Network invalid!\n");
		delete packet;
		m_State = EError;
		return;
	}
	
	// set the header infomation & key
	packet->setFileAgentKey(m_FileAgentKey);
	packet->setQQ(m_MyId);
	packet->setVersion(QQ_CLIENT_VERSION);
	packet->setSequence(m_Sequence);
	packet->setSessionId(m_Session);

	unsigned char *buffer = new unsigned char[4096];
	int len = 0;
	packet->fill(buffer, &len);
	if(!m_Connecter->write((char *)buffer, len)){
		delete []buffer;
		delete packet;
		m_State = EError;
		return;
	}
	delete []buffer;
	delete packet;
}

void EvaUDPThread::processSynPacket( unsigned char * /*data*/, int /*len*/ )
{
	fprintf(stderr, "EvaUDPThread::processSynPacket -- Not Implemented, Error!\n");
	m_State = EError;
}

void EvaUDPThread::slotNetworkReady()
{
	m_State = ENetworkReady;
}

void EvaUDPThread::slotDataComming(int len)
{
	char *rawData = new char[len+1];
	if(!m_Connecter->read(rawData, len)){
		delete []rawData;
		return;
	}
	processSynPacket((unsigned char *)rawData, len);
	delete []rawData;
}

void EvaUDPThread::slotNetworkException(int no)
{
	fprintf(stderr, "EvaUDPThread::slotNetworkException -- no: %d\n", no);
	if(m_State != EFinished) m_State = EError;
}



/** ==================================================================== */



EvaUdpUploader::EvaUdpUploader(QObject *receiver, const int id, const QValueList<QString> &dirList,
			const QValueList<QString> &filenameList)
	: EvaUDPThread(receiver, id, dirList, filenameList, QValueList<unsigned int>(), true),
	m_Dns(NULL)
{
	m_Sequence = 0x0000;// give it a random number anyway
}

EvaUdpUploader::~EvaUdpUploader()
{
	if(m_Dns) delete m_Dns;
}

void EvaUdpUploader::run()
{
	m_State = EDnsQuery;
	while(!m_ExitNow){
		switch(m_State){
		case ENone:
			break;
		case EDnsQuery:
			doDnsRequest();
			break;
		case EDnsReady:
			doCreateConnection();
			break;
		case ENetworkReady:
			doCreateRequest();
			break;
		case ECreatingReady:
			doFinishProcessing();
			break;
		case EError:
			doErrorProcessing();
			break;
		default:
			break;
		}
		msleep( 200 );
	}
}

void EvaUdpUploader::doErrorProcessing()
{
	printf("EvaUdpUploader::doErrorProcessing\n");
	if(m_Connecter){
		m_Connecter->close();
		delete m_Connecter;
		m_Connecter = NULL;
	}
	notifyNormalStatus(ESError);
	m_ExitNow = true;
}

void EvaUdpUploader::doDnsRequest()
{
	m_HostAddresses.clear();
	if(m_Dns) delete m_Dns;
	m_Dns = new QDns(SYN_SERVER_URL);
	QObject::connect(m_Dns, SIGNAL(resultsReady()), SLOT(slotDnsReady()));
	
// 	while(!m_HostAddresses.size()){
// 		if(m_ExitNow) break;
// 		sleep(1);
// 	}
	m_State = ENone;
}

void EvaUdpUploader::slotDnsReady()
{
	m_HostAddresses = m_Dns->addresses();
	if(!m_HostAddresses.size()){
		QHostAddress host;
		host.setAddress(SYN_SERVER_DEFAULT_IP);
		m_HostAddresses.append(host);
	}
	m_State = EDnsReady;
}

void EvaUdpUploader::doCreateRequest()
{
	if(!m_Token){
		m_State = EError;
		return;
	}
	m_Sequence++;
	EvaFTSynCreate *packet = new EvaFTSynCreate();

	packet->setBuddyQQ(m_Id);
	packet->setFileAgentToken(m_Token, m_TokenLength);
	sendSynPacket(packet);
	m_State = ENone; // waiting the response from server
}

void EvaUdpUploader::doNotifyBuddy(const unsigned int session, const unsigned int ip, const unsigned short port)
{
	EvaFileNotifyAddressEvent *event = new EvaFileNotifyAddressEvent();
	event->setSession(m_Session);
	event->setSynSession(session);
	event->setIp(m_HostAddresses.first().ip4Addr());
	event->setPort(m_ServerPort);
	event->setMyIp(ip);
	event->setMyPort(port);
	event->setBuddyQQ(m_Id);
	QApplication::postEvent(m_Receiver, event);
}


void EvaUdpUploader::processSynPacket( unsigned char * data, int len )
{
	unsigned short cmd = EvaUtil::read16(data + 11);

	switch(cmd){
	case QQ_FILE_SYN_CMD_CREATE:
		processCreateReply(new EvaFTSynCreateReply(data, len));
		break;
	//case QQ_FILE_SYN_CMD_REGISTER:
	//	processRegisterReply(new EvaFTAgentAskReady(data, len));
	//	break;
	default:
		break;
	}
}

void EvaUdpUploader::processCreateReply(EvaFTSynCreateReply *packet)
{
	if(!parsePacket(packet)) return;

	if(packet->isSuccessful()){
		doNotifyBuddy(packet->getSessionId(), packet->getIp(), packet->getPort());
		m_State = ECreatingReady;
	} else
		m_State = EError;
	delete packet;
}

const bool EvaUdpUploader::parsePacket( EvaFTSynPacket * packet )
{
	packet->setFileAgentKey(m_FileAgentKey);
	bool result = packet->parse();
	if(!result) { 
		m_State = EError;
		delete packet;
	}
	return result;
}

void EvaUdpUploader::doFinishProcessing()
{
	m_ExitNow = true;
}