wrong unlock removed (2ed98eea) · Commits · jan.koester / libnetplus

src/connection.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -258,7 +258,7 @@ int netplus::con::searchValue(con::condata* startblock, con::condata** findblock

		netplus::con::con(eventapi *event){
		csock=nullptr;

		conlock=false;
		_ReadDataFirst=nullptr;
		_ReadDataLast=nullptr;
		_ReadDataLength=0;
		@@ -271,7 +271,7 @@ netplus::con::con(eventapi *event){

		netplus::con::con(){
		csock=nullptr;

		conlock=false;
		_ReadDataFirst=nullptr;
		_ReadDataLast=nullptr;
		_ReadDataLength=0;

src/connection.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -25,7 +25,7 @@
		* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*******************************************************************************/

		#include <mutex>
		#include <atomic>

		#pragma once

		@@ -80,7 +80,7 @@ namespace netplus {
		void sending(bool state);

		/connection locking/
		std::mutex conlock;
		std::atomic<bool> conlock;
		protected:
		con();
		/Incomming Data/

src/eventapi.h

+17 −15

Original line number	Diff line number	Diff line
		@@ -38,18 +38,20 @@ namespace netplus {

		enum EventHandlerStatus{EVIN=0,EVOUT=1,EVUP=2,EVERR=3,EVWAIT=4,EVCON=5};

		enum LockState{NOCONNECTION=-2,ALREADLOCKED=-1,LOCKED=0};

		virtual ~eventapi();
		virtual void initEventHandler()=0;
		virtual const char *getpolltype()=0;
		/pollstate/
		virtual int pollState(con *pcon)=0;
		virtual int pollState(int pos)=0;

		/EventHandler/
		virtual unsigned int waitEventHandler()=0;
		virtual con *ConnectEventHandler(int pos)=0;
		virtual void ReadEventHandler(con *rcon)=0;
		virtual void WriteEventHandler(con *wcon)=0;
		virtual void CloseEventHandler(con *delcon)=0;
		virtual void ConnectEventHandler(int pos)=0;
		virtual void ReadEventHandler(int pos)=0;
		virtual void WriteEventHandler(int pos)=0;
		virtual void CloseEventHandler(int pos)=0;

		/HTTP API Events/
		virtual void RequestEvent(con *curcon)=0;
		@@ -58,8 +60,8 @@ namespace netplus {
		virtual void DisconnectEvent(con *curcon)=0;

		/locking for competing threads/
		virtual void unlockCon(con *ucon)=0;
		virtual bool trylockCon(con *tcon)=0;
		virtual void unlockCon(int pos)=0;
		virtual int trylockCon(int pos)=0;

		/*Connection Ready to send Data
		* DANGEROUS to burnout your cpu
		@@ -73,22 +75,22 @@ namespace netplus {
		virtual ~poll();
		const char *getpolltype();
		void initEventHandler();
		int pollState(con *pcon);
		int pollState(int pos);
		unsigned int waitEventHandler();
		con *ConnectEventHandler(int pos);
		void ReadEventHandler(con *rcon);
		void WriteEventHandler(con *wcon);
		void CloseEventHandler(con *delcon);
		void ConnectEventHandler(int pos);
		void ReadEventHandler(int pos);
		void WriteEventHandler(int pos);
		void CloseEventHandler(int pos);
		void sendReady(con *curcon,bool ready);
		void unlockCon(con *ucon);
		bool trylockCon(con *tcon);
		void unlockCon(int pos);
		int trylockCon(int pos);
		private:

		void _setpollEvents(con *curcon,int events);
		int _pollFD;
		struct poll_event *_Events;
		socket *_ServerSocket;
		std::mutex _StateLock;
		std::atomic<bool> _ConLock;
		};

		class event : public poll {

src/linux/event.cpp

+59 −37

Original line number	Diff line number	Diff line
		@@ -57,6 +57,7 @@ namespace netplus {

		poll::poll(socket* serversocket) {
		_ServerSocket = serversocket;
		_ConLock=false;
		};

		poll::~poll() {
		@@ -99,7 +100,8 @@ namespace netplus {
		_Events[i].data.ptr = nullptr;
		};

		int poll::pollState(con *pcon){
		int poll::pollState(int pos){
		con pcon = (con)_Events[pos].data.ptr;
		NetException exception;
		if (pcon->getSendData()) {
		return EventHandlerStatus::EVOUT;
		@@ -109,7 +111,7 @@ namespace netplus {

		unsigned int poll::waitEventHandler() {
		int ret = epoll_wait(_pollFD, (struct epoll_event*)_Events, _ServerSocket->getMaxconnections(), -1);
		if (ret == -1) {
		if (ret <0 ) {
		NetException exception;
		exception[NetException::Error] << "waitEventHandler: epoll wait failure";
		throw exception;
		@@ -117,15 +119,21 @@ namespace netplus {
		return ret;
		};

		con *poll::ConnectEventHandler(int pos) {
		const std::lock_guard<std::mutex> lock(_StateLock);
		void poll::ConnectEventHandler(int pos) {
		NetException exception;
		con ccon = (con)_Events[pos].data.ptr;
		if(ccon)
		return ccon;
		bool expected = false;

		if(!_ConLock.compare_exchange_strong(expected,true))
		return;

		try {
		ccon = new con(this);
		ccon->conlock.lock();
		bool expected = false;
		if(!ccon->conlock.compare_exchange_strong(expected,true)){
		exception[NetException::Note] << "ConnectEventHandler: connection already exists!";
		throw exception;
		}
		ccon->csock = _ServerSocket->accept();
		ccon->csock->setnonblocking();
		std::string ip;
		@@ -142,17 +150,23 @@ namespace netplus {
		}

		ConnectEvent(ccon);
		ccon->conlock.unlock();
		return ccon;
		ccon->conlock.store(false);
		} catch (NetException& e) {
		ccon->conlock.unlock();
		switch(e.getErrorType()){
		case NetException::Note:
		std::cout << e.what() << std::endl;
		break;
		default:
		delete ccon->csock;
		delete ccon;
		throw e;
		}
		}
		return nullptr;
		_ConLock.store(false);
		};

		void poll::ReadEventHandler(con *rcon) {
		void poll::ReadEventHandler(int pos) {
		con rcon = (con)_Events[pos].data.ptr;
		if (!rcon) {
		NetException exp;
		exp[NetException::Error] << "ReadEvent: No valied Connection! ";
		@@ -161,8 +175,7 @@ namespace netplus {
		try {
		char buf[BLOCKSIZE];
		size_t rcvsize = _ServerSocket->recvData(rcon->csock, buf, BLOCKSIZE);
		if(rcvsize==0)
		return;
		if(rcvsize!=0)
		rcon->addRecvQueue(buf, rcvsize);
		RequestEvent(rcon);
		}
		@@ -171,7 +184,8 @@ namespace netplus {
		}
		};

		void poll::WriteEventHandler(con* wcon) {
		void poll::WriteEventHandler(int pos) {
		con wcon = (con)_Events[pos].data.ptr;
		if (!wcon) {
		NetException exp;
		exp[NetException::Error] << "WriteEvent: No valied Connection!";
		@@ -196,9 +210,9 @@ namespace netplus {
		}
		};

		void poll::CloseEventHandler(con *delcon) {
		void poll::CloseEventHandler(int pos) {
		NetException except;

		con delcon = (con)_Events[pos].data.ptr;
		if(!delcon){
		except[NetException::Error] << "CloseEvent connection not exists!";
		throw except;
		@@ -217,6 +231,7 @@ namespace netplus {

		DisconnectEvent(delcon);
		delete delcon;
		_Events[pos].data.ptr=nullptr;
		};

		/Connection Ready to send Data/
		@@ -242,16 +257,21 @@ namespace netplus {
		}
		};

		void poll::unlockCon(con *ucon){
		if(ucon)
		ucon->conlock.unlock();
		void poll::unlockCon(int pos){
		con ccon = (con)_Events[pos].data.ptr;
		if(ccon)
		ccon->conlock.store(false);;
		}

		bool poll::trylockCon(con *tcon){
		const std::lock_guard<std::mutex> lock(_StateLock);
		if(tcon)
		return tcon->conlock.try_lock();
		return false;
		int poll::trylockCon(int pos){
		con ccon = (con)_Events[pos].data.ptr;
		bool expected = false;
		if(ccon){
		if(ccon->conlock.compare_exchange_strong(expected,true))
		return LockState::LOCKED;
		return LockState::ALREADLOCKED;
		}
		return LockState::NOCONNECTION;
		}

		bool event::_Run = true;
		@@ -267,26 +287,28 @@ namespace netplus {
		int wfd = eventptr->waitEventHandler();
		for (int i = 0; i < wfd; ++i) {
		try {
		con *pcon=eventptr->ConnectEventHandler(i);
		if(eventptr->trylockCon(pcon)){
		int lock=eventptr->trylockCon(i);
		if(lock == poll::LockState::LOCKED){
		try{
		switch (eventptr->pollState(pcon)) {
		case poll::EVIN:
		eventptr->ReadEventHandler(pcon);
		switch (eventptr->pollState(i)) {
		case poll::EventHandlerStatus::EVIN:
		eventptr->ReadEventHandler(i);
		break;
		case poll::EVOUT:
		eventptr->WriteEventHandler(pcon);
		case poll::EventHandlerStatus::EVOUT:
		eventptr->WriteEventHandler(i);
		break;
		default:
		NetException excep;
		excep[NetException::Note] << "Eventworker: nothing todo close connection";
		throw excep;
		}
		eventptr->unlockCon(pcon);
		eventptr->unlockCon(i);
		}catch(NetException& e){
		eventptr->CloseEventHandler(pcon);
		eventptr->CloseEventHandler(i);
		throw e;
		}
		}else if(lock == poll::LockState::NOCONNECTION){
		eventptr->ConnectEventHandler(i);
		}
		} catch (NetException& e) {
		if (e.getErrorType() == NetException::Critical) {

src/linux/socket.cpp

+4 −3

Original line number	Diff line number	Diff line
		@@ -100,7 +100,7 @@ netplus::tcp::tcp(const char* addr, int port,int maxconnections,int sockopts) :
		if(sockopts == -1)
		sockopts=SO_REUSEADDR;

		_Socket = ::socket(AF_INET,SOCK_STREAM,0);
		_Socket = ::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

		struct sockaddr_in address;
		memset(&address, 0, sizeof(address));
		@@ -150,6 +150,7 @@ netplus::socket *netplus::tcp::accept(){
		csock->_Socket = ::accept(_Socket,(struct sockaddr *)csock->_SocketPtr,&csock->_SocketPtrSize);
		if(csock->_Socket<0){
		delete csock;
		csock=nullptr;
		exception[NetException::Error] << "Can't accept on Socket";
		throw exception;
		}
		@@ -223,7 +224,7 @@ netplus::ssl::ssl(const char *addr,int port,int maxconnections,int sockopts,cons
		if(sockopts == -1)
		sockopts=SO_REUSEADDR;

		_Socket = ::socket(AF_INET,SOCK_STREAM,0);
		_Socket = ::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

		struct sockaddr_in address;
		memset(&address, 0, sizeof(address));
		@@ -295,7 +296,7 @@ unsigned int netplus::ssl::sendData(socket socket,void data,unsigned long size
		data,
		size,
		flags,
		(const struct sockaddr *)socket->_SocketPtr,
		(const struct sockaddr *)&socket->_SocketPtr,
		socket->_SocketPtrSize
		);
		if(rval<0){