added for plugins own dir

git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@1850 b45a01b8-16f6-495d-af2f-9b41ad6348cc

plugins/i2pmessenger_plugin/src/Core.cpp

@@ -0,0 +1,962 @@
+/***************************************************************************
+ *   Copyright (C) 2008 by normal   *
+ *   normal@Desktop2   *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "Core.h"
+
+cCore::cCore(){
+	init();
+}
+
+cCore::~cCore(){
+	this->UserConnectThread->stop();
+	this->saveUserList();
+	this->closeAllActiveConnections();
+	for(int i=0;i<this->users.count();i++)
+		delete users.at(i);
+		
+	QList<cPacketManager*>::Iterator it;
+	for(it=DataPacketsManagers.begin(); it<DataPacketsManagers.end() ;++it){
+		DataPacketsManagers.erase(it);
+	}
+		
+	delete this->DebugMessageHandler;
+	delete this->Protocol;
+	delete this->I2P;
+	delete this->SoundManager;
+}
+
+cDebugMessageManager* cCore::get_DebugMessageHandler(){
+	return this->DebugMessageHandler;
+}
+
+bool cCore::addNewUser(QString Name,QString I2PDestination,qint32 I2PStream_ID){
+	//TODO I2PDestination verify check
+	//check if user already exist
+
+	if(I2PDestination.length()!=516){
+		//Destination must be 516 length
+		return false;
+	}
+	
+	
+	if(!I2PDestination.right(4).contains("AAAA",Qt::CaseInsensitive)){
+		//the last 4 char must be "AAAA"
+		return false;
+	}
+
+
+	if(I2PDestination.length()>0)
+		if(this->doesUserAllReadyExitsByI2PDestination(I2PDestination)==true)
+			return false;
+
+
+	//add newuser
+	cUser* newuser=new cUser(Protocol,Name,I2PDestination,I2PStream_ID);
+	connect(newuser,SIGNAL(newIncomingMessageRecived()),SoundManager,
+		SLOT(event_NewChatMessage()));
+
+	connect(newuser,SIGNAL(connectionOnline()),SoundManager,
+		SLOT(event_User_go_Online()));
+
+	connect(newuser,SIGNAL(connectionOffline()),SoundManager,
+		SLOT(event_User_go_Offline()));
+
+	this->users.append(newuser);
+	saveUserList();
+	
+	emit eventUserChanged();
+	return true;
+}
+
+bool cCore::deleteUserByI2PDestination(QString I2PDestination){
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PDestination()==I2PDestination){
+			if(users.at(i)->get_ConnectionStatus()==ONLINE ||users.at(i)->get_ConnectionStatus()==TRYTOCONNECT)
+			{
+				this->StreamClose(users.at(i)->get_I2PStreamID());
+				deletePacketManagerByID(users.at(i)->get_I2PStreamID());
+			}
+			
+			users.removeAt(i);
+			saveUserList();
+			emit eventUserChanged();
+			return true;
+		}
+	}
+	return false;
+}
+
+
+bool cCore::doesUserAllReadyExitsByI2PDestination(const QString I2PDestination){
+	if(I2PDestination==MyDestination) return true;
+
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PDestination()==I2PDestination){
+			
+			return true;
+		}
+	}
+	
+	return false;
+}
+void cCore::doNamingLookUP(QString Name){
+	I2P->doNamingLookUP(Name);
+}
+
+void cCore::init(){
+	using namespace SESSION_Types;
+	this->MyDestination="";
+	this->currentOnlineStatus=User::USERTRYTOCONNECT;
+
+	QSettings* settings= new QSettings(QApplication::applicationDirPath()+"/application.ini",QSettings::IniFormat);
+	settings->beginGroup("Network");
+
+	this->I2P= new cConnectionI2P(	settings->value("SamHost","127.0.0.1").toString(),
+					settings->value("SamPort","7656").toString(),
+					STREAM,
+					settings->value("Destination","test").toString(),
+					BOTH,
+					settings->value("SessionOptionString","").toString()
+					,this);
+
+	this->I2P=I2P;
+	
+	//signals from I2PConnection Core
+	connect (I2P,SIGNAL(StreamClosedRecived(const SAM_Message_Types::RESULT, qint32, QString)),this,
+		SLOT(StreamClosedRecived(const SAM_Message_Types::RESULT, qint32, QString)),Qt::DirectConnection);
+	
+	connect (I2P,SIGNAL(StreamStatusRecived(const SAM_Message_Types::RESULT, const qint32, const QString)),this,
+		SLOT(StreamStatusRecived(const SAM_Message_Types::RESULT, const qint32, QString)),Qt::DirectConnection);
+
+	connect (I2P,SIGNAL(SessionStatusRecived(const SAM_Message_Types::RESULT, const QString, const QString)),this,
+		SLOT(SessionStatusRecived(const SAM_Message_Types::RESULT, const QString, QString)),Qt::DirectConnection);
+	
+	connect (I2P,SIGNAL(StreamConnectedRecived(const QString, const qint32)),this,
+		SLOT(StreamConnectedRecived(const QString, const qint32)),Qt::DirectConnection);
+
+	connect (I2P,SIGNAL(StreamReadyToSendRecived(const qint32)),this,
+		SLOT(StreamReadyToSendRecived(const qint32)),Qt::DirectConnection);
+
+	connect (I2P,SIGNAL(StreamSendRecived(const qint32, const SAM_Message_Types::RESULT, SAM_Message_Types::STATE)),this,
+		SLOT(StreamSendRecived(const qint32, const SAM_Message_Types::RESULT, SAM_Message_Types::STATE)),Qt::DirectConnection);
+	
+	connect (I2P,SIGNAL(StreamDataRecived(const qint32, const QString, const QByteArray)),this,
+		SLOT(StreamDataRecived(const qint32, const QString, const QByteArray)),Qt::DirectConnection);
+
+	connect (I2P,SIGNAL(NamingReplyRecived(const SAM_Message_Types::RESULT, QString, QString, QString)),this,
+		SLOT(NamingReplyRecived(const SAM_Message_Types::RESULT, QString, QString, QString)),Qt::DirectConnection);
+
+	this->SoundManager=new cSoundManager();
+	this->DebugMessageHandler= new cDebugMessageManager(I2P);
+	this->Protocol= new cProtocol(this);
+	this->loadUserList();
+	this->I2P->doConnect();
+
+	this->UserConnectThread= new cUserConnectThread(this,settings->value("Waittime_between_rechecking_offline_users","30000").toInt());
+
+	delete settings;	
+}
+void cCore::saveUserList(){
+     QFile file(QApplication::applicationDirPath()+"/users.config");
+     file.open(QIODevice::WriteOnly | QIODevice::Text);
+     QTextStream out(&file);
+
+	for(int i=0;i<this->users.count();i++){		
+		out<<"Nick:\t"<<(users.at(i)->get_Name())<<endl
+		<<"I2PDest:\t"<<(users.at(i)->get_I2PDestination())<<endl;
+	}
+	out.flush();
+	file.close();
+}
+void cCore::loadUserList(){
+	QFile file(QApplication::applicationDirPath()+"/users.config");
+     	if (!file.open(QIODevice::ReadOnly|QIODevice::Text))
+		return;
+
+ 	QTextStream in(&file);
+	in.skipWhiteSpace();
+	QString NickName;QString I2PDest;
+     	while (!in.atEnd()) {
+		QString line = in.readLine();
+		QStringList temp=line.split("\t");
+	
+		if(temp[0]=="Nick:")NickName=temp[1];	
+		if(temp[0]=="I2PDest:"){
+			I2PDest=temp[1];
+			this->addNewUser(NickName,I2PDest);
+			NickName.clear();
+			I2PDest.clear();
+		}
+		else if(temp[0]=="TorDest:"){
+			//ignore it
+		}
+	file.close();	
+	}
+}
+
+void cCore::StreamClosedRecived(const SAM_Message_Types::RESULT result,qint32 ID,QString Message){
+
+	if(isThisID_a_FileSendID(ID)){
+		//FileSend
+		for(int i=0;i<FileSends.size();i++){
+			if(FileSends.at(i)->get_StreamID()==ID){
+				FileSends.at(i)->StreamClosed(result,ID,Message);
+				FileSends.removeAt(i);
+				return;
+			}
+		}
+		
+	}
+	else if(isThisID_a_FileReciveID(ID)){
+		//Filerecive
+		for(int i=0;i<FileRecives.size();i++){
+			if(FileRecives.at(i)->get_StreamID()==ID){
+				FileRecives.at(i)->StreamClosed(result,ID,Message);
+				FileRecives.removeAt(i);
+				return;
+			}
+		}
+	}
+	else if(this->isThisIDunknown(ID)==true){
+	//if ID=UnKnown then remove the ID
+		this->removeUnknownID(ID);
+	}
+
+	//known ID
+
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PStreamID()==ID){
+			if(	result==SAM_Message_Types::OK ||
+				result==SAM_Message_Types::CANT_REACH_PEER ||
+				result==SAM_Message_Types::TIMEOUT
+			){
+				users.at(i)->set_ConnectionStatus(OFFLINE);
+				break;
+			}
+			else {
+				//on I2P_ERROR or PEER_NOT_FOUND
+				users.at(i)->set_ConnectionStatus(ERROR);
+				break;
+			}
+		}
+	}
+	deletePacketManagerByID(ID);
+	emit eventUserChanged();
+	
+}
+
+void cCore::StreamStatusRecived(const SAM_Message_Types::RESULT result,const qint32 ID,QString Message){
+	
+	if(isThisID_a_FileSendID(ID)){
+		//FileSend
+		for(int i=0;i<FileSends.size();i++){
+			if(FileSends.at(i)->get_StreamID()==ID){
+				FileSends.at(i)->StreamStatus(result,ID,Message);
+				if(result!=SAM_Message_Types::OK){
+					I2P->doStreamClose(ID);
+					FileSends.removeAt(i);	
+				}
+				return;
+			}
+		}
+		
+	}
+	else if(isThisID_a_FileReciveID(ID)){
+		//Filerecive
+		for(int i=0;i<FileRecives.size();i++){
+			if(FileRecives.at(i)->get_StreamID()==ID){
+				FileRecives.at(i)->StreamStatus(result,ID,Message);
+				if(result!=SAM_Message_Types::OK){
+					I2P->doStreamClose(ID);
+					FileRecives.removeAt(i);
+				}
+				return;
+			}
+		}
+	}
+	else if(this->isThisIDunknown(ID)){
+		if(result==SAM_Message_Types::OK){
+			Protocol->newConnectionChat(ID);
+			return;
+		}
+		else{
+			//I2P->doStreamClose(ID);
+			removeUnknownID(ID);
+		}
+		
+	}
+
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PStreamID()==ID){
+			if(result==SAM_Message_Types::OK){
+				users.at(i)->set_I2PStreamID(ID);
+				users.at(i)->set_ConnectionStatus(ONLINE);
+				
+                                //this->Protocol->newConnectionChat(ID);
+			}
+			else if( result==SAM_Message_Types::CANT_REACH_PEER || 
+				 result==SAM_Message_Types::TIMEOUT
+				){
+				
+				if(users.at(i)->get_OnlineState()!=USEROFFLINE && users.at(i)->get_OnlineState()!=USERTRYTOCONNECT)
+				{
+					users.at(i)->IncomingMessageFromSystem("The Connection is broken: "+Message+"\nConnection closed");
+					I2P->doStreamClose(ID);
+				}
+				deletePacketManagerByID(ID);
+				users.at(i)->set_ConnectionStatus(OFFLINE);
+			}
+			else if( result==SAM_Message_Types::INVALID_KEY){
+				users.at(i)->IncomingMessageFromSystem("Invalid User - Destination: please delete the user\n");
+				
+				if(users.at(i)->get_ConnectionStatus()==ONLINE)
+					I2P->doStreamClose(ID);
+
+				deletePacketManagerByID(ID);
+				users.at(i)->set_ConnectionStatus(ERROR);
+				
+			}
+			else if(result==SAM_Message_Types::I2P_ERROR){
+				users.at(i)->IncomingMessageFromSystem("I2P_Error: "+Message);
+
+				if(users.at(i)->get_ConnectionStatus()==ONLINE)
+					I2P->doStreamClose(ID);
+				
+				deletePacketManagerByID(ID);
+				users.at(i)->set_ConnectionStatus(ERROR);
+			}
+		
+			emit eventUserChanged();
+			break;	
+		}
+	}
+	
+}
+void cCore::SessionStatusRecived(const SAM_Message_Types::RESULT result,const QString Destination,const QString Message)
+{
+	if(result==(SAM_Message_Types::OK)){
+		currentOnlineStatus=User::USERONLINE;
+		emit eventOnlineStatusChanged();
+		I2P->doNamingLookUP("ME");//get the current Destination from this client
+		this->UserConnectThread->start();
+		
+	}
+}
+void cCore::StreamConnectedRecived(const QString Destinaton,const qint32 ID){
+	//Someone connected you
+	//this->Protocol->newConnection(ID);
+	cConnection t(ID,Destinaton);
+	this->unknownConnections.push_back(t);
+}
+bool cCore::removeUnknownID(qint32 ID)
+{
+	for(int i=0;i<this->unknownConnections.size();i++){
+		if(unknownConnections.at(i).ID==ID){
+			unknownConnections.removeAt(i);
+			return true;
+		}
+	}	
+	
+	return false;
+}
+QString cCore::get_UserProtocolVersionByStreamID(qint32 ID){
+
+	for(int i=0;i< users.size();i++)
+		if(users.at(i)->get_I2PStreamID()==ID){
+			
+			return users.at(i)->get_ProtocolVersion();
+		}
+	
+	return "";
+}
+void cCore::set_UserProtocolVersionByStreamID(qint32 ID,QString Version){
+
+	for(int i=0;i< users.size();i++)
+		if(users.at(i)->get_I2PStreamID()==ID){
+			users.at(i)->set_ProtocolVersion(Version);
+			
+			return;
+		}
+	
+}
+
+void cCore::removeUnknownIDCreateUserIfNeeded(const qint32 ID,const QString ProtocolVersion){
+	//TODO add some security thinks for adding !!! at the moment all user are allowed to connect	
+	
+	QString Destinaton;
+
+	for(int i=0;i<unknownConnections.size();i++)
+		if(unknownConnections.at(i).ID==ID){
+	
+			Destinaton=unknownConnections.at(i).Destination;
+			removeUnknownID(ID);
+			break;
+		}
+	
+	
+	if(doesUserAllReadyExitsByI2PDestination(Destinaton)==false){
+		addNewUser("Unknown",Destinaton,ID);
+	}
+
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PDestination()==Destinaton){	
+			if(users.at(i)->get_ConnectionStatus()==OFFLINE){
+					users.at(i)->set_ProtocolVersion(ProtocolVersion);
+					users.at(i)->set_I2PStreamID(ID);
+					users.at(i)->set_ConnectionStatus(ONLINE);
+				
+					cPacketManager* newPacket=new cPacketManager(ID);
+					connect(newPacket,SIGNAL(aPacketIsComplead(const qint32, const QByteArray)),Protocol,
+					SLOT(inputKnown(const qint32,const QByteArray)));
+
+					DataPacketsManagers.push_back(newPacket);
+				}
+			else if(users.at(i)->get_ConnectionStatus()==ONLINE){		
+					/*
+						//close both Streams
+						if(ID!=users.at(i)->get_I2PStreamID())
+						{
+							I2P->doStreamClose(ID);
+							I2P->doStreamClose(users.at(i)->get_I2PStreamID());
+						}
+					*/
+				//close new connection and use the old
+				if(ID!=users.at(i)->get_I2PStreamID())
+					I2P->doStreamClose(ID);
+			}
+			else if(users.at(i)->get_ConnectionStatus()==TRYTOCONNECT){
+					/*
+						//Stop the TRYTOCONNECT
+						if(ID!=users.at(i)->get_I2PStreamID())
+							I2P->doStreamClose(users.at(i)->get_I2PStreamID());
+		
+						users.at(i)->set_ProtocolVersion(ProtocolVersion);
+						users.at(i)->set_I2PStreamID(ID);
+						users.at(i)->set_ConnectionStatus(ONLINE);
+					*/
+				//close the tryconnection use the new one
+				if(ID!=users.at(i)->get_I2PStreamID())
+						I2P->doStreamClose(users.at(i)->get_I2PStreamID());
+				users.at(i)->set_ProtocolVersion(ProtocolVersion);
+				users.at(i)->set_I2PStreamID(ID);
+				users.at(i)->set_ConnectionStatus(ONLINE);
+
+				cPacketManager* newPacket=new cPacketManager(ID);
+				connect(newPacket,SIGNAL(aPacketIsComplead(const qint32, const QByteArray)),Protocol,
+				SLOT(inputKnown(const qint32,const QByteArray)));
+
+				DataPacketsManagers.push_back(newPacket);
+			}
+
+			
+			
+			
+			break;
+		}
+	}
+	
+	emit eventUserChanged();
+}
+
+void cCore::StreamReadyToSendRecived(const qint32 ID){
+	
+	//FileSendsConnections
+	for(int i=0;i<FileSends.size();i++){
+		if(FileSends.at(i)->get_StreamID()==ID){
+			FileSends.at(i)->StreamReadyToSend(true);	
+			return;
+		}
+	}
+	
+	//the Rest (Chatconnections)
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PStreamID()==ID){
+			users.at(i)->set_ReadyToSend(true);
+			return;	
+		}
+	}
+	
+}
+void cCore::StreamSendRecived(const qint32 ID,const SAM_Message_Types::RESULT result,SAM_Message_Types::STATE state){
+//FIXME what do when result = FAILED ?, impl. a stack ?
+
+	//FileSendsConnections
+	for(int i=0;i<FileSends.size();i++){
+		if(FileSends.at(i)->get_StreamID()==ID){
+			if(state==SAM_Message_Types::READY){
+				FileSends.at(i)->StreamReadyToSend(true);
+				return;
+			}
+			else{
+				FileSends.at(i)->StreamReadyToSend(false);
+				return;
+			}
+		}
+	}
+	
+	//the Rest (Chatconnections)
+	for(int i=0;i<users.count();i++){
+		if(users.at(i)->get_I2PStreamID()==ID){
+			if(state==SAM_Message_Types::BUFFER_FULL)users.at(i)->set_ReadyToSend(false);
+			if(state==SAM_Message_Types::READY)users.at(i)->set_ReadyToSend(true);
+		}
+	}
+}
+const QList<cUser*> cCore::get_userList(){
+	return users;
+}
+qint32 cCore::StreamConnect(QString Destination){
+	qint32 ID;
+	
+	ID=I2P->doStreamConnect(Destination);
+	
+	cConnection t(ID,Destination);
+	this->unknownConnections.push_back(t);
+	return (ID);
+}
+
+void cCore::StreamDataRecived(const qint32 ID,const QString Size,const QByteArray Data){
+	
+	if(Data.isEmpty()==true)return;
+
+	//FileRecive
+	for(int i=0;i<FileRecives.size();i++){
+		if(FileRecives.at(i)->get_StreamID()==ID){
+			FileRecives.at(i)->operator <<(Data);
+			return;
+		}
+	}
+
+	//FileSend
+	for(int i=0;i<FileSends.size();i++){
+		if(FileSends.at(i)->get_StreamID()==ID){
+			FileSends.at(i)->operator <<(Data);
+			return;
+		}
+	}
+	//unknown connection
+	if(this->isThisIDunknown(ID)){
+		QByteArray Data2=Protocol->inputUnknown(ID,Data);
+		if(Data2.isEmpty()==true)
+			return;
+		else{
+			QList<cPacketManager*>::Iterator it;
+			for(it=DataPacketsManagers.begin(); it!=DataPacketsManagers.end() ;++it){
+				if((*(it))->getID()==ID){
+					//(*(it))->operator <<(Data);
+					(*(*it))<<Data2;
+					return;
+				}
+			}
+
+			/*
+			QString StringSize=QString::number(Data2.length());
+			
+			StreamDataRecived(ID,StringSize,Data2);
+			
+			return;
+			*/
+		}		
+	}
+	
+	//normal connection
+	QList<cPacketManager*>::Iterator it;
+	for(it=DataPacketsManagers.begin(); it!=DataPacketsManagers.end() ;++it){
+		if((*(it))->getID()==ID){
+			//(*(it))->operator <<(Data);
+			(*(*it))<<Data;
+			return;
+		}
+	}
+
+
+	
+	//Ignore Data
+	//if you close a stream i can happen that the QSocket already have recive same data of that Stream (and send it to the Socket)
+	//if it happen forget the Data
+}
+
+void cCore::closeAllActiveConnections(){
+	//close all known Online||TrytoConnect Connections
+
+	for(int i=0;i<users.size();i++)
+		if(users.at(i)->get_ConnectionStatus()==ONLINE ||
+			users.at(i)->get_ConnectionStatus()==TRYTOCONNECT)
+		{
+			deletePacketManagerByID(users.at(i)->get_I2PStreamID());
+			I2P->doStreamClose(users.at(i)->get_I2PStreamID());
+			//removeUnknownID(users.at(i)->get_I2PStreamID());
+
+			users.at(i)->set_ConnectionStatus(User::OFFLINE);
+			users.at(i)->set_OnlineState(USEROFFLINE);
+				
+		}
+	//close all unknownConnections
+	for(int i=0;i<unknownConnections.size();i++)
+	{
+		I2P->doStreamClose(unknownConnections.at(i).ID);
+		removeUnknownID( unknownConnections.at(i).ID);
+	}
+
+	//DataPacketsManagers.clear();
+
+	emit eventUserChanged();
+	
+}
+
+bool cCore::isThisIDunknown(qint32 ID){
+
+	for(int i=0;i<this->unknownConnections.size();i++)
+		if(unknownConnections.at(i).ID==ID){
+			
+			return true;
+		}
+	
+	return false;
+}
+cUser* cCore::getUserByI2P_ID(qint32 ID){
+
+	for(int i=0;i<users.size();i++){
+		if(users.at(i)->get_I2PStreamID()==ID){
+			
+			return users.at(i);
+		}
+	}
+	
+	return NULL;
+}
+cUser* cCore::getUserByI2P_Destination(QString Destination){
+
+	for(int i=0;i<users.size();i++){
+		if(users.at(i)->get_I2PDestination()==Destination){
+			
+			return users.at(i);
+		}
+	}
+	
+	return NULL;
+}
+void cCore::NamingReplyRecived(const SAM_Message_Types::RESULT result,QString Name,QString Value,QString Message){
+	if(result==SAM_Message_Types::OK && Name=="ME")
+		this->MyDestination=Value;
+}
+const QString cCore::getMyDestination()const{
+	return this->MyDestination;
+}
+bool cCore::isThisDestinationInunknownConnections(QString Destination){
+	for(int i=0;i<unknownConnections.size();i++){
+		if(unknownConnections.at(i).Destination==Destination)return true;
+	}
+	return false;
+}
+	
+void cCore::deletePacketManagerByID(qint32 ID){
+	if(this->isThisIDunknown(ID)==true) 
+		return;
+	else
+	{
+		QList<cPacketManager*>::Iterator it;
+		for(it=DataPacketsManagers.begin(); it!=DataPacketsManagers.end() ;++it){
+			if((*(it))->getID()==ID){
+				//delete (*(it));
+				DataPacketsManagers.erase(it);
+				break;
+				
+			}
+		}
+	}
+}
+
+QString cCore::get_connectionDump(){
+	QString Message;
+
+	Message+="< Current open Unknown IDs: >\n";
+	for(int i=0;i<unknownConnections.size();i++)
+		Message+=QString::number(unknownConnections.at(i).ID,10)+"\n";
+
+	Message+="\n\n< Current open Known IDs(packetManager): >\n";
+
+	QList<cPacketManager*>::Iterator it;
+	for(it=DataPacketsManagers.begin(); it!=DataPacketsManagers.end();++it)
+		Message+= (QString::number((*(it))->getID(),10)+"\n");
+
+	Message+="\n\n< Active FileTransfer: >\n";
+	for(int i=0;i<FileSends.count();i++){
+		Message+="FileName:\t\t:"+FileSends.at(i)->get_FileName()+"\n";
+		Message+="StreamID:\t\t"+QString::number(FileSends.at(i)->get_StreamID(),10)+"\n";
+	}
+
+	Message+="\n\n< Active Filerecive: >\n";
+	for(int i=0;i<FileRecives.count();i++){
+		Message+="FileName:\t\t"+FileRecives.at(i)->get_FileName()+"\n";
+		Message+="StreamID:\t\t"+QString::number(FileRecives.at(i)->get_StreamID(),10)+"\n";
+	}
+		
+
+	Message+="\n\n< USER-Infos: >\n";
+	for(int i=0;i< users.count();i++){
+		Message+="Name:\t\t"+users.at(i)->get_Name()+"\n";
+		Message+="ClientName:\t\t"+users.at(i)->get_ClientName()+"\n";
+		Message+="ClientVersion:\t\t"+users.at(i)->get_ClientVersion()+"\n";
+		Message+="ProtocolVersion:\t" +users.at(i)->get_ProtocolVersion()+"\n";
+		Message+="I2PStreamID:\t\t" +QString::number(users.at(i)->get_I2PStreamID(),10)+"\n";
+		
+		switch(users.at(i)->get_ConnectionStatus())
+		{
+			case User::ONLINE:
+			{	
+				Message+="ConnectionStatus:\tOnline\n\n";
+				break;
+			}
+			case User::OFFLINE:
+			{	
+				Message+="ConnectionStatus:\tOffline/Invisible\n\n";
+				break;
+			}
+			case User::TRYTOCONNECT:
+			{
+				Message+="ConnectionStatus:\tTryToConnect\n\n";
+				break;
+
+			}
+
+			case User::ERROR:
+			{
+				Message+="ConnectionStatus: (Stream)\tError\n\n";
+				break;
+
+			}
+		};
+	}
+	return Message;
+}
+
+bool cCore::renameuserByI2PDestination(const QString Destination, const QString newNickname){
+	for(int i=0;i<users.size();i++){
+		if(users.at(i)->get_I2PDestination()==Destination){
+			users.at(i)->set_Name(newNickname);
+			emit eventUserChanged();
+			return true;
+		}
+	}
+	return false;
+}
+
+ONLINESTATE cCore::getOnlineStatus() const
+{
+	return this->currentOnlineStatus;
+}
+
+void cCore::setOnlineStatus(const ONLINESTATE newStatus)
+{
+	if(currentOnlineStatus==newStatus) return;
+
+	if(newStatus==User::USEROFFLINE)
+	{
+		stopCore();
+		this->currentOnlineStatus=newStatus;
+	}
+	else if(newStatus==User::USERTRYTOCONNECT)
+	{
+		if(currentOnlineStatus==User::USEROFFLINE)
+		{
+			restartCore();	
+			this->currentOnlineStatus=newStatus;
+		}
+	}
+	else
+	{
+		//send new Status to every connected User
+		this->currentOnlineStatus=newStatus;
+
+		for(int i=0;i<users.size();i++){
+			if(users.at(i)->get_ConnectionStatus()==ONLINE)
+			{
+				switch(this->currentOnlineStatus)
+				{
+					case USERONLINE:
+					{
+						Protocol->send(USER_ONLINESTATUS_ONLINE,users.at(i)->get_I2PStreamID(),"");
+						break;
+					}
+					case USEROFFLINE:
+					case USERINVISIBLE:
+					{
+						Protocol->send(USER_ONLINESTATUS_OFFLINE,users.at(i)->get_I2PStreamID(),"");
+						break;
+					}
+					case USERAWAY:
+					{
+						Protocol->send(USER_ONLINESTATUS_AWAY,users.at(i)->get_I2PStreamID(),"");
+						break;
+						
+					}
+					case USERWANTTOCHAT:
+					{
+						Protocol->send(USER_ONLINESTATUS_WANTTOCHAT,users.at(i)->get_I2PStreamID(),"");
+						break;
+					}
+					case USERDONT_DISTURB:
+					{
+						Protocol->send(USER_ONLINESTATUS_DONT_DISTURB,users.at(i)->get_I2PStreamID(),"");
+						break;
+					}
+					default:
+					{
+						QMessageBox* msgBox= new QMessageBox(NULL);
+						msgBox->setIcon(QMessageBox::Warning);
+						msgBox->setText("cCore(setOnlineStatus)");
+						msgBox->setInformativeText("Unknown USERSTATE");
+						msgBox->setStandardButtons(QMessageBox::Ok);
+						msgBox->setDefaultButton(QMessageBox::Ok);
+						msgBox->setWindowModality(Qt::NonModal);
+						msgBox->show();
+	
+					}
+				}
+			
+	
+			}//if
+		}//for
+	}
+	emit eventOnlineStatusChanged();
+}
+
+void cCore::stopCore()
+{
+	UserConnectThread->stop();
+	closeAllActiveConnections();
+	I2P->doDisconnect();
+}
+
+void cCore::restartCore()
+{
+	I2P->doConnect();
+	UserConnectThread->start();
+}
+
+void cCore::addNewFileTransfer(QString FilePath, QString Destination)
+{
+	cFileTransferSend * t= new cFileTransferSend(this,FilePath,Destination);
+	connect (t,SIGNAL(event_FileTransferFinishedOK()),SoundManager,
+		SLOT(event_FileSend_Finished()));
+
+	FileSends.append(t);
+
+}
+
+bool cCore::isThisID_a_FileSendID(qint32 ID)
+{
+	for(int i=0;i<FileSends.size();i++){
+		if(FileSends.at(i)->get_StreamID()==ID){
+			return true;
+		}
+	}
+	return false;
+}
+
+bool cCore::isThisID_a_FileReciveID(qint32 ID)
+{
+	for(int i=0;i<FileRecives.size();i++){
+		if(FileRecives.at(i)->get_StreamID()==ID){
+			return true;
+		}
+	}
+	return false;
+}
+
+void cCore::addNewFileRecive(qint32 ID, QString FileName, QString FileSize)
+{
+	if(isThisIDunknown(ID)) removeUnknownID(ID);
+
+	quint64 Size;
+	bool OK;
+	Size=FileSize.toULongLong(&OK,10);
+	if(OK==false)
+	{
+		QMessageBox* msgBox= new QMessageBox(NULL);
+		msgBox->setIcon(QMessageBox::Critical);
+		msgBox->setText("cCore(addNewFileRecive)");
+		msgBox->setInformativeText("Error convert QString to Quint64\nValue: "+FileSize +"\nFilerecive aborted");
+		msgBox->setStandardButtons(QMessageBox::Ok);
+		msgBox->setDefaultButton(QMessageBox::Ok);
+		msgBox->setWindowModality(Qt::NonModal);
+		msgBox->exec();
+
+		//abort the Filerecive
+		this->StreamSendData(ID,QString("1"));//false
+		this->StreamClose(ID);
+		return;
+	}
+	SoundManager->event_FileRecive_Incoming();
+	cFileTransferRecive* t= new cFileTransferRecive(this,ID,FileName,Size);
+	connect(t,SIGNAL(event_FileRecivedFinishedOK()),SoundManager,
+		SLOT(event_FileRecive_Finished()));
+
+	FileRecives.append(t);
+	t->start();
+}
+
+
+void cCore::StreamSendData(qint32 ID, QByteArray Data)
+{
+	I2P->doStreamSend(ID,Data);
+}
+
+
+void cCore::StreamSendData(qint32 ID, QString Data)
+{
+	I2P->doStreamSend(ID,Data);
+}
+
+void cCore::StreamClose(qint32 ID)
+{
+	if(FileSends.count()>0){
+		for(int i=0;i<FileSends.count();i++){
+			if(FileSends.at(i)->get_StreamID()==ID){
+				FileSends.removeAt(i);
+				break;
+			}
+		}	
+	}
+	
+	if(FileRecives.count()>0){
+		for(int i=0;i<FileRecives.count();i++){
+			if(FileRecives.at(i)->get_StreamID()==ID){
+				FileRecives.removeAt(i);
+				break;
+			}
+		}
+	}
+	I2P->doStreamClose(ID);
+}
+
+bool cCore::checkIfAFileTransferOrReciveisActive()
+{
+	if(FileSends.count()>0) return true;
+	if(FileRecives.count()>0) return true;
+
+	return false;
+}
+
+void cCore::MuteSound(bool t)
+{
+	SoundManager->doMute(t);
+}
+