QThread *thread = new QThread();
client_process *cl = new client_process(client);
cl->moveToThread(thread);
thread->start();

void client_process::some_func(){
	user *usr = (user*)sender();
	usr->get_socket()->write(usr->get_socket()->readAll());
}

#ifndef _CLIENT_H_	
#define _CLIENT_H_

#include <QMutex>
#include <QObject>
#include <QString>
#include <QMap>
#include <QtNetwork\QTcpSocket>
#include <server\data_base.h>

class client : public QObject{

	Q_OBJECT
		
public:
	client(QTcpSocket *socket_,QMutex *db_mutex_,QMutex *clients_mutex_,QMap<int,client*> *clients_);
	virtual ~client();

public slots:
	void disconnected();
	void send_message(QString message);

private slots:
	void sent();
	void primary_process();

signals:
	void auth_seccess(QString);
	void new_message(QString);
	void finished();

private:
	void authorization(QString login,QString password);
	void registration(QString login,QString password);
	bool auth;//needed?!
	QTcpSocket *socket;
	
	QString login;
	QString nick;
	
	const QMap<int,client*> *clients;
	QMutex *db_mutex;
	QMutex *clients_mutex;
};


#endif

#include <server\client.h>

client::client(QTcpSocket *socket_,QMutex *db_mutex_,QMutex *clients_mutex_,QMap<int,client*> *clients_)
			:auth(false),socket(socket_),db_mutex(db_mutex_),clients_mutex(clients_mutex_),clients(clients_){

	QObject::connect(socket,SIGNAL(disconnected()),this,SLOT(disconnected()));
	QObject::connect(socket,SIGNAL(readyRead()),this,SLOT(primary_process()));

}

client::~client(){
	if (auth) QObject::disconnect(socket,SIGNAL(readyRead()),this,SLOT(sent()));
	else QObject::disconnect(socket,SIGNAL(readyRead()),this,SLOT(primary_process()));

	QObject::disconnect(socket,SIGNAL(disconnected()),this,SLOT(disconnected()));

	socket->deleteLater();
	auth = false;
	emit finished();
}

void client::disconnected(){
	this->deleteLater();
}

void client::send_message(QString message){
	if (auth){
		socket->write(message.toUtf8().constData());
	}
}

void client::primary_process(){
	QString message = socket->readAll();
	if (message == "Please"){//request to database
		authorization("123","pass");
		return;
	}
	if (message == "Just"){//request to database
		registration("123","sss");
		return;
	}
	disconnected();
}

void client::authorization(QString login,QString password){
	QString real_password = "pass";//database.get_password(login);
	if (password != real_password){
		disconnected();
		return;
	}

	QObject::disconnect(socket,SIGNAL(readyRead()),this,SLOT(primary_process()));
	QObject::connect(socket,SIGNAL(readyRead()),this,SLOT(sent()));
	emit auth_seccess("Client:\nlogin - \'"+login+"\'\n was auth.\n");
	auth = true;
}

void client::registration(QString login,QString password){
	//if (data_base.reg_user(login,password));
	if (login != "223"){
		socket->write(QString("Reg is success. You may now auth on the server.").toUtf8().constData());
	}
	else {
		socket->write(QString("Sorry, but this login is busy.").toUtf8().constData());
		disconnected();	
	}
}

void client::sent(){
	QString message = socket->readAll();
	emit new_message(message);
}

#ifndef _SERVER_H_
#define _SERVER_H_

#include <QtNetwork\QTcpServer>
#include <QtNetwork\QTcpSocket>
#include <QMap>
#include <QString>
#include <QQueue>
#include <QMutex>
#include <server\client.h>



class server : public QObject {
	
	Q_OBJECT

public:
	server(int port = 0,QString db_name = "DataBase.dblite",QString server_name = "Fuckin server by timocov.");
	virtual ~server();

	void start();
	void stop();

	void set_port(int port);
	void set_name(QString name);


	bool started() const;
	int get_port() const;
	QString get_name() const;

public slots:
	void kick_all();
	void new_connection();
	void broadcasting(QString);
	
private slots:
	void delete_client();

signals:
	void disconnect_all();
	void stopped();
	void started();
	void broadcast(QString message);
	void new_connect();

private:
	int port;
	bool state;
	QString name;

	QTcpServer server_;

	QMap<int,client*> clients;
	
	QMutex db_mutex;
	QMutex clients_mutex;
};

#endif

#include <server\server.h>
#include <QThread>

server::server(int port_,QString db_name,QString server_name)
	:port(port_)/*,data_base(db_name)*/,name(server_name),state(false){}

server::~server(){
	stop();
	//db_close
	state = false;
}


void server::broadcasting(QString message){
	emit broadcast(message);		
}

void server::delete_client(){
	client *del = (client*)sender();
	int key = clients.key(del);
	clients.remove(key);
	QObject::disconnect(del,SIGNAL(destroyed()),this,SLOT(delete_client()));
}

void server::new_connection(){
	QTcpSocket *socket = server_.nextPendingConnection();
	
	client *_client = new client(socket,&db_mutex,&clients_mutex,&clients);
	int key = socket->socketDescriptor();

	clients_mutex.lock();
	clients[key] = _client;
	clients_mutex.unlock();

	QThread *thread = new QThread();

	QObject::connect(_client,SIGNAL(destroyed()),this,SLOT(delete_client()));
	QObject::connect(_client,SIGNAL(finished()),thread,SLOT(quit()));
	QObject::connect(_client,SIGNAL(new_message(QString)),this,SIGNAL(broadcast(QString)));
	QObject::connect(_client,SIGNAL(auth_seccess(QString)),this,SIGNAL(broadcast(QString)));

	QObject::connect(this,SIGNAL(broadcast(QString)),_client,SLOT(send_message(QString)));
	QObject::connect(this,SIGNAL(stopped()),_client,SLOT(disconnected()));
	QObject::connect(this,SIGNAL(disconnect_all()),_client,SLOT(disconnected()));

	_client->moveToThread(thread);

	thread->start();
	emit new_connect();
}

void server::start(){
	if (port == 0) return;
	if (state) return;

	if ( server_.listen(QHostAddress::Any,port) ){
		QObject::connect(&server_,SIGNAL(newConnection()),this,SLOT(new_connection()));
		state = true;
		emit started();
	}
}
void server::stop(){
	if (!state) return;
	kick_all();
	//emit disconnect_all();
	state = false;
	emit stopped();
}

void server::set_port(int port){
	this->port = port;
}

void server::set_name(QString name){
	this->name = name;
}

bool server::started() const{
	return state;
}

int server::get_port() const{
	return port;
}

QString server::get_name() const{
	return name;
}
void server::kick_all(){
	emit disconnect_all();
}

QThread *thread = new QThread();
...
_client->moveToThread(thread);
thread->start();

void QThread::run()
{
    (void) exec();
}