daemon begin

.gitignore

 ns_finder/loginfinder
 usermgr/usermgr
 intrabocal/intrabocal
+daemon/daemon/netsould
+daemon/client/client

Epimafia/intrabocal.cpp

     connect(reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(searchSslError(QList<QSslError>)));
 }
 
-void IntraBocal::loginError(QNetworkReply::NetworkError e)
+void IntraBocal::loginError(QNetworkReply::NetworkError)
 {
     emit error(NetworkError);
 }

Epimafia/intrabocal.h

     void searchUser(QString lastName, QString firstName, QString login, QString promo = QString(), QString school = QString(), QString city = QString());
 
 private slots:
-    void loginError(QNetworkReply::NetworkError e);
+	void loginError(QNetworkReply::NetworkError);
     void loginFinished();
     void loginSslError(QList<QSslError>);
 

Epimafia/netsoul.cpp

 #include "netsoul.h"
 
-int NetSoul::m_defaultTimeout = 1500;
+int NetSoul::m_defaultTimeout = 3000;
 
 NetSoul::NetSoul(QObject *parent) : QObject(parent)
 {
 
 NetSoul::State NetSoul::getState() const
 {
-    return m_state;
+	return m_state;
+}
+
+QString NetSoul::getLocation() const
+{
+	return m_location;
 }
 
 NetSoul::UserState NetSoul::getUserStateFromString(QString state)
     nextCommand();
 }
 
-QDebug operator<< (QDebug d, NetSoul::Command& cmd)
+QDebug &operator<< (QDebug d, NetSoul::Command& cmd)
 {
     const QMetaObject & mo = NetSoul::staticMetaObject;
-    QMetaEnum me = mo.enumerator(mo.indexOfEnumerator("Command"));
-    d<<me.valueToKey(cmd);
-    return d;
+	QMetaEnum me = mo.enumerator(mo.indexOfEnumerator("Command"));
+	return d<<me.valueToKey(cmd);
 }
 
-QDebug operator<< (QDebug d, NetSoul::State& state)
+QDebug &operator<< (QDebug d, NetSoul::State& state)
 {
     return d << NetSoul::getStringFromState(state);
 }
 
-QDebug operator<< (QDebug d, NetSoul::UserState& state)
+QDebug &operator<< (QDebug d, NetSoul::UserState& state)
 {
     return d << NetSoul::getStringFromUserState(state);
 }
 
-QDebug operator<< (QDebug d, NetSoul::User& user)
+QDebug &operator<< (QDebug d, NetSoul::User& user)
 {
     d.nospace()<<"("<<user.id<<" "<<user.login.toStdString().c_str()<<"@"<<user.location.toStdString().c_str()
               <<" "<<user.ip.toStdString().c_str()<<" "<<user.state<< (user.state == NetSoul::UnknownState ? " " + user.stateString : "")<<" "<<user.promo<<" "<<user.data<<")";
     return d.maybeSpace();
 }
 
+QDebug &operator<< (QDebug d, NetSoul::Message& msg)
+{
+	return d<<"("<<msg.from<<msg.message<<")";
+}
 
 void NSListUsersEmitter::emitList(NetSoul::Users users)
 {
     emit listed(users);
 }
+
+QDataStream &operator<<(QDataStream& stream, NetSoul::Message& msg)
+{
+	return stream << msg.from << msg.message;
+}
+
+QDataStream &operator>>(QDataStream& stream, NetSoul::Message& msg)
+{
+	QString m;
+	NetSoul::User u;
+	stream >> u;
+	stream >> m;
+	if(stream.status() == QDataStream::Ok)
+	{
+		msg.from = u;
+		msg.message = m;
+	}
+	return stream;
+}
+
+QDataStream &operator<<(QDataStream& stream, NetSoul::UserState& state)
+{
+	return stream << (quint8)state;
+}
+
+QDataStream &operator>>(QDataStream& stream, NetSoul::UserState& state)
+{
+	quint8 s;
+	stream >> s;
+	if(stream.status() == QDataStream::Ok)
+		state = (NetSoul::UserState)s;
+	return stream;
+}
+
+QDataStream &operator<<(QDataStream& stream, NetSoul::State& state)
+{
+	return stream << (quint8)state;
+}
+
+QDataStream &operator>>(QDataStream& stream, NetSoul::State& state)
+{
+	quint8 s;
+	stream >> s;
+	if(stream.status() == QDataStream::Ok)
+		state = (NetSoul::State)s;
+	return stream;
+}
+
+QDataStream &operator<<(QDataStream& stream, NetSoul::User& user)
+{
+	return stream << user.data
+	<< user.id
+	<< user.ip
+	<< user.location
+	<< user.login
+	<< user.promo
+	<< user.state
+	<< user.stateString;
+}
+
+QDataStream &operator>>(QDataStream& stream, NetSoul::User& user)
+{
+	QString data, id, ip, location, login, promo, stateString;
+	NetSoul::UserState state;
+
+	stream >> data;
+	stream >> id;
+	stream >> ip;
+	stream >> location;
+	stream >> login;
+	stream >> promo;
+	stream >> state;
+	stream >> stateString;
+
+	if(stream.status() == QDataStream::Ok)
+	{
+		user.data = data;
+		user.id = id;
+		user.ip = ip;
+		user.location = location;
+		user.login = login;
+		user.promo = promo;
+		user.state = state;
+		user.stateString = stateString;
+	}
+
+	return stream;
+}

Epimafia/netsoul.h

 #include <QDateTime>
 #include <QDebug>
 #include <QStringList>
+#include <QDataStream>
 #include "epimafia_global.h"
 #include "epimafia.h"
 
 public:
     enum State
     {
-        Disconnected,
+		Disconnected,//TODO explicit values
         HostLookUp,
         Connecting,
         Connected,
 	EpiUser getEpiUser() const;
 	User getUser() const;
 	NetSoul::State getState() const;
+	QString getLocation() const;
 
     static UserState getUserStateFromString(QString state);
     static QString getStringFromUserState(UserState state);
     void emitList(NetSoul::Users users);
 };
 
-QDebug EPIMAFIASHARED_EXPORT operator<< (QDebug, NetSoul::Command&);
-QDebug EPIMAFIASHARED_EXPORT operator<< (QDebug, NetSoul::State&);
-QDebug EPIMAFIASHARED_EXPORT operator<< (QDebug, NetSoul::UserState&);
-QDebug EPIMAFIASHARED_EXPORT operator<< (QDebug, NetSoul::User&);
+QDebug EPIMAFIASHARED_EXPORT &operator<< (QDebug, NetSoul::Command&);
+QDebug EPIMAFIASHARED_EXPORT &operator<< (QDebug, NetSoul::State&);
+QDebug EPIMAFIASHARED_EXPORT &operator<< (QDebug, NetSoul::UserState&);
+QDebug EPIMAFIASHARED_EXPORT &operator<< (QDebug, NetSoul::User&);
+QDebug EPIMAFIASHARED_EXPORT &operator<< (QDebug, NetSoul::Message&);
+
+QDataStream EPIMAFIASHARED_EXPORT &operator<< (QDataStream&, NetSoul::Message&);
+QDataStream EPIMAFIASHARED_EXPORT &operator>> (QDataStream&, NetSoul::Message&);
+
+QDataStream EPIMAFIASHARED_EXPORT &operator<< (QDataStream&, NetSoul::UserState&);
+QDataStream EPIMAFIASHARED_EXPORT &operator>> (QDataStream&, NetSoul::UserState&);
+
+QDataStream EPIMAFIASHARED_EXPORT &operator<< (QDataStream&, NetSoul::State&);
+QDataStream EPIMAFIASHARED_EXPORT &operator>> (QDataStream&, NetSoul::State&);
+
+QDataStream EPIMAFIASHARED_EXPORT &operator<< (QDataStream&, NetSoul::User&);
+QDataStream EPIMAFIASHARED_EXPORT &operator>> (QDataStream&, NetSoul::User&);
 
 #endif // NETSOUL_H

daemon/client/client.pro

+#-------------------------------------------------
+#
+# Project created by QtCreator 2014-02-15T22:13:56
+#
+#-------------------------------------------------
+
+QT       += core network
+
+QT       -= gui
+
+TARGET = client
+CONFIG   += console
+CONFIG   -= app_bundle
+
+TEMPLATE = app
+
+LIBS += -lptsocket
+
+SOURCES += main.cpp \
+    mainclass.cpp
+
+HEADERS += mainclass.h
+
+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../../Epimafia/release/ -lEpimafia
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../../Epimafia/debug/ -lEpimafia
+else:unix: LIBS += -L$$OUT_PWD/../../Epimafia/ -lEpimafia
+
+INCLUDEPATH += $$PWD/../../Epimafia
+DEPENDPATH += $$PWD/../../Epimafia
+
+OTHER_FILES += ../defs.h

daemon/client/main.cpp

+#include <QCoreApplication>
+#include <QStringList>
+#include "mainclass.h"
+
+void printUsage()
+{
+	qDebug()<<"Usage: netsouldc [options] (events|ns|users)";
+	qDebug()<<"\t-h, --help \t\t print this help.";
+	qDebug()<<"\t-k, --keep \t\t keep session active if queries are provided in arguments. Exit by default.";
+	qDebug()<<"\t-r, --responseOnly \t only print the responses, but not the info, ok and error.";
+	qDebug()<<"\t-p, --pid file \t\t indicate the file path to write de pid.";
+	qDebug()<<"\t-c, --color \t\t disable the colors in the info, ok and error.";
+}
+
+int main(int argc, char *argv[])
+{
+	QCoreApplication a(argc, argv);
+	MainClass m;
+	m.setCloseOnNextQuery(qApp->argc() >= 2);
+
+	QStringList cmds;
+
+	for(int i = 1; i < qApp->argc(); ++i)
+	{
+		QString c = qApp->arguments().at(i);
+		if(c == "-h" || c == "--help")
+		{
+			printUsage();
+			return 0;
+		}
+		else if(c == "-k" || c == "--keep")
+			m.setCloseOnNextQuery(false);
+		else if(c == "-r" || c == "--responseOnly")
+			m.setShowOnlyResponse(true);
+		else if(c == "-c" || c == "--color")
+			m.setColored(false);
+		else
+			cmds.append(c);
+	}
+
+	m.addCommands(cmds);
+	m.connectToDaemon();
+
+	return a.exec();
+}

daemon/client/mainclass.cpp

+#include "mainclass.h"
+#include <QCoreApplication>
+#include <QStringList>
+#include <iostream>
+#include "netsoul.h"
+
+MainClass::MainClass(QObject *parent) : QObject(parent)
+{
+	m_sock = new PTSocket(this);
+	connect(m_sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(stateChanged(PTSocket::State)));
+	connect(m_sock, SIGNAL(packetReceived(int,QByteArray)), this, SLOT(packetReceived(int,QByteArray)));
+	m_closeOnNextQuery = false;
+	m_showOnlyResponse = false;
+	m_colored = true;
+	m_lastQueryResult = true;
+	m_responsesCount = 0;
+}
+
+void MainClass::send(QString cmd, bool print)
+{
+	QByteArray queryData;
+	QDataStream query(&queryData, QIODevice::ReadWrite);
+	PacketType type = Invalid;
+	QString error;
+
+	QStringList commands = cmd.split(" ", QString::SkipEmptyParts);
+	if(!commands.isEmpty())
+	{
+		QString c = commands.at(0);
+		commands.removeFirst();
+		if(c == "users")
+		{
+			if(!commands.isEmpty())
+			{
+				c = commands.at(0);
+				commands.removeFirst();
+				if(c == "list")
+					type = UsersList;
+				else if(c == "add")
+				{
+					if(commands.size() >= 2)
+					{
+						type = UsersAdd;
+						query << commands.at(0) << commands.at(1);
+					}
+					else
+						error = "Usage: users add username password";
+				}
+				else if(c == "remove")
+				{
+					if(commands.size() >= 1)
+					{
+						type = UsersRemove;
+						query << commands.at(0);
+					}
+					else
+						error = "Usage: users remove username";
+				}
+				else
+					error = "Usage: users (add|list|remove)";
+			}
+			else
+				error = "Usage: users (add|list|remove)";
+		}
+		else if(c == "ns")
+		{
+			if(!commands.isEmpty())
+			{
+				c = commands.at(0);
+				commands.removeFirst();
+				if(c == "connect")
+				{
+					if(commands.size() >= 1)
+					{
+						type = NSConnect;
+						query << commands.at(0);
+					}
+					else
+						error = "Usage: ns connect username";
+				}
+				else if(c == "disconnect")
+					type = NSDisconnect;
+				else if(c == "status")
+					type = NSStatus;
+				else if(c == "location")
+				{
+					if(!commands.isEmpty())
+					{
+						c = commands.at(0);
+						commands.removeFirst();
+						if(c == "get")
+							type = NSLocationGet;
+						else if(c == "set")
+						{
+							c = cmd;
+							c = c.remove(0, c.indexOf("set") + 3);
+							if(!c.isEmpty())
+								c = c.remove(0, 1);
+							type = NSLocationSet;
+							query << c;
+						}
+						else
+							error = "Usage: ns location (get|set)";
+					}
+					else
+						error = "Usage: ns location (get|set)";
+				}
+				else
+					error = "Usage: ns (connect|disconnect|location|status)";
+			}
+			else
+				error = "Usage: ns (connect|disconnect|location|status)";
+		}
+		else if(c == "events")
+		{
+			if(commands.size() >= 2)
+			{
+				c = commands.at(0);
+				QString t = commands.at(1);
+				if(c == "ns")
+				{
+					if(t == "add")
+						type = EventsNSAdd;
+					else if(t == "remove")
+						type = EventsNSRemove;
+					else
+						error = "Usage: events ns (add|remove)";
+				}
+				else if(c == "chat")
+				{
+					if(t == "add")
+						type = EventsChatAdd;
+					else if(t == "remove")
+						type = EventsChatRemove;
+					else
+						error = "Usage: events chat (add|remove)";
+				}
+				else if(c == "watchlist")
+				{
+					if(t == "add")
+						type = EventsWatchlistAdd;
+					else if(t == "remove")
+						type = EventsWatchlistRemove;
+					else
+						error = "Usage: events watchlist (add|remove)";
+				}
+				else if(c == "all")
+				{
+					if(t == "add")
+						type = EventsAllAdd;
+					else if(t == "remove")
+						type = EventsAllRemove;
+					else
+						error = "Usage: events all (add|remove)";
+				}
+				else
+					error = "Usage: events (all|chat|ns|watchlist) (add|remove)";
+			}
+			else
+				error = "Usage: events (all|chat|ns|watchlist) (add|remove)";
+		}
+		else if(c == "watchlist")
+		{
+			if(!commands.isEmpty())
+			{
+				c = commands.at(0);
+				commands.removeFirst();
+				if(c == "add")
+				{
+					if(!commands.isEmpty())
+					{
+						type = WatchlistAdd;
+						query << commands;
+					}
+					else
+						error = "Usage: watchlist add login1 login2 ...";
+				}
+				else if(c == "whois")
+				{
+					if(!commands.isEmpty())
+					{
+						type = WatchlistWhois;
+						query << commands;
+					}
+					else
+						error = "Usage: watchlist whois login1 login2 ...";
+				}
+				else
+					error = "Usage: watchlist (add|whois)";
+			}
+			else
+				error = "Usage: watchlist (add|whois)";
+		}
+		else
+			error = "Usage: (events|ns|users)";
+	}
+	else
+		error = "Empty query";
+
+	if(error.isEmpty())
+	{
+		if(print && !m_showOnlyResponse)
+			qinfo<<"Sending command:"<<cmd.toStdString().c_str();
+		m_sock->send(type, queryData);
+	}
+	else
+	{
+		m_lastQueryResult = false;
+		if(!m_showOnlyResponse)
+			qerror<<error.toStdString().c_str();
+		mayDisconnect();
+	}
+
+	if(!print)
+		readStdin();
+}
+
+void MainClass::setCloseOnNextQuery(bool m)
+{
+	m_closeOnNextQuery = m;
+}
+
+void MainClass::setShowOnlyResponse(bool m)
+{
+	m_showOnlyResponse = m;
+}
+
+void MainClass::setColored(bool m)
+{
+	m_colored = m;
+}
+
+void MainClass::connectToDaemon()
+{
+	if(!m_sock->isOpen())
+		m_sock->connectToHost(QHostAddress::LocalHost, 12642);
+}
+
+void MainClass::addCommands(QStringList cmds)
+{
+	m_cmds << cmds;
+}
+
+void MainClass::stateChanged(PTSocket::State s)
+{
+	if(s == PTSocket::Connecting)
+	{
+		if(!m_showOnlyResponse)
+			qinfo<<"Connecting to daemon...";
+	}
+	else if(s == PTSocket::Handshaked)
+	{
+		if(!m_showOnlyResponse)
+			qok<<"Connected to daemon";
+		if(!m_cmds.isEmpty())
+			foreach(QString cmd, m_cmds)
+				send(cmd.toStdString().c_str(), true);
+		else
+			readStdin();
+	}
+	else if(s == PTSocket::Error)
+	{
+		if(!m_showOnlyResponse)
+			qerror<<m_sock->getError().toStdString().c_str();
+		qApp->exit(1);
+	}
+	else if(s == PTSocket::Disconnected)
+	{
+		if(!m_showOnlyResponse)
+			qinfo<<"Disconnected from daemon";
+		qApp->exit(m_lastQueryResult ? 0 : 1);
+	}
+}
+
+void MainClass::packetReceived(int type, QByteArray replyData)
+{
+	++m_responsesCount;
+	QDataStream reply(&replyData, QIODevice::ReadOnly);
+	reply >> m_lastQueryResult;
+	if(m_lastQueryResult)
+	{
+		if(type == UsersList)
+		{
+			QStringList users;
+			reply >> users;
+			if(!m_showOnlyResponse)
+				qinfo<<"Available users:";
+			foreach(QString user, users)
+				qDebug()<<user.toStdString().c_str();
+		}
+		else if(type == UsersAdd)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"User successfully added or updated";
+		}
+		else if(type == UsersRemove)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"User or user\'s socks password successfully removed";
+		}
+
+		else if(type == NSConnect)
+		{
+			if(!m_showOnlyResponse)
+				qinfo<<"Connecting to netsoul server";
+		}
+		else if(type == NSDisconnect)
+		{
+			if(!m_showOnlyResponse)
+				qinfo<<"Disconnecting from netsoul server";
+		}
+		else if(type == NSStatus)
+		{
+			NetSoul::State s;
+			reply >> s;
+			if(!m_showOnlyResponse)
+				qinfo<<"Status:"<<NetSoul::getStringFromState(s).toStdString().c_str();
+			else
+				qDebug()<<NetSoul::getStringFromState(s).toStdString().c_str();
+		}
+		else if(type == NSLocationGet)
+		{
+			QString l;
+			reply >> l;
+			if(!m_showOnlyResponse)
+				qinfo<<"Location:"<<l;
+			else
+				qDebug()<<l;
+		}
+		else if(type == NSLocationSet)
+		{
+			if(!m_showOnlyResponse)
+				qinfo<<"Location successfully changed";
+		}
+
+		else if(type == EventsNSAdd)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Netsoul event registered";
+		}
+		else if(type == EventsNSRemove)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Netsoul event removed";
+		}
+
+		else if(type == EventsWatchlistAdd)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Watchlist event registered";
+		}
+		else if(type == EventsWatchlistRemove)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Watchlist event removed";
+		}
+
+		else if(type == EventsChat)
+		{
+			NetSoul::Message msg;
+			reply >> msg;
+			if(!m_showOnlyResponse)
+				qinfo<<"Message received:"<<msg;
+			else
+				qDebug()<<msg;
+		}
+		else if(type == EventsChatAdd)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Chat event registered";
+		}
+		else if(type == EventsChatRemove)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Chat event removed";
+		}
+		else if(type == EventsAllAdd)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"All events registered";
+		}
+		else if(type == EventsAllRemove)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"All events removed";
+		}
+
+		else if(type == WatchlistAdd)
+		{
+			if(!m_showOnlyResponse)
+				qok<<"Users added to watchlist";
+		}
+		else if(type == WatchlistWhois)
+		{
+			NetSoul::User usr;
+			reply >> usr;
+			if(reply.status() == QDataStream::Ok)
+			{
+				if(!m_showOnlyResponse)
+					qinfo<<"Watchlist event:"<<usr;
+				else
+					qDebug()<<usr;
+			}
+			else
+				qerror<<"Failed to retreive user in whois reply";
+		}
+		else
+			qerror<<"Unknown reply ("<<type<<")";
+	}
+	else
+	{
+		QString error;
+		reply >> error;
+		if(!m_showOnlyResponse)
+			qerror<<error.toStdString().c_str();
+	}
+	mayDisconnect();
+}
+
+void MainClass::readStdin()
+{
+	/*QTextStream t(stdin);
+	send(t.readLine(), false);*/
+}
+
+void MainClass::mayDisconnect()
+{
+	if(m_closeOnNextQuery && m_responsesCount >= m_cmds.size())
+		m_sock->disconnectFromServer();
+}

daemon/client/mainclass.h

+#ifndef MAINCLASS_H
+#define MAINCLASS_H
+
+#include <QObject>
+#include <QStringList>
+#include <ptsocket/ptsocket.h>
+#include "../defs.h"
+
+#define qinfo qDebug()<<(m_colored ?	"[\033[1m\033[36mInfo\033[m ]" :		"[Info ]")
+#define qerror qDebug()<<(m_colored ?	"[\033[1m\033[31mError\033[m]" :	"[Error]")
+#define qok qDebug()<<(m_colored ?		"[ \033[1m\033[32mOK\033[m  ]" :		"[ OK  ]")
+
+class MainClass : public QObject
+{
+	Q_OBJECT
+public:
+	explicit MainClass(QObject *parent = 0);
+
+public slots:
+	void send(QString cmd, bool print);
+	void setCloseOnNextQuery(bool m);
+	void setShowOnlyResponse(bool m);
+	void setColored(bool m);
+	void addCommands(QStringList cmds);
+	void connectToDaemon();
+
+private slots:
+	void stateChanged(PTSocket::State s);
+	void packetReceived(int type, QByteArray data);
+	void readStdin();
+	void mayDisconnect();
+
+private:
+	PTSocket* m_sock;
+	bool m_closeOnNextQuery;
+	QStringList m_cmds;
+	bool m_showOnlyResponse;
+	bool m_colored;
+	bool m_lastQueryResult;
+	int m_responsesCount;
+};
+
+#endif // MAINCLASS_H

daemon/daemon.pro

+TEMPLATE = subdirs
+CONFIG += ordered
+SUBDIRS += \
+    daemon \
+    client

daemon/daemon/daemon.pro

+#-------------------------------------------------
+#
+# Project created by QtCreator 2014-02-15T19:24:40
+#
+#-------------------------------------------------
+
+QT       += core network
+
+QT       -= gui
+
+TARGET = netsould
+CONFIG   += console
+CONFIG   -= app_bundle
+
+TEMPLATE = app
+
+LIBS += -lptsocket
+
+SOURCES += main.cpp \
+    mainclass.cpp
+
+HEADERS += mainclass.h
+
+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../../Epimafia/release/ -lEpimafia
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../../Epimafia/debug/ -lEpimafia
+else:unix: LIBS += -L$$OUT_PWD/../../Epimafia/ -lEpimafia
+
+INCLUDEPATH += $$PWD/../../Epimafia
+DEPENDPATH += $$PWD/../../Epimafia
+
+OTHER_FILES += ../defs.h

daemon/daemon/main.cpp

+#include <QCoreApplication>
+#include <QDebug>
+#include <unistd.h>
+#include <QSettings>
+#include "mainclass.h"
+
+void printUsage()
+{
+	qDebug()<<"Usage: netsould";
+	qDebug()<<"\t-h, --help \t\t print this help.";
+	qDebug()<<"\t-p, --pid file \t\t indicate the file path to write de pid. The pid will be written when the daemon is connected to the netsoul server, and a blank file when disconnected.";
+}
+
+int main(int argc, char *argv[])
+{
+	QCoreApplication a(argc, argv);
+	MainClass m;
+
+	for(int i = 1; i < qApp->argc(); ++i)
+	{
+		QString c = qApp->arguments().at(i);
+		if(c == "-p" || c == "--pid")
+		{
+			if(qApp->argc() > i + 1)
+				m.setPidFile(qApp->arguments().at(++i));
+			else
+			{
+				printUsage();
+				return 1;
+			}
+		}
+		else
+		{
+			printUsage();
+			return 1;
+		}
+	}
+
+	while(!m.start())
+	{
+		qDebug()<<"[Error] Failed to start. Trying again in 5 seconds...";
+		sleep(5);
+	}
+	qDebug()<<"[Info ] Daemon started";
+
+
+	return a.exec();
+}

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())
+			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);
+}
+
+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);
+}

daemon/daemon/mainclass.h

+#ifndef MAINCLASS_H
+#define MAINCLASS_H
+
+#include <QObject>
+#include <ptsocket/ptserver.h>
+#include "netsoul.h"
+#include "epimafia.h"
+#include "../defs.h"
+
+class MainClass : public QObject
+{
+	Q_OBJECT
+public:
+	explicit MainClass(QObject *parent = 0);
+
+public slots:
+	void setPidFile(QString f);
+	bool start();
+	void execute(PacketType type, QByteArray queryData, PTSocket* sock);
+
+private slots:
+	void newClient(PTSocket* client);
+	void packetReceived(int type, QByteArray data);
+	void clientStateChanged(PTSocket::State s);
+	void netsoulStateChanged(NetSoul::State s);
+	void netsoulNewMessage(NetSoul::Message msg);
+	void netsoulUserDataChanged(NetSoul::User usr);
+
+private:
+	bool isConnected();
+	PTServer* m_serv;
+	NetSoul* m_ns;
+	QList<QList<PTSocket*>*> m_eventsList;
+	QList<PTSocket*> m_nsEvents;
+	QList<PTSocket*> m_chatEvents;
+	QList<PTSocket*> m_watchlistEvents;
+	QString m_pidFile;
+};
+
+#endif // MAINCLASS_H

daemon/defs.h

+#ifndef DEFS_H
+#define DEFS_H
+
+enum PacketType
+{
+	Invalid = 0,
+
+	UsersList = 1,
+	UsersAdd = 2,
+	UsersRemove = 3,
+
+	NSConnect = 10,
+	NSDisconnect = 11,
+	NSStatus = 12,
+	NSLocationGet = 13,
+	NSLocationSet = 14,
+
+	EventsNSAdd = 20,
+	EventsNSRemove = 21,
+
+	EventsChat = 30,
+	EventsChatAdd = 31,
+	EventsChatRemove = 32,
+
+	EventsWatchlistAdd = 40,
+	EventsWatchlistRemove = 41,
+
+	WatchlistAdd = 50,
+	WatchlistWhois = 51,
+
+	EventsAllAdd = 60,
+	EventsAllRemove = 61,
+};
+
+#endif

epimafia.pro

     ns_finder \
 	intrabocal \
 	usermgr \
-	netsoul
+	netsoul \
+    daemon

netsoul/dialogaddcontact.cpp

     emit contactAdded(ui->lineSearch->text());
 }
 
-void DialogAddContact::on_listContacts_itemDoubleClicked(QTreeWidgetItem *item, int column)
+void DialogAddContact::on_listContacts_itemDoubleClicked(QTreeWidgetItem *item, int)
 {
     emit contactAdded(item->text(0));
 }

netsoul/dialogaddcontact.h

 
 private slots:
     void on_lineSearch_returnPressed();
-    void on_listContacts_itemDoubleClicked(QTreeWidgetItem *item, int column);
+	void on_listContacts_itemDoubleClicked(QTreeWidgetItem *item, int);
     void chat();
     void addContact();
     void menuRequested(QPoint p);