QObject(parent),

m_tcpServer(NULL),

m_nextBlockSize(0)

{

//start server

//initialize client list

{

m_tcpServer = new QTcpServer(this);

m_port = nPort;

connect(m_tcpServer, SIGNAL(newConnection()), this, SLOT(serverGotNewConnection()));

//create client list, load this bastard from db

//clientList = GeneralClientList;

connect(&m_clientList, SIGNAL(logMessage(ErrorStatus, QString&)), this, SLOT(replyLog(ErrorStatus, QString&)));

m_clientList.readChannelsFromDB();

return m_tcpServer->listen(QHostAddress::Any, nPort);

//stops server

//we need to send disconnect messages to all channels

{

GeneralClientList::userSocketsList_t *userList = m_clientList.getAllSockets();

GeneralClientList::userSocketsListIterator_t itr(*userList);

ServerShutdownMessage msg;

msg.shutdownReason = shutdownReason;

while(itr.hasNext())

sendMessageToClient(itr.next(), &msg);

delete userList;

m_clientList.disconnectAll();

QString log = tr("Server stopped.");

m_tcpServer->close();

disconnect(m_tcpServer, SIGNAL(newConnection()), this, SLOT(serverGotNewConnection()));

disconnect(&m_clientList, SIGNAL(logMessage(ErrorStatus, QString&)), this, SLOT(replyLog(ErrorStatus, QString&)));

emit serverLog(esNotify, log);

delete m_tcpServer;

//activates when server got new incoming connection

//isn't very important for us, cause server requires authorization

//so we still waiting authorization/registration request from that son of a bitch

{

QTcpSocket *newSocket = m_tcpServer->nextPendingConnection();

connect(newSocket, SIGNAL(readyRead()), this, SLOT(serverGotNewMessage()));

QString log = "Server got new connection from " + newSocket->peerAddress().toString() + ":" + QString::number(newSocket->peerPort());

emit serverLog(esNotify, log);

//activates when server receives new message

//in this method we are reading new message from socket

//first we read header

//then we read body of the message and call method

//that could process message its[message body] type

{

QTcpSocket *pClientSocket = (QTcpSocket*)sender();

QDataStream input(pClientSocket);

input.setVersion(QDataStream::Qt_4_7);

while (true)

{

if (!m_nextBlockSize)

{

if (pClientSocket->bytesAvailable() < sizeof(quint16))

break;

input >> m_nextBlockSize;

}

if (pClientSocket->bytesAvailable() < m_nextBlockSize)

break;

//message in in <input>, unpack it

ChatMessageHeader *header = new ChatMessageHeader(input);

ChatMessageType msgType = (ChatMessageType) header->messageType;

delete header;

switch (msgType)

{

case cmtChannelMessage:

{

ChannelMessage *msg = new ChannelMessage(input);

processMessage(msg);

delete msg;

break;

}

case cmtAuthorizationRequest:

{

AuthorizationRequest *msg = new AuthorizationRequest(input);

processMessage(msg, pClientSocket);

delete msg;

break;

}

case cmtDisconnectMessage:

{

DisconnectMessage *msg = new DisconnectMessage(input);

processMessage(msg);

delete msg;

break;

}

case cmtRegistrationRequest:

{

RegistrationRequest *msg = new RegistrationRequest(input);

processMessage(msg, pClientSocket);

delete msg;

break;

}

case cmtChannelListRequest:

{

ChannelListRequest *msg = new ChannelListRequest(input);

processMessage(msg, pClientSocket);

delete msg;

break;

}

case cmtChannelJoinRequest:

{

ChannelJoinRequest *msg = new ChannelJoinRequest(input);

processMessage(msg, pClientSocket);

delete msg;

break;

}

case cmtChannelLeaveMessage:

{

ChannelLeaveMessage *msg = new ChannelLeaveMessage(input);

processMessage(msg);

delete msg;

break;

}

case cmtChannelCreateRequest:

{

ChannelCreateRequest *msg = new ChannelCreateRequest(input);

processMessage(msg);

delete msg;

break;

}

case cmtChannelThemeChanged:

{

ChannelThemeChanged *msg = new ChannelThemeChanged(input);

processMessage(msg);

delete msg;

break;

}

case cmtClientStatusChanged:

{

ClientStatusChanged *msg = new ClientStatusChanged(input);

processMessage(msg);

delete msg;

break;

}

case cmtUserInfoRequest:

{

UserInfoRequest *msg = new UserInfoRequest(input);

processMessage(msg, pClientSocket);

delete msg;

break;

}

case cmtUserInfoChanged:

{

UserInfoChanged *msg = new UserInfoChanged(input);

processMessage(msg);

delete msg;

break;

}

case cmtPasswordChangeRequest:

{

PasswordChangeRequest *msg = new PasswordChangeRequest(input);

processMessage(msg);

delete msg;

break;

}

default:

{

QString log = "Server received unknown-typed message" + msgType;

emit serverLog(esWarning, log);

break;

}

}

m_nextBlockSize = 0;

}

//processing channel message

//we need to reply this message to all clients in channel,

{

//got channel message

//need to reply it to all authorized clients in that channel

if (!msg)

{

QString log = "Error processing channel message - message is empty";

emit serverLog(esMinor, log);

return;

}

QString messageText = QString("%1: %2")

.arg(msg->sender)

.arg(msg->messageText);

emit channelLog(msg->receiver, messageText);

//and reply to all of receiver channel users a channel message

sendMessageToChannel(msg->receiver, msg);

//processing authorization request

//here we need to check whether user exists in table or not

//YOBA ETO YA, PSHH-PSSHHH

//and we need to form authorization answer and send it to client

{

if (!msg)

{

QString log = "Error processing authprization request- message is empty";

emit serverLog(esMinor, log);

return;

}

AuthorizationAnswer *answer = new AuthorizationAnswer();

switch (m_clientList.authorize(msg->username, msg->password, socket))

{

case GeneralClientList::arAllreadyAuthorized:

{

answer->authorizationResult = false;

answer->denialReason = "User allready authorized";

break;

}

case GeneralClientList::arWrongAuthData:

{

answer->authorizationResult = false;

answer->denialReason = "Wrong username or password";

break;

}

case GeneralClientList::arAuthSuccess:

{

answer->authorizationResult = true;

break;

}

}

sendMessageToClient(socket, answer);

if (answer->authorizationResult)

{

ChatClient client = m_clientList.getClient(msg->username);

client.setUserState("Online");

m_clientList.updateClient(client);

emit updateTable("clients");

QStringList channels = m_clientList.getChannelsForClient(msg->username).keys();

ChannelSystemMessage *informMsg = new ChannelSystemMessage();

ChannelUserList *updateListMsg = new ChannelUserList();

informMsg->message = msg->username + " entered chat.";

for (int i = 0; i < channels.count(); ++i)

{

informMsg->channelName = channels[i];

updateListMsg->channelName = channels[i];

ChatChannel channel = m_clientList.getChannel(channels[i]);

for(int k = 0; k < channel.userList.count(); k++)

{

//FIXME: GOVNOKOD

updateListMsg->userList.insert(channel.userList[k], getSendableState(channel.userList[k]));

}

for (int j = 0; j < channel.userList.count(); j++)

{

QString username = channel.userList[j];

if (username != msg->username)

{

sendMessageToClient(username, informMsg);

sendMessageToClient(username, updateListMsg);

}

}

}

delete updateListMsg;

delete informMsg;

}

delete answer;

//processing disconnect message from client

//that's simple

//we need only to delete client from client list

//and close his socket

//also we should reply disconnect fact in all client's channels

{

if (!msg)

{

QString log = "Error processing disconnect message - message is empty";

emit serverLog(esMinor, log);

return;

}

QString messageText = msg->sender + " was disconnected from server.";

emit serverLog(esNotify, messageText);

QStringList channels = m_clientList.getChannelsForClient(msg->sender).keys();

ChannelSystemMessage *inform = new ChannelSystemMessage();

ChannelUserList *list;

inform->message = msg->sender+ " leaved chat.";

m_clientList.disconnect(msg->sender);

for (int i = 0; i < channels.count(); ++i)

{

list = new ChannelUserList();

list->channelName = channels[i];

ChatChannel channel = m_clientList.getChannel(channels[i]);

for(int j = 0; j < channel.userList.count(); j++)

{

//FIXME: GOVNOKOD

list->userList.insert(channel.userList[j], getSendableState(channel.userList[j]));

}

sendMessageToChannel(channels[i], list);

delete list;

inform->channelName = channels[i];

sendMessageToChannel(channels[i], inform);

}

emit updateTable("clients");

delete inform;

//processing regisration message

//registration logic stored in clientList,

//we just call it and use results to send registration answer

{

if (!msg)

{

QString log = "Error processing registration request - message is empty";

emit serverLog(esMinor, log);

return;

}

RegistrationAnswer *answer = new RegistrationAnswer();

switch (m_clientList.registrate(msg->username, msg->password))

{

case GeneralClientList::rrOccupiedUsername:

{

answer->registrationResult = false;

answer->denialReason = "Username allready reserved, please choose another";

break;

}

case GeneralClientList::rrBadUsername:

{

answer->registrationResult = false;

answer->denialReason = "Your username isn't allowed";

break;

}

case GeneralClientList::rrRegSuccess:

{

answer->registrationResult = true;

emit updateTable("clients");

emit updateTable("membership");

break;

}

}

sendMessageToClient(socket, answer);

//

QString log = msg->username + ((answer->registrationResult) ? " was registered." : "wasn't registered");

emit serverLog(esNotify, log);

//

delete answer;

//new processMessage for ChannelListRequest

{

if (!msg)

{

QString log = "Error processing authorization request- message is empty";

emit serverLog(esMinor, log);

return;

}

ChannelListMessage *chanListMsg = new ChannelListMessage();

if(msg->listType == ChannelListRequest::listOfAll)

{

chanListMsg->listType = ChannelListMessage::listOfAll;

chanListMsg->channelList = m_clientList.getAllChanells();

sendMessageToClient(socket, chanListMsg);

}

else

{

chanListMsg->listType = ChannelListMessage::listOfJoined;

chanListMsg->channelList = m_clientList.getChannelsForClient(msg->nick);

sendMessageToClient(socket, chanListMsg);

ChannelUserList *userListMsg = new ChannelUserList();

ChannelThemeChanged *theme = new ChannelThemeChanged();

QMap<QString, QString>::iterator channel = chanListMsg->channelList.begin();

for(;channel != chanListMsg->channelList.end(); ++channel)

{

QString channelName = channel.key();

ChatChannel tempChannel = m_clientList.getChannel(channelName);

userListMsg->channelName = channel.key();

for(int i = 0; i < tempChannel.userList.count(); i++)

{

//FIXME: GOVNOKOD

userListMsg->userList.insert(tempChannel.userList[i], getSendableState(tempChannel.userList[i]));

}

theme->channel = channel.key();

theme->theme = m_clientList.getChannel(userListMsg->channelName).topic();

sendMessageToChannel(channel.key(), userListMsg);

sendMessageToClient(msg->nick, theme);

}

delete userListMsg;

delete theme;

UserInfoMessage *userInfo = new UserInfoMessage();

userInfo->username = msg->nick;

userInfo->info = m_clientList.getClient(msg->nick).userInfo();

sendMessageToClient(msg->nick, userInfo);

delete userInfo;

}

delete chanListMsg;

{

ChannelJoinResult *answer = new ChannelJoinResult();

if(m_clientList.hasChannel(msg->channelName) && !m_clientList.getChannel(msg->channelName).hasClient(msg->nick))

{

m_clientList.joinChannel(msg->nick, msg->channelName);

answer->result = true;

ChannelListMessage *listUpdate = new ChannelListMessage();

listUpdate->listType = ChannelListMessage::listOfJoined;

listUpdate->channelList = m_clientList.getChannelsForClient(msg->nick);

sendMessageToClient(msg->nick, listUpdate);

delete listUpdate;

ChannelSystemMessage *newmsg = new ChannelSystemMessage();

newmsg->message = msg->nick + " joined channel";

newmsg->channelName = msg->channelName;

sendMessageToChannel(msg->channelName, newmsg);

delete newmsg;

emit updateTable("membership");

ChannelUserList *list = new ChannelUserList();

list->channelName = msg->channelName;

ChatChannel tempChannel = m_clientList.getChannel(msg->channelName);

for(int i = 0; i < tempChannel.userList.count(); i++)

{

//FIXME: GOVNOKOD

list->userList.insert(tempChannel.userList[i], getSendableState(tempChannel.userList[i]));

}

sendMessageToChannel(msg->channelName, list);

delete list;

ChannelThemeChanged *theme = new ChannelThemeChanged();

theme->channel = msg->channelName;

theme->theme = m_clientList.getChannel(msg->channelName).topic();

sendMessageToClient(msg->nick, theme);

delete theme;

}

else

{

answer->result = false;

}

answer->channelName = msg->channelName;

sendMessageToClient(socket, answer);

delete answer;

{

if(m_clientList.getChannel(msg->channelName).hasClient(msg->nick))

{

//deleting user from channel

m_clientList.leaveChannel(msg->nick, msg->channelName);

//send message "user <tadada> left channel" to all remaining users in channel

ChannelSystemMessage *notifyMsg = new ChannelSystemMessage();

notifyMsg->message = msg->nick + " left channel";

notifyMsg->channelName = msg->channelName;

sendMessageToChannel(msg->channelName, notifyMsg);

//write a log about it

channelLog(msg->channelName, notifyMsg->message);

delete notifyMsg;

//update membership table

emit updateTable("membership");

//update userlists of all remaining users in channel

ChannelUserList *userListUpdateMsg = new ChannelUserList();

userListUpdateMsg->channelName = msg->channelName;

ChatChannel tempChannel = m_clientList.getChannel(msg->channelName);

for(int i = 0; i < tempChannel.userList.count(); i++)

{

//FIXME: GOVNOKOD

userListUpdateMsg->userList.insert(tempChannel.userList[i], getSendableState(tempChannel.userList[i]));

}

sendMessageToChannel(msg->channelName, userListUpdateMsg);

delete userListUpdateMsg;

}

{

ChannelCreateResult *result = new ChannelCreateResult();

switch (m_clientList.createChannel(msg->channelName,

msg->channelDescription,

msg->channelTopic))

{

case GeneralClientList::ccrTooManyChannels:

{

result->answer = false;

result->denialReason = "Too many channels already created on server.";

}

case GeneralClientList::ccrBadName:

{

result->answer = false;

result->denialReason = "Name of channel is already reserved";

}

case GeneralClientList::ccrSuccess:

{

result->answer = true;

}

}

sendMessageToClient(msg->username, result);

if (result->answer)

{

m_clientList.joinChannel(msg->username, msg->channelName);

ChannelListMessage *userListUpdate = new ChannelListMessage();

userListUpdate->listType = ChannelListMessage::listOfJoined;

userListUpdate->channelList = m_clientList.getChannelsForClient(msg->username);

sendMessageToClient(msg->username, userListUpdate);

delete userListUpdate;

ChannelListMessage *listUpdate = new ChannelListMessage();

listUpdate->listType = ChannelListMessage::listOfAll;

listUpdate->channelList = m_clientList.getAllChanells();

sendMessageToChannel("main", listUpdate);

delete listUpdate;

ChannelUserList *list = new ChannelUserList();

list->channelName = msg->channelName;

ChatChannel tempChannel = m_clientList.getChannel(msg->channelName);

for(int i = 0; i < tempChannel.userList.count(); i++)

{

//FIXME: GOVNOKOD

list->userList.insert(tempChannel.userList[i], getSendableState(tempChannel.userList[i]));

}

sendMessageToChannel(msg->channelName, list);

delete list;

ChannelThemeChanged *theme = new ChannelThemeChanged();

theme->channel = msg->channelName;

theme->theme = m_clientList.getChannel(msg->channelName).topic();

sendMessageToClient(msg->username, theme);

delete theme;

emit updateTable("channels");

emit updateTable("membership");

}

delete result;

{

QString channelName = msg->channel;

QString theme = msg->theme;

QString username = msg->username;

ChatChannel channel = m_clientList.getChannel(channelName);

channel.setTopic(theme);

m_clientList.updateChannel(channel);

sendMessageToChannel(channelName, msg);

ChannelSystemMessage *newmsg = new ChannelSystemMessage();

newmsg->channelName = channelName;

newmsg->message = QString("%1 changed channel theme to \"%2\"")

.arg(username)

.arg(theme);

emit channelLog(channelName, newmsg->message);

emit updateTable("channels");

sendMessageToChannel(channelName, newmsg);

delete newmsg;

{

QStringList list = m_clientList.getChannelsForClient(msg->username).keys();

QStringList::iterator itr = list.begin();

ChannelSystemMessage *system = new ChannelSystemMessage();

ChatClient client = m_clientList.getClient(msg->username);

if(msg->status.isEmpty())

{

system->message = msg->username + " returned to original state";

client.setUserState("Online");

}

else

{

client.setUserState(msg->status);

system->message = QString("%1 changed his state to \"%2\"")

.arg(msg->username)

.arg(msg->status);

}

m_clientList.updateClient(client);

emit updateTable("clients");

for(; itr != list.end(); ++itr)

{

system->channelName = *itr;

sendMessageToChannel(*itr, msg);

sendMessageToChannel(*itr, system);

emit channelLog(*itr, system->message);

}

delete system;

{

UserInfoMessage *answer = new UserInfoMessage();

answer->username = msg->username;

answer->info = m_clientList.getClient(msg->username).userInfo();

sendMessageToClient(socket, answer);

delete answer;

{

ChatClient client = m_clientList.getClient(msg->username);

client.setUserInfo(msg->info);

m_clientList.updateClient(client);

QString log = "User " + msg->username + " changed his info";

emit updateTable("clients");

emit serverLog(esNotify, log);

{

PasswordChangeResult *answer = new PasswordChangeResult;

ChatClient client = m_clientList.getClient(msg->username);

QString log;

if(client.password() == msg->oldPassword)

{

client.setPassword(msg->newPassword);

m_clientList.updateClient(client);

answer->result = "Password changed!\nDon't forget to use new password in the next authorization.";

log = "User " + msg->username + " changed his password";

emit updateTable("clients");

}

else

{

answer->result = "Given old password is incorrect!";

log = "User " + msg->username + " tried to change his password. Unfortunately, unsuccessfull.";

}

emit serverLog(esNotify, log);

sendMessageToClient(msg->username, answer);

//packing and sending allready formed message to authorized client

{

QTcpSocket *socket = m_clientList.getClient(username).userSocket();

QByteArray arrBlock;

QDataStream output(&arrBlock, QIODevice::WriteOnly);

output.setVersion(QDataStream::Qt_4_7);

output << quint16(0);

ChatMessageHeader *header = new ChatMessageHeader(msgBody);

header->pack(output);

msgBody->pack(output);

delete header;

output.device()->seek(0);

output << quint16(arrBlock.size() - sizeof(quint16));

socket->write(arrBlock);

//send message to client by his socket

//needed to send messages to non-authorized clients

//for example - registration answer

{

QByteArray arrBlock;

QDataStream output(&arrBlock, QIODevice::WriteOnly);

output.setVersion(QDataStream::Qt_4_7);

output << quint16(0);

ChatMessageHeader *header = new ChatMessageHeader(msgBody);

header->pack(output);

msgBody->pack(output);

delete header;

output.device()->seek(0);

output << quint16(arrBlock.size() - sizeof(quint16));

socket->write(arrBlock);

//send message *msgBody to all clients, which are in channel <channelName>

//needed for replying channel and other messages for all channel

{

if (!m_clientList.hasChannel(channelName))

return;

/*QByteArray arrBlock;

QDataStream output(&arrBlock, QIODevice::WriteOnly);

output.setVersion(QDataStream::Qt_4_7);

output << quint16(0);

ChatMessageHeader *header = new ChatMessageHeader(msgBody);

header->pack(output);

msgBody->pack(output);

delete header;

output << quint16(arrBlock.size() - sizeof(quint16));*/

ChatChannel channel = m_clientList.getChannel(channelName);

for (int i = 0; i < channel.userList.count(); i++)

{

sendMessageToClient(channel.userList[i], msgBody);

/*channel.userList[i]->userSocket()->write(arrBlock);*/

}

{

QString state = m_clientList.getClient(clientName).userState();

return (state == "Online") ? "" : state;