Remote turn_realloc()

Do not overload realloc() with a different API.

src/apps/common/ns_turn_utils.c

@@ -787,23 +787,6 @@ void tm_print_func(void) {
   pthread_mutex_unlock(&tm);
 } 
 
-extern "C" void *turn_realloc_func(void *ptr, size_t old_sz, size_t new_sz, const char* function, int line);
-void *turn_realloc_func(void *ptr, size_t old_sz, size_t new_sz, const char* function, int line) {
-
-  UNUSED_ARG(old_sz);
-
-  TM_START();
-
-  if(ptr)
-	  del_tm_ptr(ptr,id);
-
-  ptr = realloc(ptr,new_sz);
-
-  add_tm_ptr(ptr,id);
-
-  return ptr;
-}
-
 extern "C" void turn_free_func(void *ptr, size_t sz, const char* function, int line);
 void turn_free_func(void *ptr, size_t sz, const char* function, int line) {
 

src/apps/relay/netengine.c

@@ -185,7 +185,7 @@ static void add_aux_server_list(const char *saddr, turn_server_addrs_list_t *lis
 		if(make_ioa_addr_from_full_string((const u08bits*)saddr, 0, &addr)!=0) {
 			TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong full address format: %s\n",saddr);
 		} else {
-		  list->addrs = (ioa_addr*)turn_realloc(list->addrs,0,sizeof(ioa_addr)*(list->size+1));
+		  list->addrs = (ioa_addr*)realloc(list->addrs,sizeof(ioa_addr)*(list->size+1));
 			addr_cpy(&(list->addrs[(list->size)++]),&addr);
 			{
 				u08bits s[1025];
@@ -213,7 +213,7 @@ static void add_alt_server(const char *saddr, int default_port, turn_server_addr
 		if(make_ioa_addr_from_full_string((const u08bits*)saddr, default_port, &addr)!=0) {
 			TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong IP address format: %s\n",saddr);
 		} else {
-		  list->addrs = (ioa_addr*)turn_realloc(list->addrs,0,sizeof(ioa_addr)*(list->size+1));
+		  list->addrs = (ioa_addr*)realloc(list->addrs,sizeof(ioa_addr)*(list->size+1));
 			addr_cpy(&(list->addrs[(list->size)++]),&addr);
 			{
 				u08bits s[1025];
@@ -372,9 +372,9 @@ void add_listener_addr(const char* addr) {
 		}
 		++turn_params.listener.addrs_number;
 		++turn_params.listener.services_number;
-		turn_params.listener.addrs = (char**)turn_realloc(turn_params.listener.addrs, 0, sizeof(char*)*turn_params.listener.addrs_number);
+		turn_params.listener.addrs = (char**)realloc(turn_params.listener.addrs, sizeof(char*)*turn_params.listener.addrs_number);
 		turn_params.listener.addrs[turn_params.listener.addrs_number-1]=turn_strdup(sbaddr);
-		turn_params.listener.encaddrs = (ioa_addr**)turn_realloc(turn_params.listener.encaddrs, 0, sizeof(ioa_addr*)*turn_params.listener.addrs_number);
+		turn_params.listener.encaddrs = (ioa_addr**)realloc(turn_params.listener.encaddrs, sizeof(ioa_addr*)*turn_params.listener.addrs_number);
 		turn_params.listener.encaddrs[turn_params.listener.addrs_number-1]=(ioa_addr*)malloc(sizeof(ioa_addr));
 		addr_cpy(turn_params.listener.encaddrs[turn_params.listener.addrs_number-1],&baddr);
 		TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "Listener address to use: %s\n",sbaddr);
@@ -399,7 +399,7 @@ int add_relay_addr(const char* addr) {
 		}
 
 		++turn_params.relays_number;
-		turn_params.relay_addrs = (char**)turn_realloc(turn_params.relay_addrs, 0, sizeof(char*)*turn_params.relays_number);
+		turn_params.relay_addrs = (char**)realloc(turn_params.relay_addrs, sizeof(char*)*turn_params.relays_number);
 		turn_params.relay_addrs[turn_params.relays_number-1]=turn_strdup(sbaddr);
 
 		TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "Relay address to use: %s\n",sbaddr);

src/apps/relay/ns_ioalib_engine_impl.c

@@ -3731,10 +3731,10 @@ void* allocate_super_memory_region_func(super_memory_t *r, size_t size, const ch
 
 		if(!region) {
 			r->sm_chunk += 1;
-			r->super_memory = (char**)turn_realloc(r->super_memory,0, (r->sm_chunk+1) * sizeof(char*));
+			r->super_memory = (char**)realloc(r->super_memory,(r->sm_chunk+1) * sizeof(char*));
 			r->super_memory[r->sm_chunk] = (char*)malloc(TURN_SM_SIZE);
 			ns_bzero(r->super_memory[r->sm_chunk],TURN_SM_SIZE);
-			r->sm_allocated = (size_t*)turn_realloc(r->sm_allocated,0,(r->sm_chunk+1) * sizeof(size_t*));
+			r->sm_allocated = (size_t*)realloc(r->sm_allocated,(r->sm_chunk+1) * sizeof(size_t*));
 			r->sm_allocated[r->sm_chunk] = 0;
 			region = r->super_memory[r->sm_chunk];
 			rsz = r->sm_allocated + r->sm_chunk;

src/apps/relay/turn_admin_server.c

@@ -462,11 +462,9 @@ static int print_session(ur_map_key_type key, ur_map_value_type value, void *arg
 			if(!ur_string_map_get(csarg->users, (ur_string_map_key_type)(char*)tsi->username, &value)) {
 				value = (ur_string_map_value_type)csarg->users_number;
 				csarg->users_number += 1;
-				csarg->user_counters = (size_t*)turn_realloc(csarg->user_counters,
+				csarg->user_counters = (size_t*)realloc(csarg->user_counters,
-						(size_t)value * sizeof(size_t),
 						csarg->users_number * sizeof(size_t));
-				csarg->user_names = (char**)turn_realloc(csarg->user_names,
+				csarg->user_names = (char**)realloc(csarg->user_names,
-						(size_t)value * sizeof(char*),
 						csarg->users_number * sizeof(char*));
 				csarg->user_names[(size_t)value] = turn_strdup((char*)tsi->username);
 				csarg->user_counters[(size_t)value] = 0;

src/apps/relay/userdb.c

@@ -291,7 +291,7 @@ const char* get_secrets_list_elem(secrets_list_t *sl, size_t i)
 void add_to_secrets_list(secrets_list_t *sl, const char* elem)
 {
 	if(sl && elem) {
-	  sl->secrets = (char**)turn_realloc(sl->secrets,0,(sizeof(char*)*(sl->sz+1)));
+	  sl->secrets = (char**)realloc(sl->secrets,(sizeof(char*)*(sl->sz+1)));
 	  sl->secrets[sl->sz] = turn_strdup(elem);
 	  sl->sz += 1;
 	}
@@ -1240,7 +1240,7 @@ int add_ip_list_range(const char * range0, const char * realm, ip_range_list_t *
 		*separator = '-';
 
 	++(list->ranges_number);
-	list->rs = (ip_range_t*) turn_realloc(list->rs, 0, sizeof(ip_range_t) * list->ranges_number);
+	list->rs = (ip_range_t*) realloc(list->rs, sizeof(ip_range_t) * list->ranges_number);
 	STRCPY(list->rs[list->ranges_number - 1].str,range);
 	if(realm)
 		STRCPY(list->rs[list->ranges_number - 1].realm,realm);

src/apps/uclient/startuclient.c

@@ -1536,7 +1536,7 @@ void tcp_data_connect(app_ur_session *elem, u32bits cid)
 
 	++elem->pinfo.tcp_conn_number;
 	int i = (int)(elem->pinfo.tcp_conn_number-1);
-	elem->pinfo.tcp_conn=(app_tcp_conn_info**)turn_realloc(elem->pinfo.tcp_conn,0,elem->pinfo.tcp_conn_number*sizeof(app_tcp_conn_info*));
+	elem->pinfo.tcp_conn=(app_tcp_conn_info**)realloc(elem->pinfo.tcp_conn,elem->pinfo.tcp_conn_number*sizeof(app_tcp_conn_info*));
 	elem->pinfo.tcp_conn[i]=(app_tcp_conn_info*)malloc(sizeof(app_tcp_conn_info));
 	ns_bzero(elem->pinfo.tcp_conn[i],sizeof(app_tcp_conn_info));
 

src/client/ns_turn_ioaddr.c

@@ -509,8 +509,8 @@ static size_t msz = 0;
 void ioa_addr_add_mapping(ioa_addr *apub, ioa_addr *apriv)
 {
 	size_t new_size = msz + sizeof(ioa_addr*);
-	public_addrs = (ioa_addr**)turn_realloc(public_addrs, msz, new_size);
+	public_addrs = (ioa_addr**)realloc(public_addrs, new_size);
-	private_addrs = (ioa_addr**)turn_realloc(private_addrs, msz, new_size);
+	private_addrs = (ioa_addr**)realloc(private_addrs, new_size);
 	public_addrs[mcount]=(ioa_addr*)malloc(sizeof(ioa_addr));
 	private_addrs[mcount]=(ioa_addr*)malloc(sizeof(ioa_addr));
 	addr_cpy(public_addrs[mcount],apub);

src/ns_turn_defs.h

@@ -118,7 +118,6 @@ static inline u64bits _ioa_ntoh64(u64bits v)
 #define TURN_LOG_FUNC(level, ...) printf (__VA_ARGS__)
 
   void tm_print_func(void);
-  void *turn_realloc_func(void *ptr, size_t old_sz, size_t new_sz, const char* function, int line);
   void turn_free_func(void *ptr, size_t sz, const char* function, int line);
   void *turn_calloc_func(size_t number, size_t size, const char* function, int line);
   char *turn_strdup_func(const char* s, const char* function, int line);
@@ -129,7 +128,6 @@ static inline u64bits _ioa_ntoh64(u64bits v)
 #define debug_ptr_del(ptr) debug_ptr_del_func((ptr),__FUNCTION__,__LINE__)
 #define tm_print() tm_print_func()
 #define turn_free(ptr,sz) turn_free_func((ptr),(size_t)(sz),__FUNCTION__,__LINE__)
-#define turn_realloc(ptr, old_sz, new_sz) turn_realloc_func((ptr),(size_t)(old_sz),(size_t)(new_sz),__FUNCTION__,__LINE__)
 #define turn_calloc(number, sz) turn_calloc_func((number),(size_t)(sz),__FUNCTION__,__LINE__)
 #define turn_strdup(s) turn_strdup_func((s),__FUNCTION__,__LINE__)
 
@@ -141,7 +139,6 @@ static inline u64bits _ioa_ntoh64(u64bits v)
 #define debug_ptr_del(ptr)
 #define tm_print() 
 #define turn_free(ptr,sz) free((ptr))
-#define turn_realloc(ptr, old_sz, new_sz) realloc((ptr),(size_t)(new_sz))
 #define turn_calloc(number, sz) calloc((number),(size_t)(sz))
 #define turn_strdup(s) strdup((s))
 

src/server/ns_turn_allocation.c

@@ -427,8 +427,8 @@ turn_permission_info* allocation_add_permission(allocation *a, const ioa_addr* a
 
 			if(!slot) {
 				size_t old_sz_mem = old_sz * sizeof(turn_permission_slot*);
-				parray->extra_slots = (turn_permission_slot **) turn_realloc(parray->extra_slots,
+				parray->extra_slots = (turn_permission_slot **) realloc(parray->extra_slots,
-						old_sz_mem, old_sz_mem + sizeof(turn_permission_slot*));
+						old_sz_mem + sizeof(turn_permission_slot*));
 				slots = parray->extra_slots;
 				parray->extra_sz = old_sz + 1;
 				slots[old_sz] = (turn_permission_slot *)malloc(sizeof(turn_permission_slot));
@@ -485,7 +485,7 @@ ch_info *ch_map_get(ch_map* map, u16bits chnum, int new_chn)
 
 		if(new_chn) {
 			size_t old_sz_mem = old_sz * sizeof(ch_info*);
-			a->extra_chns = (ch_info**)turn_realloc(a->extra_chns,old_sz_mem,old_sz_mem + sizeof(ch_info*));
+			a->extra_chns = (ch_info**)realloc(a->extra_chns,old_sz_mem + sizeof(ch_info*));
 			a->extra_chns[old_sz] = (ch_info*)malloc(sizeof(ch_info));
 			ns_bzero(a->extra_chns[old_sz],sizeof(ch_info));
 			a->extra_sz += 1;
@@ -596,7 +596,7 @@ tcp_connection *create_tcp_connection(u08bits server_id, allocation *a, stun_tid
 
 	if(!found) {
 		size_t old_sz_mem = a->tcs.sz * sizeof(tcp_connection*);
-		a->tcs.elems = (tcp_connection**)turn_realloc(a->tcs.elems,old_sz_mem,old_sz_mem+sizeof(tcp_connection*));
+		a->tcs.elems = (tcp_connection**)realloc(a->tcs.elems,old_sz_mem+sizeof(tcp_connection*));
 		a->tcs.elems[a->tcs.sz] = tc;
 		a->tcs.sz += 1;
 		tcl = &(a->tcs);
@@ -723,7 +723,7 @@ void add_unsent_buffer(unsent_buffer *ub, ioa_network_buffer_handle nbh)
 	if(!ub || (ub->sz >= MAX_UNSENT_BUFFER_SIZE)) {
 		ioa_network_buffer_delete(NULL, nbh);
 	} else {
-		ub->bufs = (ioa_network_buffer_handle*)turn_realloc(ub->bufs, sizeof(ioa_network_buffer_handle) * ub->sz, sizeof(ioa_network_buffer_handle) * (ub->sz+1));
+		ub->bufs = (ioa_network_buffer_handle*)realloc(ub->bufs, sizeof(ioa_network_buffer_handle) * (ub->sz+1));
 		ub->bufs[ub->sz] = nbh;
 		ub->sz +=1;
 	}

src/server/ns_turn_khash.h

@@ -171,10 +171,10 @@ static const double __ac_HASH_UPPER = 0.77;
 			  new_flags = (u32bits*)malloc(new_flags_size);	\
 			  memset(new_flags, 0xaa, new_flags_size); \
 			  if (h->n_buckets < new_n_buckets) {		\
-			    h->keys = (khkey_t*)turn_realloc(h->keys, h->keys_size, new_n_buckets * sizeof(khkey_t)); \
+			    h->keys = (khkey_t*)realloc(h->keys, new_n_buckets * sizeof(khkey_t)); \
 			    h->keys_size = new_n_buckets * sizeof(khkey_t); \
 			    if (kh_is_map)	{			\
-			      h->vals = (khval_t*)turn_realloc(h->vals, h->vals_size, new_n_buckets * sizeof(khval_t)); \
+			      h->vals = (khval_t*)realloc(h->vals, new_n_buckets * sizeof(khval_t)); \
 			      h->vals_size = new_n_buckets * sizeof(khval_t); \
 			    } \
 			  }						\
@@ -210,10 +210,10 @@ static const double __ac_HASH_UPPER = 0.77;
 				}														\
 			}															\
 			if (h->n_buckets > new_n_buckets) {							\
-			  h->keys = (khkey_t*)turn_realloc(h->keys, h->keys_size, new_n_buckets * sizeof(khkey_t)); \
+			  h->keys = (khkey_t*)realloc(h->keys, new_n_buckets * sizeof(khkey_t)); \
 			  h->keys_size = new_n_buckets * sizeof(khkey_t); \
 			  if (kh_is_map)	{			\
-			    h->vals = (khval_t*)turn_realloc(h->vals, h->vals_size, new_n_buckets * sizeof(khval_t)); \
+			    h->vals = (khval_t*)realloc(h->vals, new_n_buckets * sizeof(khval_t)); \
 			    h->vals_size = new_n_buckets * sizeof(khval_t); \
 			  } \
 			}															\

src/server/ns_turn_maps.c

@@ -308,12 +308,12 @@ int lm_map_put(lm_map* map, ur_map_key_type key, ur_map_value_type value)
 
 		size_t old_sz = esz;
 		size_t old_sz_mem = esz * sizeof(ur_map_key_type*);
-		a->extra_keys = (ur_map_key_type**)turn_realloc(a->extra_keys,old_sz_mem,old_sz_mem + sizeof(ur_map_key_type*));
+		a->extra_keys = (ur_map_key_type**)realloc(a->extra_keys,old_sz_mem + sizeof(ur_map_key_type*));
 		a->extra_keys[old_sz] = (ur_map_key_type*)malloc(sizeof(ur_map_key_type));
 		*(a->extra_keys[old_sz]) = key;
 
 		old_sz_mem = esz * sizeof(ur_map_value_type*);
-		a->extra_values = (ur_map_value_type**)turn_realloc(a->extra_values,old_sz_mem,old_sz_mem + sizeof(ur_map_value_type*));
+		a->extra_values = (ur_map_value_type**)realloc(a->extra_values,old_sz_mem + sizeof(ur_map_value_type*));
 		a->extra_values[old_sz] = (ur_map_value_type*)malloc(sizeof(ur_map_value_type));
 		*(a->extra_values[old_sz]) = value;
 
@@ -620,7 +620,7 @@ static void addr_list_add(addr_list_header* slh, const ioa_addr* key,  ur_addr_m
   if(!elem) {
 	  size_t old_sz = slh->extra_sz;
 	  size_t old_sz_mem = old_sz * sizeof(addr_elem);
-	  slh->extra_list = (addr_elem*)turn_realloc(slh->extra_list, old_sz_mem, old_sz_mem + sizeof(addr_elem));
+	  slh->extra_list = (addr_elem*)realloc(slh->extra_list, old_sz_mem + sizeof(addr_elem));
 	  elem = &(slh->extra_list[old_sz]);
 	  slh->extra_sz += 1;
   }

src/server/ns_turn_server.c

@@ -406,7 +406,7 @@ void turn_session_info_add_peer(struct turn_session_info* tsi, ioa_addr *peer)
 				}
 			}
 		}
-		tsi->extra_peers_data = (addr_data*)turn_realloc(tsi->extra_peers_data,tsi->extra_peers_size*sizeof(addr_data),(tsi->extra_peers_size+1)*sizeof(addr_data));
+		tsi->extra_peers_data = (addr_data*)realloc(tsi->extra_peers_data,(tsi->extra_peers_size+1)*sizeof(addr_data));
 		addr_cpy(&(tsi->extra_peers_data[tsi->extra_peers_size].addr),peer);
 		addr_to_string(&(tsi->extra_peers_data[tsi->extra_peers_size].addr),
 			       (u08bits*)tsi->extra_peers_data[tsi->extra_peers_size].saddr);