sync

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@481 a93c3328-9c30-0410-af19-c9cd2b2d52af

libs/openzap/mod_openzap/mod_openzap.c

@@ -981,6 +981,7 @@ zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t
 	*sp = NULL;
 	
 	if (!(session = switch_core_session_request(openzap_endpoint_interface, NULL))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Initilization Error!\n");
 		return ZAP_FAIL;
 	}
 	
@@ -1045,6 +1046,7 @@ zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t
 	}
 
 	if (zap_channel_add_token(sigmsg->channel, switch_core_session_get_uuid(session), 0) != ZAP_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error adding token\n");
 		switch_core_session_destroy(&session);
 		return ZAP_FAIL;
 	}
@@ -1351,11 +1353,11 @@ static ZIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal)
     case ZAP_SIGEVENT_STOP:
 		{	
 			while((session = zap_channel_get_session(sigmsg->channel, 0))) {
-				switch_core_session_signal_lock(session);
+				//switch_core_session_signal_lock(session);
 				channel = switch_core_session_get_channel(session);
 				switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause);
 				zap_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session));
-				switch_core_session_signal_unlock(session);
+				//switch_core_session_signal_unlock(session);
 				switch_core_session_rwunlock(session);
 			}
 		}
@@ -1364,23 +1366,23 @@ static ZIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal)
 		{
 			if ((session = zap_channel_get_session(sigmsg->channel, 0))) {
 				zap_tone_type_t tt = ZAP_TONE_DTMF;
-				switch_core_session_signal_lock(session);
+				//switch_core_session_signal_lock(session);
 				channel = switch_core_session_get_channel(session);
 				switch_channel_mark_answered(channel);
 				if (zap_channel_command(sigmsg->channel, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) {
 					zap_log(ZAP_LOG_ERROR, "TONE ERROR\n");
 				}
-				switch_core_session_signal_unlock(session);
+				//switch_core_session_signal_unlock(session);
 				switch_core_session_rwunlock(session);
 			}
 		}
     case ZAP_SIGEVENT_PROGRESS_MEDIA:
 		{
 			if ((session = zap_channel_get_session(sigmsg->channel, 0))) {
-				switch_core_session_signal_lock(session);
+				//switch_core_session_signal_lock(session);
 				channel = switch_core_session_get_channel(session);
 				switch_channel_mark_pre_answered(channel);
-				switch_core_session_signal_unlock(session);
+				//switch_core_session_signal_unlock(session);
 				switch_core_session_rwunlock(session);
 			}
 		}
@@ -1388,10 +1390,10 @@ static ZIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal)
     case ZAP_SIGEVENT_PROGRESS:
 		{
 			if ((session = zap_channel_get_session(sigmsg->channel, 0))) {
-				switch_core_session_signal_lock(session);
+				//switch_core_session_signal_lock(session);
 				channel = switch_core_session_get_channel(session);
 				switch_channel_mark_ring_ready(channel);
-				switch_core_session_signal_unlock(session);
+				//switch_core_session_signal_unlock(session);
 				switch_core_session_rwunlock(session);
 			}
 		}

libs/openzap/src/include/openzap.h

@@ -175,6 +175,7 @@
 */
 #define zap_test_flag(obj, flag) ((obj)->flags & flag)
 #define zap_test_pflag(obj, flag) ((obj)->pflags & flag)
+#define zap_test_sflag(obj, flag) ((obj)->sflags & flag)
 
 
 #define zap_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag)
@@ -198,6 +199,12 @@
 	(obj)->pflags |= (flag);											\
 	zap_mutex_unlock(obj->mutex);
 
+#define zap_set_sflag(obj, flag) (obj)->sflags |= (flag)
+#define zap_set_sflag_locked(obj, flag) assert(obj->mutex != NULL);	\
+	zap_mutex_lock(obj->mutex);										\
+	(obj)->sflags |= (flag);											\
+	zap_mutex_unlock(obj->mutex);
+
 /*!
   \brief Clear a flag on an arbitrary object while locked
   \command obj the object to test
@@ -211,16 +218,35 @@
 
 #define zap_clear_pflag_locked(obj, flag) assert(obj->mutex != NULL); zap_mutex_lock(obj->mutex); (obj)->pflags &= ~(flag); zap_mutex_unlock(obj->mutex);
 
+#define zap_clear_sflag(obj, flag) (obj)->sflags &= ~(flag)
+
+#define zap_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); zap_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); zap_mutex_unlock(obj->mutex);
+
 
 #define zap_set_state_locked(obj, s) if ( obj->state == s ) {			\
 		zap_log(ZAP_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(obj->state), zap_channel_state2str(s)); \
 	} else if (zap_test_flag(obj, ZAP_CHANNEL_READY)) {									\
 		int st = obj->state;											\
-		zap_channel_set_state(obj, s);									\
+		zap_channel_set_state(obj, s, 1);									\
 		if (obj->state == s) zap_log(ZAP_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s)); \
 		else zap_log(ZAP_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s)); \
 	}
 
+typedef enum {
+	ZAP_STATE_CHANGE_FAIL,
+	ZAP_STATE_CHANGE_SUCCESS,
+	ZAP_STATE_CHANGE_SAME,
+} zap_state_change_result_t;
+
+#define zap_set_state_r(obj, s, l, r) if ( obj->state == s ) {	\
+		zap_log(ZAP_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(obj->state), zap_channel_state2str(s)); r = ZAP_STATE_CHANGE_SAME;	\
+	} else if (zap_test_flag(obj, ZAP_CHANNEL_READY)) {					\
+		int st = obj->state;											\
+		r = (zap_channel_set_state(obj, s, l) == ZAP_SUCCESS) ? ZAP_STATE_CHANGE_SUCCESS : ZAP_STATE_CHANGE_FAIL; \
+		if (obj->state == s) {zap_log(ZAP_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s));} \
+		else {zap_log(ZAP_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s)); } \
+	}
+
 
 #define zap_is_dtmf(key)  ((key > 47 && key < 58) || (key > 64 && key < 69) || (key > 96 && key < 101) || key == 35 || key == 42 || key == 87 || key == 119)
 
@@ -358,6 +384,7 @@ struct zap_channel {
 	zap_socket_t sockfd;
 	zap_channel_flag_t flags;
 	uint32_t pflags;
+	uint32_t sflags;
 	zap_alarm_flag_t alarm_flags;
 	zap_channel_feature_t features;
 	zap_codec_t effective_codec;
@@ -455,6 +482,7 @@ struct zap_span {
 	void *mod_data;
 	char *type;
 	int suggest_chan_id;
+	zap_state_map_t *state_map;
 };
 
 
@@ -515,7 +543,7 @@ zap_status_t zap_channel_get_alarms(zap_channel_t *zchan);
 zap_status_t zap_channel_send_fsk_data(zap_channel_t *zchan, zap_fsk_data_state_t *fsk_data, float db_level);
 zap_status_t zap_channel_clear_token(zap_channel_t *zchan, const char *token);
 zap_status_t zap_channel_add_token(zap_channel_t *zchan, char *token, int end);
-zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state);
+zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state, int lock);
 zap_status_t zap_span_load_tones(zap_span_t *span, char *mapname);
 zap_size_t zap_channel_dequeue_dtmf(zap_channel_t *zchan, char *dtmf, zap_size_t len);
 zap_status_t zap_channel_queue_dtmf(zap_channel_t *zchan, const char *dtmf);

libs/openzap/src/include/ss7_boost_client.h

@@ -119,7 +119,8 @@ int ss7bc_connection_close(ss7bc_connection_t *mcon);
 int ss7bc_connection_open(ss7bc_connection_t *mcon, char *local_ip, int local_port, char *ip, int port);
 ss7bc_event_t *ss7bc_connection_read(ss7bc_connection_t *mcon, int iteration);
 ss7bc_event_t *ss7bc_connection_readp(ss7bc_connection_t *mcon, int iteration);
-int ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event);
+int __ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event, const char *file, const char *func, int line);
+#define ss7bc_connection_write(_m,_e) __ss7bc_connection_write(_m, _e, __FILE__, __func__, __LINE__)
 void ss7bc_event_init(ss7bc_event_t *event, ss7bc_event_id_t event_id, int chan, int span);
 void ss7bc_call_init(ss7bc_event_t *event, const char *calling, const char *called, int setup_id);
 const char *ss7bc_event_id_name(uint32_t event_id);

libs/openzap/src/include/zap_types.h

@@ -66,6 +66,9 @@ struct zap_io_interface;
 #define ZAP_DEFAULT_DTMF_ON 250
 #define ZAP_DEFAULT_DTMF_OFF 50
 
+#define ZAP_END -1
+#define ZAP_ANY_STATE -1
+
 typedef uint64_t zap_time_t; 
 
 typedef enum {
@@ -343,6 +346,33 @@ typedef enum {
 	ZAP_CHANNEL_ANSWERED = (1 << 23)
 } zap_channel_flag_t;
 
+typedef enum {
+	ZSM_NONE,
+	ZSM_UNACCEPTABLE,
+	ZSM_ACCEPTABLE
+} zap_state_map_type_t;
+
+typedef enum {
+	ZSD_INBOUND,
+	ZSD_OUTBOUND,
+} zap_state_direction_t;
+
+#define ZAP_MAP_NODE_SIZE 512
+#define ZAP_MAP_MAX ZAP_CHANNEL_STATE_INVALID+2
+
+struct zap_state_map_node {
+	zap_state_direction_t direction;
+	zap_state_map_type_t type;
+	zap_channel_state_t check_states[ZAP_MAP_MAX];
+	zap_channel_state_t states[ZAP_MAP_MAX];
+};
+typedef struct zap_state_map_node zap_state_map_node_t;
+
+struct zap_state_map {
+	zap_state_map_node_t nodes[ZAP_MAP_NODE_SIZE];
+};
+typedef struct zap_state_map zap_state_map_t;
+
 typedef struct zap_channel zap_channel_t;
 typedef struct zap_event zap_event_t;
 typedef struct zap_sigmsg zap_sigmsg_t;

libs/openzap/src/ss7_boost_client.c

@@ -135,9 +135,11 @@ int ss7bc_connection_close(ss7bc_connection_t *mcon)
 		close(mcon->socket);
 	}
 
-	zap_mutex_lock(mcon->mutex);
-	zap_mutex_unlock(mcon->mutex);
-	zap_mutex_destroy(&mcon->mutex);
+	if (mcon->mutex) {
+		zap_mutex_lock(mcon->mutex);
+		zap_mutex_unlock(mcon->mutex);
+		zap_mutex_destroy(&mcon->mutex);
+	}
 	memset(mcon, 0, sizeof(*mcon));
 	mcon->socket = -1;
 
@@ -245,17 +247,19 @@ ss7bc_event_t *ss7bc_connection_readp(ss7bc_connection_t *mcon, int iteration)
 }
 
 
-int ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event)
+int __ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event, const char *file, const char *func, int line)
 {
 	int err;
 
 	if (!event || mcon->socket < 0 || !mcon->mutex) {
-		zap_log(ZAP_LOG_DEBUG,  "Critical Error: No Event Device\n");
+		zap_log(file, func, line, ZAP_LOG_LEVEL_CRIT,  "Critical Error: No Event Device\n");
 		return -EINVAL;
+		abort();
 	}
 
 	if (event->span > 16 || event->chan > 31) {
-		zap_log(ZAP_LOG_CRIT, "Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n", ss7bc_event_id_name(event->event_id), event->span,event->chan);
+		zap_log(file, func, line, ZAP_LOG_LEVEL_CRIT, "Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n", ss7bc_event_id_name(event->event_id), event->span,event->chan);
+		abort();
 		return -1;
 	}
 
@@ -269,9 +273,10 @@ int ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event)
 
 	if (err != sizeof(ss7bc_event_t)) {
 		err = -1;
+		abort();
 	}
 	
- 	zap_log(ZAP_LOG_DEBUG, "TX EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n",
+ 	zap_log(file, func, line, ZAP_LOG_LEVEL_DEBUG, "TX EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n",
 			ss7bc_event_id_name(event->event_id),
 			event->event_id,
 			event->span+1,
@@ -286,6 +291,7 @@ int ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event)
 	return err;
 }
 
+
 void ss7bc_call_init(ss7bc_event_t *event, const char *calling, const char *called, int setup_id)
 {
 	memset(event, 0, sizeof(ss7bc_event_t));

libs/openzap/src/zap_io.c

@@ -621,16 +621,69 @@ zap_status_t zap_channel_complete_state(zap_channel_t *zchan)
 	return ZAP_SUCCESS;
 }
 
+static int zap_parse_state_map(zap_channel_t *zchan, zap_channel_state_t state, zap_state_map_t *state_map)
+{
+	int x = 0, ok = 0;
+	zap_state_direction_t direction = zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) ? ZSD_OUTBOUND : ZSD_INBOUND;
+
+	for(x = 0; x < ZAP_MAP_NODE_SIZE; x++) {
+		int i = 0, proceed = 0;
+		if (!state_map->nodes[x].type) {
+			break;
+		}
+
+		if (state_map->nodes[x].direction != direction) {
+			continue;
+		}
+		
+		if (state_map->nodes[x].check_states[0] == ZAP_ANY_STATE) {
+			proceed = 1;
+		} else {
+			for(i = 0; i < ZAP_MAP_MAX; i++) {
+				if (state_map->nodes[x].check_states[i] == zchan->state) {
+					proceed = 1;
+					break;
+				}
+			}
+		}
+
+		if (!proceed) {
+			continue;
+		}
+		
+		for(i = 0; i < ZAP_MAP_MAX; i++) {
+			ok = (state_map->nodes[x].type == ZSM_ACCEPTABLE);
+			if (state_map->nodes[x].states[i] == ZAP_END) {
+				break;
+			}
+			if (state_map->nodes[x].states[i] == state) {
+				ok = !ok;
+				goto end;
+			}
+		}
+	}
+ end:
+	
+	return ok;
+}
 
-zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state)
+zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state, int lock)
 {
-	int ok = 1;
+	int ok = 0;
 	
 	if (!zap_test_flag(zchan, ZAP_CHANNEL_READY)) {
 		return ZAP_FAIL;
 	}
 
-	zap_mutex_lock(zchan->mutex);
+	if (lock) {
+		zap_mutex_lock(zchan->mutex);
+	}
+
+	if (zchan->span->state_map) {
+		ok = zap_parse_state_map(zchan, state, zchan->span->state_map);
+		goto end;
+	}
+
 	switch(zchan->state) {
 	case ZAP_CHANNEL_STATE_HANGUP:
 	case ZAP_CHANNEL_STATE_TERMINATING:
@@ -649,6 +702,7 @@ zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t sta
 		break;
 	case ZAP_CHANNEL_STATE_UP:
 		{
+			ok = 0;
 			switch(state) {
 			case ZAP_CHANNEL_STATE_PROGRESS:
 			case ZAP_CHANNEL_STATE_PROGRESS_MEDIA:
@@ -661,11 +715,12 @@ zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t sta
 		break;
 	case ZAP_CHANNEL_STATE_DOWN:
 		{
+			ok = 0;
+			
 			switch(state) {
-			case ZAP_CHANNEL_STATE_BUSY:
-			case ZAP_CHANNEL_STATE_HANGUP:
-			case ZAP_CHANNEL_STATE_TERMINATING:
-				ok = 0;
+			case ZAP_CHANNEL_STATE_DIALTONE:
+			case ZAP_CHANNEL_STATE_RING:
+				ok = 1;
 				break;
 			default:
 				break;
@@ -683,14 +738,28 @@ zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t sta
 			}
 		}
 		break;
+	case ZAP_CHANNEL_STATE_RING:
+		{
+			switch(state) {
+			case ZAP_CHANNEL_STATE_UP:
+				ok = 0;
+				break;
+			default:
+				break;
+			}
+		}
+		break;
 	default:
 		break;
 	}
 
+ end:
+
 	if (state == zchan->state) {
 		ok = 0;
 	}
-		 
+	
+
 	if (ok) {
 		if (zchan->state == ZAP_CHANNEL_STATE_DOWN) {
 			zchan->span->active_count++;
@@ -704,7 +773,9 @@ zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t sta
 		zchan->state = state;
 	}
 
-	zap_mutex_unlock(zchan->mutex);
+	if (lock) {
+		zap_mutex_unlock(zchan->mutex);
+	}
 
 	return ok ? ZAP_SUCCESS : ZAP_FAIL;
 }
@@ -868,6 +939,7 @@ static zap_status_t zap_channel_reset(zap_channel_t *zchan)
 
 zap_status_t zap_channel_init(zap_channel_t *zchan)
 {
+
 	if (zchan->init_state != ZAP_CHANNEL_STATE_DOWN) {
 		zap_set_state_locked(zchan, zchan->init_state);
 		zchan->init_state = ZAP_CHANNEL_STATE_DOWN;