Implement TLS support on top of polarssl.

README

 Dependencies:
 
-libantlr3c-3.4
-antlr3-3.4
-CUinit-2.x
-
+*libantlr3c-3.4
+*antlr3-3.4
 Newer versions won't compile.
 
+Optional:
+*CUinit-2.x
+*polarssl>=1.2
+
+
 On windows you have to edit /usr/local/include/antl3defs.h
 replace:
 #include <winsock.h>
@@ -16,6 +19,8 @@ Or get the source code from linphone's git (linphone branch):
 git clone -b linphone git://git.linphone.org/antlr3.git
 git clone -b linphone git://git.linphone.org/cunit.git
 
+polarssl build system is Make (or Cmake). To build the shared library version, use "make SHARED=1 DEBUG=1", followed by "make install".
+
 Prequisites
 ***********
 You must jave 'java' in your PATH.

configure.ac

@@ -64,8 +64,12 @@ AC_ARG_WITH( antlr,
       [ antlr_prefix=${withval}],[ antlr_prefix=${prefix} ])
 
 found_antlr3=no
-ANTLR_CFLAGS="-I${antlr_prefix}/include"
-ANTLR_LIBS="-L${antlr_prefix}/lib -lantlr3c"
+if test "$antlr_prefix" != "/usr" ; then
+	ANTLR_CFLAGS="-I${antlr_prefix}/include"
+	ANTLR_LIBS="-L${antlr_prefix}/lib"
+fi
+
+ANTLR_LIBS="$ANTLR_LIBS -lantlr3c"
 
 dnl check antlr headers
 CPPFLAGS_save=$CPPFLAGS
@@ -119,25 +123,44 @@ AC_ARG_ENABLE(	tls,
 		*) AC_MSG_ERROR(bad value ${enableval} for --enable-tls) ;;
 		esac],[use_tls=true])
 
+AC_ARG_WITH( polarssl,
+      [  --with-polarssl      Set prefix where libantlr3c can be found (ex:/usr, /usr/local)[default=PREFIX] ],
+      [ polarssl_prefix=${withval}],[ polarssl_prefix=${prefix} ])
+
+if test "$polarssl_prefix" != "/usr" ; then
+	POLARSSL_CFLAGS="-I${polarssl_prefix}/include"
+	POLARSSL_LIBS="-L${polarssl_prefix}/lib"
+fi
+
+POLARSSL_LIBS="$POLARSSL_LIBS -lpolarssl"
+found_polarssl=no
+
 if test "$use_tls" = "true" ; then
-	PKG_CHECK_MODULES(GNUTLS, gnutls, [found_gnutls=yes],
-		[AC_MSG_ERROR([Gnutls not found. You can use --disable-tls to turn tls support off.])] )
+	CPPFLAGS_save=$CPPFLAGS
+	LIBS_save=$LIBS
+
+	CPPFLAGS="$CPPFLAGS $POLARSSL_CFLAGS"
+	LIBS="$LIBS $POLARSSL_LIBS"
+	AC_CHECK_HEADERS(polarssl/ssl.h,
+		[
+			AC_CHECK_LIB(polarssl,x509parse_crtpath,[
+				found_polarssl=yes
+				POLARSSL_LIBS=" -lpolarssl"
+			])
+			
+	])
+	CPPFLAGS=$CPPFLAGS_save
+	LIBS=$LIBS_save
 fi
 
-AM_CONDITIONAL([BUILD_TLS], [test "x$found_gnutls" = "xyes" || test "x$found_openssl" = "xyes"])
+AM_CONDITIONAL([BUILD_TLS], [test "x$found_polarssl" = "xyes"])
 TLS_CFLAGS=""
 TLS_LIBS=""
 TLS_PC=""
-if test "x$found_gnutls" = "xyes" ; then
-	GNUTLS_LIBS+="$GNUTLS_LIBS -lgnutls "
-	AC_DEFINE(HAVE_GNUTLS,1,[Defined when gnutls api is available])
-	TLS_CFLAGS=$GNUTLS_CFLAGS
-	TLS_LIBS=$GNUTLS_LIBS
-	TLS_PC=gnutls
-elif test "x$found_openssl" = "xyes" ; then
-	AC_DEFINE(HAVE_OPENSSL,1,[Defined when openssl api is available])
-	TLS_CFLAGS=$OPENSSL_CFLAGS
-	TLS_LIBS=$OPENSSL_LIBS
+if test "x$found_polarssl" = "xyes" ; then
+	AC_DEFINE(HAVE_POLARSSL,1,[Defined when polarssl api is available])
+	TLS_CFLAGS=$POLARSSL_CFLAGS
+	TLS_LIBS=$POLARSSL_LIBS
 fi
 AC_SUBST(TLS_CFLAGS)
 AC_SUBST(TLS_LIBS)	

include/belle-sip/belle-sip.h

@@ -126,6 +126,7 @@ BELLE_SIP_END_DECLS
 /*these types are declared here because they are widely used in many headers included after*/
 
 typedef struct belle_sip_listening_point belle_sip_listening_point_t;
+typedef struct belle_sip_tls_listening_point belle_sip_tls_listening_point_t;
 typedef struct belle_sip_stack belle_sip_stack_t;
 typedef struct belle_sip_provider belle_sip_provider_t;
 typedef struct belle_sip_dialog belle_sip_dialog_t;

include/belle-sip/listeningpoint.h

@@ -59,6 +59,18 @@ BELLESIP_EXPORT void belle_sip_listening_point_clean_channels(belle_sip_listenin
 BELLESIP_EXPORT int belle_sip_listening_point_get_channel_count(const belle_sip_listening_point_t *lp);
 BELLESIP_EXPORT int belle_sip_listening_point_get_well_known_port(const char *transport);
 
+int belle_sip_tls_listening_point_set_root_ca(belle_sip_tls_listening_point_t *s, const char *path);
+
+#define BELLE_SIP_TLS_LISTENING_POINT_BADCERT_CN_MISMATCH 	(1)
+#define BELLE_SIP_TLS_LISTENING_POINT_BADCERT_ANY_REASON 	(0xff)
+int belle_sip_tls_listening_point_set_verify_exceptions(belle_sip_tls_listening_point_t *s, int flags);
+
+
+
+#define BELLE_SIP_UDP_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_udp_listening_point_t)
+#define BELLE_SIP_STREAM_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_stream_listening_point_t)
+#define BELLE_SIP_TLS_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_tls_listening_point_t)
+
 BELLE_SIP_END_DECLS
 
 

include/belle-sip/utils.h

@@ -133,6 +133,8 @@ BELLESIP_EXPORT void belle_sip_set_log_level(int level);
 
 BELLESIP_EXPORT char * belle_sip_random_token(char *ret, size_t size);
 
+unsigned char * belle_sip_random_bytes(unsigned char *ret, size_t size);
+
 char * belle_sip_octets_to_text(const unsigned char *hash, size_t hash_len, char *ret, size_t size);
 
 char * belle_sip_create_tag(char *ret, size_t size);

src/Makefile.am

@@ -58,12 +58,11 @@ libbellesip_la_SOURCES=				\
 									transports/stream_channel.c \
 									transports/stream_channel.h \
 									transports/stream_listeningpoint.c \
-									transports/tls_listeningpoint.c \
+									transports/tls_listeningpoint_polarssl.c \
+									transports/tls_channel_polarssl.c \
 									refresher.c refresher-helper.h \
 									dns.c dns.h
-if BUILD_TLS
-libbellesip_la_SOURCES+=transports/tls_channel.c 
-endif
+
 
 libbellesip_la_CFLAGS=$(STRICT_OPTIONS) $(ANTLR_CFLAGS) $(TLS_CFLAGS) $(LIBBELLESIP_CFLAGS)
 

src/auth_helper.c

@@ -63,13 +63,13 @@ int belle_sip_auth_helper_compute_ha1(const char* userid,const char* realm,const
 		 return -1;
 	}
 
-	md5_init(&state);
-	md5_append(&state,(const md5_byte_t *)userid,strlen(userid));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state,(const md5_byte_t *)realm,strlen(realm));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state,(const md5_byte_t *)password,strlen(password));
-	md5_finish(&state,out);
+	belle_sip_md5_init(&state);
+	belle_sip_md5_append(&state,(const md5_byte_t *)userid,strlen(userid));
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state,(const md5_byte_t *)realm,strlen(realm));
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state,(const md5_byte_t *)password,strlen(password));
+	belle_sip_md5_finish(&state,out);
 	for (di = 0; di < 16; ++di)
 			    sprintf(ha1 + di * 2, "%02x", out[di]);
 	ha1[32]='\0';
@@ -82,11 +82,11 @@ int belle_sip_auth_helper_compute_ha2(const char* method,const char* uri, char h
 	int di;
 	ha2[32]='\0';
 	/*HA2=MD5(method:uri)*/
-	md5_init(&state);
-	md5_append(&state,(const md5_byte_t *)method,strlen(method));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state,(const md5_byte_t *)uri,strlen(uri));
-	md5_finish(&state,out);
+	belle_sip_md5_init(&state);
+	belle_sip_md5_append(&state,(const md5_byte_t *)method,strlen(method));
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state,(const md5_byte_t *)uri,strlen(uri));
+	belle_sip_md5_finish(&state,out);
 	for (di = 0; di < 16; ++di)
 				    sprintf(ha2 + di * 2, "%02x", out[di]);
 	return 0;
@@ -97,15 +97,15 @@ int belle_sip_auth_helper_compute_response(const char* ha1,const char* nonce, co
 	int di;
 	response[32]='\0';
 
-	md5_init(&state);
-	md5_append(&state,(const md5_byte_t *)ha1,strlen(ha1));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state
+	belle_sip_md5_init(&state);
+	belle_sip_md5_append(&state,(const md5_byte_t *)ha1,strlen(ha1));
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state
 			,(const md5_byte_t *)nonce
 			,strlen(nonce));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state,(const md5_byte_t *)ha2,strlen(ha2));
-		md5_finish(&state,out);
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state,(const md5_byte_t *)ha2,strlen(ha2));
+		belle_sip_md5_finish(&state,out);
 		/*copy values*/
 		for (di = 0; di < 16; ++di)
 			    sprintf(response + di * 2, "%02x", out[di]);
@@ -128,28 +128,28 @@ int belle_sip_auth_helper_compute_response_qop_auth(const char* ha1
 	snprintf(nounce_count_as_string,sizeof(nounce_count_as_string),"%08x",nonce_count);
 	/*response=MD5(HA1:nonce:nonce_count:cnonce:qop:HA2)*/
 
-	md5_init(&state);
-	md5_append(&state,(const md5_byte_t *)ha1,strlen(ha1));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state
+	belle_sip_md5_init(&state);
+	belle_sip_md5_append(&state,(const md5_byte_t *)ha1,strlen(ha1));
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state
 			,(const md5_byte_t *)nonce
 			,strlen(nonce));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state
 				,(const md5_byte_t *)nounce_count_as_string
 				,strlen(nounce_count_as_string));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state
 				,(const md5_byte_t *)cnonce
 				,strlen(cnonce));
-	md5_append(&state,(const md5_byte_t *)":",1);
-	md5_append(&state
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state
 				,(const md5_byte_t *)qop
 				,strlen(qop));
-	md5_append(&state,(const md5_byte_t *)":",1);
+	belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
 
-	md5_append(&state,(const md5_byte_t *)ha2,strlen(ha2));
-	md5_finish(&state,out);
+	belle_sip_md5_append(&state,(const md5_byte_t *)ha2,strlen(ha2));
+	belle_sip_md5_finish(&state,out);
 	/*copy values*/
 	for (di = 0; di < 16; ++di)
 		    sprintf(response + di * 2, "%02x", out[di]);

src/belle_sip_internal.h

@@ -457,6 +457,7 @@ void belle_sip_parameters_init(belle_sip_parameters_t *obj);
 
 struct belle_sip_hop{
 	belle_sip_object_t base;
+	char *cname;
 	char *host;
 	char *transport;
 	int port;
@@ -479,7 +480,7 @@ struct belle_sip_stack{
 	int resolver_send_error;	/* used to simulate network error*/
 };
 
-belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char* host,int port);
+belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char *cname, 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);
@@ -511,7 +512,7 @@ belle_sip_server_transaction_t * belle_sip_provider_find_matching_server_transac
                                                                                    belle_sip_request_t *req);
 void belle_sip_provider_remove_server_transaction(belle_sip_provider_t *prov, belle_sip_server_transaction_t *t);
 void belle_sip_provider_set_transaction_terminated(belle_sip_provider_t *p, belle_sip_transaction_t *t);
-belle_sip_channel_t * belle_sip_provider_get_channel(belle_sip_provider_t *p, const char *name, int port, const char *transport);
+belle_sip_channel_t * belle_sip_provider_get_channel(belle_sip_provider_t *p, const belle_sip_hop_t *hop);
 void belle_sip_provider_add_dialog(belle_sip_provider_t *prov, belle_sip_dialog_t *dialog);
 void belle_sip_provider_remove_dialog(belle_sip_provider_t *prov, belle_sip_dialog_t *dialog);
 void belle_sip_provider_release_channel(belle_sip_provider_t *p, belle_sip_channel_t *chan);

src/belle_sip_loop.c

@@ -188,6 +188,8 @@ void belle_sip_socket_source_init(belle_sip_source_t *s, belle_sip_source_func_t
 	belle_sip_source_init(s,func,data,sock,events,timeout_value_ms);
 #endif
 	s->sock=sock;
+	if (sock!=(belle_sip_socket_t)-1)
+		belle_sip_socket_set_nonblocking(sock);
 }
 
 void belle_sip_fd_source_init(belle_sip_source_t *s, belle_sip_source_func_t func, void *data, belle_sip_fd_t fd, unsigned int events, unsigned int timeout_value_ms){

src/belle_sip_utils.c

@@ -582,9 +582,10 @@ static const char *symbols="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ
 **/
 char * belle_sip_random_token(char *ret, size_t size){
 	unsigned int val;
-	unsigned int i,j;
-	for(i=0,j=0;i<size-1;++i,++j){
-		if (j%5==0) val=belle_sip_random();
+	unsigned int i;
+	
+	for(i=0;i<size-1;++i){
+		if (i%5==0) val=belle_sip_random();
 		ret[i]=symbols[val & 63];
 		val=val>>6;
 	}
@@ -592,6 +593,20 @@ char * belle_sip_random_token(char *ret, size_t size){
 	return ret;
 }
 
+/**
+ * Write random bytes of supplied size.
+**/
+unsigned char * belle_sip_random_bytes(unsigned char *ret, size_t size){
+	unsigned int val;
+	unsigned int i;
+	for(i=0;i<size;++i){
+		if (i%4==0) val=belle_sip_random();
+		ret[i]=val & 0xff;
+		val=val>>8;
+	}
+	return ret;
+}
+
 typedef struct bits_reader{
 	const uint8_t *buffer;
 	size_t buf_size;

src/channel.c

@@ -54,6 +54,7 @@ static belle_sip_list_t * for_each_weak_unref_free(belle_sip_list_t *l, belle_si
 
 static void belle_sip_channel_destroy(belle_sip_channel_t *obj){
 	if (obj->peer) freeaddrinfo(obj->peer);
+	belle_sip_free(obj->peer_cname);
 	belle_sip_free(obj->peer_name);
 	if (obj->local_ip) belle_sip_free(obj->local_ip);
 	obj->listeners=for_each_weak_unref_free(obj->listeners,(belle_sip_object_destroy_notify_t)belle_sip_channel_remove_listener,obj);
@@ -277,7 +278,8 @@ static void update_inactivity_timer(belle_sip_channel_t *obj){
 	}
 }
 
-void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_stack_t *stack,const char *bindip,int localport,const char *peername, int peer_port){
+void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_stack_t *stack,const char *bindip,int localport,const char *peer_cname, const char *peername, int peer_port){
+	obj->peer_cname=peer_cname ? belle_sip_strdup(peer_cname) : belle_sip_strdup(peername);
 	obj->peer_name=belle_sip_strdup(peername);
 	obj->peer_port=peer_port;
 	obj->stack=stack;
@@ -299,7 +301,7 @@ void belle_sip_channel_init_with_addr(belle_sip_channel_t *obj, belle_sip_stack_
 	ai.ai_addr=(struct sockaddr*)peer_addr;
 	ai.ai_addrlen=addrlen;
 	belle_sip_addrinfo_to_ip(&ai,remoteip,sizeof(remoteip),&peer_port);
-	belle_sip_channel_init(obj,stack,NULL,0,remoteip,peer_port);
+	belle_sip_channel_init(obj,stack,NULL,0,NULL,remoteip,peer_port);
 	obj->peer=belle_sip_ip_address_to_addrinfo(ai.ai_family, obj->peer_name,obj->peer_port);
 }
 
@@ -323,9 +325,12 @@ void belle_sip_channel_remove_listener(belle_sip_channel_t *obj, belle_sip_chann
 	obj->listeners=belle_sip_list_remove(obj->listeners,l);
 }
 
-int belle_sip_channel_matches(const belle_sip_channel_t *obj, const char *peername, int peerport, const struct addrinfo *addr){
-	if (peername && strcmp(peername,obj->peer_name)==0 && peerport==obj->peer_port)
+int belle_sip_channel_matches(const belle_sip_channel_t *obj, const belle_sip_hop_t *hop, const struct addrinfo *addr){
+	if (hop && strcmp(hop->host,obj->peer_name)==0 && hop->port==obj->peer_port){
+		if (hop->cname && obj->peer_cname && strcmp(hop->cname,obj->peer_cname)!=0)
+			return 0; /*cname mismatch*/
 		return 1;
+	}
 	if (addr && obj->peer) 
 		return addr->ai_addrlen==obj->peer->ai_addrlen && memcmp(addr->ai_addr,obj->peer->ai_addr,addr->ai_addrlen)==0;
 	return 0;

src/channel.h

@@ -78,6 +78,7 @@ struct belle_sip_channel{
 	belle_sip_stack_t *stack;
 	belle_sip_channel_state_t state;
 	belle_sip_list_t *listeners;
+	char *peer_cname;
 	char *peer_name;
 	int peer_port;
 	char *local_ip;
@@ -99,7 +100,7 @@ void belle_sip_channel_add_listener(belle_sip_channel_t *chan, belle_sip_channel
 
 void belle_sip_channel_remove_listener(belle_sip_channel_t *obj, belle_sip_channel_listener_t *l);
 
-int belle_sip_channel_matches(const belle_sip_channel_t *obj, const char *peername, int peerport, const struct addrinfo *addr);
+int belle_sip_channel_matches(const belle_sip_channel_t *obj, const belle_sip_hop_t *hop, const struct addrinfo *addr);
 
 void belle_sip_channel_resolve(belle_sip_channel_t *obj);
 
@@ -117,7 +118,7 @@ int belle_sip_channel_send(belle_sip_channel_t *obj, const void *buf, size_t buf
 int belle_sip_channel_recv(belle_sip_channel_t *obj, void *buf, size_t buflen);
 /*only used by channels implementation*/
 void belle_sip_channel_set_ready(belle_sip_channel_t *obj, const struct sockaddr *addr, socklen_t slen);
-void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_stack_t *stack, const char *bindip,int localport,const char *peername, int peer_port);
+void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_stack_t *stack, const char *bindip,int localport, const char *peer_cname, const char *peername, int peer_port);
 void belle_sip_channel_init_with_addr(belle_sip_channel_t *obj, belle_sip_stack_t *stack, const struct sockaddr *peer_addr, socklen_t addrlen);
 void belle_sip_channel_set_socket(belle_sip_channel_t *obj, belle_sip_socket_t sock, belle_sip_source_func_t datafunc);
 /*end of channel implementations*/

src/listeningpoint.c

@@ -45,8 +45,8 @@ void belle_sip_listening_point_add_channel(belle_sip_listening_point_t *lp, bell
 	lp->channels=belle_sip_list_append(lp->channels,chan);/*channel is already owned*/
 }
 
-belle_sip_channel_t *belle_sip_listening_point_create_channel(belle_sip_listening_point_t *obj, const char *dest, int port){
-	belle_sip_channel_t *chan=BELLE_SIP_OBJECT_VPTR(obj,belle_sip_listening_point_t)->create_channel(obj,dest,port);
+belle_sip_channel_t *belle_sip_listening_point_create_channel(belle_sip_listening_point_t *obj, const belle_sip_hop_t *hop){
+	belle_sip_channel_t *chan=BELLE_SIP_OBJECT_VPTR(obj,belle_sip_listening_point_t)->create_channel(obj,hop);
 	if (chan){
 		chan->lp=obj;
 		belle_sip_listening_point_add_channel(obj,chan);
@@ -114,29 +114,29 @@ int belle_sip_listening_point_get_well_known_port(const char *transport){
 	return -1;
 }
 
-belle_sip_channel_t *_belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const char *peer_name, int peer_port, const struct addrinfo *addr){
+belle_sip_channel_t *_belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp, const belle_sip_hop_t *hop, const struct addrinfo *addr){
 	belle_sip_list_t *elem;
 	belle_sip_channel_t *chan;
 	
 	for(elem=lp->channels;elem!=NULL;elem=elem->next){
 		chan=(belle_sip_channel_t*)elem->data;
-		if (belle_sip_channel_matches(chan,peer_name,peer_port,addr)){
+		if (belle_sip_channel_matches(chan,hop,addr)){
 			return chan;
 		}
 	}
 	return NULL;
 }
 
-belle_sip_channel_t *belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const char *peer_name, int peer_port){
+belle_sip_channel_t *belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const belle_sip_hop_t *hop){
 	struct addrinfo *res=NULL;
 	struct addrinfo hints={0};
 	char portstr[20];
 	belle_sip_channel_t *chan;
 
 	hints.ai_flags=AI_NUMERICHOST|AI_NUMERICSERV;
-	snprintf(portstr,sizeof(portstr),"%i",peer_port);
-	getaddrinfo(peer_name,portstr,&hints,&res);
-	chan=_belle_sip_listening_point_get_channel(lp,peer_name,peer_port,res);
+	snprintf(portstr,sizeof(portstr),"%i",hop->port);
+	getaddrinfo(hop->host,portstr,&hints,&res);
+	chan=_belle_sip_listening_point_get_channel(lp,hop,res);
 	if (res) freeaddrinfo(res);
 	return chan;
 }
@@ -211,6 +211,6 @@ int belle_sip_listening_point_get_keep_alive(const belle_sip_listening_point_t *
 	return lp->keep_alive_timer?belle_sip_source_get_timeout(lp->keep_alive_timer):-1;
 }
 
-void belle_sip_listener_set_channel_listener(belle_sip_listening_point_t *lp,belle_sip_channel_listener_t* channel_listener) {
+void belle_sip_listening_point_set_channel_listener(belle_sip_listening_point_t *lp,belle_sip_channel_listener_t* channel_listener) {
 	lp->channel_listener=channel_listener;
 }

src/listeningpoint_internal.h

@@ -23,9 +23,13 @@
 #include "gnutls/openssl.h"
 #endif
 
+#ifdef HAVE_POLARSSL
+#include <polarssl/ssl.h>
+#endif
+
 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_listening_point_t,belle_sip_object_t)
 const char *transport;
-belle_sip_channel_t * (*create_channel)(belle_sip_listening_point_t *,const char *dest_ip, int port);
+belle_sip_channel_t * (*create_channel)(belle_sip_listening_point_t *, const belle_sip_hop_t *hop);
 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
 
 
@@ -47,13 +51,13 @@ struct belle_sip_listening_point{
 };
 
 void belle_sip_listening_point_init(belle_sip_listening_point_t *lp, belle_sip_stack_t *s,  const char *address, int port);
-belle_sip_channel_t *_belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const char *peer_name, int peer_port, const struct addrinfo *addr);
-belle_sip_channel_t *belle_sip_listening_point_create_channel(belle_sip_listening_point_t *ip,const char *dest, int port);
+belle_sip_channel_t *_belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const belle_sip_hop_t *hop, const struct addrinfo *addr);
+belle_sip_channel_t *belle_sip_listening_point_create_channel(belle_sip_listening_point_t *ip, const belle_sip_hop_t *hop);
 void belle_sip_listening_point_remove_channel(belle_sip_listening_point_t *lp, belle_sip_channel_t *chan);
 int belle_sip_listening_point_get_well_known_port(const char *transport);
-belle_sip_channel_t *belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const char *peer_name, int peer_port);
+belle_sip_channel_t *belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp, const belle_sip_hop_t *hop);
 void belle_sip_listening_point_add_channel(belle_sip_listening_point_t *lp, belle_sip_channel_t *chan);
-void belle_sip_listener_set_channel_listener(belle_sip_listening_point_t *lp,belle_sip_channel_listener_t* channel_listener);
+void belle_sip_listening_point_set_channel_listener(belle_sip_listening_point_t *lp,belle_sip_channel_listener_t* channel_listener);
 
 /**udp*/
 typedef struct belle_sip_udp_listening_point belle_sip_udp_listening_point_t;
@@ -62,14 +66,23 @@ belle_sip_channel_t * belle_sip_channel_new_udp_with_addr(belle_sip_stack_t *sta
 belle_sip_listening_point_t * belle_sip_udp_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port);
 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_udp_listening_point_t,belle_sip_listening_point_t)
 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
-#define BELLE_SIP_UDP_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_udp_listening_point_t)
+
 
 /*stream*/
 typedef struct belle_sip_stream_listening_point belle_sip_stream_listening_point_t;
 
+struct belle_sip_stream_listening_point{
+	belle_sip_listening_point_t base;
+	belle_sip_socket_t server_sock;
+	belle_sip_source_t *source;
+};
+
 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_stream_listening_point_t,belle_sip_listening_point_t)
 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
-#define BELLE_SIP_STREAM_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_stream_listening_point_t)
+
+void belle_sip_stream_listening_point_setup_server_socket(belle_sip_stream_listening_point_t *obj, belle_sip_source_func_t on_new_connection_cb );
+void belle_sip_stream_listening_point_destroy_server_socket(belle_sip_stream_listening_point_t *lp);
+void belle_sip_stream_listening_point_init(belle_sip_stream_listening_point_t *obj, belle_sip_stack_t *s, const char *ipaddress, int port, belle_sip_source_func_t on_new_connection_cb );
 belle_sip_listening_point_t * belle_sip_stream_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port);
 
 /*tls*/
@@ -77,17 +90,21 @@ belle_sip_listening_point_t * belle_sip_stream_listening_point_new(belle_sip_sta
 typedef struct belle_sip_tls_listening_point belle_sip_tls_listening_point_t;
 
 struct belle_sip_tls_listening_point{
-	belle_sip_listening_point_t base;
+	belle_sip_stream_listening_point_t base;
 #ifdef HAVE_OPENSSL
 	SSL_CTX *ssl_context;
 #endif
+#ifdef HAVE_POLARSSL
+	x509_cert root_ca;
+#endif
+	int verify_exceptions;
 };
 
 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_tls_listening_point_t,belle_sip_listening_point_t)
 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
 #define BELLE_SIP_TLS_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_tls_listening_point_t)
 belle_sip_listening_point_t * belle_sip_tls_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port);
-belle_sip_channel_t * belle_sip_channel_new_tls(belle_sip_tls_listening_point_t* lp, const char *bindip, int localport,const char *name, int port);
+belle_sip_channel_t * belle_sip_channel_new_tls(belle_sip_tls_listening_point_t* lp, const char *bindip, int localport,const char *cname, const char *name, int port);
 
 #include "transports/stream_channel.h"
 

src/md5.c

@@ -310,7 +310,7 @@ md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
 }
 
 void
-md5_init(md5_state_t *pms)
+belle_sip_md5_init(md5_state_t *pms)
 {
     pms->count[0] = pms->count[1] = 0;
     pms->abcd[0] = 0x67452301;
@@ -320,7 +320,7 @@ md5_init(md5_state_t *pms)
 }
 
 void
-md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+belle_sip_md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
 {
     const md5_byte_t *p = data;
     int left = nbytes;
@@ -358,7 +358,7 @@ md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
 }
 
 void
-md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+belle_sip_md5_finish(md5_state_t *pms, md5_byte_t digest[16])
 {
     static const md5_byte_t pad[64] = {
 	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -373,9 +373,9 @@ md5_finish(md5_state_t *pms, md5_byte_t digest[16])
     for (i = 0; i < 8; ++i)
 	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
     /* Pad to 56 bytes mod 64. */
-    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+    belle_sip_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
     /* Append the length. */
-    md5_append(pms, data, 8);
+    belle_sip_md5_append(pms, data, 8);
     for (i = 0; i < 16; ++i)
 	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
 }

src/md5.h

@@ -76,13 +76,13 @@ extern "C"
 #endif
 
 /* Initialize the algorithm. */
-void md5_init(md5_state_t *pms);
+void belle_sip_md5_init(md5_state_t *pms);
 
 /* Append a string to the message. */
-void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+void belle_sip_md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
 
 /* Finish the message and return the digest. */
-void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+void belle_sip_md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
 
 #ifdef __cplusplus
 }  /* end extern "C" */

src/message.c

@@ -556,7 +556,7 @@ 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=belle_sip_header_via_get_received(via) ? belle_sip_header_via_get_received(via) : belle_sip_header_via_get_host(via);
 	int port=belle_sip_header_via_get_rport(via)>0 ? belle_sip_header_via_get_rport(via) : belle_sip_header_via_get_listening_port(via);
-	return belle_sip_hop_new(belle_sip_header_via_get_transport_lowercase(via),host,port);
+	return belle_sip_hop_new(belle_sip_header_via_get_transport_lowercase(via),NULL,host,port);
 }
 
 int belle_sip_response_fix_contact(const belle_sip_response_t* response,belle_sip_header_contact_t* contact) {