memory debug

src/apps/common/apputils.c

@@ -549,7 +549,7 @@ void set_execdir(void)
   /* On some systems, this may give us the execution path */
   char *_var = getenv("_");
   if(_var && *_var) {
-    _var = strdup(_var);
+    _var = turn_strdup(_var);
     char *edir=_var;
     if(edir[0]!='.') 
       edir = strstr(edir,"/");
@@ -559,7 +559,7 @@ void set_execdir(void)
       edir = dirname(_var);
     if(c_execdir)
       turn_free(c_execdir,strlen(c_execdir)+1);
-    c_execdir = strdup(edir);
+    c_execdir = turn_strdup(edir);
     turn_free(_var,strlen(_var)+1);
   }
 }
@@ -604,7 +604,7 @@ char* find_config_file(const char *config_file, int print_file_name)
 			FILE *f = fopen(config_file, "r");
 			if (f) {
 				fclose(f);
-				full_path_to_config_file = strdup(config_file);
+				full_path_to_config_file = turn_strdup(config_file);
 			}
 		} else {
 			int i = 0;

src/apps/common/hiredis_libevent2.c

@@ -250,10 +250,10 @@ redis_context_handle redisLibeventAttach(struct event_base *base, char *ip0, int
   e->allocated = 1;
   e->context = ac;
   e->base = base;
-  e->ip = strdup(ip);
+  e->ip = turn_strdup(ip);
   e->port = port;
   if(pwd)
-	  e->pwd = strdup(pwd);
+	  e->pwd = turn_strdup(pwd);
   e->db = db;
 
   /* Register functions to start/stop listening for events */

src/apps/common/ns_turn_utils.c

@@ -295,11 +295,11 @@ static void set_log_file_name_func(char *base, char *f, size_t fsz)
 	}
 
 	char logdate[125];
-	char *tail=strdup(".log");
+	char *tail=turn_strdup(".log");
 
 	get_date(logdate,sizeof(logdate));
 
-	char *base1=strdup(base);
+	char *base1=turn_strdup(base);
 
 	int len=(int)strlen(base1);
 
@@ -319,11 +319,11 @@ static void set_log_file_name_func(char *base, char *f, size_t fsz)
 			break;
 		else if(base1[len]=='.') {
 			turn_free(tail,strlen(tail)+1);
-			tail=strdup(base1+len);
+			tail=turn_strdup(base1+len);
 			base1[len]=0;
 			if(strlen(tail)<2) {
 				turn_free(tail,strlen(tail)+1);
-				tail = strdup(".log");
+				tail = turn_strdup(".log");
 			}
 			break;
 		}
@@ -656,3 +656,158 @@ int get_canonic_origin(const char* o, char *co, int sz)
 }
 
 //////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+
+#include <map>
+#include <set>
+#include <string>
+
+using namespace std;
+
+static volatile int tmm_init = 0;
+static pthread_mutex_t tm;
+
+typedef void* ptrtype;
+typedef set<ptrtype> ptrs_t;
+typedef map<string,ptrs_t> str_to_ptrs_t;
+typedef map<ptrtype,string> ptr_to_str_t;
+
+static str_to_ptrs_t str_to_ptrs;
+static ptr_to_str_t ptr_to_str;
+
+static void tm_init(void) {
+  if(!tmm_init) {
+    pthread_mutex_init(&tm,NULL);
+    tmm_init = 1;
+  }
+}
+
+static void add_tm_ptr(void *ptr, const char *id) {
+
+  UNUSED_ARG(ptr);
+  UNUSED_ARG(id);
+
+  if(!ptr)
+    return;
+
+  pthread_mutex_lock(&tm);
+
+  string sid(id);
+  if(str_to_ptrs.find(sid) == str_to_ptrs.end()) {
+    set<ptrtype> sp;
+    str_to_ptrs[sid]=sp;
+  }
+
+  str_to_ptrs[sid].insert(ptr);
+  ptr_to_str[ptr]=sid;
+
+  pthread_mutex_unlock(&tm);
+}
+
+static void del_tm_ptr(void *ptr, const char *id) {
+
+  UNUSED_ARG(ptr);
+  UNUSED_ARG(id);
+
+  if(!ptr)
+    return;
+
+  pthread_mutex_lock(&tm);
+
+  ptr_to_str_t::iterator pts_iter = ptr_to_str.find(ptr);
+  if(pts_iter != ptr_to_str.end()) {
+    string sid = pts_iter->second;
+    ptr_to_str.erase(pts_iter);
+    if(str_to_ptrs.find(sid) != str_to_ptrs.end()) {
+      str_to_ptrs[sid].erase(ptr);
+    }
+  }
+
+  pthread_mutex_unlock(&tm);
+}
+
+static void tm_id(char *id, const char* file, int line) {
+  sprintf(id,"%s:%d",file,line);
+}
+
+#define TM_START() char id[128];tm_id(id,file,line);tm_init()
+
+void tm_print_func(void);
+void tm_print_func(void) {
+  pthread_mutex_lock(&tm);
+  printf("=============================================\n");
+  for(str_to_ptrs_t::const_iterator iter=str_to_ptrs.begin();iter != str_to_ptrs.end();++iter) {
+    printf("%s: %s: %d\n",__FUNCTION__,iter->first.c_str(),(int)(iter->second.size()));
+  }
+  printf("=============================================\n");
+  pthread_mutex_unlock(&tm);
+} 
+
+void *turn_malloc_func(size_t sz, const char* file, int line);
+void *turn_malloc_func(size_t sz, const char* file, int line) {
+
+  TM_START();
+
+  void *ptr = malloc(sz);
+  
+  add_tm_ptr(ptr,id);
+
+  return ptr;
+}
+
+void *turn_realloc_func(void *ptr, size_t old_sz, size_t new_sz, const char* file, int line);
+void *turn_realloc_func(void *ptr, size_t old_sz, size_t new_sz, const char* file, int line) {
+
+  UNUSED_ARG(old_sz);
+
+  TM_START();
+
+  del_tm_ptr(ptr,id);
+
+  ptr = realloc(ptr,new_sz);
+
+  add_tm_ptr(ptr,id);
+
+  return ptr;
+}
+
+void turn_free_func(void *ptr, size_t sz, const char* file, int line);
+void turn_free_func(void *ptr, size_t sz, const char* file, int line) {
+
+  UNUSED_ARG(sz);
+
+  TM_START();
+
+  del_tm_ptr(ptr,id);
+
+  free(ptr);
+}
+
+void *turn_calloc_func(size_t number, size_t size, const char* file, int line);
+void *turn_calloc_func(size_t number, size_t size, const char* file, int line) {
+  
+  TM_START();
+
+  void *ptr = calloc(number,size);
+
+  add_tm_ptr(ptr,id);
+
+  return ptr;
+}
+
+char *turn_strdup_func(const char* s, const char* file, int line);
+char *turn_strdup_func(const char* s, const char* file, int line) {
+
+  TM_START();
+
+  char *ptr = strdup(s);
+
+  add_tm_ptr(ptr,id);
+
+  return ptr;
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////

src/apps/relay/dbdrivers/dbd_redis.c

@@ -59,7 +59,7 @@ typedef struct _Ryconninfo Ryconninfo;
 static void RyconninfoFree(Ryconninfo *co) {
 	if(co) {
 		if(co->host) turn_free(co->host, strlen(co->host)+1);
-		if(co->dbname) turn_free(co->dbname, strlen(co->username)+1);
+		if(co->dbname) turn_free(co->dbname, strlen(co->dbname)+1);
 		if(co->password) turn_free(co->password, strlen(co->password)+1);
 		ns_bzero(co,sizeof(Ryconninfo));
 	}

src/apps/relay/mainrelay.c

@@ -1034,7 +1034,7 @@ static void set_option(int c, char *value)
 		if(value) {
 			char *div = strchr(value,'/');
 			if(div) {
-				char *nval=strdup(value);
+				char *nval=turn_strdup(value);
 				div = strchr(nval,'/');
 				div[0]=0;
 				++div;

src/apps/relay/netengine.c

@@ -168,7 +168,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*)realloc(list->addrs,sizeof(ioa_addr)*(list->size+1));
+		  list->addrs = (ioa_addr*)turn_realloc(list->addrs,0,sizeof(ioa_addr)*(list->size+1));
 			addr_cpy(&(list->addrs[(list->size)++]),&addr);
 			{
 				u08bits s[1025];
@@ -196,7 +196,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*)realloc(list->addrs,sizeof(ioa_addr)*(list->size+1));
+		  list->addrs = (ioa_addr*)turn_realloc(list->addrs,0,sizeof(ioa_addr)*(list->size+1));
 			addr_cpy(&(list->addrs[(list->size)++]),&addr);
 			{
 				u08bits s[1025];
@@ -233,7 +233,7 @@ static void del_alt_server(const char *saddr, int default_port, turn_server_addr
 			if(found) {
 
 				size_t j;
-				ioa_addr *new_addrs = (ioa_addr*)malloc(sizeof(ioa_addr)*(list->size-1));
+				ioa_addr *new_addrs = (ioa_addr*)turn_malloc(sizeof(ioa_addr)*(list->size-1));
 				for(j=0;j<i;++j) {
 					addr_cpy(&(new_addrs[j]),&(list->addrs[j]));
 				}
@@ -241,7 +241,7 @@ static void del_alt_server(const char *saddr, int default_port, turn_server_addr
 					addr_cpy(&(new_addrs[j]),&(list->addrs[j+1]));
 				}
 
-				free(list->addrs);
+				turn_free(list->addrs,0);
 				list->addrs = new_addrs;
 				list->size -= 1;
 
@@ -298,9 +298,9 @@ void add_listener_addr(const char* addr) {
 		}
 		++turn_params.listener.addrs_number;
 		++turn_params.listener.services_number;
-		turn_params.listener.addrs = (char**)realloc(turn_params.listener.addrs, sizeof(char*)*turn_params.listener.addrs_number);
+		turn_params.listener.addrs = (char**)turn_realloc(turn_params.listener.addrs, 0, sizeof(char*)*turn_params.listener.addrs_number);
-		turn_params.listener.addrs[turn_params.listener.addrs_number-1]=strdup(sbaddr);
+		turn_params.listener.addrs[turn_params.listener.addrs_number-1]=turn_strdup(sbaddr);
-		turn_params.listener.encaddrs = (ioa_addr**)realloc(turn_params.listener.encaddrs, sizeof(ioa_addr*)*turn_params.listener.addrs_number);
+		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[turn_params.listener.addrs_number-1]=(ioa_addr*)turn_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);
@@ -325,8 +325,8 @@ int add_relay_addr(const char* addr) {
 		}
 
 		++turn_params.relays_number;
-		turn_params.relay_addrs = (char**)realloc(turn_params.relay_addrs, sizeof(char*)*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[turn_params.relays_number-1]=strdup(sbaddr);
+		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);
 		return 1;
@@ -1539,6 +1539,9 @@ void run_listener_server(struct listener_server *ls)
 		run_events(ls->event_base, ls->ioa_eng);
 
 		rollover_logfile();
+
+		tm_print();
+
 	}
 }
 

src/apps/relay/userdb.c

@@ -174,7 +174,7 @@ int get_realm_options_by_origin(char *origin, realm_options_t* ro)
 		realm_params_t rp;
 		get_realm_data(realm, &rp);
 		ns_bcopy(&(rp.options),ro,sizeof(realm_options_t));
-		free(realm);
+		turn_free(realm,strlen(realm)+1);
 		return 1;
 	} else {
 		TURN_MUTEX_UNLOCK(&o_to_realm_mutex);
@@ -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**)realloc(sl->secrets,(sizeof(char*)*(sl->sz+1)));
+	  sl->secrets = (char**)turn_realloc(sl->secrets,0,(sizeof(char*)*(sl->sz+1)));
 	  sl->secrets[sl->sz] = strdup(elem);
 	  sl->sz += 1;
 	}
@@ -707,7 +707,7 @@ int check_new_allocation_quota(u08bits *user, int oauth, u08bits *realm)
 		} else {
 			++(rp->status.total_current_allocs);
 		}
-		turn_free(username,strlen(username)+1);
+		turn_free(username,strlen((char*)username)+1);
 		ur_string_map_unlock(rp->status.alloc_counters);
 	}
 	return ret;
@@ -730,7 +730,7 @@ void release_allocation_quota(u08bits *user, int oauth, u08bits *realm)
 		if (rp->status.total_current_allocs)
 			--(rp->status.total_current_allocs);
 		ur_string_map_unlock(rp->status.alloc_counters);
-		turn_free(username, strlen(username)+1);
+		turn_free(username, strlen((char*)username)+1);
 	}
 }
 
@@ -839,8 +839,8 @@ int add_user_account(char *user, int dynamic)
 					TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong key format: %s\n",s);
 				} if(convert_string_key_to_binary(keysource, *key, sz)<0) {
 					TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong key: %s\n",s);
-					free(usname);
+					turn_free(usname,strlen(usname)+1);
-					free(key);
+					turn_free(key,sizeof(hmackey_t));
 					return -1;
 				}
 			} else {
@@ -857,7 +857,7 @@ int add_user_account(char *user, int dynamic)
 				ur_string_map_unlock(turn_params.default_users_db.ram_db.static_accounts);
 			}
 			turn_params.default_users_db.ram_db.users_number++;
-			free(usname);
+			turn_free(usname,strlen(usname)+1);
 			return 0;
 		}
 	}
@@ -1153,7 +1153,7 @@ int adminuser(u08bits *user, u08bits *realm, u08bits *pwd, u08bits *secret, u08b
 				}
 
 				add_and_cont:
-				content = (char**)realloc(content, sizeof(char*) * (++csz));
+				content = (char**)turn_realloc(content, 0, sizeof(char*) * (++csz));
 				content[csz - 1] = strdup(s0);
 			}
 
@@ -1168,7 +1168,7 @@ int adminuser(u08bits *user, u08bits *realm, u08bits *pwd, u08bits *secret, u08b
 		  for(i=0;i<sz;i++) {
 		    snprintf(us+strlen(us),sizeof(us)-strlen(us),"%02x",(unsigned int)key[i]);
 		  }
-		  content = (char**)realloc(content,sizeof(char*)*(++csz));
+		  content = (char**)turn_realloc(content,0,sizeof(char*)*(++csz));
 		  content[csz-1]=strdup(us);
 		}
 
@@ -1199,7 +1199,7 @@ int adminuser(u08bits *user, u08bits *realm, u08bits *pwd, u08bits *secret, u08b
 		fclose(f);
 
 		rename(dir,full_path_to_userdb_file);
-		free(dir);
+		turn_free(dir,dirsz+1);
 	}
 
 	return 0;
@@ -1396,15 +1396,15 @@ static void ip_list_free(ip_range_list_t *l)
 		size_t i;
 		for(i=0;i<l->ranges_number;++i) {
 			if(l->ranges && l->ranges[i])
-				free(l->ranges[i]);
+			  turn_free(l->ranges[i],0);
 			if(l->encaddrsranges && l->encaddrsranges[i])
-				free(l->encaddrsranges[i]);
+			  turn_free(l->encaddrsranges[i],0);
 		}
 		if(l->ranges)
-			free(l->ranges);
+		  turn_free(l->ranges,0);
 		if(l->encaddrsranges)
-			free(l->encaddrsranges);
+		  turn_free(l->encaddrsranges,0);
-		free(l);
+		turn_free(l,sizeof(ip_range_list_t));
 	}
 }
 
@@ -1446,14 +1446,14 @@ int add_ip_list_range(const char * range0, ip_range_list_t * list)
 
 	if (make_ioa_addr((const u08bits*) range, 0, &min) < 0) {
 		TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong address format: %s\n", range);
-		free(range);
+		turn_free(range,0);
 		return -1;
 	}
 
 	if (separator) {
 		if (make_ioa_addr((const u08bits*) separator + 1, 0, &max) < 0) {
 			TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong address format: %s\n", separator + 1);
-			free(range);
+			turn_free(range,0);
 			return -1;
 		}
 	} else {
@@ -1465,9 +1465,9 @@ int add_ip_list_range(const char * range0, ip_range_list_t * list)
 		*separator = '-';
 
 	++(list->ranges_number);
-	list->ranges = (char**) realloc(list->ranges, sizeof(char*) * list->ranges_number);
+	list->ranges = (char**) turn_realloc(list->ranges, 0, sizeof(char*) * list->ranges_number);
 	list->ranges[list->ranges_number - 1] = range;
-	list->encaddrsranges = (ioa_addr_range**) realloc(list->encaddrsranges, sizeof(ioa_addr_range*) * list->ranges_number);
+	list->encaddrsranges = (ioa_addr_range**) turn_realloc(list->encaddrsranges, 0, sizeof(ioa_addr_range*) * list->ranges_number);
 
 	list->encaddrsranges[list->ranges_number - 1] = (ioa_addr_range*) turn_malloc(sizeof(ioa_addr_range));
 

src/ns_turn_defs.h

@@ -111,10 +111,32 @@ static inline u64bits _ioa_ntoh64(u64bits v)
 #define ioa_ntoh64 _ioa_ntoh64
 #define ioa_hton64 _ioa_ntoh64
 
-#define turn_malloc(sz) malloc(sz)
+#if defined(TURN_MEMORY_DEBUG)
-#define turn_free(ptr,sz) free(ptr)
+
-#define turn_realloc(ptr, old_sz, new_sz) realloc((ptr),(new_sz))
+  void tm_print_func(void);
-#define turn_calloc(number, sz) calloc((number),(sz))
+  void *turn_malloc_func(size_t sz, const char* file, int line);
+  void *turn_realloc_func(void *ptr, size_t old_sz, size_t new_sz, const char* file, int line);
+  void turn_free_func(void *ptr, size_t sz, const char* file, int line);
+  void *turn_calloc_func(size_t number, size_t size, const char* file, int line);
+  char *turn_strdup_func(const char* s, const char* file, int line);
+
+#define tm_print() tm_print_func()
+#define turn_malloc(sz) turn_malloc_func((size_t)(sz),__FUNCTION__,__LINE__)
+#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__)
+
+#else
+
+#define tm_print() 
+#define turn_malloc(sz) malloc((size_t)(sz))
+#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))
+
+#endif
 
 #define turn_time() ((turn_time_t)time(NULL))