commit 9d96eb9422b23fecacc198bf110e3a944ab182be Author: George Kadianakis <desnacked@gmail.com> Date: Fri Jul 8 18:15:55 2011 +0200 Improvements on the signal handling code. * Implemented a generic double linked list, which is now used for connections and listeners. * We now close the listeners when we are shutting down instead of closing their sockets. --- src/main.c | 69 ++++++++++++++++++++------ src/network.c | 153 ++++++++++++++++++-------------------------------------- src/network.h | 1 + src/util.c | 141 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/util.h | 19 +++++++ 5 files changed, 264 insertions(+), 119 deletions(-) diff --git a/src/main.c b/src/main.c index 81e8c31..56ea9c9 100644 --- a/src/main.c +++ b/src/main.c @@ -35,6 +35,9 @@ extern int n_supported_protocols; static struct event_base *the_event_base=NULL; +/** Doubly linked list holding all our listeners. */ +static dll_t *ll=NULL; + /** Prints the obfsproxy usage instructions then exits. */ @@ -58,6 +61,24 @@ usage(void) } /** + Disables all active listeners. +*/ +static void +disable_all_listeners(void) +{ + if (!ll) + return; + log_info("Disabling all listeners."); + + /* Iterate listener doubly linked list and disable them all. */ + dll_node_t *ll_node = ll->head; + while (ll_node) { + listener_disable(ll_node->data); + ll_node = ll_node->next; + } +} + +/** This is called when we receive a signal. It figures out the signal type and acts accordingly. @@ -73,17 +94,29 @@ handle_signal_cb(evutil_socket_t fd, short what, void *arg) { int signum = (int) fd; static int got_sigint=0; + static int disabled_listeners=0; switch (signum) { case SIGINT: + if (!disabled_listeners) { + disable_all_listeners(); + disabled_listeners++; + } if (!got_sigint) { + log_info("Got SIGINT. Preparing shutdown."); start_shutdown(0); got_sigint++; } else { + log_info("Got SIGINT for the second time. Terminating."); start_shutdown(1); } break; case SIGTERM: + if (!disabled_listeners) { + disable_all_listeners(); + disabled_listeners++; + } + log_info("Got SIGTERM. Terminating."); start_shutdown(1); break; } @@ -348,18 +381,10 @@ main(int argc, const char **argv) /*Let's open a new listener for each protocol. */ int h; - listener_t **listeners; listener_t *temp_listener; int n_listeners=0; protocol_params_t *proto_params=NULL; - listeners = calloc(sizeof(listener_t*), actual_protocols); - if (!listeners) { - log_warn("Allocation failure: %s", strerror(errno)); - return 1; - } - for (h=0;h<actual_protocols;h++) { - log_debug("Spawning listener %d!", h+1); /** normally free'd in listener_free() */ @@ -379,8 +404,16 @@ main(int argc, const char **argv) continue; log_info("Succesfully created listener %d.", h+1); - listeners[n_listeners] = temp_listener; - + + /* If we don't have a listener dll, create one now. */ + if (!ll) { + ll = calloc(1, sizeof(dll_t)); + if (!ll) + return 1; + } + + /* Append our new listener in the listener dll. */ + dll_append(ll, temp_listener); n_listeners++; } @@ -398,11 +431,17 @@ main(int argc, const char **argv) if (close_obfsproxy_logfile() < 0) printf("Failed closing logfile!\n"); - /* We are exiting. Clean everything. */ - for (h=0;h<n_listeners;h++) - listener_free(listeners[h]); - if (listeners) - free(listeners); + /* Free all listeners in our listener dll. */ + if (ll) { + dll_node_t *ll_node = ll->head; + while (ll_node) { + listener_free(ll_node->data); + dll_remove(ll, ll_node); + ll_node = ll->head; + } + /* free dll memory */ + free(ll); + } free(protocol_options); free(n_options_array); diff --git a/src/network.c b/src/network.c index fc53564..1103eeb 100644 --- a/src/network.c +++ b/src/network.c @@ -26,19 +26,8 @@ struct listener_t { protocol_params_t *proto_params; }; -/** - Linked list carrying all currently active connections. - [linked list code was copied off tor.] -*/ -typedef struct conn_list_t { - conn_t *conn; - struct conn_list_t *next; -} conn_list_t; - -/** First and last elements in the linked list of active - connections. */ -static conn_list_t *cl_list=NULL; -static conn_list_t *cl_tail=NULL; +/** Doubly linked list holding all connections. */ +static dll_t *cl=NULL; /** Active connection counter */ static int n_connections=0; @@ -68,6 +57,8 @@ static void output_event_cb(struct bufferevent *bev, short what, void *arg); If 'barbaric' is set, we forcefully close all open connections and finish shutdown. + + (Only called by signal handlers) */ void start_shutdown(int barbaric) @@ -76,6 +67,8 @@ start_shutdown(int barbaric) shutting_down=1; if (!n_connections) { + if (cl) + free(cl); finish_shutdown(); return; } @@ -83,7 +76,6 @@ start_shutdown(int barbaric) if (barbaric) { if (n_connections) close_all_connections(); - finish_shutdown(); return; } } @@ -94,87 +86,18 @@ start_shutdown(int barbaric) static void close_all_connections(void) { - conn_t *conn; - - while (cl_list) { - assert(cl_list->conn); - assert(n_connections > 0); - conn = cl_list->conn; - conn_free(conn); - } -} - -/** - Places 'conn' to the end of the linked list of active connections. - Returns 1 on success, -1 on fail. -*/ -static int -cl_add(conn_t *conn) -{ - conn_list_t *cl; - - cl = calloc(1, sizeof(conn_list_t)); - if (!cl) - return -1; - - cl->conn = conn; - - if (!cl_tail) { - assert(!cl_list); - assert(!n_connections); - cl_list=cl; - cl_tail=cl; - } else { - assert(cl_list); - assert(!cl_tail->next); - cl_tail->next = cl; - cl_tail = cl; - } - - n_connections++; - - return 1; -} - -/** - Removes 'conn' from the linked list of connections: - It frees the list node carrying 'conn', but leaves 'conn' itself intact. -*/ -static void -cl_remove(conn_t *conn) -{ - conn_list_t *tmpo, *victim; - - if (!cl_list) - return; /* nothing here. */ - - /* first check to see if it's the first entry */ - tmpo = cl_list; - if (tmpo->conn == conn) { - /* it's the first one. remove it from the list. */ - cl_list = tmpo->next; - if (!cl_list) - cl_tail = NULL; - n_connections--; - victim = tmpo; - } else { /* we need to hunt through the rest of the list */ - for ( ;tmpo->next && tmpo->next->conn != conn; tmpo=tmpo->next) ; - if (!tmpo->next) { - return; + /** Traverse the dll and close all connections */ + dll_node_t *cl_node = cl->head; + while (cl_node) { + conn_free(cl_node->data); + + if (cl) { /* last conn_free() wipes the cl. */ + cl_node = cl->head; /* move to next connection */ + } else { + assert(!n_connections); + return; /* connections are now all closed. */ } - /* now we know tmpo->next->conn == conn */ - victim = tmpo->next; - tmpo->next = victim->next; - if (cl_tail == victim) - cl_tail = tmpo; - n_connections--; - } - - assert(n_connections>=0); - - /* now victim points to the element that needs to be removed */ - free(victim); - victim = NULL; + } } /** @@ -197,6 +120,13 @@ listener_new(struct event_base *base, return NULL; } + /** If we don't have a connection dll, create one now. */ + if (!cl) { + cl = calloc(1, sizeof(dll_t)); + if (!cl) + return NULL; + } + lsn->proto_params = proto_params; lsn->listener = evconnlistener_new_bind(base, simple_listener_cb, lsn, @@ -214,6 +144,17 @@ listener_new(struct event_base *base, return lsn; } +/** + Disable listener 'lsn'. +*/ +void +listener_disable(listener_t *lsn) +{ + assert(lsn); + + evconnlistener_disable(lsn->listener); +} + void listener_free(listener_t *lsn) { @@ -229,12 +170,6 @@ static void simple_listener_cb(struct evconnlistener *evcl, evutil_socket_t fd, struct sockaddr *sourceaddr, int socklen, void *arg) { - if (shutting_down) { - if (fd >= 0) - evutil_closesocket(fd); - return ; - } - listener_t *lsn = arg; struct event_base *base; conn_t *conn = calloc(1, sizeof(conn_t)); @@ -315,8 +250,9 @@ simple_listener_cb(struct evconnlistener *evcl, } /* add conn to the linked list of connections */ - if (cl_add(conn)<0) + if (dll_append(cl, conn)<0) goto err; + n_connections++; log_debug("Connection setup completed. " "We currently have %d connections!", n_connections); @@ -340,18 +276,27 @@ conn_free(conn_t *conn) bufferevent_free(conn->input); if (conn->output) bufferevent_free(conn->output); - memset(conn, 0x99, sizeof(conn_t)); + /* remove conn from the linked list of connections */ - cl_remove(conn); + dll_remove_with_data(cl, conn); + n_connections--; + + memset(conn, 0x99, sizeof(conn_t)); free(conn); + assert(n_connections>=0); log_debug("Connection destroyed. " "We currently have %d connections!", n_connections); /** If this was the last connection AND we are shutting down, finish shutdown. */ - if (!n_connections && shutting_down) + if (!n_connections && shutting_down) { + if (cl) { /* free connection dll */ + free(cl); + cl = NULL; + } finish_shutdown(); + } } static void diff --git a/src/network.h b/src/network.h index 28a0d7d..a8c02ac 100644 --- a/src/network.h +++ b/src/network.h @@ -46,6 +46,7 @@ struct addrinfo; listener_t *listener_new(struct event_base *base, struct protocol_params_t *params); void listener_free(listener_t *listener); +void listener_disable(listener_t *lsn); void start_shutdown(int barbaric); diff --git a/src/util.c b/src/util.c index 7e3e747..1ee7bcb 100644 --- a/src/util.c +++ b/src/util.c @@ -148,6 +148,146 @@ obfs_vsnprintf(char *str, size_t size, const char *format, va_list args) return r; } +/************************ Doubly Linked List (DLL) ******************/ + +/** + Insert 'new_node' after 'node' in the doubly linked list 'list'. +*/ +static void +dll_insert_after(dll_t *list, dll_node_t *node, dll_node_t *new_node) +{ + assert(node); + assert(new_node); + + if (!list) + return; + + new_node->prev = node; + new_node->next = node->next; + if (!node->next) + list->tail = new_node; + else + node->next->prev = new_node; + node->next = new_node; +} + +/** + Insert 'new_node' before 'node' in the doubly linked list 'list'. +*/ +static void +dll_insert_before(dll_t *list, dll_node_t *node, dll_node_t *new_node) +{ + assert(node); + assert(new_node); + + if (!list) + return; + + new_node->prev = node->prev; + new_node->next = node; + if (!node->prev) + list->head = new_node; + else + node->prev->next = new_node; + node->prev = new_node; +} + +/** + Insert 'node' in the beginning of the doubly linked 'list'. +*/ +static void +dll_insert_beginning(dll_t *list, dll_node_t *node) +{ + assert(node); + + if (!list) + return; + + if (!list->head) { + list->head = node; + list->tail = node; + node->prev = NULL; + node->next = NULL; + } else { + dll_insert_before(list, list->head, node); + } +} + +/** + Appends 'data' to the end of the doubly linked 'list'. + Returns 1 on success, -1 on fail. +*/ +int +dll_append(dll_t *list, void *data) +{ + assert(data); + + if (!list) + return -1; + + dll_node_t *node; + + node = calloc(1, sizeof(dll_node_t)); + if (!node) + return -1; + node->data = data; + + if (!list->tail) + dll_insert_beginning(list, node); + else + dll_insert_after(list, list->tail, node); + + return 1; +} + +/** + Removes 'node' from the doubly linked list 'list'. + It frees the list node, but leaves its data intact. +*/ +void +dll_remove(dll_t *list, dll_node_t *node) +{ + assert(node); + + if (!list) + return; + + if (!node->prev) + list->head = node->next; + else + node->prev->next = node->next; + if (!node->next) + list->tail = node->prev; + else + node->next->prev = node->prev; + + free(node); +} + +/** + Removes node carrying 'data' from the doubly linked list 'list'. + It frees the list node, but leaves 'data' intact. +*/ +void +dll_remove_with_data(dll_t *list, void *data) +{ + assert(data); + + if (!list) + return; + + dll_node_t *node = list->head; + while (node) { + if (node->data == data) { + dll_remove(list, node); + return; + } else { + node = node->next; + } + } + assert(0); /*too brutal?*/ +} + /************************ Logging Subsystem *************************/ /** The code of this section was to a great extend shamelessly copied off tor. It's basicaly a stripped down version of tor's logging @@ -404,3 +544,4 @@ log_debug(const char *format, ...) va_end(ap); } #endif + diff --git a/src/util.h b/src/util.h index 2705d51..999c5df 100644 --- a/src/util.h +++ b/src/util.h @@ -50,6 +50,25 @@ int obfs_snprintf(char *str, size_t size, const char *format, ...) __attribute__((format(printf, 3, 4))); +/***** Doubly Linked List stuff. *****/ + +/** A doubly linked list node. + [algorithms ripped off Wikipedia (Doubly_linked_list) ] */ +typedef struct dll_node_t { + struct dll_node_t *next, *prev; + void *data; +} dll_node_t; + +/** A doubly linked list. */ +typedef struct dll_t { + struct dll_node_t *head; + struct dll_node_t *tail; +} dll_t; + +int dll_append(dll_t *list, void *data); +void dll_remove(dll_t *list, dll_node_t *node); +void dll_remove_with_data(dll_t *list, void *data); + /***** Logging subsystem stuff. *****/ void log_fn(int severity, const char *format, ...)