add some write locks to the core and a function to unregister event bindings

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@8880 d0543943-73ff-0310-b7d9-9358b9ac24b2

src/include/switch_core.h

@@ -599,6 +599,9 @@ SWITCH_DECLARE(void) switch_core_set_variable(_In_z_ const char *varname, _In_op
 */
 SWITCH_DECLARE(void) switch_core_session_hupall(_In_ switch_call_cause_t cause);
 
+SWITCH_DECLARE(void) switch_core_session_hupall_matching_var(_In_ const char *var_name, _In_ const char *var_val, _In_ switch_call_cause_t cause);
+SWITCH_DECLARE(void) switch_core_session_hupall_endpoint(const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause);
+
 /*! 
   \brief Send a message to another session using it's uuid
   \param uuid_str the unique id of the session you want to send a message to

src/include/switch_event.h

@@ -70,14 +70,6 @@ SWITCH_BEGIN_EXTERN_C
 	struct switch_event_header *next;
 };
 
-/*! \brief A registered custom event subclass  */
-struct switch_event_subclass {
-	/*! the owner of the subclass */
-	char *owner;
-	/*! the subclass name */
-	char *name;
-};
-
 /*! \brief Representation of an event */
 struct switch_event {
 	/*! the event id (descriptor) */
@@ -87,7 +79,7 @@ struct switch_event {
 	/*! the owner of the event */
 	char *owner;
 	/*! the subclass of the event */
-	switch_event_subclass_t *subclass;
+	char *subclass_name;
 	/*! the event headers */
 	switch_event_header_t *headers;
 	/*! the event headers tail pointer */
@@ -103,20 +95,7 @@ struct switch_event {
 	struct switch_event *next;
 };
 
-/*! \brief A node to store binded events */
-struct switch_event_node {
-	/*! the id of the node */
-	char *id;
-	/*! the event id enumeration to bind to */
-	switch_event_types_t event_id;
-	/*! the event subclass to bind to for custom events */
-	switch_event_subclass_t *subclass;
-	/*! a callback function to execute when the event is triggered */
-	switch_event_callback_t callback;
-	/*! private data */
-	void *user_data;
-	struct switch_event_node *next;
-};
+struct switch_event_node;
 
 #define SWITCH_EVENT_SUBCLASS_ANY NULL
 
@@ -228,6 +207,25 @@ SWITCH_DECLARE(switch_status_t) switch_event_fire_detailed(const char *file, con
 SWITCH_DECLARE(switch_status_t) switch_event_bind(const char *id, switch_event_types_t event, const char *subclass_name, switch_event_callback_t callback,
 												  void *user_data);
 
+/*!
+  \brief Bind an event callback to a specific event
+  \param id an identifier token of the binder
+  \param event the event enumeration to bind to
+  \param subclass_name the event subclass to bind to in the case if SWITCH_EVENT_CUSTOM
+  \param callback the callback functon to bind
+  \param user_data optional user specific data to pass whenever the callback is invoked
+  \param node bind handle to later remove the binding.
+  \return SWITCH_STATUS_SUCCESS if the event was binded
+*/
+SWITCH_DECLARE(switch_status_t) switch_event_bind_removable(const char *id, switch_event_types_t event, const char *subclass_name, 
+															switch_event_callback_t callback, void *user_data, switch_event_node_t **node);
+/*!
+  \brief Unbind a bound event consumer
+  \param node node to unbind
+  \return SWITCH_STATUS_SUCCESS if the consumer was unbinded
+*/
+SWITCH_DECLARE(switch_status_t) switch_event_unbind(switch_event_node_t **node);
+
 /*!
   \brief Render the name of an event id enumeration
   \param event the event id to render the name of
@@ -253,6 +251,8 @@ SWITCH_DECLARE(switch_status_t) switch_name_event(const char *name, switch_event
 */
 SWITCH_DECLARE(switch_status_t) switch_event_reserve_subclass_detailed(const char *owner, const char *subclass_name);
 
+SWITCH_DECLARE(switch_status_t) switch_event_free_subclass_detailed(const char *owner, const char *subclass_name);
+
 /*!
   \brief Render a string representation of an event sutable for printing or network transport 
   \param event the event to render
@@ -311,6 +311,7 @@ SWITCH_DECLARE(switch_status_t) switch_event_create_pres_in_detailed(_In_z_ char
   \note the body supplied by this function will supersede an existing body the event may have
 */
 #define switch_event_reserve_subclass(subclass_name) switch_event_reserve_subclass_detailed(__FILE__, subclass_name)
+#define switch_event_free_subclass(subclass_name) switch_event_free_subclass_detailed(__FILE__, subclass_name)
 
 /*!
   \brief Create a new event assuming it will not be custom event and therefore hiding the unused parameters

src/include/switch_module_interfaces.h

@@ -195,6 +195,8 @@ struct switch_endpoint_interface {
 	/*! private information */
 	void *private_info;
 
+	switch_thread_rwlock_t *rwlock;
+
 	/* to facilitate linking */
 	struct switch_endpoint_interface *next;
 };
@@ -245,6 +247,7 @@ struct switch_timer_interface {
 	switch_status_t (*timer_check) (switch_timer_t *, switch_bool_t);
 	/*! function to deallocate the timer */
 	switch_status_t (*timer_destroy) (switch_timer_t *);
+	switch_thread_rwlock_t *rwlock;
 	struct switch_timer_interface *next;
 };
 
@@ -254,6 +257,7 @@ struct switch_dialplan_interface {
 	const char *interface_name;
 	/*! the function to read an extension and set a channels dialpan */
 	switch_dialplan_hunt_function_t hunt_function;
+	switch_thread_rwlock_t *rwlock;
 	struct switch_dialplan_interface *next;
 };
 
@@ -277,6 +281,7 @@ struct switch_file_interface {
 	switch_status_t (*file_get_string) (switch_file_handle_t *fh, switch_audio_col_t col, const char **string);
 	/*! list of supported file extensions */
 	char **extens;
+	switch_thread_rwlock_t *rwlock;
 	struct switch_file_interface *next;
 };
 
@@ -353,6 +358,7 @@ struct switch_asr_interface {
 	switch_status_t (*asr_check_results) (switch_asr_handle_t *ah, switch_asr_flag_t *flags);
 	/*! function to read results from the ASR */
 	switch_status_t (*asr_get_results) (switch_asr_handle_t *ah, char **xmlstr, switch_asr_flag_t *flags);
+	switch_thread_rwlock_t *rwlock;
 	struct switch_asr_interface *next;
 };
 
@@ -393,7 +399,7 @@ struct switch_speech_interface {
 	void (*speech_text_param_tts) (switch_speech_handle_t *sh, char *param, const char *val);
 	void (*speech_numeric_param_tts) (switch_speech_handle_t *sh, char *param, int val);
 	void (*speech_float_param_tts) (switch_speech_handle_t *sh, char *param, double val);
-
+	switch_thread_rwlock_t *rwlock;
 	struct switch_speech_interface *next;
 };
 
@@ -426,6 +432,7 @@ struct switch_say_interface {
 	const char *interface_name;
 	/*! function to pass down to the module */
 	switch_say_callback_t say_function;
+	switch_thread_rwlock_t *rwlock;
 	struct switch_say_interface *next;
 };
 
@@ -435,6 +442,7 @@ struct switch_chat_interface {
 	const char *interface_name;
 	/*! function to open the directory interface */
 	switch_status_t (*chat_send) (char *proto, char *from, char *to, char *subject, char *body, char *hint);
+	switch_thread_rwlock_t *rwlock;
 	struct switch_chat_interface *next;
 };
 
@@ -444,6 +452,7 @@ struct switch_management_interface {
 	const char *relative_oid;
 	/*! function to open the directory interface */
 	switch_status_t (*management_function) (char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen);
+	switch_thread_rwlock_t *rwlock;
 	struct switch_management_interface *next;
 };
 
@@ -461,7 +470,7 @@ struct switch_directory_interface {
 	switch_status_t (*directory_next) (switch_directory_handle_t *dh);
 	/*! function to advance to the next name/value pair in the current record */
 	switch_status_t (*directory_next_pair) (switch_directory_handle_t *dh, char **var, char **val);
-
+	switch_thread_rwlock_t *rwlock;
 	struct switch_directory_interface *next;
 };
 
@@ -586,6 +595,7 @@ struct switch_codec_interface {
 	/*! a list of codec implementations related to the codec */
 	switch_codec_implementation_t *implementations;
 	uint32_t codec_id;
+	switch_thread_rwlock_t *rwlock;
 	struct switch_codec_interface *next;
 };
 
@@ -603,6 +613,7 @@ struct switch_application_interface {
 	const char *syntax;
 	/*! flags to control behaviour */
 	uint32_t flags;
+	switch_thread_rwlock_t *rwlock;
 	struct switch_application_interface *next;
 };
 
@@ -616,6 +627,7 @@ struct switch_api_interface {
 	switch_api_function_t function;
 	/*! an example of the api syntax */
 	const char *syntax;
+	switch_thread_rwlock_t *rwlock;
 	struct switch_api_interface *next;
 };
 

src/include/switch_types.h

@@ -100,6 +100,7 @@ SWITCH_BEGIN_EXTERN_C
 #define SWITCH_PATH_SEPARATOR "/"
 #endif
 #define SWITCH_URL_SEPARATOR "://"
+#define SWITCH_CURRENT_APPLICATION_VARIABLE "current_application"
 #define SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE "proto_specific_hangup_cause"
 #define SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE "execute_on_answer"
 #define SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE "execute_on_ring"

src/mod/applications/mod_fifo/mod_fifo.c

@@ -242,6 +242,7 @@ static struct {
 	switch_mutex_t *mutex;
 	switch_memory_pool_t *pool;
 	int running;
+	switch_event_node_t *node;
 } globals;
 
 
@@ -1182,7 +1183,8 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_fifo_load)
 	}
 
 	/* Subscribe to presence request events */
-	if (switch_event_bind(modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, pres_event_handler, NULL) != SWITCH_STATUS_SUCCESS) {
+	if (switch_event_bind_removable(modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, 
+									pres_event_handler, NULL, &globals.node) != SWITCH_STATUS_SUCCESS) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't subscribe to presence request events!\n");
 		return SWITCH_STATUS_GENERR;
 	}
@@ -1215,7 +1217,10 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_fifo_shutdown)
 	fifo_node_t *node;
 	switch_memory_pool_t *pool = globals.pool;
 	switch_mutex_t *mutex = globals.mutex;
-
+	
+	switch_event_unbind(&globals.node);
+	switch_event_free_subclass(FIFO_EVENT);
+	
 	switch_mutex_lock(mutex);
 
 	globals.running = 0;
@@ -1229,6 +1234,7 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_fifo_shutdown)
 				free(pop);
 			}
 		}
+
 		switch_core_hash_destroy(&node->caller_hash);
 		switch_core_hash_destroy(&node->consumer_hash);
 	}

src/mod/event_handlers/mod_event_multicast/mod_event_multicast.c

@@ -147,7 +147,7 @@ static void event_handler(switch_event_t *event)
 		return;
 	}
 
-	if (event->subclass && !strcmp(event->subclass->name, MULTICAST_EVENT)) {
+	if (event->subclass_name && !strcmp(event->subclass_name, MULTICAST_EVENT)) {
 		/* ignore our own events to avoid ping pong */
 		return;
 	}
@@ -155,7 +155,7 @@ static void event_handler(switch_event_t *event)
 	if (globals.event_list[(uint8_t) SWITCH_EVENT_ALL]) {
 		send = 1;
 	} else if ((globals.event_list[(uint8_t) event->event_id])) {
-		if (event->event_id != SWITCH_EVENT_CUSTOM || (event->subclass && switch_core_hash_find(globals.event_hash, event->subclass->name))) {
+		if (event->event_id != SWITCH_EVENT_CUSTOM || (event->subclass_name && switch_core_hash_find(globals.event_hash, event->subclass_name))) {
 			send = 1;
 		}
 	}

src/mod/event_handlers/mod_event_socket/mod_event_socket.c

@@ -162,7 +162,7 @@ static void event_handler(switch_event_t *event)
 		if (l->event_list[SWITCH_EVENT_ALL]) {
 			send = 1;
 		} else if ((l->event_list[event->event_id])) {
-			if (event->event_id != SWITCH_EVENT_CUSTOM || !event->subclass || (switch_core_hash_find(l->event_hash, event->subclass->name))) {
+			if (event->event_id != SWITCH_EVENT_CUSTOM || !event->subclass_name || (switch_core_hash_find(l->event_hash, event->subclass_name))) {
 				send = 1;
 			}
 		}

src/switch_core_session.c

@@ -72,6 +72,50 @@ SWITCH_DECLARE(switch_core_session_t *) switch_core_session_locate(const char *u
 	return session;
 }
 
+
+SWITCH_DECLARE(void) switch_core_session_hupall_matching_var(const char *var_name, const char *var_val, switch_call_cause_t cause)
+{
+	switch_hash_index_t *hi;
+	void *val;
+	switch_core_session_t *session;
+
+	switch_mutex_lock(runtime.throttle_mutex);
+	for (hi = switch_hash_first(NULL, session_manager.session_table); hi; hi = switch_hash_next(hi)) {
+		switch_hash_this(hi, NULL, NULL, &val);
+		if (val) {
+			const char *this_val;
+			session = (switch_core_session_t *) val;
+			switch_core_session_read_lock(session);
+			if ((this_val = switch_channel_get_variable(session->channel, var_name)) && (!strcmp(this_val, var_val))) {
+				switch_channel_hangup(switch_core_session_get_channel(session), cause);
+			}
+			switch_core_session_rwunlock(session);
+		}
+	}
+	switch_mutex_unlock(runtime.throttle_mutex);
+}	
+
+SWITCH_DECLARE(void) switch_core_session_hupall_endpoint(const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause)
+{
+	switch_hash_index_t *hi;
+	void *val;
+	switch_core_session_t *session;
+
+	switch_mutex_lock(runtime.throttle_mutex);
+	for (hi = switch_hash_first(NULL, session_manager.session_table); hi; hi = switch_hash_next(hi)) {
+		switch_hash_this(hi, NULL, NULL, &val);
+		if (val) {
+			session = (switch_core_session_t *) val;
+			switch_core_session_read_lock(session);
+			if (session->endpoint_interface == endpoint_interface) {
+				switch_channel_hangup(switch_core_session_get_channel(session), cause);
+			}
+			switch_core_session_rwunlock(session);
+		}
+	}
+	switch_mutex_unlock(runtime.throttle_mutex);
+}	
+
 SWITCH_DECLARE(void) switch_core_session_hupall(switch_call_cause_t cause)
 {
 	switch_hash_index_t *hi;
@@ -686,6 +730,8 @@ SWITCH_DECLARE(void) switch_core_session_perform_destroy(switch_core_session_t *
 {
 	switch_memory_pool_t *pool;
 	switch_event_t *event;
+	const switch_endpoint_interface_t *endpoint_interface = (*session)->endpoint_interface;
+
 
 	switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_NOTICE, "Close Channel %s [%s]\n",
 					  switch_channel_get_name((*session)->channel), switch_channel_state_name(switch_channel_get_state((*session)->channel)));
@@ -720,6 +766,8 @@ SWITCH_DECLARE(void) switch_core_session_perform_destroy(switch_core_session_t *
 	*session = NULL;
 	switch_core_destroy_memory_pool(&pool);
 
+	switch_thread_rwlock_unlock(endpoint_interface->rwlock);
+
 }
 
 static void *SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread_t *thread, void *obj)
@@ -827,6 +875,8 @@ SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request(const switch
 		return NULL;
 	}
 
+	switch_thread_rwlock_rdlock(endpoint_interface->rwlock);
+
 	if (pool && *pool) {
 		usepool = *pool;
 		*pool = NULL;
@@ -1047,8 +1097,12 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_exec(switch_core_session_t *
 
 	switch_assert(application_interface->application_function);
 
-	application_interface->application_function(session, arg);
+	switch_channel_set_variable(session->channel, SWITCH_CURRENT_APPLICATION_VARIABLE, application_interface->interface_name);
 
+	switch_thread_rwlock_rdlock(application_interface->rwlock);
+	application_interface->application_function(session, arg);
+	switch_thread_rwlock_unlock(application_interface->rwlock);
+	
 	if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE) == SWITCH_STATUS_SUCCESS) {
 		switch_channel_event_set_data(session->channel, event);
 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Application", "%s", application_interface->interface_name);

src/switch_loadable_module.c

@@ -412,8 +412,16 @@ static switch_status_t switch_loadable_module_unprocess(switch_loadable_module_t
 
 	if (old_module->module_interface->endpoint_interface) {
 		const switch_endpoint_interface_t *ptr;
+
 		for (ptr = old_module->module_interface->endpoint_interface; ptr; ptr = ptr->next) {
 			if (ptr->interface_name) {
+
+				switch_core_session_hupall_endpoint(ptr, SWITCH_CAUSE_SYSTEM_SHUTDOWN);
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n", ptr->interface_name);
+				switch_thread_rwlock_wrlock(ptr->rwlock);
+				switch_thread_rwlock_unlock(ptr->rwlock);
+			
+
 				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Endpoint '%s'\n", ptr->interface_name);
 				switch_core_hash_delete(loadable_modules.endpoint_hash, ptr->interface_name);
 			}
@@ -486,10 +494,14 @@ static switch_status_t switch_loadable_module_unprocess(switch_loadable_module_t
 
 	if (old_module->module_interface->application_interface) {
 		const switch_application_interface_t *ptr;
-
 		for (ptr = old_module->module_interface->application_interface; ptr; ptr = ptr->next) {
 			if (ptr->interface_name) {
 				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Application '%s'\n", ptr->interface_name);
+				switch_core_session_hupall_matching_var(SWITCH_CURRENT_APPLICATION_VARIABLE, ptr->interface_name, SWITCH_CAUSE_SYSTEM_SHUTDOWN);
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n", ptr->interface_name);
+				switch_thread_rwlock_wrlock(ptr->rwlock);
+				switch_thread_rwlock_unlock(ptr->rwlock);
+
 				if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
 					switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "%s", "application");
 					switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
@@ -508,6 +520,11 @@ static switch_status_t switch_loadable_module_unprocess(switch_loadable_module_t
 		for (ptr = old_module->module_interface->api_interface; ptr; ptr = ptr->next) {
 			if (ptr->interface_name) {
 				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting API Function '%s'\n", ptr->interface_name);
+
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n", ptr->interface_name);
+				switch_thread_rwlock_wrlock(ptr->rwlock);
+				switch_thread_rwlock_unlock(ptr->rwlock);
+
 				if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
 					switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "%s", "api");
 					switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
@@ -1357,9 +1374,11 @@ SWITCH_DECLARE(switch_status_t) switch_api_execute(const char *cmd, const char *
 
 
 	if (cmd && (api = switch_loadable_module_get_api_interface(cmd)) != 0) {
+		switch_thread_rwlock_rdlock(api->rwlock);
 		if ((status = api->function(arg, session, stream)) != SWITCH_STATUS_SUCCESS) {
 			stream->write_function(stream, "COMMAND RETURNED ERROR!\n");
 		}
+		switch_thread_rwlock_unlock(api->rwlock);
 	} else {
 		status = SWITCH_STATUS_FALSE;
 		stream->write_function(stream, "INVALID COMMAND!\n");
@@ -1398,7 +1417,7 @@ SWITCH_DECLARE(switch_loadable_module_interface_t *) switch_loadable_module_crea
 		} else {														\
 			mod->_TYPE_##_interface = i;								\
 		}																\
-																		\
+		switch_thread_rwlock_create(&i->rwlock, mod->pool);				\
 		return i; }