Formatting fixes, proper locking and to shut bkw up. Bug #4185

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@5628 65c4cc65-6c06-0410-ace0-fbb531ad65f3

1 files changed, 200 insertions, 183 deletions

diff --git a/channels/chan_h323.c b/channels/chan_h323.c
index 1d8b08e15..f4f595019 100755
--- a/channels/chan_h323.c
+++ b/channels/chan_h323.c
@@ -110,6 +110,7 @@ static int capability = AST_FORMAT_ULAW;
 static int tos = 0;
 static int dtmfmode = H323_DTMF_RFC2833;
 static char secret[50];
+static unsigned int unique = 0;
 
 static call_options_t global_options;
 
@@ -122,7 +123,7 @@ struct oh323_pvt {
 	call_details_t cd;					/* Call details */
 	struct ast_channel *owner;				/* Who owns us */
 	struct sockaddr_in sa;                  		/* Our peer */
-        struct sockaddr_in redirip; 			        /* Where our RTP should be going if not to us */
+	struct sockaddr_in redirip; 			        /* Where our RTP should be going if not to us */
 	int capability;						/* audio capability */
 	int nonCodecCapability;					/* non-audio capability */
 	int outgoing;						/* Outgoing or incoming call? */
@@ -217,11 +218,9 @@ static const struct ast_channel_tech oh323_tech = {
 #endif
 };
 
-static void oh323_update_info(struct ast_channel *c)
+/* Channel and private structures should be already locked */
+static void __oh323_update_info(struct ast_channel *c, struct oh323_pvt *pvt)
 {
-	struct oh323_pvt *pvt = c->tech_pvt;
-
-	ast_mutex_lock(&pvt->lock);
 	if (c->nativeformats != pvt->nativeformats) {
 		if (h323debug)
 			ast_log(LOG_DEBUG, "Preparing %s for new native format\n", c->name);
@@ -237,7 +236,18 @@ static void oh323_update_info(struct ast_channel *c)
 		ast_queue_hangup(c);
 		pvt->needhangup = 0;
 	}
-	ast_mutex_unlock(&pvt->lock);
+}
+
+/* Only channel structure should be locked */
+static void oh323_update_info(struct ast_channel *c)
+{
+	struct oh323_pvt *pvt = c->tech_pvt;
+
+	if (pvt) {
+		ast_mutex_lock(&pvt->lock);
+		__oh323_update_info(c, pvt);
+		ast_mutex_unlock(&pvt->lock);
+	}
 }
 
 static void cleanup_call_details(call_details_t *cd) 
@@ -272,30 +282,30 @@ static void cleanup_call_details(call_details_t *cd)
         }
 }
 
-static void __oh323_destroy(struct oh323_pvt *p)
+static void __oh323_destroy(struct oh323_pvt *pvt)
 {
 	struct oh323_pvt *cur, *prev = NULL;
 	
-	if (p->rtp) {
-		ast_rtp_destroy(p->rtp);
+	if (pvt->rtp) {
+		ast_rtp_destroy(pvt->rtp);
 	}
 	
 	/* Free dsp used for in-band DTMF detection */
-	if (p->vad) {
-		ast_dsp_free(p->vad);
+	if (pvt->vad) {
+		ast_dsp_free(pvt->vad);
 	}
-	cleanup_call_details(&p->cd);
+	cleanup_call_details(&pvt->cd);
 
 	/* Unlink us from the owner if we have one */
-	if (p->owner) {
-		ast_mutex_lock(&p->owner->lock);
-		ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
-		p->owner->tech_pvt = NULL;
-		ast_mutex_unlock(&p->owner->lock);
+	if (pvt->owner) {
+		ast_mutex_lock(&pvt->owner->lock);
+		ast_log(LOG_DEBUG, "Detaching from %s\n", pvt->owner->name);
+		pvt->owner->tech_pvt = NULL;
+		ast_mutex_unlock(&pvt->owner->lock);
 	}
 	cur = iflist;
 	while(cur) {
-		if (cur == p) {
+		if (cur == pvt) {
 			if (prev)
 				prev->next = cur->next;
 			else
@@ -308,15 +318,15 @@ static void __oh323_destroy(struct oh323_pvt *p)
 	if (!cur) {
 		ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
 	} else {
-                ast_mutex_destroy(&p->lock);
-		free(p);
-        }
+		ast_mutex_destroy(&pvt->lock);
+		free(pvt);
+	}
 }
 
-static void oh323_destroy(struct oh323_pvt *p)
+static void oh323_destroy(struct oh323_pvt *pvt)
 {
 	ast_mutex_lock(&iflock);
-	__oh323_destroy(p);
+	__oh323_destroy(pvt);
 	ast_mutex_unlock(&iflock);
 }
 
@@ -583,27 +593,27 @@ static struct oh323_peer *build_peer(char *name, struct ast_variable *v)
  */
 static int oh323_digit(struct ast_channel *c, char digit)
 {
-	struct oh323_pvt *p = (struct oh323_pvt *) c->tech_pvt;
+	struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
 	char *token;
 	if (h323debug)
 		ast_log(LOG_DEBUG, "Sending digit %c on %s\n", digit, c->name);
-	if (!p)
+	if (!pvt)
 		return -1;
-	ast_mutex_lock(&p->lock);
-	if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833)) {
-		ast_rtp_senddigit(p->rtp, digit);
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->rtp && (pvt->dtmfmode & H323_DTMF_RFC2833)) {
+		ast_rtp_senddigit(pvt->rtp, digit);
 	}
 	/* If in-band DTMF is desired, send that */
-	if ((p->dtmfmode & H323_DTMF_INBAND)) {
-		token = p->cd.call_token ? strdup(p->cd.call_token) : NULL;
-		ast_mutex_unlock(&p->lock);
+	if ((pvt->dtmfmode & H323_DTMF_INBAND)) {
+		token = pvt->cd.call_token ? strdup(pvt->cd.call_token) : NULL;
+		ast_mutex_unlock(&pvt->lock);
 		h323_send_tone(token, digit);
 		if (token)
 			free(token);
 		oh323_update_info(c);
 	}
 	else
-		ast_mutex_unlock(&p->lock);
+		ast_mutex_unlock(&pvt->lock);
 	return 0;
 }
 
@@ -614,32 +624,32 @@ static int oh323_digit(struct ast_channel *c, char digit)
  */
 static int oh323_call(struct ast_channel *c, char *dest, int timeout)
 {  
-        int res = 0;
-        struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
-        char addr[INET_ADDRSTRLEN];
-        char called_addr[1024];
-  
-  	if (h323debug) {
-  		ast_log(LOG_DEBUG, "Calling to %s on %s\n", dest, c->name);
-        }
+	int res = 0;
+	struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
+	char addr[INET_ADDRSTRLEN];
+	char called_addr[1024];
+
+	if (h323debug) {
+		ast_log(LOG_DEBUG, "Calling to %s on %s\n", dest, c->name);
+	}
 	if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
-                ast_log(LOG_WARNING, "Line is already in use (%s)\n", c->name);
-                return -1;
-        }
-        if (usingGk) {
-                pvt->options.port = h323_signalling_port;
-                if (ast_strlen_zero(pvt->exten)) {
-	               	strncpy(called_addr, dest, sizeof(called_addr));
-                } else {
-                        snprintf(called_addr, sizeof(called_addr), "%s@%s", pvt->exten, dest);
-     		}
-        } else {
-                ast_inet_ntoa(addr, sizeof(addr), pvt->sa.sin_addr);
-                pvt->options.port = htons(pvt->sa.sin_port);
-                if (ast_strlen_zero(pvt->exten)) {
-                        snprintf(called_addr, sizeof(called_addr), "%s:%d", addr, pvt->options.port);
-                } else {
-                        snprintf(called_addr, sizeof(called_addr), "%s@%s:%d", pvt->exten, addr, pvt->options.port);
+		ast_log(LOG_WARNING, "Line is already in use (%s)\n", c->name);
+		return -1;
+	}
+	ast_mutex_lock(&pvt->lock);
+	if (usingGk) {
+		if (ast_strlen_zero(pvt->exten)) {
+			strncpy(called_addr, dest, sizeof(called_addr));
+		} else {
+			snprintf(called_addr, sizeof(called_addr), "%s@%s", pvt->exten, dest);
+		}
+	} else {
+		ast_inet_ntoa(addr, sizeof(addr), pvt->sa.sin_addr);
+		res = htons(pvt->sa.sin_port);
+		if (ast_strlen_zero(pvt->exten)) {
+			snprintf(called_addr, sizeof(called_addr), "%s:%d", addr, res);
+		} else {
+			snprintf(called_addr, sizeof(called_addr), "%s@%s:%d", pvt->exten, addr, res);
 		}
 	}
 	/* make sure null terminated */
@@ -656,6 +666,7 @@ static int oh323_call(struct ast_channel *c, char *dest, int timeout)
 	pvt->outgoing = 1;
 
 	ast_log(LOG_DEBUG, "Placing outgoing call to %s, %d\n", called_addr, pvt->options.dtmfcodec);
+	ast_mutex_unlock(&pvt->lock);
 	res = h323_make_call(called_addr, &(pvt->cd), &pvt->options);
 	if (res) {
 		ast_log(LOG_NOTICE, "h323_make_call failed(%s)\n", c->name);
@@ -814,7 +825,7 @@ static struct ast_frame  *oh323_read(struct ast_channel *c)
 	struct ast_frame *fr;
 	struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
 	ast_mutex_lock(&pvt->lock);
-	oh323_update_info(c);
+	__oh323_update_info(c, pvt);
 	fr = oh323_rtp_read(pvt);
 	ast_mutex_unlock(&pvt->lock);
 	return fr;
@@ -882,7 +893,9 @@ static int oh323_indicate(struct ast_channel *c, int condition)
 	case AST_CONTROL_BUSY:
 		if (c->_state != AST_STATE_UP) {
 			h323_answering_call(token, 1);
- 			pvt->alreadygone = 1;
+			ast_mutex_lock(&pvt->lock);
+			pvt->alreadygone = 1;
+			ast_mutex_unlock(&pvt->lock);
 			ast_softhangup_nolock(c, AST_SOFTHANGUP_DEV);			
 			break;
 		}
@@ -892,7 +905,9 @@ static int oh323_indicate(struct ast_channel *c, int condition)
 	case AST_CONTROL_CONGESTION:
 		if (c->_state != AST_STATE_UP) {
 			h323_answering_call(token, 1);
+			ast_mutex_lock(&pvt->lock);
 			pvt->alreadygone = 1;
+			ast_mutex_unlock(&pvt->lock);
 			ast_softhangup_nolock(c, AST_SOFTHANGUP_DEV);
 			break;
 		}
@@ -934,7 +949,8 @@ static int oh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
 	return 0;
 }
 
-static struct ast_channel *oh323_new(struct oh323_pvt *pvt, int state, const char *host)
+/* Private structure should be locked on a call */
+static struct ast_channel *__oh323_new(struct oh323_pvt *pvt, int state, const char *host)
 {
 	struct ast_channel *ch;
 	int fmt;
@@ -1058,45 +1074,47 @@ static struct oh323_pvt *oh323_alloc(int callid)
 	return pvt;
 }
 
-static struct oh323_pvt *find_call(int call_reference, const char *token)
+static struct oh323_pvt *find_call_locked(int call_reference, const char *token)
 {  
-        struct oh323_pvt *pvt;
+	struct oh323_pvt *pvt;
 
 	ast_mutex_lock(&iflock);
-        pvt = iflist; 
-        while(pvt) {
-                if (!pvt->needdestroy && ((signed int)pvt->cd.call_reference == call_reference)) {
-                        /* Found the call */             
-                        if ((token != NULL) && (!strcmp(pvt->cd.call_token, token))) {
-        			ast_mutex_unlock(&iflock);
-	        		return pvt;
-                        } else if (token == NULL) {
-                                ast_log(LOG_DEBUG, "Call Token is NULL\n");
-                                ast_mutex_unlock(&iflock);
-                                return pvt;
-                        }
-                }
-                pvt = pvt->next; 
-        }
-        ast_mutex_unlock(&iflock);
+	pvt = iflist; 
+	while(pvt) {
+		if (!pvt->needdestroy && ((signed int)pvt->cd.call_reference == call_reference)) {
+			/* Found the call */             
+			if ((token != NULL) && (!strcmp(pvt->cd.call_token, token))) {
+				ast_mutex_lock(&pvt->lock);
+				ast_mutex_unlock(&iflock);
+				return pvt;
+			} else if (token == NULL) {
+				ast_log(LOG_WARNING, "Call Token is NULL\n");
+				ast_mutex_lock(&pvt->lock);
+				ast_mutex_unlock(&iflock);
+				return pvt;
+			}
+		}
+		pvt = pvt->next; 
+	}
+	ast_mutex_unlock(&iflock);
 	return NULL;
 }
 
-struct oh323_user *find_user(const call_details_t cd)
+struct oh323_user *find_user(const call_details_t *cd)
 {
 	struct oh323_user *u;
 	char iabuf[INET_ADDRSTRLEN];
 	u = userl.users;
 	if (userbyalias) {
 		while(u) {
-			if (!strcasecmp(u->name, cd.call_source_aliases)) {
+			if (!strcasecmp(u->name, cd->call_source_aliases)) {
 				break;
 			}
 			u = u->next;
 		}
 	} else {
 		while(u) {
-			if (!strcasecmp(cd.sourceIp, ast_inet_ntoa(iabuf, sizeof(iabuf), u->addr.sin_addr))) {
+			if (!strcasecmp(cd->sourceIp, ast_inet_ntoa(iabuf, sizeof(iabuf), u->addr.sin_addr))) {
 				break;
 			}
 			u = u->next;
@@ -1212,7 +1230,7 @@ static struct ast_channel *oh323_request(const char *type, int format, void *dat
 	char *dest = (char *)data;
 	char *ext, *host;
 	char *h323id = NULL;
-	char tmp[256];
+	char tmp[256], tmp1[256];
 	
 	ast_log(LOG_DEBUG, "type=%s, format=%d, data=%s.\n", type, format, (char *)data);
 	pvt = oh323_alloc(0);
@@ -1256,10 +1274,13 @@ static struct ast_channel *oh323_request(const char *type, int format, void *dat
 	/* pass on our capabilites to the H.323 stack */
 	ast_mutex_lock(&caplock);
 	h323_set_capability(pvt->capability, pvt->dtmfmode);
+	/* Generate unique channel identifier */
+	snprintf(tmp1, sizeof(tmp1)-1, "%s-%u", host, ++unique);
+	tmp1[sizeof(tmp1)-1] = '\0';
 	ast_mutex_unlock(&caplock);
-	
+
 	ast_mutex_lock(&pvt->lock);
-	tmpc = oh323_new(pvt, AST_STATE_DOWN, host);
+	tmpc = __oh323_new(pvt, AST_STATE_DOWN, tmp1);
 	ast_mutex_unlock(&pvt->lock);
 	if (!tmpc) {
 		oh323_destroy(pvt);
@@ -1292,9 +1313,10 @@ int send_digit(unsigned call_reference, char digit, const char *token)
 {
 	struct oh323_pvt *pvt;
 	struct ast_frame f;
+	int res;
 
-	ast_log(LOG_DEBUG, "Recieved Digit: %c\n", digit);
-	pvt = find_call(call_reference, token); 
+	ast_log(LOG_DEBUG, "Received Digit: %c\n", digit);
+	pvt = find_call_locked(call_reference, token); 
 	if (!pvt) {
 		ast_log(LOG_ERROR, "Private structure not found in send_digit.\n");
 		return -1;
@@ -1305,10 +1327,12 @@ int send_digit(unsigned call_reference, char digit, const char *token)
 	f.datalen = 0;
 	f.samples = 800;
 	f.offset = 0;
- 	f.data = NULL;
-    	f.mallocd = 0;
-    	f.src = "SEND_DIGIT";	
-	return ast_queue_frame(pvt->owner, &f);	
+	f.data = NULL;
+	f.mallocd = 0;
+	f.src = "SEND_DIGIT";	
+	res = ast_queue_frame(pvt->owner, &f);
+	ast_mutex_unlock(&pvt->lock);
+	return res;
 }
 
 /**
@@ -1327,20 +1351,20 @@ struct rtp_info *external_rtp_create(unsigned call_reference, const char * token
 		ast_log(LOG_ERROR, "Unable to allocated info structure, this is very bad\n");
 		return NULL;
 	}
-	pvt = find_call(call_reference, token); 
+	pvt = find_call_locked(call_reference, token); 
 	if (!pvt) {
 		free(info);
 		ast_log(LOG_ERROR, "Unable to find call %s(%d)\n", token, call_reference);
 		return NULL;
 	}
-	ast_mutex_lock(&pvt->lock);
 	/* figure out our local RTP port and tell the H.323 stack about it */
 	ast_rtp_get_us(pvt->rtp, &us);
 	ast_mutex_unlock(&pvt->lock);
 	/* evil hack, until I (or someone?) figures out a better way */
 	ast_inet_ntoa(info->addr, sizeof(info->addr), bindaddr.sin_addr);
 	info->port = ntohs(us.sin_port);
-	ast_log(LOG_DEBUG, "Sending RTP 'US' %s:%d\n", info->addr, info->port);
+	if (h323debug)
+		ast_log(LOG_DEBUG, "Sending RTP 'US' %s:%d\n", info->addr, info->port);
 	return info;
 }
 
@@ -1361,19 +1385,19 @@ struct rtpPayloadType {
   */
 void setup_rtp_connection(unsigned call_reference, const char *remoteIp, int remotePort, const char *token, int pt)
 {
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 	struct sockaddr_in them;
 	struct rtpPayloadType rtptype;
 
 	if (h323debug)
 		ast_log(LOG_DEBUG, "Setting up RTP connection for %s\n", token);
+
 	/* Find the call or allocate a private structure if call not found */
-	pvt = find_call(call_reference, token); 
+	pvt = find_call_locked(call_reference, token); 
 	if (!pvt) {
 		ast_log(LOG_ERROR, "Something is wrong: rtp\n");
 		return;
 	}
-	ast_mutex_lock(&pvt->lock);
 	if (pvt->alreadygone) {
 		ast_mutex_unlock(&pvt->lock);
 		return;
@@ -1386,6 +1410,8 @@ void setup_rtp_connection(unsigned call_reference, const char *remoteIp, int rem
 		ast_set_write_format(pvt->owner, pvt->owner->writeformat);
 		ast_mutex_unlock(&pvt->owner->lock);
 	}
+	else if (h323debug)
+		ast_log(LOG_DEBUG, "RTP connection preparation for %s is pending...\n", token);
 
 	them.sin_family = AF_INET;
 	/* only works for IPv4 */
@@ -1412,19 +1438,17 @@ void setup_rtp_connection(unsigned call_reference, const char *remoteIp, int rem
 void connection_made(unsigned call_reference, const char *token)
 {
 	struct ast_channel *c = NULL;
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 
 	if (h323debug)
 		ast_log(LOG_DEBUG, "Call %s answered\n", token);
-	
-	pvt = find_call(call_reference, token); 
-	
+
+	pvt = find_call_locked(call_reference, token); 
 	if (!pvt) {
 		ast_log(LOG_ERROR, "Something is wrong: connection\n");
 		return;
 	}
 
-	ast_mutex_lock(&pvt->lock);
 	/* Inform asterisk about remote party connected only on outgoing calls */
 	if (!pvt->outgoing) {
 		ast_mutex_unlock(&pvt->lock);
@@ -1446,25 +1470,24 @@ void connection_made(unsigned call_reference, const char *token)
 
 int progress(unsigned call_reference, const char *token, int inband)
 {
-	struct oh323_pvt *p;
+	struct oh323_pvt *pvt;
 
 	ast_log(LOG_DEBUG, "Received ALERT/PROGRESS message for %s tones\n", (inband ? "inband" : "self-generated"));
-	p = find_call(call_reference, token);
 
-	if (!p) {
+	pvt = find_call_locked(call_reference, token);
+	if (!pvt) {
 		ast_log(LOG_ERROR, "Private structure not found in progress.\n");
 		return -1;
 	}
-	ast_mutex_lock(&p->lock);
-	if (!p->owner) {
-		ast_mutex_unlock(&p->lock);
+	if (!pvt->owner) {
+		ast_mutex_unlock(&pvt->lock);
 		ast_log(LOG_ERROR, "No Asterisk channel associated with private structure.\n");
 		return -1;
 	}
-	ast_mutex_lock(&p->owner->lock);
-	ast_queue_control(p->owner, (inband ? AST_CONTROL_PROGRESS : AST_CONTROL_RINGING));
-	ast_mutex_unlock(&p->owner->lock);
-	ast_mutex_unlock(&p->lock);
+	ast_mutex_lock(&pvt->owner->lock);
+	ast_queue_control(pvt->owner, (inband ? AST_CONTROL_PROGRESS : AST_CONTROL_RINGING));
+	ast_mutex_unlock(&pvt->owner->lock);
+	ast_mutex_unlock(&pvt->lock);
 
 	return 0;
 }
@@ -1476,10 +1499,9 @@ int progress(unsigned call_reference, const char *token, int inband)
  */
 call_options_t *setup_incoming_call(call_details_t cd)
 {
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 	struct oh323_user *user = NULL;
 	struct oh323_alias *alias = NULL;
-	call_options_t *call_options;
 	char iabuf[INET_ADDRSTRLEN];
 
 	if (h323debug)
@@ -1500,7 +1522,6 @@ call_options_t *setup_incoming_call(call_details_t cd)
 	pvt->cd.call_source_name = strdup(cd.call_source_name);
 	pvt->cd.call_source_e164 = strdup(cd.call_source_e164);
 	pvt->cd.call_dest_e164 = strdup(cd.call_dest_e164);
-	call_options = &pvt->options;
 
 	if (h323debug) {
 		ast_verbose(VERBOSE_PREFIX_3 "Setting up Call\n");
@@ -1512,7 +1533,7 @@ call_options_t *setup_incoming_call(call_details_t cd)
 	}
 
 	/* Decide if we are allowing Gatekeeper routed calls*/
-	if ((!strcasecmp(cd.sourceIp, gatekeeper)) && (gkroute == -1) && (usingGk)) {		
+	if ((!strcasecmp(cd.sourceIp, gatekeeper)) && (gkroute == -1) && (usingGk)) {
 		if (!ast_strlen_zero(cd.call_dest_e164)) {
 			strncpy(pvt->exten, cd.call_dest_e164, sizeof(pvt->exten) - 1);
 			strncpy(pvt->context, default_context, sizeof(pvt->context) - 1); 
@@ -1525,10 +1546,10 @@ call_options_t *setup_incoming_call(call_details_t cd)
 			strncpy(pvt->exten, alias->name, sizeof(pvt->exten) - 1);
 			strncpy(pvt->context, alias->context, sizeof(pvt->context) - 1);
 		}
-	} else { 
+	} else {
 		/* Either this call is not from the Gatekeeper 
 		   or we are not allowing gk routed calls */
-		user  = find_user(cd);
+		user  = find_user(&cd);
 		if (!user) {
 			if (!ast_strlen_zero(pvt->cd.call_dest_e164)) {
 				strncpy(pvt->exten, cd.call_dest_e164, sizeof(pvt->exten) - 1);
@@ -1544,9 +1565,9 @@ call_options_t *setup_incoming_call(call_details_t cd)
 			memset(&pvt->options, 0, sizeof(pvt->options));
 		} else {					
 			if (user->host) {
-				if (strcasecmp(cd.sourceIp, ast_inet_ntoa(iabuf, sizeof(iabuf), user->addr.sin_addr))){					
+				if (strcasecmp(cd.sourceIp, ast_inet_ntoa(iabuf, sizeof(iabuf), user->addr.sin_addr))) {
 					if (ast_strlen_zero(user->context)) {
-						if (ast_strlen_zero(default_context)) {					
+						if (ast_strlen_zero(default_context)) {
 							ast_log(LOG_ERROR, "Call from '%s' rejected due to non-matching IP address (%s) and no default context\n", user->name, cd.sourceIp);
                 					return NULL;
 						}
@@ -1563,6 +1584,7 @@ call_options_t *setup_incoming_call(call_details_t cd)
 			strncpy(pvt->context, user->context, sizeof(pvt->context) - 1);
 			pvt->bridge = user->bridge;
 			pvt->nat = user->nat;
+			memcpy(&pvt->options, &user->options, sizeof(pvt->options));
 			if (!ast_strlen_zero(pvt->cd.call_dest_e164)) {
 				strncpy(pvt->exten, cd.call_dest_e164, sizeof(pvt->exten) - 1);
 			} else {
@@ -1574,10 +1596,9 @@ call_options_t *setup_incoming_call(call_details_t cd)
 			if (user->amaflags) {
 				pvt->amaflags = user->amaflags;
 			} 
-			call_options = &user->options;
 		} 
 	}
-	return call_options;
+	return &pvt->options;
 }
 
 /**
@@ -1587,23 +1608,20 @@ call_options_t *setup_incoming_call(call_details_t cd)
  */
 static int answer_call(unsigned call_reference, const char *token)
 {
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 	struct ast_channel *c = NULL;
 
 	if (h323debug)
 		ast_log(LOG_DEBUG, "Preparing Asterisk to answer for %s\n", token);
 
 	/* Find the call or allocate a private structure if call not found */
-	pvt = find_call(call_reference, token); 
+	pvt = find_call_locked(call_reference, token); 
 	if (!pvt) {
 		ast_log(LOG_ERROR, "Something is wrong: answer_call\n");
 		return 0;
 	}
-	/* Briefly lock call for oh323_new() */
-	ast_mutex_lock(&pvt->lock);
-
 	/* allocate a channel and tell asterisk about it */
-	c = oh323_new(pvt, AST_STATE_RINGING, pvt->cd.call_token);
+	c = __oh323_new(pvt, AST_STATE_RINGING, pvt->cd.call_token);
 
 	/* And release when done */
 	ast_mutex_unlock(&pvt->lock);
@@ -1631,16 +1649,15 @@ int setup_outgoing_call(call_details_t cd)
 void chan_ringing(unsigned call_reference, const char *token)
 {
         struct ast_channel *c = NULL;
-        struct oh323_pvt *pvt = NULL;
+        struct oh323_pvt *pvt;
 
 	if (h323debug)
 		ast_log(LOG_DEBUG, "Ringing on %s\n", token);
 
-        pvt = find_call(call_reference, token); 
+        pvt = find_call_locked(call_reference, token); 
         if (!pvt) {
                 ast_log(LOG_ERROR, "Something is wrong: ringing\n");
 	}
-	ast_mutex_lock(&pvt->lock);
         if (!pvt->owner) {
         	ast_mutex_unlock(&pvt->lock);
                 ast_log(LOG_ERROR, "Channel has no owner\n");
@@ -1661,17 +1678,18 @@ void chan_ringing(unsigned call_reference, const char *token)
   */
 static void cleanup_connection(call_details_t cd)
 {	
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 	struct ast_rtp *rtp = NULL;
 
 	ast_log(LOG_DEBUG, "Cleaning connection to %s\n", cd.call_token);
 	
 	while (1) {
-		pvt = find_call(cd.call_reference, cd.call_token); 
+		pvt = find_call_locked(cd.call_reference, cd.call_token); 
 		if (!pvt) {
+			if (h323debug)
+				ast_log(LOG_DEBUG, "No connection for %s\n", cd.call_token);
 			return;
 		}
-		ast_mutex_lock(&pvt->lock);
 		if (!pvt->owner || !ast_mutex_trylock(&pvt->owner->lock))
 			break;
 #if 1
@@ -1704,20 +1722,21 @@ static void cleanup_connection(call_details_t cd)
 		ast_mutex_unlock(&pvt->owner->lock);
 	}
 	ast_mutex_unlock(&pvt->lock);
+	if (h323debug)
+		ast_log(LOG_DEBUG, "Connection to %s cleaned\n", cd.call_token);
 	return;	
 }
 
 static void hangup_connection(unsigned int call_reference, const char *token, int cause)
 {
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 
 	ast_log(LOG_DEBUG, "Hanging up connection to %s with cause %d\n", token, cause);
 	
-	pvt = find_call(call_reference, token); 
+	pvt = find_call_locked(call_reference, token); 
 	if (!pvt) {
 		return;
 	}
-	ast_mutex_lock(&pvt->lock);
 	if (pvt->owner && !ast_mutex_trylock(&pvt->owner->lock)) {
 		pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
 		pvt->owner->hangupcause = pvt->hangupcause = cause;
@@ -1734,16 +1753,15 @@ static void hangup_connection(unsigned int call_reference, const char *token, in
 
 void set_dtmf_payload(unsigned call_reference, const char *token, int payload)
 {
-	struct oh323_pvt *pvt = NULL;
+	struct oh323_pvt *pvt;
 
 	if (h323debug)
 		ast_log(LOG_DEBUG, "Setting DTMF payload to %d on %s\n", payload, token);
 
-	pvt = find_call(call_reference, token);
+	pvt = find_call_locked(call_reference, token);
 	if (!pvt) {
 		return;
 	}
-	ast_mutex_lock(&pvt->lock);
 	if (pvt->rtp) {
 		ast_rtp_set_rtpmap_type(pvt->rtp, payload, "audio", "telephone-event");
 	}
@@ -1876,7 +1894,6 @@ static int h323_no_debug(int fd, int argc, char *argv[])
 
 static int h323_gk_cycle(int fd, int argc, char *argv[])
 {
-	return RESULT_SUCCESS;
 #if 0
 	if (argc != 3) {
 		return RESULT_SHOWUSAGE;
@@ -1889,8 +1906,8 @@ static int h323_gk_cycle(int fd, int argc, char *argv[])
 			ast_log(LOG_ERROR, "Gatekeeper registration failed.\n");
 		}
 	}
-	return RESULT_SUCCESS;
 #endif
+	return RESULT_SUCCESS;
 }
 
 static int h323_ep_hangup(int fd, int argc, char *argv[])
@@ -2250,10 +2267,10 @@ static struct ast_cli_entry  cli_h323_reload =
 
 static struct ast_rtp *oh323_get_rtp_peer(struct ast_channel *chan)
 {
-	struct oh323_pvt *p;
-	p = (struct oh323_pvt *) chan->tech_pvt;
-	if (p && p->rtp && p->bridge) {
-		return p->rtp;
+	struct oh323_pvt *pvt;
+	pvt = (struct oh323_pvt *) chan->tech_pvt;
+	if (pvt && pvt->rtp && pvt->bridge) {
+		return pvt->rtp;
 	}
 	return NULL;
 }
@@ -2291,7 +2308,7 @@ static char *convertcap(int cap)
 static int oh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs)
 {
 	/* XXX Deal with Video */
-	struct oh323_pvt *p;
+	struct oh323_pvt *pvt;
 	struct sockaddr_in them;
 	struct sockaddr_in us;
 	char *mode;
@@ -2302,14 +2319,14 @@ static int oh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, str
 	}
 
 	mode = convertcap(chan->writeformat); 
-	p = (struct oh323_pvt *) chan->tech_pvt;
-	if (!p) {
+	pvt = (struct oh323_pvt *) chan->tech_pvt;
+	if (!pvt) {
 		ast_log(LOG_ERROR, "No Private Structure, this is bad\n");
 		return -1;
 	}
 	ast_rtp_get_peer(rtp, &them);	
 	ast_rtp_get_us(rtp, &us);
-	h323_native_bridge(p->cd.call_token, ast_inet_ntoa(iabuf, sizeof(iabuf), them.sin_addr), mode);
+	h323_native_bridge(pvt->cd.call_token, ast_inet_ntoa(iabuf, sizeof(iabuf), them.sin_addr), mode);
 	return 0;
 }
 
@@ -2323,9 +2340,9 @@ static struct ast_rtp_protocol oh323_rtp = {
 int load_module()
 {
 	int res;
-        ast_mutex_init(&userl.lock);
-        ast_mutex_init(&peerl.lock);
-        ast_mutex_init(&aliasl.lock);
+	ast_mutex_init(&userl.lock);
+	ast_mutex_init(&peerl.lock);
+	ast_mutex_init(&aliasl.lock);
 	sched = sched_context_create();
 	if (!sched) {
 		ast_log(LOG_WARNING, "Unable to create schedule context\n");
@@ -2358,17 +2375,17 @@ int load_module()
 
 		/* Register our callback functions */
 		h323_callback_register(setup_incoming_call, 
-			               setup_outgoing_call,							 
-	 			       external_rtp_create, 
-				       setup_rtp_connection, 
-				       cleanup_connection, 
-				       chan_ringing,
-				       connection_made, 
-				       send_digit,
-				       answer_call,
-				       progress,
-				       set_dtmf_payload,
-				       hangup_connection);
+						setup_outgoing_call,							 
+						external_rtp_create, 
+						setup_rtp_connection, 
+						cleanup_connection, 
+						chan_ringing,
+						connection_made, 
+						send_digit,
+						answer_call,
+						progress,
+						set_dtmf_payload,
+						hangup_connection);
 		/* start the h.323 listener */
 		if (h323_start_listener(h323_signalling_port, bindaddr)) {
 			ast_log(LOG_ERROR, "Unable to create H323 listener.\n");
@@ -2392,15 +2409,15 @@ int unload_module()
 	struct oh323_pvt *p, *pl;
 
 	/* unregister commands */
-        ast_cli_unregister(&cli_debug);
-        ast_cli_unregister(&cli_no_debug);
-        ast_cli_unregister(&cli_trace);
-        ast_cli_unregister(&cli_no_trace);   
-        ast_cli_unregister(&cli_show_codecs);
-        ast_cli_unregister(&cli_gk_cycle);
-        ast_cli_unregister(&cli_hangup_call);
-        ast_cli_unregister(&cli_show_tokens);
-        ast_cli_unregister(&cli_h323_reload);
+	ast_cli_unregister(&cli_debug);
+	ast_cli_unregister(&cli_no_debug);
+	ast_cli_unregister(&cli_trace);
+	ast_cli_unregister(&cli_no_trace);   
+	ast_cli_unregister(&cli_show_codecs);
+	ast_cli_unregister(&cli_gk_cycle);
+	ast_cli_unregister(&cli_hangup_call);
+	ast_cli_unregister(&cli_show_tokens);
+	ast_cli_unregister(&cli_h323_reload);
 	ast_rtp_proto_unregister(&oh323_rtp);
 	ast_channel_unregister(&oh323_tech);
 		
@@ -2420,18 +2437,18 @@ int unload_module()
 		return -1;
 	}
 	if (!ast_mutex_lock(&monlock)) {
-                if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
-                        /* this causes a seg, anyone know why? */
+		if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
+			/* this causes a seg, anyone know why? */
 			pthread_cancel(monitor_thread);
-                        pthread_kill(monitor_thread, SIGURG);
-                        pthread_join(monitor_thread, NULL);
-                 }
-                monitor_thread = AST_PTHREADT_STOP;
-                ast_mutex_unlock(&monlock);
-        } else {
-                ast_log(LOG_WARNING, "Unable to lock the monitor\n");
-                return -1;
-        }
+			pthread_kill(monitor_thread, SIGURG);
+			pthread_join(monitor_thread, NULL);
+		}
+		monitor_thread = AST_PTHREADT_STOP;
+		ast_mutex_unlock(&monlock);
+	} else {
+		ast_log(LOG_WARNING, "Unable to lock the monitor\n");
+		return -1;
+	}
 	if (!ast_mutex_lock(&iflock)) {
 		/* destroy all the interfaces and free their memory */
 		p = iflist;