summaryrefslogtreecommitdiff
path: root/LocalListener.cpp
blob: d76b50501fbc42cfd2cc227d39b6e570df65984e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
/** \file LocalListener.cpp
\brief The have local server, to have unique instance, and send arguments to the current running instance
\author alpha_one_x86
\version 0.3
\date 2010
\licence GPL3, see the file COPYING */

#include "LocalListener.h"

LocalListener::LocalListener(QObject *parent) :
    QObject(parent)
{
	//for detect the timeout on QLocalSocket
	TimeOutQLocalSocket.setInterval(500);
	TimeOutQLocalSocket.setSingleShot(true);
	connect(&TimeOutQLocalSocket, SIGNAL(timeout()), this, SLOT(timeoutDectected()));
}

LocalListener::~LocalListener()
{
	if(localServer.isListening())
	{
		localServer.close();
		if(!QLocalServer::removeServer(ExtraSocket::pathSocket(ULTRACOPIER_SOCKETNAME)))
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,QString("Unable to remove the listening server"));
	}
}

bool LocalListener::tryConnect()
{
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"start");
	QStringList ultracopierArguments=QCoreApplication::arguments();
	//remove excutable path because is useless (unsafe to use)
	ultracopierArguments.removeFirst();
	//add the current path to file full path resolution if needed
	ultracopierArguments.insert(0,QFSFileEngine::currentPath());
	QLocalSocket localSocket;
	localSocket.connectToServer(ExtraSocket::pathSocket(ULTRACOPIER_SOCKETNAME),QIODevice::WriteOnly);
	if(localSocket.waitForConnected(1000))
	{
		if(!localSocket.isValid())
		{
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"localSocket is not valid!");
			return false;
		}
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Information,"connection succes, number arguments given: "+QString::number(ultracopierArguments.size()));
		#ifdef ULTRACOPIER_DEBUG
		for (int i = 0; i < ultracopierArguments.size(); ++i) {
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Information,"argument["+QString::number(i)+"]: "+ultracopierArguments.at(i));
		}
		#endif // ULTRACOPIER_DEBUG
		//cut string list and send it as block of 32KB
		QByteArray block;
		QDataStream out(&block, QIODevice::WriteOnly);
		//for total size
		out << int(0);
		//send the arguments
		out << ultracopierArguments;
		//write the size content
		out.device()->seek(0);
		out << block.size();
		do
		{
			QByteArray blockToSend;
			int byteWriten;
			blockToSend=block.left(32*1024);//32KB
			block.remove(0,blockToSend.size());
			byteWriten = localSocket.write(blockToSend);
			#ifdef ULTRACOPIER_DEBUG
			if(!localSocket.isValid())
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"localSocket is not valid!");
			if(localSocket.errorString()!="Unknown error" && localSocket.errorString()!="")
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"localSocket->errorString(): "+localSocket.errorString());
			if(blockToSend.size()!=byteWriten)
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"blockToSend("+QString::number(blockToSend.size())+")!=byteWriten("+QString::number(byteWriten)+")");
			#endif // ULTRACOPIER_DEBUG
			if(localSocket.waitForBytesWritten(200))
			{
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"Block send correctly");
			}
			else
			{
				QMessageBox::critical(NULL,"Alert","No arguments send because timeout detected!");
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Critical,"Block not send correctly");
			}
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"blockToSend: "+QString(blockToSend.toHex()));
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"byteWriten: "+QString::number(byteWriten)+", size sending: "+QString::number(blockToSend.size()));
		}
		while(block.size());
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"disconnect the socket");
		localSocket.disconnectFromServer();
		return true;
	}
	else
	{
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"connection failed, continu...");
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"ultracopierArguments: "+ultracopierArguments.join(";"));
		emit cli(ultracopierArguments,false);
		return false;
	}
}

/// the listen server
void LocalListener::listenServer()
{
	if(!QLocalServer::removeServer(ExtraSocket::pathSocket(ULTRACOPIER_SOCKETNAME)))
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,QString("Unable to remove the listening server"));
	if(!localServer.listen(ExtraSocket::pathSocket(ULTRACOPIER_SOCKETNAME)))
	{
		QMessageBox::critical(NULL,"Alert",QString("Ultracopier have not able to lock unique instance: %1").arg(localServer.errorString()));
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,QString("Ultracopier have not able to lock unique instance: %1").arg(localServer.errorString()));
	}
	else
		connect(&localServer, SIGNAL(newConnection()), this, SLOT(newConnexion()));
}

//the time is done
void LocalListener::timeoutDectected()
{
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"start");
	while(clientList.size()>0)
	{
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"clientList.first().size: "+QString::number(clientList.first().size));
		clientList.removeFirst();
	}
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"Timeout while recomposing data from connected clients");
	QMessageBox::warning(NULL,tr("Warning"),tr("Timeout while recomposing data from connected clients"));
}

/// \brief Data is incomming
void LocalListener::dataIncomming()
{
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Information,"start");
	// 1 : we get packets from client

	//Which client send the message (Search of the QLocalSocket of client)
	QLocalSocket *socket = qobject_cast<QLocalSocket *>(sender());
	if (socket == 0) // If not found
	{
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"bad socket");
		return;
	}

	int index=-1;
	for (int i=0;i<clientList.size(); ++i) {
		if(clientList.at(i).socket==socket)
			index=i;
	}
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"socket->bytesAvailable() "+QString::number(socket->bytesAvailable()));
	if(index!=-1)
	{
		if(!clientList.at(index).haveData)
		{
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"tempComposed index found, but no have data, create new entry");
			// If all is ok we get the message
			QDataStream in(socket);
			in.setVersion(QDataStream::Qt_4_4);

			if (socket->bytesAvailable() < (int)sizeof(quint32)*2) // We have not receveive all the message, ignore because first int is cuted!
			{
				/*socket->readAll();
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"wrong size for set the message size");*/
				return;
			}
			in >> clientList[index].size; // Store the size of the message
			clientList[index].size-=sizeof(int);

			// Check if all the message size is the same as the size given
			if(socket->bytesAvailable() < clientList.at(index).size) // If not all get then stop it
			{
				clientList[index].haveData=true;
				clientList[index].data.append(socket->readAll());
				TimeOutQLocalSocket.start();
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"Need wait to recomposite: "+QString::number(clientList.at(index).data.size())+", targeted: "+QString::number(clientList.at(index).size));
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"tempComposed.data: "+QString(clientList.at(index).data.toHex()));
			}
			else if(socket->bytesAvailable() == clientList.at(index).size) //if the size match
			{
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"socket->bytesAvailable(): "+QString::number(socket->bytesAvailable())+", for total of: "+QString::number(socket->bytesAvailable()+sizeof(quint32)));
				QStringList ultracopierArguments;
				in >> ultracopierArguments;
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"ultracopierArguments: "+ultracopierArguments.join(";"));
				emit cli(ultracopierArguments,true);
				clientList[index].data.clear();
				clientList[index].haveData=false;
			}
			else
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"socket->bytesAvailable(): "+QString::number(socket->bytesAvailable())+" > clientList.at(index).size!: "+QString::number(clientList.at(index).size));
		}
		else
		{
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"Query recomposed with this size: "+QString::number(clientList.at(index).data.size()));
			clientList[index].data.append(socket->readAll());
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"Query recomposed with this size: "+QString::number(clientList.at(index).data.size()));
			if(clientList.at(index).data.size()==clientList.at(index).size)
			{
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Information,"QByteArray reconstruction finished");
				QDataStream in(clientList.at(index).data);
				QStringList ultracopierArguments;
				in >> ultracopierArguments;
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"ultracopierArguments: "+ultracopierArguments.join(";"));
				emit cli(ultracopierArguments,true);
				clientList[index].data.clear();
				clientList[index].haveData=false;
			}
			else
			{
				TimeOutQLocalSocket.start();
				ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"Need wait to recomposite: "+QString::number(clientList.at(index).data.size())+", targeted: "+QString::number(clientList.at(index).size));
				return;
			}
		}
	}
	else
		ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"Socket not found???");
}

/// \brief Deconnexion client
/// \todo Remove the data in wait linker with this socket
void LocalListener::deconnectClient()
{
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"start");

	// Wich client leave
	QLocalSocket *socket = qobject_cast<QLocalSocket *>(sender());
	if (socket == 0) // If not found
		return;
	for (int i = 0; i < clientList.size(); ++i) {
		if(clientList.at(i).socket==socket)
			clientList.removeAt(i);
	}
	socket->deleteLater();
}

/// LocalListener New connexion
void LocalListener::newConnexion()
{
	ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Information,"start");
	composedData newClient;
	newClient.socket = localServer.nextPendingConnection();
	#ifdef ULTRACOPIER_DEBUG
	connect(newClient.socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(error(QLocalSocket::LocalSocketError)));
	#endif
	connect(newClient.socket, SIGNAL(readyRead()), this, SLOT(dataIncomming()));
	connect(newClient.socket, SIGNAL(disconnected()), this, SLOT(deconnectClient()));
	newClient.size=-1;
	newClient.haveData=false;
	clientList << newClient;
}

#ifdef ULTRACOPIER_DEBUG
/** \brief If error occured at socket
\param theErrorDefine The error define */
void LocalListener::error(QLocalSocket::LocalSocketError theErrorDefine)
{
	if(theErrorDefine!=QLocalSocket::PeerClosedError)
	{
		QLocalSocket *client=qobject_cast<QLocalSocket *>(QObject::sender());
		if(client!=NULL)
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"Value:"+QString::number(theErrorDefine)+", Error message: "+client->errorString());
		else
			ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"Value:"+QString::number(theErrorDefine));
	}
}
#endif