Merge pull request #24 from domoticz/master

szczukot · web-flow · commit 92ac09ea9195 · 2016-08-03T18:56:36.000+02:00
merge
diff --git a/hardware/Kodi.cpp b/hardware/Kodi.cpp
@@ -400,12 +400,12 @@ void CKodiNode::handleMessage(std::string& pMessage)
 								bCanShutdown = root["result"]["canshutdown"].asBool();
 								if (bCanShutdown) sAction = "Shutdown";
 							}
-							if (root["result"].isMember("canhibernate"))
+							if (root["result"].isMember("canhibernate") && sAction != "Nothing")
 							{
 								bCanHibernate = root["result"]["canhibernate"].asBool();
 								if (bCanHibernate) sAction = "Hibernate";
 							}
-							if (root["result"].isMember("cansuspend"))
+							if (root["result"].isMember("cansuspend")&& sAction != "Nothing")
 							{
 								bCanSuspend = root["result"]["cansuspend"].asBool();
 								if (bCanSuspend) sAction = "Suspend";
diff --git a/main/EventSystem.cpp b/main/EventSystem.cpp
@@ -2237,7 +2237,8 @@ void CEventSystem::EvaluatePython(const std::string &reason, const std::string &
 		else
 			_log.Log(LOG_ERROR, "%s",formatted_str.c_str());
 	}
-	fclose(PythonScriptFile);
+	if (PythonScriptFile!=NULL)
+		fclose(PythonScriptFile);
 	//Py_Finalize();
 }
 #endif // ENABLE_PYTHON
diff --git a/main/WebServerHelper.cpp b/main/WebServerHelper.cpp
@@ -7,7 +7,7 @@ namespace http {
 
 		typedef std::vector<CWebServer*>::iterator server_iterator;
 #ifndef NOCLOUD
-		typedef std::vector<CProxyManager*>::iterator proxy_iterator;
+		typedef std::vector<boost::shared_ptr<CProxyManager> >::iterator proxy_iterator;
 		extern CProxySharedData sharedData;
 #endif
 
@@ -70,8 +70,7 @@ namespace http {
 
 #ifndef NOCLOUD
 			for (proxy_iterator it = proxymanagerCollection.begin(); it != proxymanagerCollection.end(); ++it) {
-				((CProxyManager*) *it)->Stop();
-				if (*it) delete (*it);
+				(*it)->Stop();
 			}
 			proxymanagerCollection.clear();
 #endif
@@ -82,14 +81,13 @@ namespace http {
 			sharedData.StopTCPClients();
 			for (proxy_iterator it = proxymanagerCollection.begin(); it != proxymanagerCollection.end(); ++it) {
 				(*it)->Stop();
-				delete (*it);
 			}
 
 			// restart threads
 			const unsigned int connections = GetNrMyDomoticzThreads();
-			proxymanagerCollection.resize(connections);
+			proxymanagerCollection.clear();
 			for (unsigned int i = 0; i < connections; i++) {
-				proxymanagerCollection[i] = new CProxyManager(our_serverpath, plainServer_->m_pWebEm, m_pDomServ);
+				proxymanagerCollection.push_back(boost::shared_ptr<CProxyManager>(new CProxyManager(our_serverpath, plainServer_->m_pWebEm, m_pDomServ)));
 				proxymanagerCollection[i]->Start(i == 0);
 			}
 			_log.Log(LOG_STATUS, "Proxymanager started.");
diff --git a/main/WebServerHelper.h b/main/WebServerHelper.h
@@ -56,7 +56,7 @@ namespace http {
 
 			std::string our_serverpath;
 #ifndef NOCLOUD
-			std::vector<CProxyManager*> proxymanagerCollection;
+			std::vector<boost::shared_ptr<CProxyManager> > proxymanagerCollection;
 			int GetNrMyDomoticzThreads();
 
 #endif
diff --git a/scripts/templates/All.Python b/scripts/templates/All.Python
@@ -74,5 +74,5 @@ for name, device in domoticz.devices.items():
   if device.is_off():
       domoticz.log("could turn it on in 3 seconds")
       #device.on(after=3)
-for name, value in user_variables:
+for name, value in user_variables.items():
   domoticz.log("var", name, "has value", value)
diff --git a/webserver/proxyclient.cpp b/webserver/proxyclient.cpp
@@ -27,7 +27,7 @@ namespace http {
 		CProxySharedData sharedData;
 
 		CProxyClient::CProxyClient(boost::asio::io_service& io_service, boost::asio::ssl::context& context, http::server::cWebem *webEm)
-			: _socket(io_service, context),
+			: _context(context),
 			_io_service(io_service),
 			doStop(false),
 			b_Connected(false),
@@ -49,6 +49,7 @@ namespace http {
 			}
 			m_pWebEm = webEm;
 			m_pDomServ = NULL;
+			_socket.reset(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(_io_service, _context));
 		}
 
 		void CProxyClient::WriteSlaveData(const std::string &token, const char *pData, size_t Length)
@@ -75,10 +76,7 @@ namespace http {
 
 		void CProxyClient::Reconnect()
 		{
-
-			std::string address = "my.domoticz.com";
-			std::string port = "9999";
-
+			b_Connected = false;
 			if (we_locked_prefs_mutex) {
 				// avoid deadlock if we got a read or write error in between handle_handshake() and HandleAuthresp()
 				we_locked_prefs_mutex = false;
@@ -87,41 +85,57 @@ namespace http {
 			if (doStop) {
 				return;
 			}
-			if (b_Connected) {
-				_socket.lowest_layer().close();
+			if (_socket->lowest_layer().is_open()) {
+				boost::system::error_code ec;
+				_socket->lowest_layer().cancel(ec);
+				_socket->lowest_layer().shutdown(boost::asio::socket_base::shutdown_both, ec);
+				_socket->lowest_layer().close(ec);
 			}
-			sleep_seconds(15);
-			b_Connected = false;
+			timer_.expires_from_now(boost::posix_time::seconds(15));
+			timer_.async_wait(boost::bind(&CProxyClient::ContinueConnect, shared_from_this(), boost::asio::placeholders::error));
+		}
+
+		void CProxyClient::ContinueConnect(const boost::system::error_code& error)
+		{
+			std::string address = "my.domoticz.com";
+			std::string port = "9999";
+
+			_socket.reset(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(_io_service, _context));
+			// set timeout timer
+			timer_.expires_from_now(boost::posix_time::seconds(timeout_));
+			timer_.async_wait(boost::bind(&CProxyClient::handle_timeout, shared_from_this(), boost::asio::placeholders::error));
 			boost::asio::ip::tcp::resolver resolver(_io_service);
 			boost::asio::ip::tcp::resolver::query query(address, port);
 			boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
 			boost::asio::ip::tcp::endpoint endpoint = *iterator;
-			_socket.lowest_layer().async_connect(endpoint,
+			_socket->lowest_layer().async_connect(endpoint,
 				boost::bind(&CProxyClient::handle_connect, shared_from_this(),
 					boost::asio::placeholders::error, iterator));
 		}
 
 		void CProxyClient::handle_connect(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
 		{
+			if (doStop) {
+				return;
+			}
 			if (!error)
 			{
-				_socket.async_handshake(boost::asio::ssl::stream_base::client,
+				_socket->async_handshake(boost::asio::ssl::stream_base::client,
 					boost::bind(&CProxyClient::handle_handshake, shared_from_this(),
 						boost::asio::placeholders::error));
 			}
-			else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
+		else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
 			{
-				_socket.lowest_layer().close();
+				_socket->lowest_layer().close();
 				boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
-				_socket.lowest_layer().async_connect(endpoint,
+				_socket->lowest_layer().async_connect(endpoint,
 					boost::bind(&CProxyClient::handle_connect, shared_from_this(),
 						boost::asio::placeholders::error, ++endpoint_iterator));
 			}
 			else
 			{
 				if (!doStop) {
 					_log.Log(LOG_ERROR, "PROXY: Connect failed, reconnecting: %s", error.message().c_str());
-					b_Connected = true; // signal re-connect
 					Reconnect();
 				}
 			}
@@ -131,12 +145,15 @@ namespace http {
 		{
 			if (error != boost::asio::error::operation_aborted) {
 				_log.Log(LOG_ERROR, "PROXY: timeout occurred, reconnecting");
-				_socket.lowest_layer().close(); // should induce a reconnect in handle_read with error != 0
+				Reconnect();
 			}
 		}
 
 		void CProxyClient::handle_write(const boost::system::error_code& error, size_t bytes_transferred)
 		{
+			if (doStop) {
+				return;
+			}
 			boost::unique_lock<boost::mutex>(writeMutex);
 			if (bytes_transferred < writePdu->length()) {
 				_log.Log(LOG_ERROR, "PROXY: Only wrote %ld of %ld bytes.", bytes_transferred, writePdu->length());
@@ -158,7 +175,7 @@ namespace http {
 			writePdu = pdu;
 			_writebuf.clear(); // make sure
 			_writebuf.push_back(boost::asio::buffer(writePdu->content(), writePdu->length()));
-			boost::asio::async_write(_socket, _writebuf, boost::bind(&CProxyClient::handle_write, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
+			boost::asio::async_write(*_socket, _writebuf, boost::bind(&CProxyClient::handle_write, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
 		}
 
 		void CProxyClient::MyWrite(pdu_type type, CValueLengthPart &parameters)
@@ -197,6 +214,9 @@ namespace http {
 
 		void CProxyClient::handle_handshake(const boost::system::error_code& error)
 		{
+			if (doStop) {
+				return;
+			}
 			if (!error)
 			{
 				// lock until we have a valid api id
@@ -209,10 +229,8 @@ namespace http {
 			}
 			else
 			{
-				if (!doStop) {
-					_log.Log(LOG_ERROR, "PROXY: Handshake failed, reconnecting: %s", error.message().c_str());
-					Reconnect();
-				}
+				_log.Log(LOG_ERROR, "PROXY: Handshake failed, reconnecting: %s", error.message().c_str());
+				Reconnect();
 			}
 		}
 
@@ -225,7 +243,7 @@ namespace http {
 			timer_.expires_from_now(boost::posix_time::seconds(timeout_));
 			timer_.async_wait(boost::bind(&CProxyClient::handle_timeout, shared_from_this(), boost::asio::placeholders::error));
 
-			_socket.async_read_some(buf,
+			_socket->async_read_some(buf,
 				boost::bind(&CProxyClient::handle_read, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)
 				);
 		}
@@ -529,6 +547,9 @@ namespace http {
 		void CProxyClient::handle_read(const boost::system::error_code& error, size_t bytes_transferred)
 		{
 			// data read, no need for timeouts anymore
+			if (!b_Connected || doStop) {
+				return;
+			}
 			timer_.cancel();
 			if (!error)
 			{
@@ -560,14 +581,17 @@ namespace http {
 
 		void CProxyClient::Stop()
 		{
+			timer_.cancel(); // to be sure
 			if (we_locked_prefs_mutex) {
 				we_locked_prefs_mutex = false;
 				sharedData.UnlockPrefsMutex();
 			}
 
 			doStop = true;
 			// signal end of WriteThread
-			_socket.lowest_layer().close();
+			boost::system::error_code ec;
+			_socket->shutdown(ec);
+			_socket->lowest_layer().close(ec);
 		}
 
 		void CProxyClient::SetSharedServer(tcp::server::CTCPServerProxied *domserv)
@@ -581,6 +605,7 @@ namespace http {
 
 		CProxyManager::CProxyManager(const std::string& doc_root, http::server::cWebem *webEm, tcp::server::CTCPServer *domServ)
 		{
+			m_pDocRoot = doc_root;
 			m_pWebEm = webEm;
 			m_pDomServ = domServ;
 			m_thread = NULL;
@@ -590,14 +615,14 @@ namespace http {
 		CProxyManager::~CProxyManager()
 		{
 			if (m_thread) {
-				m_thread->join();
+				delete m_thread;
 			}
 		}
 
 		int CProxyManager::Start(bool first)
 		{
 			_first = first;
-			m_thread = new boost::thread(boost::bind(&CProxyManager::StartThread, this));
+			m_thread = new boost::thread(boost::bind(&CProxyManager::StartThread, shared_from_this()));
 			return 1;
 		}
 
@@ -624,10 +649,11 @@ namespace http {
 
 		void CProxyManager::Stop()
 		{
-			proxyclient->Stop();
-			io_service.stop();
-			m_thread->interrupt();
-			m_thread->join();
+			if (m_thread) {
+				io_service.post(boost::bind(&CProxyClient::Stop, proxyclient));
+				delete m_thread;
+				m_thread = NULL;
+			}
 		}
 
 		boost::shared_ptr<CProxyClient> CProxyManager::GetProxyForMaster(DomoticzTCP *master) {
diff --git a/webserver/proxyclient.h b/webserver/proxyclient.h
@@ -38,6 +38,7 @@ namespace http {
 			~CProxyClient();
 
 			void Reconnect();
+			void ContinueConnect(const boost::system::error_code& error);
 			void Stop();
 			void WriteMasterData(const std::string &token, const char *pData, size_t Length);
 			void WriteSlaveData(const std::string &token, const char *pData, size_t Length);
@@ -84,11 +85,12 @@ namespace http {
 
 			int _allowed_subsystems;
 			std::string GetResponseHeaders(const http::server::reply &reply_);
-			boost::asio::ssl::stream<boost::asio::ip::tcp::socket> _socket;
+			boost::shared_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket> > _socket;
 			std::string _apikey;
 			std::string _password;
 			boost::asio::streambuf _readbuf;
 			boost::asio::io_service& _io_service;
+			boost::asio::ssl::context& _context;
 			bool doStop;
 			http::server::cWebem *m_pWebEm;
 			tcp::server::CTCPServerProxied *m_pDomServ;
@@ -104,7 +106,7 @@ namespace http {
 			std::queue<ProxyPdu *> writeQ;
 		};
 
-		class CProxyManager {
+		class CProxyManager : public boost::enable_shared_from_this<CProxyManager> {
 		public:
 			CProxyManager(const std::string& doc_root, http::server::cWebem *webEm, tcp::server::CTCPServer *domServ);
 			~CProxyManager();
@@ -116,6 +118,7 @@ namespace http {
 			boost::asio::io_service io_service;
 			boost::shared_ptr<CProxyClient> proxyclient;
 			boost::thread* m_thread;
+			std::string m_pDocRoot;
 			http::server::cWebem *m_pWebEm;
 			tcp::server::CTCPServer *m_pDomServ;
 			bool _first;
diff --git a/www/index.html b/www/index.html
@@ -1481,7 +1481,7 @@ <h1 id="theader" data-i18n="Usage this Year">Usage this Year</h1>
                                     <li class="divider"></li>
                                     <li ng-class="{'current_page_item':getClass('/Log')}" id="mLog"><a id="cLog" href="#Log"><img src="images/log.png"> <span data-i18n="Log">Log</span></a></li>
                                     <li class="divider"></li>
-                                    <li ng-class="{'current_page_item':getClass('/About')}" id="mAbout"><a id="cLog" href="#About"><img src="images/about.png"> <span data-i18n="About">About</span></a></li>
+                                    <li ng-class="{'current_page_item':getClass('/About')}" id="mAbout"><a id="cAbout" href="#About"><img src="images/about.png"> <span data-i18n="About">About</span></a></li>
                                     <li id="dLogoutSetup" class="divider" style="display: none;" has-Login=true></li>
 									<li id="mLogoutSetup" style="display: none;" has-Login=true><a id="cLogout" href="#Logout"><img src="images/logout.png"> <span data-i18n="Logout">Logout</span></a></li>
                                 </ul>
diff --git a/www/zwavetopology.html b/www/zwavetopology.html
@@ -66,7 +66,7 @@
 					+ '<br>On node ' + getNodeName(node)), function(result) {
 				if (result==true) {
 					$.ajax({
-						 url: "json.htm?type=command&param=zwaveremovegroupnode&idx=" + hwid + "&node=" + node.nodeID + "&group=" + group.id + "&removeNode=" + removeNode,
+						 url: "json.htm?type=command&param=zwaveremovegroupnode&idx=" + hwid + "&node=" + node.nodeID + "&group=" + group.id + "&removenode=" + removeNodeId,
 						 async: false, 
 						 dataType: 'json',
 						 success: function(data) {

Original file line number	Diff line number	Diff line change
`@@ -400,12 +400,12 @@ void CKodiNode::handleMessage(std::string& pMessage)`
`400`	`400`	`bCanShutdown = root["result"]["canshutdown"].asBool();`
`401`	`401`	`if (bCanShutdown) sAction = "Shutdown";`
`402`	`402`	`}`
`403`		`- if (root["result"].isMember("canhibernate"))`
	`403`	`+ if (root["result"].isMember("canhibernate") && sAction != "Nothing")`
`404`	`404`	`{`
`405`	`405`	`bCanHibernate = root["result"]["canhibernate"].asBool();`
`406`	`406`	`if (bCanHibernate) sAction = "Hibernate";`
`407`	`407`	`}`
`408`		`- if (root["result"].isMember("cansuspend"))`
	`408`	`+ if (root["result"].isMember("cansuspend")&& sAction != "Nothing")`
`409`	`409`	`{`
`410`	`410`	`bCanSuspend = root["result"]["cansuspend"].asBool();`
`411`	`411`	`if (bCanSuspend) sAction = "Suspend";`
Original file line number	Diff line number	Diff line change
`@@ -2237,7 +2237,8 @@ void CEventSystem::EvaluatePython(const std::string &reason, const std::string &`
`2237`	`2237`	`else`
`2238`	`2238`	`_log.Log(LOG_ERROR, "%s",formatted_str.c_str());`
`2239`	`2239`	`}`
`2240`		`- fclose(PythonScriptFile);`
	`2240`	`+ if (PythonScriptFile!=NULL)`
	`2241`	`+ fclose(PythonScriptFile);`
`2241`	`2242`	`//Py_Finalize();`
`2242`	`2243`	`}`
`2243`	`2244`	`#endif // ENABLE_PYTHON`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ namespace http {`
`27`	`27`	`CProxySharedData sharedData;`
`28`	`28`
`29`	`29`	`CProxyClient::CProxyClient(boost::asio::io_service& io_service, boost::asio::ssl::context& context, http::server::cWebem *webEm)`
`30`		`- : _socket(io_service, context),`
	`30`	`+ : _context(context),`
`31`	`31`	`_io_service(io_service),`
`32`	`32`	`doStop(false),`
`33`	`33`	`b_Connected(false),`
`@@ -49,6 +49,7 @@ namespace http {`
`49`	`49`	`}`
`50`	`50`	`m_pWebEm = webEm;`
`51`	`51`	`m_pDomServ = NULL;`
	`52`	`+ _socket.reset(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(_io_service, _context));`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`void CProxyClient::WriteSlaveData(const std::string &token, const char *pData, size_t Length)`
`@@ -75,10 +76,7 @@ namespace http {`
`75`	`76`
`76`	`77`	`void CProxyClient::Reconnect()`
`77`	`78`	`{`
`78`		`-`
`79`		`- std::string address = "my.domoticz.com";`
`80`		`- std::string port = "9999";`
`81`		`-`
	`79`	`+ b_Connected = false;`
`82`	`80`	`if (we_locked_prefs_mutex) {`
`83`	`81`	`// avoid deadlock if we got a read or write error in between handle_handshake() and HandleAuthresp()`
`84`	`82`	`we_locked_prefs_mutex = false;`
`@@ -87,41 +85,57 @@ namespace http {`
`87`	`85`	`if (doStop) {`
`88`	`86`	`return;`
`89`	`87`	`}`
`90`		`- if (b_Connected) {`
`91`		`- _socket.lowest_layer().close();`
	`88`	`+ if (_socket->lowest_layer().is_open()) {`
	`89`	`+ boost::system::error_code ec;`
	`90`	`+ _socket->lowest_layer().cancel(ec);`
	`91`	`+ _socket->lowest_layer().shutdown(boost::asio::socket_base::shutdown_both, ec);`
	`92`	`+ _socket->lowest_layer().close(ec);`
`92`	`93`	`}`
`93`		`- sleep_seconds(15);`
`94`		`- b_Connected = false;`
	`94`	`+ timer_.expires_from_now(boost::posix_time::seconds(15));`
	`95`	`+ timer_.async_wait(boost::bind(&CProxyClient::ContinueConnect, shared_from_this(), boost::asio::placeholders::error));`
	`96`	`+ }`
	`97`	`+`
	`98`	`+ void CProxyClient::ContinueConnect(const boost::system::error_code& error)`
	`99`	`+ {`
	`100`	`+ std::string address = "my.domoticz.com";`
	`101`	`+ std::string port = "9999";`
	`102`	`+`
	`103`	`+ _socket.reset(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(_io_service, _context));`
	`104`	`+ // set timeout timer`
	`105`	`+ timer_.expires_from_now(boost::posix_time::seconds(timeout_));`
	`106`	`+ timer_.async_wait(boost::bind(&CProxyClient::handle_timeout, shared_from_this(), boost::asio::placeholders::error));`
`95`	`107`	`boost::asio::ip::tcp::resolver resolver(_io_service);`
`96`	`108`	`boost::asio::ip::tcp::resolver::query query(address, port);`
`97`	`109`	`boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);`
`98`	`110`	`boost::asio::ip::tcp::endpoint endpoint = *iterator;`
`99`		`- _socket.lowest_layer().async_connect(endpoint,`
	`111`	`+ _socket->lowest_layer().async_connect(endpoint,`
`100`	`112`	`boost::bind(&CProxyClient::handle_connect, shared_from_this(),`
`101`	`113`	`boost::asio::placeholders::error, iterator));`
`102`	`114`	`}`
`103`	`115`
`104`	`116`	`void CProxyClient::handle_connect(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator endpoint_iterator)`
`105`	`117`	`{`
	`118`	`+ if (doStop) {`
	`119`	`+ return;`
	`120`	`+ }`
`106`	`121`	`if (!error)`
`107`	`122`	`{`
`108`		`- _socket.async_handshake(boost::asio::ssl::stream_base::client,`
	`123`	`+ _socket->async_handshake(boost::asio::ssl::stream_base::client,`
`109`	`124`	`boost::bind(&CProxyClient::handle_handshake, shared_from_this(),`
`110`	`125`	`boost::asio::placeholders::error));`
`111`	`126`	`}`
`112`		`- else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())`
	`127`	`+ else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())`
`113`	`128`	`{`
`114`		`- _socket.lowest_layer().close();`
	`129`	`+ _socket->lowest_layer().close();`
`115`	`130`	`boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;`
`116`		`- _socket.lowest_layer().async_connect(endpoint,`
	`131`	`+ _socket->lowest_layer().async_connect(endpoint,`
`117`	`132`	`boost::bind(&CProxyClient::handle_connect, shared_from_this(),`
`118`	`133`	`boost::asio::placeholders::error, ++endpoint_iterator));`
`119`	`134`	`}`
`120`	`135`	`else`
`121`	`136`	`{`
`122`	`137`	`if (!doStop) {`
`123`	`138`	`_log.Log(LOG_ERROR, "PROXY: Connect failed, reconnecting: %s", error.message().c_str());`
`124`		`- b_Connected = true; // signal re-connect`
`125`	`139`	`Reconnect();`
`126`	`140`	`}`
`127`	`141`	`}`
`@@ -131,12 +145,15 @@ namespace http {`
`131`	`145`	`{`
`132`	`146`	`if (error != boost::asio::error::operation_aborted) {`
`133`	`147`	`_log.Log(LOG_ERROR, "PROXY: timeout occurred, reconnecting");`
`134`		`- _socket.lowest_layer().close(); // should induce a reconnect in handle_read with error != 0`
	`148`	`+ Reconnect();`
`135`	`149`	`}`
`136`	`150`	`}`
`137`	`151`
`138`	`152`	`void CProxyClient::handle_write(const boost::system::error_code& error, size_t bytes_transferred)`
`139`	`153`	`{`
	`154`	`+ if (doStop) {`
	`155`	`+ return;`
	`156`	`+ }`
`140`	`157`	`boost::unique_lock<boost::mutex>(writeMutex);`
`141`	`158`	`if (bytes_transferred < writePdu->length()) {`
`142`	`159`	`_log.Log(LOG_ERROR, "PROXY: Only wrote %ld of %ld bytes.", bytes_transferred, writePdu->length());`
`@@ -158,7 +175,7 @@ namespace http {`
`158`	`175`	`writePdu = pdu;`
`159`	`176`	`_writebuf.clear(); // make sure`
`160`	`177`	`_writebuf.push_back(boost::asio::buffer(writePdu->content(), writePdu->length()));`
`161`		`- boost::asio::async_write(_socket, _writebuf, boost::bind(&CProxyClient::handle_write, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));`
	`178`	`+ boost::asio::async_write(*_socket, _writebuf, boost::bind(&CProxyClient::handle_write, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));`
`162`	`179`	`}`
`163`	`180`
`164`	`181`	`void CProxyClient::MyWrite(pdu_type type, CValueLengthPart &parameters)`
`@@ -197,6 +214,9 @@ namespace http {`
`197`	`214`
`198`	`215`	`void CProxyClient::handle_handshake(const boost::system::error_code& error)`
`199`	`216`	`{`
	`217`	`+ if (doStop) {`
	`218`	`+ return;`
	`219`	`+ }`
`200`	`220`	`if (!error)`
`201`	`221`	`{`
`202`	`222`	`// lock until we have a valid api id`
`@@ -209,10 +229,8 @@ namespace http {`
`209`	`229`	`}`
`210`	`230`	`else`
`211`	`231`	`{`
`212`		`- if (!doStop) {`
`213`		`- _log.Log(LOG_ERROR, "PROXY: Handshake failed, reconnecting: %s", error.message().c_str());`
`214`		`- Reconnect();`
`215`		`- }`
	`232`	`+ _log.Log(LOG_ERROR, "PROXY: Handshake failed, reconnecting: %s", error.message().c_str());`
	`233`	`+ Reconnect();`
`216`	`234`	`}`
`217`	`235`	`}`
`218`	`236`
`@@ -225,7 +243,7 @@ namespace http {`
`225`	`243`	`timer_.expires_from_now(boost::posix_time::seconds(timeout_));`
`226`	`244`	`timer_.async_wait(boost::bind(&CProxyClient::handle_timeout, shared_from_this(), boost::asio::placeholders::error));`
`227`	`245`
`228`		`- _socket.async_read_some(buf,`
	`246`	`+ _socket->async_read_some(buf,`
`229`	`247`	`boost::bind(&CProxyClient::handle_read, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)`
`230`	`248`	`);`
`231`	`249`	`}`
`@@ -529,6 +547,9 @@ namespace http {`
`529`	`547`	`void CProxyClient::handle_read(const boost::system::error_code& error, size_t bytes_transferred)`
`530`	`548`	`{`
`531`	`549`	`// data read, no need for timeouts anymore`
	`550`	`+ if (!b_Connected \|\| doStop) {`
	`551`	`+ return;`
	`552`	`+ }`
`532`	`553`	`timer_.cancel();`
`533`	`554`	`if (!error)`
`534`	`555`	`{`
`@@ -560,14 +581,17 @@ namespace http {`
`560`	`581`
`561`	`582`	`void CProxyClient::Stop()`
`562`	`583`	`{`
	`584`	`+ timer_.cancel(); // to be sure`
`563`	`585`	`if (we_locked_prefs_mutex) {`
`564`	`586`	`we_locked_prefs_mutex = false;`
`565`	`587`	`sharedData.UnlockPrefsMutex();`
`566`	`588`	`}`
`567`	`589`
`568`	`590`	`doStop = true;`
`569`	`591`	`// signal end of WriteThread`
`570`		`- _socket.lowest_layer().close();`
	`592`	`+ boost::system::error_code ec;`
	`593`	`+ _socket->shutdown(ec);`
	`594`	`+ _socket->lowest_layer().close(ec);`
`571`	`595`	`}`
`572`	`596`
`573`	`597`	`void CProxyClient::SetSharedServer(tcp::server::CTCPServerProxied *domserv)`
`@@ -581,6 +605,7 @@ namespace http {`
`581`	`605`
`582`	`606`	`CProxyManager::CProxyManager(const std::string& doc_root, http::server::cWebem webEm, tcp::server::CTCPServer domServ)`
`583`	`607`	`{`
	`608`	`+ m_pDocRoot = doc_root;`
`584`	`609`	`m_pWebEm = webEm;`
`585`	`610`	`m_pDomServ = domServ;`
`586`	`611`	`m_thread = NULL;`
`@@ -590,14 +615,14 @@ namespace http {`
`590`	`615`	`CProxyManager::~CProxyManager()`
`591`	`616`	`{`
`592`	`617`	`if (m_thread) {`
`593`		`- m_thread->join();`
	`618`	`+ delete m_thread;`
`594`	`619`	`}`
`595`	`620`	`}`
`596`	`621`
`597`	`622`	`int CProxyManager::Start(bool first)`
`598`	`623`	`{`
`599`	`624`	`_first = first;`
`600`		`- m_thread = new boost::thread(boost::bind(&CProxyManager::StartThread, this));`
	`625`	`+ m_thread = new boost::thread(boost::bind(&CProxyManager::StartThread, shared_from_this()));`
`601`	`626`	`return 1;`
`602`	`627`	`}`
`603`	`628`
`@@ -624,10 +649,11 @@ namespace http {`
`624`	`649`
`625`	`650`	`void CProxyManager::Stop()`
`626`	`651`	`{`
`627`		`- proxyclient->Stop();`
`628`		`- io_service.stop();`
`629`		`- m_thread->interrupt();`
`630`		`- m_thread->join();`
	`652`	`+ if (m_thread) {`
	`653`	`+ io_service.post(boost::bind(&CProxyClient::Stop, proxyclient));`
	`654`	`+ delete m_thread;`
	`655`	`+ m_thread = NULL;`
	`656`	`+ }`
`631`	`657`	`}`
`632`	`658`
`633`	`659`	`boost::shared_ptr<CProxyClient> CProxyManager::GetProxyForMaster(DomoticzTCP *master) {`