initial import of latest svn version

1 files changed, 301 insertions, 0 deletions

diff --git a/src/core/pvsClient.cpp b/src/core/pvsClient.cpp
new file mode 100644
index 0000000..0d08b1d
--- /dev/null
+++ b/src/core/pvsClient.cpp
@@ -0,0 +1,301 @@
+/*
+# Copyright (c) 2009 - OpenSLX Project, Computer Center University of Freiburg
+#
+# This program is free software distributed under the GPL version 2.
+# See http://openslx.org/COPYING
+#
+# If you have any feedback please consult http://openslx.org/feedback and
+# send your suggestions, praise, or complaints to feedback@openslx.org
+#
+# General information about OpenSLX can be found at http://openslx.org/
+# -----------------------------------------------------------------------------
+# src/core/pvsConnection.cpp
+#    - ...
+# -----------------------------------------------------------------------------
+*/
+
+#include "pvsClient.h"
+#include "pvsServer.h"
+#include "pvsConnectionManager.h"
+#include "src/util/consoleLogger.h"
+#include "src/core/vncConnection.h"
+#include "src/gui/mainWindow.h"
+
+#define CONST_PASS ""
+
+PVSClient::PVSClient(PVSClientConnection *newClient)
+{
+    newClient->setParent(this); // so the object will be deleted when this object dies
+    _pvsClientConnection = newClient;
+    _vncConnection = NULL;
+    _vncRwPasswordReceived = _vncPasswordReceived = _vncAllowed = false;
+    _vncInitMutex = false;
+    _hostString = newClient->getAddress();
+    _hostName = _hostString; // for now
+    //_gotFrame = false;
+    _vncPort = -1;
+    _vncProject = false;
+    _connectionFrame = NULL;
+    _loginName = "unseted";
+}
+
+PVSClient::~PVSClient()
+{
+    if (_vncConnection)
+    {
+    	disconnect(_vncConnection, SIGNAL(finished()), this, SLOT(vncFinished()));
+        _vncConnection->clear();
+        delete _vncConnection;
+        _vncConnection = NULL;
+    }
+}
+
+/* TODO: Call this method from an extra thread.
+ * Imo there should be one thread (probably in ConnectionManager) that does this job.
+ * Also, this function should just receive the data etc, but the actual drawing has to happen
+ * in the Qt main thread (the thread the window belongs to)
+ * Right now with GTK it would, but pay attention when switching to Qt
+ * */
+
+void PVSClient::tick()
+{
+    if (_vncInitMutex) return;
+	if (_vncPasswordReceived && _vncAllowed && _vncRequested && _vncConnection == NULL)
+	{
+		vncProbe();
+	}
+}
+
+QString PVSClient::getIp()
+{
+    return _hostString;
+}
+
+QString PVSClient::getDesktopName()
+{
+    if (_vncConnection)
+    {
+        return _vncConnection->getDesktopName();
+    }
+
+    return _hostName;
+}
+
+QString PVSClient::getUserName()
+{
+    return _userName;
+}
+
+QString PVSClient::getLoginName()
+{
+	return _loginName;
+}
+
+//Returns Port
+int PVSClient::getPort(){
+	return _vncPort;
+}
+
+
+bool PVSClient::getVNCAllowed()
+{
+	return _vncAllowed;
+}
+
+void PVSClient::requestVNCConnect()
+{
+    _vncRequested = true;
+    _pvsClientConnection->push_back_send(PVSMsg(PVSCOMMAND, "VNCREQUEST", "YES"));
+}
+
+void PVSClient::setVncPassword(QString password)
+{
+    _vncPassword = password;
+    _vncPasswordReceived = true;
+}
+
+void PVSClient::setVncRwPassword(QString password)
+{
+    _vncRwPassword = password;
+    _vncRwPasswordReceived = true;
+}
+
+QString PVSClient::getPassword()
+{
+    return _vncPassword;
+}
+
+QString PVSClient::getRWPassword()
+{
+    return _vncRwPassword;
+}
+
+void PVSClient::setProject(bool value)
+{
+	_vncProject = value;
+
+}
+
+void PVSClient::setVncPort(int newPort)
+{
+    if (newPort < 1)
+    {
+        ConsoleLog writeNetwork("Client sent invalid vnc-port.");
+        return;
+    }
+    _vncPort = newPort;
+    ConsoleLog writeNetwork(QString("Received new vnc-port: ").append(int2String(newPort)));
+}
+void PVSClient::setAllowed(bool allow)
+{
+    _vncAllowed = allow;
+
+    if (allow)
+    {
+        ConsoleLog writeLine(QString("VNCConnection was granted by the Client."));
+        _vncRequested = true;
+    }
+    else
+    {
+        ConsoleLog writeLine(QString("VNCConnection was denied by the Client."));
+        _vncPort = 0;
+        _vncPasswordReceived = false;
+    }
+
+    if(_vncProject){
+    	if(allow){
+    		MainWindow::getConnectionWindow()->projectStations(_hostString);
+    	}
+    	else{
+    		_vncProject = false;
+    	}
+    }
+}
+
+void PVSClient::shutDownVNC()
+{
+    if (_vncConnection)
+    {
+    	disconnect(_vncConnection, SIGNAL(finished()), this, SLOT(vncFinished()));
+        _vncConnection->clear();
+        delete _vncConnection;
+        _vncConnection = NULL;
+    }
+}
+
+void PVSClient::shutDownClient()
+{
+    if (_pvsClientConnection)
+    {
+        _pvsClientConnection->closeConnection();
+    }
+}
+
+void PVSClient::onClientDisconnected()
+{
+    _pvsClientConnection = NULL;
+
+}
+
+bool PVSClient::getLocked()
+{
+    // TODO: Implement!
+	// Previously "_pvsClientConnection->isLocked()" war returned,
+	// but that method always returned "false" and was removed now.
+	// It really didn't make any sense to put that there anyways, it has
+	// to be taken care of in this class.
+	return false;
+}
+
+
+bool PVSClient::sendMessage(PVSMsgType type, QString ident, QString message)
+{
+    if (_pvsClientConnection)
+    {
+        _pvsClientConnection->push_back_send(PVSMsg(type, (char*)ident.toUtf8().data(), message));
+        return true;
+    }
+    return false;
+}
+
+bool PVSClient::sendMessage(PVSMsg message)
+{
+    if (_pvsClientConnection)
+    {
+        _pvsClientConnection->push_back_send(message);
+        return true;
+    }
+    return false;
+}
+
+void PVSClient::vncProbe()
+{
+    _vncInitMutex = true;
+    if (_vncPasswordReceived && _vncAllowed && _vncRequested)
+    {
+#ifndef local_test
+        QString portString;
+        if (_vncPort > 0)
+        {
+            portString = int2String(_vncPort);
+        }
+        else
+        {
+            portString = int2String(5900); //std port
+            ConsoleLog writeError("WARNING: Using default vnc-port 5900");
+        }
+#else
+        QString portString;
+        portString = int2String(5900);
+#endif
+
+        if (_hostString.length() > 0)
+        {
+			char ** args = new char*[1];
+			QString fullstring(_hostString);
+			fullstring.append(":");
+			fullstring.append(portString);
+			args[0] = new char[fullstring.length()+1];
+			std::cout << "[pvsC]connecting to: " << fullstring.toStdString() << std::endl;
+			ConsoleLog writeNetwork(QString("connecting to: ").append(fullstring));
+			//strcpy(args[0], host);
+			strcpy(args[0], fullstring.toUtf8().data());
+			VNCConnectInfo tmpInfo(1, args, _vncPassword);
+
+            VNCConnection* newConnection = new VNCConnection(tmpInfo.getPassword());
+            if (newConnection)
+            {
+                if (newConnection->initClient(&tmpInfo))
+                {
+                    _vncProject = false;
+                    if (_vncConnection) _vncConnection->setDead();
+                    _vncConnection = newConnection;
+                    connect(_vncConnection, SIGNAL(finished()), this, SLOT(vncFinished()));
+                    //TODO: comment beachten !!!!!
+                    //vncAllowed = false; // to make sure we recheck if the allowance wasnt revoked in the meantime to prevent
+                    // another connection
+                    ConsoleLog writeLine(QString("VNC connection attempt succeeded."));
+                    MainWindow::getWindow()->getConnectionWindow()->onVNCAdd(this);
+                }
+                else
+                {
+                    delete newConnection;
+                    // TODO: post on the log console
+                    ConsoleLog writeError(QString("VNC connection attempt failed."));
+                    _vncRequested = false; // otherwise loop of death
+                }
+            }
+        }
+    }
+    _vncInitMutex = false;
+}
+
+void PVSClient::vncFinished()
+{
+	disconnect(_vncConnection, SIGNAL(finished()), this, SLOT(vncFinished()));
+	delete _vncConnection;
+	_vncConnection = NULL;
+	_vncPort = 0;
+	_vncPasswordReceived = false;
+}
+