fix memory leak in hop

implement maddr in hop resolution
make belle_sip_hop_t a real object.

include/belle-sip/belle-sip.h

@@ -101,7 +101,8 @@ BELLE_SIP_DECLARE_TYPES_BEGIN(belle_sip,1)
 	BELLE_SIP_TYPE_ID(belle_sip_header_service_route_t),
 	BELLE_SIP_TYPE_ID(belle_sip_header_refer_to_t),
 	BELLE_SIP_TYPE_ID(belle_sip_header_referred_by_t),
-	BELLE_SIP_TYPE_ID(belle_sip_header_replaces_t)
+	BELLE_SIP_TYPE_ID(belle_sip_header_replaces_t),
+	BELLE_SIP_TYPE_ID(belle_sip_hop_t)
 BELLE_SIP_DECLARE_TYPES_END
 
 
@@ -133,6 +134,7 @@ typedef struct belle_sip_client_transaction belle_sip_client_transaction_t;
 typedef struct _belle_sip_message belle_sip_message_t;
 typedef struct _belle_sip_request belle_sip_request_t;
 typedef struct _belle_sip_response belle_sip_response_t;
+typedef struct belle_sip_hop belle_sip_hop_t;
 
 #include "belle-sip/utils.h"
 #include "belle-sip/list.h"

include/belle-sip/sipstack.h

@@ -20,13 +20,6 @@
 #ifndef belle_sip_stack_h
 #define belle_sip_stack_h
 
-struct belle_sip_hop{
-	char *host;
-	char *transport;
-	int port;
-};
-
-typedef struct belle_sip_hop belle_sip_hop_t;
 
 struct belle_sip_timer_config{
 	int T1;
@@ -59,8 +52,6 @@ BELLESIP_EXPORT int belle_sip_stack_get_dns_timeout(const belle_sip_stack_t *sta
 
 BELLESIP_EXPORT void belle_sip_stack_set_dns_timeout(belle_sip_stack_t *stack, int timeout);
 
-void belle_sip_hop_free(belle_sip_hop_t *hop);
-
 /**
  * Can be used to simulate network transmission delays, for tests.
 **/

src/belle_sip_internal.h

@@ -182,6 +182,7 @@ BELLE_SIP_DECLARE_VPTR(belle_sip_header_service_route_t);
 BELLE_SIP_DECLARE_VPTR(belle_sip_header_refer_to_t);
 BELLE_SIP_DECLARE_VPTR(belle_sip_header_referred_by_t);
 BELLE_SIP_DECLARE_VPTR(belle_sip_header_replaces_t);
+BELLE_SIP_DECLARE_VPTR(belle_sip_hop_t);
 
 typedef void (*belle_sip_source_remove_callback_t)(belle_sip_source_t *);
 
@@ -455,6 +456,15 @@ void belle_sip_parameters_init(belle_sip_parameters_t *obj);
 
 #include "listeningpoint_internal.h"
 
+
+struct belle_sip_hop{
+	belle_sip_object_t base;
+	char *host;
+	char *transport;
+	int port;
+};
+
+
 /*
  belle_sip_stack_t
 */
@@ -470,10 +480,10 @@ struct belle_sip_stack{
 	int resolver_send_error;	/* used to simulate network error*/
 };
 
-belle_sip_hop_t* belle_sip_hop_create(const char* transport, const char* host,int port);
-
-belle_sip_hop_t * belle_sip_stack_create_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req);
+belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char* host,int port);
+belle_sip_hop_t* belle_sip_hop_new_from_uri(const belle_sip_uri_t *uri);
 
+belle_sip_hop_t * belle_sip_stack_get_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req);
 const belle_sip_timer_config_t *belle_sip_stack_get_timer_config(const belle_sip_stack_t *stack);
 
 /*
@@ -706,7 +716,7 @@ int belle_sip_dialog_handle_ack(belle_sip_dialog_t *obj, belle_sip_request_t *ac
 /*
  belle_sip_response_t
 */
-void belle_sip_response_get_return_hop(belle_sip_response_t *msg, belle_sip_hop_t *hop);
+belle_sip_hop_t * belle_sip_response_get_return_hop(belle_sip_response_t *msg);
 
 #define IS_TOKEN(token) \
 		(INPUT->toStringTT(INPUT,LT(1),LT(strlen(#token)))->chars ?\

src/message.c

@@ -551,18 +551,21 @@ void belle_sip_response_fill_for_dialog(belle_sip_response_t *obj, belle_sip_req
 	}	
 }
 
-void belle_sip_response_get_return_hop(belle_sip_response_t *msg, belle_sip_hop_t *hop){
+belle_sip_hop_t * belle_sip_response_get_return_hop(belle_sip_response_t *msg){
 	belle_sip_header_via_t *via=BELLE_SIP_HEADER_VIA(belle_sip_message_get_header(BELLE_SIP_MESSAGE(msg),"via"));
 	const char *host;
-	hop->transport=belle_sip_strdup(belle_sip_header_via_get_transport_lowercase(via));
+	const char *transport;
+	int port;
+	transport=belle_sip_strdup(belle_sip_header_via_get_transport_lowercase(via));
 	host=belle_sip_header_via_get_received(via);
 	if (host==NULL)
 		host=belle_sip_header_via_get_host(via);
-	hop->host=belle_sip_strdup(host);
-	hop->port=belle_sip_header_via_get_rport(via);
-	if (hop->port==-1)
-		hop->port=belle_sip_header_via_get_listening_port(via);
+	port=belle_sip_header_via_get_rport(via);
+	if (port==-1)
+		port=belle_sip_header_via_get_listening_port(via);
+	return belle_sip_hop_new(transport,host,port);
 }
+
 int belle_sip_response_fix_contact(const belle_sip_response_t* response,belle_sip_header_contact_t* contact) {
 	belle_sip_header_via_t* via_header;
 	belle_sip_uri_t* contact_uri;

src/provider.c

@@ -429,9 +429,7 @@ belle_sip_client_transaction_t *belle_sip_provider_create_client_transaction(bel
 				 * The destination address,
 				   port, and transport for the CANCEL MUST be identical to those used to
 				   send the original request.*/
-				t->next_hop=belle_sip_hop_create(inv_transaction->next_hop->transport
-												, inv_transaction->next_hop->host
-												, inv_transaction->next_hop->port);
+				t->next_hop=(belle_sip_hop_t*)belle_sip_object_ref(inv_transaction->next_hop);
 			} else {
 				belle_sip_error (" No corresponding ict nor dest found for cancel request attached to transaction [%p]",t);
 			}
@@ -500,16 +498,15 @@ void belle_sip_provider_clean_channels(belle_sip_provider_t *p){
 void belle_sip_provider_send_request(belle_sip_provider_t *p, belle_sip_request_t *req){
 	belle_sip_hop_t* hop;
 	belle_sip_channel_t *chan;
-	hop=belle_sip_stack_create_next_hop(p->stack,req);
+	hop=belle_sip_stack_get_next_hop(p->stack,req);
 	chan=belle_sip_provider_get_channel(p,hop->host, hop->port, hop->transport);
 	if (chan) {
 		belle_sip_channel_queue_message(chan,BELLE_SIP_MESSAGE(req));
 	}
-	belle_sip_hop_free(hop);
 }
 
 void belle_sip_provider_send_response(belle_sip_provider_t *p, belle_sip_response_t *resp){
-	belle_sip_hop_t hop;
+	belle_sip_hop_t *hop;
 	belle_sip_channel_t *chan;
 	belle_sip_header_to_t *to=(belle_sip_header_to_t*)belle_sip_message_get_header((belle_sip_message_t*)resp,"to");
 
@@ -518,10 +515,9 @@ void belle_sip_provider_send_response(belle_sip_provider_t *p, belle_sip_respons
 		compute_hash_from_invariants((belle_sip_message_t*)resp,token,sizeof(token),"tag");
 		belle_sip_header_to_set_tag(to,token);
 	}
-	belle_sip_response_get_return_hop(resp,&hop);
-	chan=belle_sip_provider_get_channel(p,hop.host, hop.port, hop.transport);
+	hop=belle_sip_response_get_return_hop(resp);
+	chan=belle_sip_provider_get_channel(p,hop->host, hop->port, hop->transport);
 	if (chan) belle_sip_channel_queue_message(chan,BELLE_SIP_MESSAGE(resp));
-	belle_sip_hop_free(&hop);
 }
 
 

src/sipstack.c

@@ -20,6 +20,37 @@
 #include "listeningpoint_internal.h"
 
 
+belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char* host,int port) {
+	belle_sip_hop_t* hop = belle_sip_object_new(belle_sip_hop_t);
+	if (transport) hop->transport=belle_sip_strdup(transport);
+	if (host) hop->host=belle_sip_strdup(host);
+	hop->port=port;
+	return hop;
+}
+
+belle_sip_hop_t* belle_sip_hop_new_from_uri(const belle_sip_uri_t *uri){
+	const char *host;
+	host=belle_sip_uri_get_maddr_param(uri);
+	if (!host) host=belle_sip_uri_get_host(uri);
+	return belle_sip_hop_new(belle_sip_uri_get_transport_param(uri),
+				host,
+				belle_sip_uri_get_listening_port(uri));
+}
+
+static void belle_sip_hop_destroy(belle_sip_hop_t *hop){
+	if (hop->host) {
+		belle_sip_free(hop->host);
+		hop->host=NULL;
+	}
+	if (hop->transport){
+		belle_sip_free(hop->transport);
+		hop->transport=NULL;
+	}
+}
+
+BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_hop_t);
+BELLE_SIP_INSTANCIATE_VPTR(belle_sip_hop_t,belle_sip_object_t,belle_sip_hop_destroy,NULL,NULL,TRUE);
+
 static void belle_sip_stack_destroy(belle_sip_stack_t *stack){
 	belle_sip_object_unref(stack->ml);
 }
@@ -93,36 +124,20 @@ void belle_sip_stack_sleep(belle_sip_stack_t *stack, unsigned int milliseconds){
 	belle_sip_main_loop_sleep (stack->ml,milliseconds);
 }
 
-belle_sip_hop_t * belle_sip_stack_create_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req) {
+belle_sip_hop_t * belle_sip_stack_get_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req) {
 	belle_sip_header_route_t *route=BELLE_SIP_HEADER_ROUTE(belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),"route"));
 	belle_sip_uri_t *uri;
+
 	if (route!=NULL){
 		uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(route));
 	}else{
 		uri=belle_sip_request_get_uri(req);
 	}
-	return belle_sip_hop_create(	belle_sip_uri_get_transport_param(uri)
-								,belle_sip_uri_get_host(uri)
-								,belle_sip_uri_get_listening_port(uri));
-}
-belle_sip_hop_t* belle_sip_hop_create(const char* transport, const char* host,int port) {
-	belle_sip_hop_t* hop = belle_sip_new0(belle_sip_hop_t);
-	if (transport) hop->transport=belle_sip_strdup(transport);
-	if (host) hop->host=belle_sip_strdup(host);
-	hop->port=port;
-	return hop;
-}
-void belle_sip_hop_free(belle_sip_hop_t *hop){
-	if (hop->host) {
-		belle_sip_free(hop->host);
-		hop->host=NULL;
-	}
-	if (hop->transport){
-		belle_sip_free(hop->transport);
-		hop->transport=NULL;
-	}
+	return belle_sip_hop_new_from_uri(uri);
 }
 
+
+
 void belle_sip_stack_set_tx_delay(belle_sip_stack_t *stack, int delay_ms){
 	stack->tx_delay=delay_ms;
 }

src/transaction.c

@@ -149,11 +149,10 @@ void belle_sip_server_transaction_send_response(belle_sip_server_transaction_t *
 	
 	belle_sip_object_ref(resp);
 	if (!base->last_response){
-		belle_sip_hop_t hop;
-		belle_sip_response_get_return_hop(resp,&hop);
-		base->channel=belle_sip_provider_get_channel(base->provider,hop.host, hop.port, hop.transport);
+		belle_sip_hop_t *hop;
+		hop=belle_sip_response_get_return_hop(resp);
+		base->channel=belle_sip_provider_get_channel(base->provider,hop->host, hop->port, hop->transport);
 		belle_sip_object_ref(base->channel);
-		belle_sip_hop_free(&hop);
 	}
 	status_code=belle_sip_response_get_status_code(resp);
 	if (status_code!=100){
@@ -277,12 +276,11 @@ int belle_sip_client_transaction_send_request_to(belle_sip_client_transaction_t
 	if (t->preset_route) belle_sip_object_ref(t->preset_route);
 	if (!t->next_hop) {
 		if (outbound_proxy) {
-			t->next_hop=belle_sip_hop_create(	belle_sip_uri_get_transport_param(outbound_proxy)
-					,belle_sip_uri_get_host(outbound_proxy)
-					,belle_sip_uri_get_listening_port(outbound_proxy));
+			t->next_hop=belle_sip_hop_new_from_uri(outbound_proxy);
 		} else {
-			t->next_hop = belle_sip_stack_create_next_hop(prov->stack,t->base.request);
+			t->next_hop = belle_sip_stack_get_next_hop(prov->stack,t->base.request);
 		}
+		belle_sip_object_ref(t->next_hop);
 	} else {
 		/*next hop already preset, probably in case of CANCEL*/
 	}
@@ -369,7 +367,7 @@ void belle_sip_client_transaction_add_response(belle_sip_client_transaction_t *t
 
 static void client_transaction_destroy(belle_sip_client_transaction_t *t ){
 	if (t->preset_route) belle_sip_object_unref(t->preset_route);
-	if (t->next_hop) belle_sip_hop_free(t->next_hop);
+	if (t->next_hop) belle_sip_object_unref(t->next_hop);
 }
 
 static void on_channel_state_changed(belle_sip_channel_listener_t *l, belle_sip_channel_t *chan, belle_sip_channel_state_t state){

tester/belle_sip_register_tester.c

@@ -347,6 +347,7 @@ static void test_bad_request(void) {
 	belle_sip_provider_remove_sip_listener(prov,bad_req_listener);
 	belle_sip_object_unref(bad_req_listener);
 }
+
 static void test_register_authenticate(void) {
 	belle_sip_request_t *reg;
 	number_of_challenge=0;