upgrade from raptor sources (ef097b35) · Commits · epita / slmanager

sld/trunk/Makefile.am

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@ sld_SOURCES= src/sld.cc \
	src/daemon.cc \		src/daemon.cc \
	src/log.cc \		src/log.cc \
	src/sll/error.cc \		src/sll/error.cc \
			src/sll/buffer.cc \
	src/sll/connection.cc \		src/sll/connection.cc \
	src/sll/cypher.cc		src/sll/cypher.cc

	@@ -30,6 +31,7 @@ noinst_HEADER= src/sld.hh \
	src/log.hh \		src/log.hh \
	src/sll/slm.hh \		src/sll/slm.hh \
	src/sll/error.hh \		src/sll/error.hh \
			src/sll/buffer.hh \
	src/sll/connection.hh \		src/sll/connection.hh \
	src/sll/connection.hxx \		src/sll/connection.hxx \
	src/sll/cypher.hh		src/sll/cypher.hh

sld/trunk/src/sll/connection.cc

+107 −38

Original line number	Original line	Diff line number	Diff line
	@@ -44,7 +44,8 @@ unsigned long int Connection::getconnid() {
	*		*
	* @param fd socket of the connection (-1) is not exist		* @param fd socket of the connection (-1) is not exist
	*/		*/
	Connection::Connection(int fd) : socket_fd_(fd), local_port_(-1), remote_port_(-1), id_(0) {		Connection::Connection(int fd, bool bufferized)
			: socket_fd_(fd), local_port_(-1), remote_port_(-1), id_(0), bufferized_(bufferized) {
	pthread_mutex_init(&c_mutex_, 0);		pthread_mutex_init(&c_mutex_, 0);
	pthread_mutex_init(&r_mutex_, 0);		pthread_mutex_init(&r_mutex_, 0);
	pthread_mutex_init(&w_mutex_, 0);		pthread_mutex_init(&w_mutex_, 0);
	@@ -74,14 +75,8 @@ void Connection::disconnect() {
	throw Error(ERR_NET, "No connection established but trying to disconnect");		throw Error(ERR_NET, "No connection established but trying to disconnect");
	}		}

	// lock all mutex
	pthread_mutex_lock(&r_mutex_);
	pthread_mutex_lock(&w_mutex_);

	disconnect_();		disconnect_();

	pthread_mutex_unlock(&w_mutex_);
	pthread_mutex_unlock(&r_mutex_);
	pthread_mutex_unlock(&c_mutex_);		pthread_mutex_unlock(&c_mutex_);
	}		}

	@@ -282,7 +277,7 @@ Connection *Connection::accept() {
	/**		/**
	* Send data on @param buf of size @param len on socket		* Send data on @param buf of size @param len on socket
	*/		*/
	void Connection::send(const char* buf, size_t len) {		void Connection::send(const void* buf, size_t len) {
	// lock mutex for operation		// lock mutex for operation
	pthread_mutex_lock(&c_mutex_);		pthread_mutex_lock(&c_mutex_);
	pthread_mutex_lock(&w_mutex_);		pthread_mutex_lock(&w_mutex_);
	@@ -297,24 +292,59 @@ void Connection::send(const char* buf, size_t len) {
	throw Error(ERR_NET, "No connection established but trying to send data");		throw Error(ERR_NET, "No connection established but trying to send data");
	}		}

	// send is a write operation		// call send
	int ret = ::send(socket_fd_, buf, len, MSG_NOSIGNAL);		try { send_(socket_fd, buf, len); }
			catch (...) {
			pthread_mutex_lock(&c_mutex_);
			pthread_mutex_lock(&r_mutex_);
			disconnect_();
			pthread_mutex_unlock(&r_mutex_);
			pthread_mutex_unlock(&w_mutex_);
			pthread_mutex_unlock(&c_mutex_);
			throw;
			}

			// release the mutex
			pthread_mutex_unlock(&w_mutex_);
			}

			/**
			* Free read buffer and send write buffer if connected
			*
			*/
			void Connection::flush() {
			if (!bufferized_)
			return;

	// treat error		// lock mutex for operation
	if (ret == -1) {		pthread_mutex_lock(&c_mutex_);
	int errno__ = errno;		pthread_mutex_lock(&w_mutex_);

			// retreive socket_fd and free conn mutex
			int socket_fd = socket_fd_;
			pthread_mutex_unlock(&c_mutex_);

			// test socket validity
			if (socket_fd < 0) {
			pthread_mutex_unlock(&w_mutex_);
			throw Error(ERR_NET, "No connection established but trying to flush data");
			}

			// call send
			try { send_(socket_fd, rbuf_.c_str(), rbuf_.length()); }
			catch (...) {
	pthread_mutex_lock(&c_mutex_);		pthread_mutex_lock(&c_mutex_);
	pthread_mutex_lock(&r_mutex_);		pthread_mutex_lock(&r_mutex_);
	disconnect_();		disconnect_();
	pthread_mutex_unlock(&r_mutex_);		pthread_mutex_unlock(&r_mutex_);
	pthread_mutex_unlock(&w_mutex_);		pthread_mutex_unlock(&w_mutex_);
	pthread_mutex_unlock(&c_mutex_);		pthread_mutex_unlock(&c_mutex_);
	if (errno__ == ECONNRESET \|\| errno__ == EPIPE)		throw;
	throw Error(ERR_NET, "Connection reset by peer");
	else
	throw Error(ERR_NET, "send: " + (string) strerror(errno__));
	}		}

			// clean read buffer
			rbuf_.clear();

	// release the mutex		// release the mutex
	pthread_mutex_unlock(&w_mutex_);		pthread_mutex_unlock(&w_mutex_);
	}		}
	@@ -322,9 +352,53 @@ void Connection::send(const char* buf, size_t len) {
	/**		/**
	* Receive raw data		* Receive raw data
	*/		*/
	char *Connection::recv(size_t size) {		int Connection::recv(void *buf, size_t size) {
	assert(0);		// lock mutex for operation
	return 0;		pthread_mutex_lock(&c_mutex_);
			pthread_mutex_lock(&r_mutex_);

			int socket_fd = socket_fd_;
			pthread_mutex_unlock(&c_mutex_);

			// test socket validity
			if (socket_fd < 0) {
			pthread_mutex_unlock(&r_mutex_);
			throw Error(ERR_NET, "No connection established but trying to receive line");
			}

			int ret = 0;

			if (rbuf_.size() > 0) {
			size_t msize = (rbuf.length() > size) ? size : rbuf.length();

			memcpy(buf, rbuf_.c_str(), msize);
			ret += msize;
			rbuf_.remove(0, msize);
			}

			if (ret < size) {
			static char local_buf[MAX_LINE_SIZE];

			try { ret = recv_(socket_fd, local_buf, MAX_LINE_SIZE); }
			catch (...) {
			pthread_mutex_lock(&c_mutex_);
			pthread_mutex_lock(&w_mutex_);
			*local_buf = 0;
			disconnect_();
			pthread_mutex_unlock(&w_mutex_);
			pthread_mutex_unlock(&r_mutex_);
			pthread_mutex_unlock(&c_mutex_);
			throw;
			}
			local_buf[ret] = 0;
			}


			// add read data in buffer
			rbuf_ += local_buf;

			} while (1);
			return ret;
	}		}

	/**		/**
	@@ -356,22 +430,17 @@ string Connection::recvln() {

	// read data		// read data
	static char local_buf[MAX_LINE_SIZE];		static char local_buf[MAX_LINE_SIZE];
	int ret = ::recv(socket_fd, local_buf, MAX_LINE_SIZE, 0);

	if (ret == -1 \|\| ret == 0) {		try { recv_(socket_fd, local_buf, MAX_LINE_SIZE); }
			catch (...) {
	pthread_mutex_lock(&c_mutex_);		pthread_mutex_lock(&c_mutex_);
	pthread_mutex_lock(&w_mutex_);		pthread_mutex_lock(&w_mutex_);
			*local_buf = 0;
	disconnect_();		disconnect_();
	pthread_mutex_unlock(&w_mutex_);		pthread_mutex_unlock(&w_mutex_);
	pthread_mutex_unlock(&r_mutex_);		pthread_mutex_unlock(&r_mutex_);
	pthread_mutex_unlock(&c_mutex_);		pthread_mutex_unlock(&c_mutex_);
			throw;
	*local_buf = 0;

	if (ret == 0)
	throw Error(ERR_NET, "Connection reset by peer");
	else
	throw Error(ERR_NET, (string) "recvln: " + strerror(errno));
	}		}
	local_buf[ret] = 0;		local_buf[ret] = 0;

	@@ -379,11 +448,7 @@ string Connection::recvln() {
	rbuf_ += local_buf;		rbuf_ += local_buf;

	} while (1);		} while (1);
	assert(1);		abort();
	}

	void Connection::flush() {
	assert(0);
	}		}

	string Connection::getlocalip() {		string Connection::getlocalip() {
	@@ -509,10 +574,6 @@ int Connection::getremoteport() {
	return port;		return port;
	}		}

	unsigned long int Connection::getid() {
	return id_;
	}

	int Connection::getsocket() {		int Connection::getsocket() {
	// get socket is a conn op		// get socket is a conn op
	pthread_mutex_lock(&c_mutex_);		pthread_mutex_lock(&c_mutex_);
	@@ -525,6 +586,14 @@ int Connection::getsocket() {
	return socket_fd;		return socket_fd;
	}		}

			unsigned long int Connection::getid() const {
			return id_;
			}

			bool Connection::isbufferized() const {
			return bufferized_;
			}

	/*******************************************************************************		/*******************************************************************************
	** Protected method		** Protected method
	******************************************************************************/		******************************************************************************/

sld/trunk/src/sll/connection.hh

+11 −5

Original line number	Original line	Diff line number	Diff line
	@@ -28,7 +28,7 @@ public:

	// public methods		// public methods
	public:		public:
	Connection(int fd = -1);		Connection(int fd = -1, bool bufferized = false);
	virtual ~Connection();		virtual ~Connection();

	void connect(const char *addr, int port);		void connect(const char *addr, int port);
	@@ -40,12 +40,12 @@ public:
	Connection *accept();		Connection *accept();

	// send methods		// send methods
	void send(const char* buf, size_t len);		void send(const void* buf, size_t len);
	inline void send(const string &data);		inline void send(const string &data);
	inline void sendln(const string &data);		inline void sendln(const string &data);

	// recv methods		// recv methods
	char *recv(size_t size);		int recv(void *buf, size_t size);
	string recvln();		string recvln();

	// buffer methods		// buffer methods
	@@ -60,15 +60,19 @@ public:
	string getremotehostname();		string getremotehostname();
	int getremoteport();		int getremoteport();

	unsigned long int getid();

	int getsocket();		int getsocket();

			unsigned long int getid() const;
			bool isbufferized() const;

	// protected methods		// protected methods
	protected:		protected:
	inline void socket_();		inline void socket_();
	inline void disconnect_();		inline void disconnect_();

			inline void send_(int socket_fd, const void *buf, size_t size);
			inline int recv_(int socket_fd, void *buf, size_t size);

	inline void setlocalip_();		inline void setlocalip_();
	inline void setlocalport_();		inline void setlocalport_();
	inline void setremoteip_();		inline void setremoteip_();
	@@ -90,6 +94,8 @@ protected:

	unsigned long int id_;		unsigned long int id_;

			bool bufferized_;

	string rbuf_; // read buffer		string rbuf_; // read buffer
	string wbuf_; // write buffer		string wbuf_; // write buffer

sld/trunk/src/sll/connection.hxx

+30 −1

Original line number	Original line	Diff line number	Diff line
	@@ -70,10 +70,13 @@ void Connection::sendln(const string &data) {
	* No mutex used !		* No mutex used !
	*/		*/
	void Connection::disconnect_() {		void Connection::disconnect_() {
	assert(socket_fd_ >= 0);		if (socket_fd_ < 0)
			return;

	close(socket_fd_);		close(socket_fd_);
	socket_fd_ = -1;		socket_fd_ = -1;
			rbuf_.clear();
			wbuf_.clear();
	}		}

	/**		/**
	@@ -91,6 +94,32 @@ void Connection::socket_() {
	throw Error(ERR_NET, (string) "Unable to set socket options: " + strerror(errno));		throw Error(ERR_NET, (string) "Unable to set socket options: " + strerror(errno));
	}		}

			/**
			* Send @param size byte of @param buf into socket @param socket
			* No mutex used!
			*/
			void Connection::send_(int socket_fd, const void *buf, size_t size) {
			if (::send(socket_fd, buf, size, MSG_NOSIGNAL)) {
			if (errno == ECONNRESET \|\| errno == EPIPE)
			throw Error(ERR_NET, "Connection reset by peer");
			else
			throw Error(ERR_NET, "send: " + (string) strerror(errno));
			}
			}

			/**
			* Send @param size byte of @param buf into socket @param socket
			* No mutex used!
			*/
			int Connection::recv_(int socket_fd, void *buf, size_t size) {
			int ret = ::recv(socket_fd, buf, size, 0);
			if (ret == 0)
			throw Error(ERR_NET, "Connection reset by peer");
			else if (ret == -1)
			throw Error(ERR_NET, (string) "recvln: " + strerror(errno));
			return ret;
			}

	/**		/**
	* Set local ip		* Set local ip
	* No mutex used !		* No mutex used !

sll/trunk/connection.cc

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -323,7 +323,8 @@ void Connection::send(const char* buf, size_t len) {
	* Receive raw data		* Receive raw data
	*/		*/
	char *Connection::recv(size_t size) {		char *Connection::recv(size_t size) {
	assert(0);		abort();
			size = size + 1;
	return 0;		return 0;
	}		}