epimafia/daemon/daemon/mainclass.cpp

#include "mainclass.h"
#include <QFile>
#include <unistd.h>
#include <limits.h>

MainClass::MainClass(QObject *parent) : QObject(parent)
{
	m_serv = new PTServer(this);
	connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(newClient(PTSocket*)));

	m_ns = new NetSoul(this);
	connect(m_ns, SIGNAL(stateChanged(NetSoul::State)), this, SLOT(netsoulStateChanged(NetSoul::State)));
	connect(m_ns, SIGNAL(newMessage(NetSoul::Message)), this, SLOT(netsoulNewMessage(NetSoul::Message)));
	connect(m_ns, SIGNAL(userDataChanged(NetSoul::User)), this, SLOT(netsoulUserDataChanged(NetSoul::User)));

	m_eventsList.append(&m_nsEvents);
	m_eventsList.append(&m_chatEvents);
	m_eventsList.append(&m_watchlistEvents);
}

bool MainClass::start()
{
	return m_serv->listen(QHostAddress::LocalHost, 12642);
}

void MainClass::execute(PacketType type, QByteArray queryData, PTSocket* sock)
{
	QByteArray respData;
	QDataStream resp(&respData, QIODevice::ReadWrite);
	QDataStream query(&queryData, QIODevice::ReadOnly);
	QString error;
	resp << true;
	if(type == UsersList)
	{
		QStringList users;
		foreach(EpiUser user, Epimafia::loadUsers())
			if(user.hasPwd_socks())
				users << user.getLogin();
		resp << users;
	}
	else if(type == UsersAdd)
	{
		QString user, password;
		query >> user >> password;
		if(!user.isEmpty() && !password.isEmpty())
		{
			EpiUser usr;
			foreach(EpiUser u, Epimafia::loadUsers())
				if(u.getLogin() == user)
				{
					usr = u;
					break;
				}
			usr.setLogin(user);
			usr.setPwd_socks(password);
			Epimafia::saveUser(usr);
		}
		else
			error = "Empty username or password";
	}
	else if(type == UsersRemove)
	{
		QString user;
		query >> user;
		if(!user.isEmpty())
		{
			EpiUsers users = Epimafia::loadUsers();
			EpiUser usr;
			foreach(EpiUser u, users)
				if(u.getLogin() == user)
				{
					usr = u;
					break;
				}
			if(usr.hasLogin())
			{
				if(usr.hasPassword() || usr.hasPwd_num() || usr.hasPwd_ppp())
				{
					usr.setPwd_socks(QString());
					Epimafia::saveUser(usr);
				}
				else
					Epimafia::removeUser(usr);
			}
		}
		else
			error = "Empty username";
	}
	else if(type == NSConnect)
	{
		if(!isConnected())
		{
			QString user;
			query >> user;
			if(!user.isEmpty())
			{
				EpiUsers users = Epimafia::loadUsers();
				EpiUser usr;
				foreach(EpiUser u, users)
					if(u.getLogin() == user)
					{
						usr = u;
						break;
					}
				if(usr.hasLogin())
				{
					if(usr.hasPwd_socks())
					{
						m_ns->setLogin(usr);
						m_ns->login();
					}
					else
						error = "User has no socks password";
				}
				else
					error = "User not found";
			}
			else
				error = "Empty username";
		}
		else
			error = "Already in use (" + NetSoul::getStringFromState(m_ns->getState()) + ")";
	}
	else if(type == NSDisconnect)
	{
		if(isConnected())
			m_ns->logout();
		else
			error = "Not connected (" + NetSoul::getStringFromState(m_ns->getState()) + ")";
	}
	else if(type == NSStatus)
		resp << m_ns->getState();
	else if(type == NSLocationGet)
		resp << m_ns->getLocation();
	else if(type == NSLocationSet)
	{
		QString l;
		query >> l;
		m_ns->setLocation(l);
	}
	else if(type == EventsNSAdd)
	{
		if(!m_nsEvents.contains(sock))
			m_nsEvents.append(sock);
	}
	else if(type == EventsNSRemove)
		m_nsEvents.removeOne(sock);
	else if(type == EventsChatAdd)
	{
		if(!m_chatEvents.contains(sock))
			m_chatEvents.append(sock);
	}
	else if(type == EventsChatRemove)
		m_chatEvents.removeOne(sock);
	else if(type == EventsWatchlistAdd)
	{
		if(!m_watchlistEvents.contains(sock))
			m_watchlistEvents.append(sock);
	}
	else if(type == EventsWatchlistRemove)
		m_watchlistEvents.removeOne(sock);
	else if(type == EventsAllAdd)
	{
		foreach(QList<PTSocket*>* e, m_eventsList)
			if(!e->contains(sock))
				e->append(sock);
	}
	else if(type == EventsAllRemove)
	{
		foreach(QList<PTSocket*>* e, m_eventsList)
			e->removeOne(sock);
	}
	else if(type == WatchlistAdd)
	{
		QStringList logins;
		query >> logins;
		m_ns->addToWatchList(logins);
	}
	else if(type == WatchlistWhois)
	{
		QStringList logins;
		query >> logins;
		m_ns->whois(logins);
		return;
	}
	else
		error = "Unknown query type " + QString::number((int)type);
	resp.device()->seek(0);
	resp << error.isEmpty();
	if(!error.isEmpty())
		resp << error;

	if(sock)
		sock->send(type, respData);
}

void MainClass::setPidFile(QString f)
{
	m_pidFile = f;
}

void MainClass::newClient(PTSocket* client)
{
	connect(client, SIGNAL(packetReceived(int,QByteArray)), this, SLOT(packetReceived(int,QByteArray)));
	connect(client, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(clientStateChanged(PTSocket::State)));
	qDebug()<<"[Info ] New client ("<<m_serv->getClients().size()<<")";
}

void MainClass::packetReceived(int type, QByteArray data)
{
	PTSocket* sock = (PTSocket*)sender();
	if(!sock)
		return;

	execute((PacketType)type, data, sock);
}

void MainClass::clientStateChanged(PTSocket::State s)
{
	PTSocket* sock = (PTSocket*)sender();
	if(!sock)
		return;
	if(s == PTSocket::Disconnected)
		qDebug()<<"[Info ] Client left ("<<m_serv->getClients().size()<<")";
	else if(s == PTSocket::Error)
		qDebug()<<"[Error] Client error:"<<sock->getError().toStdString().c_str()<<"("<<m_serv->getClients().size()<<")";
	if(s == PTSocket::Disconnected || s == PTSocket::Error)
		foreach(QList<PTSocket*>* e, m_eventsList)
			e->removeOne(sock);
}

void MainClass::netsoulStateChanged(NetSoul::State s)
{
	if(!m_pidFile.isEmpty())
	{
		QFile f(m_pidFile);
		if(f.open(QIODevice::Truncate | QIODevice::WriteOnly))
		{
			int pid = s == NetSoul::LoggedIn ? getpid() : INT_MAX;
			f.write(QString::number(pid).toStdString().c_str());
			f.close();
		}
		else
			qDebug()<<"[Error] Could not write the pid file";
	}
	QByteArray respData;
	QDataStream resp(&respData, QIODevice::WriteOnly);
	resp << true;
	resp << s;
	foreach(PTSocket* sock, m_nsEvents)
		sock->send(NSStatus, respData);
	if(s == NetSoul::NetworkError || s == NetSoul::ProtocolError)
		QTimer::singleShot(1000, m_ns, SLOT(login()));
}

void MainClass::netsoulNewMessage(NetSoul::Message msg)
{
	QByteArray respData;
	QDataStream resp(&respData, QIODevice::WriteOnly);
	resp << true;
	resp << msg;
	foreach(PTSocket* sock, m_chatEvents)
		sock->send(EventsChat, respData);
}

void MainClass::netsoulUserDataChanged(NetSoul::User usr)
{
	QByteArray respData;
	QDataStream resp(&respData, QIODevice::WriteOnly);
	resp << true;
	resp << usr;
	foreach(PTSocket* sock, m_watchlistEvents)
		sock->send(WatchlistWhois, respData);
}

bool MainClass::isConnected()
{
	return !(m_ns->getState() == NetSoul::Disconnected || m_ns->getState() == NetSoul::ProtocolError || m_ns->getState() == NetSoul::NetworkError || m_ns->getState() == NetSoul::BadLogin);
}