check the handler is used as expected and prevent strange clients from triggering incorrect events

Author: splitice

src/core/connection.cpp

@@ -74,19 +74,24 @@ static bool connection_event_update(int fd, uint32_t events) {
 	return res == 0;
 }
 
-bool connection_register_write(int fd) {
-	return connection_event_update(fd, EPOLLOUT | EPOLLHUP);
+bool connection_register_write(struct scache_connection* c) {
+	c->epollout = true;
+	c->epollin = false;
+	return connection_event_update(c->client_sock, EPOLLOUT | EPOLLHUP);
 }
 
-bool connection_register_read(int fd) {
-	return connection_event_update(fd, EPOLLIN | EPOLLHUP | EPOLLRDHUP);
+bool connection_register_read(struct scache_connection* c) {
+	c->epollout = false;
+	c->epollin = true;
+	return connection_event_update(c->client_sock, EPOLLIN | EPOLLHUP | EPOLLRDHUP);
 }
 
 void connection_setup(struct scache_binds cache_binds, struct scache_binds monitor_binds) {
 	int i;
 
 	for (i = 0; i < CONNECTION_HASH_ENTRIES; i++) {
 		ctable[i].connection.client_sock = -1;
+		ctable[i].connection.epollin = ctable[i].connection.epollout = false;
 	}
 
 	// Allocate for all listeners
@@ -291,6 +296,7 @@ static scache_connection* connection_add(int fd, listener_type client_type) {
 
 	// do last as marks connection slot as used
 	newNode->connection.client_sock = fd;
+	newNode->connection.epollout = newNode->connection.epollin = false;
 
 	// this is a chained connection
 	if(node != newNode){
@@ -634,6 +640,7 @@ void connection_event_loop(void (*connection_handler)(scache_connection* connect
 					DEBUG("[#%d] A new %s socket was accepted %d\n", fd, listener_type_string(client_type), client_sock);
 					scache_connection* connection = connection_add(client_sock, client_type);
 					assert(connection->client_sock == client_sock);
+					connection->epollin = true;
 					connection_handler(connection);
 				}
 			}
@@ -729,6 +736,8 @@ void connection_cleanup_http(scache_connection_node* connection, bool toFree = f
 		close_fd(fd);
 	}
 
+	connection->connection.epollout = connection->connection.epollin = false;
+
 	//Handle chained connections
 	if (connection->next != NULL) {
 		connection_cleanup_http(connection->next, true);

src/core/connection.h

@@ -4,8 +4,8 @@
 #include "config.h"
 #include "connection_structures.h"
 
-bool connection_register_write(int fd);
-bool connection_register_read(int fd);
+bool connection_register_write(struct scache_connection* c);
+bool connection_register_read(struct scache_connection* c);
 int connection_open_listener(struct scache_bind bind);
 void connection_close_listeners();
 void connection_event_loop(void(*connection_handler)(scache_connection* connection));
@@ -17,11 +17,14 @@ bool connection_stop_soon();
 
 void close_fd(int fd);
 
+#define CONNECTION_HANDLER_ACTUAL(con, value) (con)->handler = (value) 
 #define _DEBUG_CONNECTION_HANDLER
 #ifdef DEBUG_CONNECTION_HANDLER
 #define CONNECTION_HANDLER(con, value) printf("Setting connection handler to " #value "\n"); (con)->handler = (value) 
+#elif defined(DEBUG_BUILD)
+#define CONNECTION_HANDLER(con, value) (con)->handler_name=#value;CONNECTION_HANDLER_ACTUAL(con, value)
 #else
-#define CONNECTION_HANDLER(con, value) (con)->handler = (value) 
+#define CONNECTION_HANDLER(con, value) CONNECTION_HANDLER_ACTUAL(con, value)
 #endif
 
 #define CONNECTION_HASH_KEY(x) (x)%CONNECTION_HASH_ENTRIES

src/core/connection_structures.h

@@ -36,12 +36,17 @@ struct scache_connection {
 	int output_length;
 	char* output_buffer_free;
 	state_action(*handler)(scache_connection* connection);
+#ifdef DEBUG_BUILD
+	const char* handler_name;
+#endif
 	uint32_t state;
 	int client_sock;
 	struct read_buffer input;
 
-	unsigned int type : 15;
-	unsigned int writing : 1;
+	uint16_t method;
+	bool cache_writing,
+	     epollin,
+		 epollout;
 
 	listener_type ltype;
 

src/core/http.cpp

@@ -76,14 +76,19 @@ state_action http_read_handle(scache_connection* connection) {
 	state_action run;
 	int to_end = -1, to_end_old;
 	do {
+		if(!connection->epollin) break;
 		run = http_read_handle_state(connection);
 		to_end_old = to_end;
 		to_end = rbuf_read_remaining(&connection->input);
 	} while (run == needs_more_read && to_end != 0 && to_end != to_end_old);
 
 	//Handle buffer is full, not being processed
 	if (num == 0 && rbuf_write_remaining(&connection->input) == 0) {
-		WARN("Buffer full, not processed, disconnecting.");
+		const char* handling = "<unknown>";
+		#ifdef DEBUG_BUILD
+			handling = connection->handler_name;
+		#endif
+		WARN("Buffer overlowed while handling %s (epollin=%d), will disconnect", handling, connection->epollin);
 		return close_connection;
 	}
 
@@ -128,7 +133,7 @@ state_action http_write_handle(scache_connection* connection) {
 	}
 
 	state_action run = continue_processing;
-	if (connection->output_buffer == NULL) {
+	if (connection->output_buffer == NULL && connection->epollout) {
 //		do {
 		run = http_write_handle_state(connection);
 //		} while (run == needs_more_write);

src/core/http_parse.cpp

@@ -82,7 +82,7 @@ state_action http_read_eoltoend(scache_connection* connection, char* buffer, int
 		// register a handler to write the output (and then the request is over)
 		connection->state = 0;
 		CONNECTION_HANDLER(connection,  http_respond_writeonly);
-		bool res = connection_register_write(connection->client_sock);
+		bool res = connection_register_write(connection);
 
 		if (!res) {
 			return close_connection;
@@ -114,7 +114,7 @@ state_action http_handle_eolwritetoend(scache_connection* connection) {
 
 state_action http_discard_input(scache_connection* connection) {
 	//todo discard from readbuffer
-	connection_register_read(connection->client_sock);
+	connection_register_read(connection);
 	rbuf_read_to_end(&connection->input);
 	return continue_processing;
 }