FS-10025: fix global symbol scope issue causing modules to use another modules global pointer

Conflicts:
	libs/sofia-sip/.update

libs/sofia-sip/.update

-Fri Dec 30 15:29:04 CST 2016
+Thu Feb  9 17:36:33 CST 2017

libs/sofia-sip/libsofia-sip-ua/tport/ws.c

@@ -25,7 +25,7 @@
 #define WS_NOBLOCK 0
 
 #define SHA1_HASH_SIZE 20
-struct ws_globals_s ws_globals;
+static struct ws_globals_s ws_globals;
 
 #ifndef WSS_STANDALONE
 

libs/sofia-sip/libsofia-sip-ua/tport/ws.h

@@ -61,7 +61,7 @@ struct ws_globals_s {
 	char key[512];
 };
 
-extern struct ws_globals_s ws_globals;
+//extern struct ws_globals_s ws_globals;
 
 #ifndef WIN32
 typedef int ws_socket_t;

src/mod/applications/mod_avmd/mod_avmd.c

@@ -187,7 +187,7 @@ typedef struct {
     size_t sample_count;
 } avmd_session_t;
 
-struct avmd_globals
+static struct avmd_globals
 {
     switch_mutex_t          *mutex;
     struct avmd_settings    settings;

src/mod/applications/mod_oreka/mod_oreka.c

@@ -60,7 +60,7 @@ typedef struct oreka_session_s {
     int mux_streams;
 } oreka_session_t;
 
-struct {
+static struct {
 	char local_ipv4_str[256];
 	char sip_server_addr_str[256];
 	char sip_server_ipv4_str[256];

src/mod/applications/mod_sms_flowroute/mod_sms_flowroute.c

@@ -35,7 +35,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_sms_flowroute_load);
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_sms_flowroute_shutdown);
 SWITCH_MODULE_DEFINITION(mod_sms_flowroute, mod_sms_flowroute_load, mod_sms_flowroute_shutdown, NULL);
 
-mod_sms_flowroute_globals_t mod_sms_flowroute_globals;
+static mod_sms_flowroute_globals_t mod_sms_flowroute_globals;
 
 static void on_accept(h2o_socket_t *listener, const char *error)
 {

src/mod/applications/mod_spy/mod_spy.c

@@ -38,7 +38,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_spy_load);
 
 SWITCH_MODULE_DEFINITION(mod_spy, mod_spy_load, mod_spy_shutdown, NULL);
 
-struct mod_spy_globals {
+static struct mod_spy_globals {
 	switch_memory_pool_t *pool;
 	switch_event_node_t *node;
 	switch_hash_t *spy_hash;

src/mod/endpoints/mod_h323/mod_h323.cpp

@@ -47,7 +47,7 @@ SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_rtp_timer_name, mod_h323_globals.rt
 
 
 #define CF_NEED_FLUSH (1 << 1)
-struct mod_h323_globals mod_h323_globals = { 0 };
+static struct mod_h323_globals mod_h323_globals = { 0 };
 
 static switch_call_cause_t create_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,
                                                    switch_caller_profile_t *outbound_profile, switch_core_session_t **new_session,

src/mod/endpoints/mod_skinny/mod_skinny.h

@@ -101,7 +101,7 @@ struct skinny_globals {
 };
 typedef struct skinny_globals skinny_globals_t;
 
-extern skinny_globals_t globals;
+extern skinny_globals_t skinny_globals;
 
 typedef enum {
 	PFLAG_LISTENER_READY = (1 << 0),

src/mod/endpoints/mod_skinny/skinny_api.c

@@ -48,14 +48,14 @@ static switch_status_t skinny_api_list_profiles(const char *line, const char *cu
 	skinny_profile_t *profile;
 
 	/* walk profiles */
-	switch_mutex_lock(globals.mutex);
-	for (hi = switch_core_hash_first(globals.profile_hash); hi; hi = switch_core_hash_next(&hi)) {
+	switch_mutex_lock(skinny_globals.mutex);
+	for (hi = switch_core_hash_first(skinny_globals.profile_hash); hi; hi = switch_core_hash_next(&hi)) {
 		switch_core_hash_this(hi, NULL, NULL, &val);
 		profile = (skinny_profile_t *) val;
 
 		switch_console_push_match(&my_matches, profile->name);
 	}
-	switch_mutex_unlock(globals.mutex);
+	switch_mutex_unlock(skinny_globals.mutex);
 
 	if (my_matches) {
 		*matches = my_matches;

src/mod/endpoints/mod_verto/mod_verto.h

@@ -308,8 +308,6 @@ struct globals_s {
 };
 
 
-extern struct globals_s globals;
-
 typedef switch_bool_t (*jrpc_func_t)(const char *method, cJSON *params, jsock_t *jsock, cJSON **response);
 
 

src/mod/endpoints/mod_verto/ws.c

@@ -25,7 +25,7 @@
 #define WS_NOBLOCK 0
 
 #define SHA1_HASH_SIZE 20
-struct ws_globals_s ws_globals;
+static struct ws_globals_s ws_globals;
 
 #ifndef WSS_STANDALONE
 
@@ -107,13 +107,13 @@ void init_ssl(void) {
 	assert(ws_globals.ssl_ctx);
 
 	/* Disable SSLv2 */
-	SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_SSLv2);
+	SSL_CTX_set_options(ws_globals.ssl_ctx, SSL_OP_NO_SSLv2);
 	/* Disable SSLv3 */
-	SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_SSLv3);
+	SSL_CTX_set_options(ws_globals.ssl_ctx, SSL_OP_NO_SSLv3);
 	/* Disable TLSv1 */
-	SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_TLSv1);
+	SSL_CTX_set_options(ws_globals.ssl_ctx, SSL_OP_NO_TLSv1);
 	/* Disable Compression CRIME (Compression Ratio Info-leak Made Easy) */
-	SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_COMPRESSION);
+	SSL_CTX_set_options(ws_globals.ssl_ctx, SSL_OP_NO_COMPRESSION);
 	/* set the local certificate from CertFile */
 	SSL_CTX_use_certificate_file(ws_globals.ssl_ctx, ws_globals.cert, SSL_FILETYPE_PEM);
 	/* set the private key from KeyFile */

src/mod/endpoints/mod_verto/ws.h

@@ -61,7 +61,7 @@ struct ws_globals_s {
 	char key[512];
 };
 
-extern struct ws_globals_s ws_globals;
+//extern struct ws_globals_s ws_globals;
 
 #ifndef WIN32
 typedef int ws_socket_t;

src/mod/event_handlers/mod_erlang_event/ei_helpers.c

@@ -202,21 +202,21 @@ void ei_init_ref(ei_cnode * ec, erlang_ref * ref)
 	memset(ref, 0, sizeof(*ref));	/* zero out the struct */
 	snprintf(ref->node, MAXATOMLEN, "%s", ec->thisnodename);
 
-	switch_mutex_lock(globals.ref_mutex);
-	globals.reference0++;
-	if (globals.reference0 >= MAX_REFERENCE) {
-		globals.reference0 = 0;
-		globals.reference1++;
-		if (globals.reference1 == 0) {
-			globals.reference2++;
+	switch_mutex_lock(mod_erlang_event_globals.ref_mutex);
+	mod_erlang_event_globals.reference0++;
+	if (mod_erlang_event_globals.reference0 >= MAX_REFERENCE) {
+		mod_erlang_event_globals.reference0 = 0;
+		mod_erlang_event_globals.reference1++;
+		if (mod_erlang_event_globals.reference1 == 0) {
+			mod_erlang_event_globals.reference2++;
 		}
 	}
 
-	ref->n[0] = globals.reference0;
-	ref->n[1] = globals.reference1;
-	ref->n[2] = globals.reference2;
+	ref->n[0] = mod_erlang_event_globals.reference0;
+	ref->n[1] = mod_erlang_event_globals.reference1;
+	ref->n[2] = mod_erlang_event_globals.reference2;
 
-	switch_mutex_unlock(globals.ref_mutex);
+	switch_mutex_unlock(mod_erlang_event_globals.ref_mutex);
 
 	ref->creation = 1;			/* why is this 1 */
 	ref->len = 3;				/* why is this 3 */

src/mod/event_handlers/mod_erlang_event/handle_msg.c

@@ -958,7 +958,7 @@ static switch_status_t handle_msg_bind(listener_t *listener, erlang_msg * msg, e
 			binding->process.pid = msg->from;
 			binding->listener = listener;
 
-			switch_thread_rwlock_wrlock(globals.bindings_rwlock);
+			switch_thread_rwlock_wrlock(mod_erlang_event_globals.bindings_rwlock);
 
 			for (ptr = bindings.head; ptr && ptr->next; ptr = ptr->next);
 
@@ -969,7 +969,7 @@ static switch_status_t handle_msg_bind(listener_t *listener, erlang_msg * msg, e
 			}
 
 			switch_xml_set_binding_sections(bindings.search_binding, switch_xml_get_binding_sections(bindings.search_binding) | section);
-			switch_thread_rwlock_unlock(globals.bindings_rwlock);
+			switch_thread_rwlock_unlock(mod_erlang_event_globals.bindings_rwlock);
 
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "sections %d\n", switch_xml_get_binding_sections(bindings.search_binding));
 

src/mod/event_handlers/mod_erlang_event/mod_erlang_event.h

@@ -222,12 +222,12 @@ typedef struct prefs_struct prefs_t;
 
 /* shared globals */
 #ifdef DEFINE_GLOBALS
-globals_t globals;
+globals_t mod_erlang_event_globals;
 listen_list_t listen_list;
 bindings_t bindings;
 prefs_t prefs;
 #else
-extern globals_t globals;
+extern globals_t mod_erlang_event_globals;
 extern listen_list_t listen_list;
 extern bindings_t bindings;
 extern prefs_t prefs;

src/mod/event_handlers/mod_kazoo/kazoo_event_stream.c

@@ -73,11 +73,11 @@ static switch_status_t kazoo_event_dup(switch_event_t **clone, switch_event_t *e
 			continue;
 		}
 
-		if (strncmp(header->name, globals.kazoo_var_prefix, globals.var_prefix_length)
+		if (strncmp(header->name, kazoo_globals.kazoo_var_prefix, kazoo_globals.var_prefix_length)
 			&& filter
 			&& !switch_core_hash_find(filter, header->name)
-			&& (!globals.send_all_headers)
-			&& (!(globals.send_all_private_headers && is_private_header(header->name)))
+			&& (!kazoo_globals.send_all_headers)
+			&& (!(kazoo_globals.send_all_private_headers && is_private_header(header->name)))
 			)
 			{
 				continue;
@@ -107,7 +107,7 @@ static void event_handler(switch_event_t *event) {
 	ei_event_stream_t *event_stream = (ei_event_stream_t *) event->bind_user_data;
 
 	/* if mod_kazoo or the event stream isn't running dont push a new event */
-	if (!switch_test_flag(event_stream, LFLAG_RUNNING) || !switch_test_flag(&globals, LFLAG_RUNNING)) {
+	if (!switch_test_flag(event_stream, LFLAG_RUNNING) || !switch_test_flag(&kazoo_globals, LFLAG_RUNNING)) {
 		return;
 	}
 
@@ -138,7 +138,7 @@ static void event_handler(switch_event_t *event) {
 	/* try to clone the event and push it to the event stream thread */
 	/* TODO: someday maybe the filter comes from the event_stream (set during init only)
 	 * and is per-binding so we only send headers that a process requests */
-	if (kazoo_event_dup(&clone, event, globals.event_filter) == SWITCH_STATUS_SUCCESS) {
+	if (kazoo_event_dup(&clone, event, kazoo_globals.event_filter) == SWITCH_STATUS_SUCCESS) {
 		if (switch_queue_trypush(event_stream->queue, clone) != SWITCH_STATUS_SUCCESS) {
 			/* if we couldn't place the cloned event into the listeners */
 			/* event queue make sure we destroy it, real good like */
@@ -157,9 +157,9 @@ static void *SWITCH_THREAD_FUNC event_stream_loop(switch_thread_t *thread, void
     char ipbuf[48];
     const char *ip_addr;
 	void *pop;
-	short event_stream_framing = globals.event_stream_framing;
+	short event_stream_framing = kazoo_globals.event_stream_framing;
 
-	switch_atomic_inc(&globals.threads);
+	switch_atomic_inc(&kazoo_globals.threads);
 
 	switch_assert(event_stream != NULL);
 
@@ -172,7 +172,7 @@ static void *SWITCH_THREAD_FUNC event_stream_loop(switch_thread_t *thread, void
 					  ,(void *)event_stream, ip_addr, port, event_stream->pid.node, event_stream->pid.creation
 					  ,event_stream->pid.num, event_stream->pid.serial);
 
-	while (switch_test_flag(event_stream, LFLAG_RUNNING) && switch_test_flag(&globals, LFLAG_RUNNING)) {
+	while (switch_test_flag(event_stream, LFLAG_RUNNING) && switch_test_flag(&kazoo_globals, LFLAG_RUNNING)) {
 		const switch_pollfd_t *fds;
 		int32_t numfds;
 
@@ -226,9 +226,9 @@ static void *SWITCH_THREAD_FUNC event_stream_loop(switch_thread_t *thread, void
 				short i = event_stream_framing;
 				switch_size_t size = 1;
 
-				if(globals.event_stream_preallocate > 0) {
-					ebuf.buff = malloc(globals.event_stream_preallocate);
-					ebuf.buffsz = globals.event_stream_preallocate;
+				if(kazoo_globals.event_stream_preallocate > 0) {
+					ebuf.buff = malloc(kazoo_globals.event_stream_preallocate);
+					ebuf.buffsz = kazoo_globals.event_stream_preallocate;
 					ebuf.index = 0;
 					if(ebuf.buff == NULL) {
 						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not pre-allocate memory for mod_kazoo message\n");
@@ -241,7 +241,7 @@ static void *SWITCH_THREAD_FUNC event_stream_loop(switch_thread_t *thread, void
 
 				ei_encode_switch_event(&ebuf, event);
 
-				if (globals.event_stream_preallocate > 0 && ebuf.buffsz > globals.event_stream_preallocate) {
+				if (kazoo_globals.event_stream_preallocate > 0 && ebuf.buffsz > kazoo_globals.event_stream_preallocate) {
 					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "increased event stream buffer size to %d\n", ebuf.buffsz);
 				}
 
@@ -292,7 +292,7 @@ static void *SWITCH_THREAD_FUNC event_stream_loop(switch_thread_t *thread, void
 	/* clean up the memory */
 	switch_core_destroy_memory_pool(&event_stream->pool);
 
-	switch_atomic_dec(&globals.threads);
+	switch_atomic_dec(&kazoo_globals.threads);
 
 	return NULL;
 }

src/mod/event_handlers/mod_kazoo/kazoo_fetch_agent.c

@@ -136,7 +136,7 @@ static switch_xml_t fetch_handler(const char *section, const char *tag_name, con
 
 	now = switch_micro_time_now();
 
-	if (!switch_test_flag(&globals, LFLAG_RUNNING)) {
+	if (!switch_test_flag(&kazoo_globals, LFLAG_RUNNING)) {
 		return xml;
 	}
 
@@ -144,7 +144,7 @@ static switch_xml_t fetch_handler(const char *section, const char *tag_name, con
 	switch_thread_rwlock_rdlock(agent->lock);
 
 	/* serialize access to current, used to round-robin requests */
-	/* TODO: check globals for round-robin boolean or loop all clients */
+	/* TODO: check kazoo_globals for round-robin boolean or loop all clients */
 	switch_mutex_lock(agent->current_client_mutex);
 	if (!agent->current_client) {
 		client = agent->clients;
@@ -572,31 +572,31 @@ static switch_status_t handle_api_command_stream(ei_node_t *ei_node, switch_stre
 }
 
 switch_status_t bind_fetch_agents() {
-	bind_fetch_agent(SWITCH_XML_SECTION_CONFIG, &globals.config_fetch_binding);
-	bind_fetch_agent(SWITCH_XML_SECTION_DIRECTORY, &globals.directory_fetch_binding);
-	bind_fetch_agent(SWITCH_XML_SECTION_DIALPLAN, &globals.dialplan_fetch_binding);
-	bind_fetch_agent(SWITCH_XML_SECTION_CHATPLAN, &globals.chatplan_fetch_binding);
-	bind_fetch_agent(SWITCH_XML_SECTION_CHANNELS, &globals.channels_fetch_binding);
+	bind_fetch_agent(SWITCH_XML_SECTION_CONFIG, &kazoo_globals.config_fetch_binding);
+	bind_fetch_agent(SWITCH_XML_SECTION_DIRECTORY, &kazoo_globals.directory_fetch_binding);
+	bind_fetch_agent(SWITCH_XML_SECTION_DIALPLAN, &kazoo_globals.dialplan_fetch_binding);
+	bind_fetch_agent(SWITCH_XML_SECTION_CHATPLAN, &kazoo_globals.chatplan_fetch_binding);
+	bind_fetch_agent(SWITCH_XML_SECTION_CHANNELS, &kazoo_globals.channels_fetch_binding);
 
 	return SWITCH_STATUS_SUCCESS;
 }
 
 switch_status_t unbind_fetch_agents() {
-	unbind_fetch_agent(&globals.config_fetch_binding);
-	unbind_fetch_agent(&globals.directory_fetch_binding);
-	unbind_fetch_agent(&globals.dialplan_fetch_binding);
-	unbind_fetch_agent(&globals.chatplan_fetch_binding);
-	unbind_fetch_agent(&globals.channels_fetch_binding);
+	unbind_fetch_agent(&kazoo_globals.config_fetch_binding);
+	unbind_fetch_agent(&kazoo_globals.directory_fetch_binding);
+	unbind_fetch_agent(&kazoo_globals.dialplan_fetch_binding);
+	unbind_fetch_agent(&kazoo_globals.chatplan_fetch_binding);
+	unbind_fetch_agent(&kazoo_globals.channels_fetch_binding);
 
 	return SWITCH_STATUS_SUCCESS;
 }
 
 switch_status_t remove_xml_clients(ei_node_t *ei_node) {
-	remove_xml_client(ei_node, globals.config_fetch_binding);
-	remove_xml_client(ei_node, globals.directory_fetch_binding);
-	remove_xml_client(ei_node, globals.dialplan_fetch_binding);
-	remove_xml_client(ei_node, globals.chatplan_fetch_binding);
-	remove_xml_client(ei_node, globals.channels_fetch_binding);
+	remove_xml_client(ei_node, kazoo_globals.config_fetch_binding);
+	remove_xml_client(ei_node, kazoo_globals.directory_fetch_binding);
+	remove_xml_client(ei_node, kazoo_globals.dialplan_fetch_binding);
+	remove_xml_client(ei_node, kazoo_globals.chatplan_fetch_binding);
+	remove_xml_client(ei_node, kazoo_globals.channels_fetch_binding);
 
 	return SWITCH_STATUS_SUCCESS;
 }
@@ -644,17 +644,17 @@ switch_status_t add_fetch_handler(ei_node_t *ei_node, erlang_pid *from, switch_x
 
 	switch_thread_rwlock_unlock(agent->lock);
 
-	ei_link(ei_node, ei_self(&globals.ei_cnode), from);
+	ei_link(ei_node, ei_self(&kazoo_globals.ei_cnode), from);
 
 	return SWITCH_STATUS_SUCCESS;
 }
 
 switch_status_t remove_fetch_handlers(ei_node_t *ei_node, erlang_pid *from) {
-	remove_fetch_handler(ei_node, from, globals.config_fetch_binding);
-	remove_fetch_handler(ei_node, from, globals.directory_fetch_binding);
-	remove_fetch_handler(ei_node, from, globals.dialplan_fetch_binding);
-	remove_fetch_handler(ei_node, from, globals.chatplan_fetch_binding);
-	remove_fetch_handler(ei_node, from, globals.channels_fetch_binding);
+	remove_fetch_handler(ei_node, from, kazoo_globals.config_fetch_binding);
+	remove_fetch_handler(ei_node, from, kazoo_globals.directory_fetch_binding);
+	remove_fetch_handler(ei_node, from, kazoo_globals.dialplan_fetch_binding);
+	remove_fetch_handler(ei_node, from, kazoo_globals.chatplan_fetch_binding);
+	remove_fetch_handler(ei_node, from, kazoo_globals.channels_fetch_binding);
 
 	return SWITCH_STATUS_SUCCESS;
 }
@@ -686,11 +686,11 @@ switch_status_t fetch_reply(char *uuid_str, char *xml_str, switch_xml_binding_t
 }
 
 switch_status_t handle_api_command_streams(ei_node_t *ei_node, switch_stream_handle_t *stream) {
-	handle_api_command_stream(ei_node, stream, globals.config_fetch_binding);
-	handle_api_command_stream(ei_node, stream, globals.directory_fetch_binding);
-	handle_api_command_stream(ei_node, stream, globals.dialplan_fetch_binding);
-	handle_api_command_stream(ei_node, stream, globals.chatplan_fetch_binding);
-	handle_api_command_stream(ei_node, stream, globals.channels_fetch_binding);
+	handle_api_command_stream(ei_node, stream, kazoo_globals.config_fetch_binding);
+	handle_api_command_stream(ei_node, stream, kazoo_globals.directory_fetch_binding);
+	handle_api_command_stream(ei_node, stream, kazoo_globals.dialplan_fetch_binding);
+	handle_api_command_stream(ei_node, stream, kazoo_globals.chatplan_fetch_binding);
+	handle_api_command_stream(ei_node, stream, kazoo_globals.channels_fetch_binding);
 
 	return SWITCH_STATUS_SUCCESS;
 }

src/mod/event_handlers/mod_kazoo/kazoo_utils.c

@@ -142,7 +142,7 @@ switch_socket_t *create_socket_with_port(switch_memory_pool_t *pool, switch_port
 	switch_sockaddr_t *sa;
 	switch_socket_t *socket;
 
-	if(switch_sockaddr_info_get(&sa, globals.ip, SWITCH_UNSPEC, port, 0, pool)) {
+	if(switch_sockaddr_info_get(&sa, kazoo_globals.ip, SWITCH_UNSPEC, port, 0, pool)) {
 		return NULL;
 	}
 
@@ -162,9 +162,9 @@ switch_socket_t *create_socket_with_port(switch_memory_pool_t *pool, switch_port
 		return NULL;
 	}
 
-	switch_getnameinfo(&globals.hostname, sa, 0);
+	switch_getnameinfo(&kazoo_globals.hostname, sa, 0);
 
-	//	if (globals.nat_map && switch_nat_get_type()) {
+	//	if (kazoo_globals.nat_map && switch_nat_get_type()) {
 	//		switch_nat_add_mapping(port, SWITCH_NAT_TCP, NULL, SWITCH_FALSE);
 	//	}
 
@@ -188,20 +188,20 @@ switch_status_t create_ei_cnode(const char *ip_addr, const char *name, struct ei
 
     if ((atsign = strchr(cnodename, '@'))) {
         /* we got a qualified node name, don't guess the host/domain */
-        snprintf(nodename, MAXNODELEN + 1, "%s", globals.ei_nodename);
+        snprintf(nodename, MAXNODELEN + 1, "%s", kazoo_globals.ei_nodename);
         /* truncate the alivename at the @ */
         *atsign = '\0';
     } else {
-        if (zstr(globals.hostname) || !strncasecmp(globals.ip, "0.0.0.0", 7) || !strncasecmp(globals.ip, "::", 2)) {
+        if (zstr(kazoo_globals.hostname) || !strncasecmp(kazoo_globals.ip, "0.0.0.0", 7) || !strncasecmp(kazoo_globals.ip, "::", 2)) {
             memcpy(hostname, switch_core_get_hostname(), EI_MAXHOSTNAMELEN);
         } else {
-            memcpy(hostname, globals.hostname, EI_MAXHOSTNAMELEN);
+            memcpy(hostname, kazoo_globals.hostname, EI_MAXHOSTNAMELEN);
         }
 
-        snprintf(nodename, MAXNODELEN + 1, "%s@%s", globals.ei_nodename, hostname);
+        snprintf(nodename, MAXNODELEN + 1, "%s@%s", kazoo_globals.ei_nodename, hostname);
     }
 
-	if (globals.ei_shortname) {
+	if (kazoo_globals.ei_shortname) {
 		char *off;
 		if ((off = strchr(nodename, '.'))) {
 			*off = '\0';
@@ -209,7 +209,7 @@ switch_status_t create_ei_cnode(const char *ip_addr, const char *name, struct ei
 	}
 
     /* init the ec stuff */
-    if (ei_connect_xinit(ei_cnode, hostname, cnodename, nodename, (Erl_IpAddr) ip_addr, globals.ei_cookie, 0) < 0) {
+    if (ei_connect_xinit(ei_cnode, hostname, cnodename, nodename, (Erl_IpAddr) ip_addr, kazoo_globals.ei_cookie, 0) < 0) {
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to initialize the erlang interface connection structure\n");
         return SWITCH_STATUS_FALSE;
     }
@@ -654,9 +654,9 @@ static void *SWITCH_THREAD_FUNC fetch_config_filters_exec(switch_thread_t *threa
 				switch_core_hash_insert(filter, var, "1");
 			}
 
-			old_filter = globals.event_filter;
-			globals.config_filters_fetched = 1;
-			globals.event_filter = filter;
+			old_filter = kazoo_globals.event_filter;
+			kazoo_globals.config_filters_fetched = 1;
+			kazoo_globals.event_filter = filter;
 			if (old_filter) {
 				switch_core_hash_destroy(&old_filter);
 			}

src/mod/event_handlers/mod_kazoo/mod_kazoo.h

@@ -122,7 +122,7 @@ struct globals_s {
 	int io_fault_tolerance;
 };
 typedef struct globals_s globals_t;
-extern globals_t globals;
+extern globals_t kazoo_globals;
 
 /* kazoo_node.c */
 switch_status_t new_kazoo_node(int nodefd, ErlConnect *conn);

src/mod/event_handlers/mod_rayo/rayo_cpa_component.c

@@ -35,7 +35,7 @@
 /**
  * Module globals
  */
-struct {
+static struct {
 	/** signal subscribers */
 	switch_hash_t *subscribers;
 	/** synchronizes access to subscribers */

src/mod/languages/mod_managed/freeswitch_managed.h

@@ -26,7 +26,7 @@
  * Michael Giagnocavo <mgg@packetrino.com>
  * Jeff Lenk <jlenk@frontiernet.net> - Modified class to support Dotnet
  * 
- * freeswitch_managed.h -- Header for ManagedSession and globals
+ * freeswitch_managed.h -- Header for ManagedSession and managed_globals
  *
  */
 
@@ -60,13 +60,13 @@ struct mod_managed_globals {
 #endif
 };
 typedef struct mod_managed_globals mod_managed_globals;
-extern mod_managed_globals globals;
+extern mod_managed_globals managed_globals;
 #endif
 
 #ifdef _MANAGED
 #define ATTACH_THREADS
 #else
-#define ATTACH_THREADS mono_thread_attach(globals.domain);
+#define ATTACH_THREADS mono_thread_attach(managed_globals.domain);
 #endif
 
 #ifdef WIN32

src/mod/languages/mod_managed/mod_managed.cpp

@@ -67,7 +67,7 @@ SWITCH_STANDARD_API(managedlist_api_function); /* List modules */
 #define MOD_MANAGED_IMAGE_NAME "FreeSWITCH"
 #define MOD_MANAGED_CLASS_NAME "Loader"
 
-mod_managed_globals globals = { 0 };
+mod_managed_globals managed_globals = { 0 };
 
 // Global delegates to call managed functions
 typedef int (*runFunction)(const char *data, void *sessionPtr);
@@ -201,14 +201,14 @@ switch_status_t loadRuntime()
 #endif
 
 	switch_snprintf(filename, 256, "%s%s%s", SWITCH_GLOBAL_dirs.mod_dir, SWITCH_PATH_SEPARATOR, MOD_MANAGED_DLL);
-	globals.domain = mono_jit_init(filename);
+	managed_globals.domain = mono_jit_init(filename);
 
 	/* Already got a Mono domain? */
-	if ((globals.domain = mono_get_root_domain())) {
-		mono_thread_attach(globals.domain);
-		globals.embedded = SWITCH_TRUE;
+	if ((managed_globals.domain = mono_get_root_domain())) {
+		mono_thread_attach(managed_globals.domain);
+		managed_globals.embedded = SWITCH_TRUE;
 	} else {
-		if (!(globals.domain = mono_jit_init(filename))) {
+		if (!(managed_globals.domain = mono_jit_init(filename))) {
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mono_jit_init failed.\n");
 			return SWITCH_STATUS_FALSE;
 		}
@@ -221,11 +221,11 @@ switch_status_t loadRuntime()
 	
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Calling mono_assembly_loaded.\n");
 
-	if (!(globals.mod_mono_asm = mono_assembly_loaded(name))) {
+	if (!(managed_globals.mod_mono_asm = mono_assembly_loaded(name))) {
 		/* Open the assembly */ 
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Calling mono_domain_assembly_open.\n");
-		globals.mod_mono_asm = mono_domain_assembly_open(globals.domain, filename);
-		if (!globals.mod_mono_asm) {
+		managed_globals.mod_mono_asm = mono_domain_assembly_open(managed_globals.domain, filename);
+		if (!managed_globals.mod_mono_asm) {
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mono_domain_assembly_open failed.\n");
 			return SWITCH_STATUS_FALSE;
 		}
@@ -254,14 +254,14 @@ switch_status_t findLoader()
 {
 	/* Find loader class and methods */ 
 	MonoClass * loaderClass;
-	MonoImage * img = mono_assembly_get_image(globals.mod_mono_asm);
+	MonoImage * img = mono_assembly_get_image(managed_globals.mod_mono_asm);
 
 	if (!(loaderClass = mono_class_from_name(img, MOD_MANAGED_IMAGE_NAME, MOD_MANAGED_CLASS_NAME))) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not find " MOD_MANAGED_IMAGE_NAME "." MOD_MANAGED_CLASS_NAME " class.\n");
 		return SWITCH_STATUS_FALSE;
 	}
 
-	if (!(globals.loadMethod = getMethod(MOD_MANAGED_IMAGE_NAME "." MOD_MANAGED_CLASS_NAME ":Load()", loaderClass))) {
+	if (!(managed_globals.loadMethod = getMethod(MOD_MANAGED_IMAGE_NAME "." MOD_MANAGED_CLASS_NAME ":Load()", loaderClass))) {
 		return SWITCH_STATUS_FALSE;
 	}
 
@@ -317,7 +317,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_managed_load)
 	*module_interface = switch_loadable_module_create_module_interface(pool, modname);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Loading mod_managed (Common Language Infrastructure), " MOD_MANAGED_VERSION "\n");
 
-	globals.pool = pool;
+	managed_globals.pool = pool;
 	
 	if (loadRuntime() != SWITCH_STATUS_SUCCESS) {			
 		return SWITCH_STATUS_FALSE;
@@ -340,11 +340,11 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_managed_load)
 	}
 #else
 	/* Not sure if this is necesary on the loading thread */ 
-	mono_thread_attach(globals.domain);
+	mono_thread_attach(managed_globals.domain);
 
 	/* Run loader */ 
 	MonoObject * exception = NULL;
-	MonoObject * objResult = mono_runtime_invoke(globals.loadMethod, NULL, NULL, &exception);
+	MonoObject * objResult = mono_runtime_invoke(managed_globals.loadMethod, NULL, NULL, &exception);
 	if (exception) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Load threw an exception.\n");
 		mono_print_unhandled_exception(exception);
@@ -381,7 +381,7 @@ SWITCH_STANDARD_API(managedrun_api_function)
 		return SWITCH_STATUS_SUCCESS;
 	}
 #ifndef _MANAGED
-	mono_thread_attach(globals.domain);
+	mono_thread_attach(managed_globals.domain);
 #endif
 	if (executeBackgroundDelegate(cmd)) {
 		stream->write_function(stream, "+OK\n");
@@ -401,7 +401,7 @@ SWITCH_STANDARD_API(managed_api_function)
 		return SWITCH_STATUS_SUCCESS;
 	}
 #ifndef _MANAGED
-	mono_thread_attach(globals.domain);
+	mono_thread_attach(managed_globals.domain);
 #endif
 	if (!(executeDelegate(cmd, stream, stream->param_event))) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Execute failed for %s (unknown module or exception).\n", cmd); 
@@ -419,7 +419,7 @@ SWITCH_STANDARD_APP(managed_app_function)
 		return;
 	}
 #ifndef _MANAGED
-	mono_thread_attach(globals.domain);
+	mono_thread_attach(managed_globals.domain);
 #endif
 	if (!(runDelegate(data, session))) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Application run failed for %s (unknown module or exception).\n", data);
@@ -436,7 +436,7 @@ SWITCH_STANDARD_API(managedreload_api_function)
 		return SWITCH_STATUS_SUCCESS;
 	}
 #ifndef _MANAGED
-	mono_thread_attach(globals.domain);
+	mono_thread_attach(managed_globals.domain);
 #endif
 	if (!(reloadDelegate(cmd))) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Execute failed for %s (unknown module or exception).\n", cmd); 
@@ -450,7 +450,7 @@ SWITCH_STANDARD_API(managedreload_api_function)
 SWITCH_STANDARD_API(managedlist_api_function)
 {
 #ifndef _MANAGED
-	mono_thread_attach(globals.domain);
+	mono_thread_attach(managed_globals.domain);
 #endif
 	listDelegate(cmd, stream, stream->param_event);
 #ifndef _MANAGED

src/mod/languages/mod_managed/mono28.patch

@@ -36,7 +36,7 @@ index 1d0b6a7..13ffe5d 100644
  #include <mono/jit/jit.h>
  #include <mono/metadata/assembly.h>
  #include <mono/metadata/environment.h>
-@@ -73,7 +72,7 @@ extern mod_managed_globals globals;
+@@ -73,7 +72,7 @@ extern mod_managed_globals managed_globals;
  #ifdef WIN32
  #define RESULT_FREE(x) CoTaskMemFree(x)
  #else
@@ -68,8 +68,8 @@ index ec2d866..87e831f 100644
 +	
  	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Calling mono_assembly_loaded.\n");
  
--	if (!(globals.mod_mono_asm = mono_assembly_loaded(&name))) {
-+	if (!(globals.mod_mono_asm = mono_assembly_loaded(name))) {
+-	if (!(managed_globals.mod_mono_asm = mono_assembly_loaded(&name))) {
++	if (!(managed_globals.mod_mono_asm = mono_assembly_loaded(name))) {
  		/* Open the assembly */ 
  		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Calling mono_domain_assembly_open.\n");
- 		globals.mod_mono_asm = mono_domain_assembly_open(globals.domain, filename);
+ 		managed_globals.mod_mono_asm = mono_domain_assembly_open(managed_globals.domain, filename);

src/mod/languages/mod_v8/mod_v8.cpp

@@ -118,7 +118,7 @@ typedef struct {
 	set<FSEventHandler *> *event_handlers;
 } mod_v8_global_t;
 
-mod_v8_global_t globals = { 0 };
+static mod_v8_global_t globals = { 0 };
 
 /* Loadable module struct, used for external extension modules */
 typedef struct {

src/mod/xml_int/mod_xml_rpc/ws.c

@@ -5,7 +5,7 @@
 #endif
 
 #define SHA1_HASH_SIZE 20
-struct globals_s globals;
+static struct globals_s globals;
 
 #ifndef WSS_STANDALONE