svn commit: r184289 - in stable/7/usr.sbin/nscd: . agents

Xin LI delphij at FreeBSD.org
Sun Oct 26 09:35:10 UTC 2008


Author: delphij
Date: Sun Oct 26 09:35:08 2008
New Revision: 184289
URL: http://svn.freebsd.org/changeset/base/184289

Log:
  MFC:  Sync code with -CURRENT state.
      Merged r183755,183770,184186-184189
  
  Approved by:	re (kib)

Modified:
  stable/7/usr.sbin/nscd/   (props changed)
  stable/7/usr.sbin/nscd/agent.c
  stable/7/usr.sbin/nscd/agents/group.c
  stable/7/usr.sbin/nscd/agents/passwd.c
  stable/7/usr.sbin/nscd/agents/services.c
  stable/7/usr.sbin/nscd/cachelib.c
  stable/7/usr.sbin/nscd/cacheplcs.c
  stable/7/usr.sbin/nscd/config.c
  stable/7/usr.sbin/nscd/hashtable.h
  stable/7/usr.sbin/nscd/mp_rs_query.c
  stable/7/usr.sbin/nscd/mp_ws_query.c
  stable/7/usr.sbin/nscd/nscd.c
  stable/7/usr.sbin/nscd/nscdcli.c
  stable/7/usr.sbin/nscd/query.c

Modified: stable/7/usr.sbin/nscd/agent.c
==============================================================================
--- stable/7/usr.sbin/nscd/agent.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/agent.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -60,9 +60,8 @@ init_agent_table()
    	struct agent_table	*retval;
 
 	TRACE_IN(init_agent_table);
-	retval = (struct agent_table *)malloc(sizeof(struct agent_table));
+	retval = (struct agent_table *)calloc(1, sizeof(struct agent_table));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct agent_table));
 
 	TRACE_OUT(init_agent_table);
 	return (retval);

Modified: stable/7/usr.sbin/nscd/agents/group.c
==============================================================================
--- stable/7/usr.sbin/nscd/agents/group.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/agents/group.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -140,9 +140,8 @@ group_lookup_func(const char *key, size_
 	switch (lookup_type) {
 	case nss_lt_name:
 		size = key_size - sizeof(enum nss_lookup_type)	+ 1;
-		name = (char *)malloc(size);
+		name = (char *)calloc(1, size);
 		assert(name != NULL);
-		memset(name, 0, size);
 		memcpy(name, key + sizeof(enum nss_lookup_type), size - 1);
 		break;
 	case nss_lt_id:
@@ -225,9 +224,8 @@ init_group_agent()
 	struct common_agent	*retval;
 
 	TRACE_IN(init_group_agent);
-	retval = (struct common_agent *)malloc(sizeof(struct common_agent));
+	retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct common_agent));
 
 	retval->parent.name = strdup("group");
 	assert(retval->parent.name != NULL);
@@ -245,10 +243,9 @@ init_group_mp_agent()
 	struct multipart_agent	*retval;
 
 	TRACE_IN(init_group_mp_agent);
-	retval = (struct multipart_agent *)malloc(
+	retval = (struct multipart_agent *)calloc(1,
 		sizeof(struct multipart_agent));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct multipart_agent));
 
 	retval->parent.name = strdup("group");
 	retval->parent.type = MULTIPART_AGENT;

Modified: stable/7/usr.sbin/nscd/agents/passwd.c
==============================================================================
--- stable/7/usr.sbin/nscd/agents/passwd.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/agents/passwd.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -148,9 +148,8 @@ passwd_lookup_func(const char *key, size
 	switch (lookup_type) {
 	case nss_lt_name:
 		size = key_size - sizeof(enum nss_lookup_type)	+ 1;
-		login = (char *)malloc(size);
+		login = (char *)calloc(1, size);
 		assert(login != NULL);
-		memset(login, 0, size);
 		memcpy(login, key + sizeof(enum nss_lookup_type), size - 1);
 		break;
 	case nss_lt_id:
@@ -232,9 +231,8 @@ init_passwd_agent()
 	struct common_agent	*retval;
 
 	TRACE_IN(init_passwd_agent);
-	retval = (struct common_agent *)malloc(sizeof(struct common_agent));
+	retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct common_agent));
 
 	retval->parent.name = strdup("passwd");
 	assert(retval->parent.name != NULL);
@@ -252,10 +250,9 @@ init_passwd_mp_agent()
 	struct multipart_agent	*retval;
 
 	TRACE_IN(init_passwd_mp_agent);
-	retval = (struct multipart_agent *)malloc(
+	retval = (struct multipart_agent *)calloc(1,
 		sizeof(struct multipart_agent));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct multipart_agent));
 
 	retval->parent.name = strdup("passwd");
 	retval->parent.type = MULTIPART_AGENT;

Modified: stable/7/usr.sbin/nscd/agents/services.c
==============================================================================
--- stable/7/usr.sbin/nscd/agents/services.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/agents/services.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -145,9 +145,8 @@ services_lookup_func(const char *key, si
 	switch (lookup_type) {
 	case nss_lt_name:
 		size = key_size - sizeof(enum nss_lookup_type);
-		name = (char *)malloc(size + 1);
+		name = (char *)calloc(1, size + 1);
 		assert(name != NULL);
-		memset(name, 0, size + 1);
 		memcpy(name, key + sizeof(enum nss_lookup_type), size);
 
 		size2 = strlen(name) + 1;
@@ -169,9 +168,8 @@ services_lookup_func(const char *key, si
 
 		size = key_size - sizeof(enum nss_lookup_type) - sizeof(int);
 		if (size > 0) {
-			proto = (char *)malloc(size + 1);
+			proto = (char *)calloc(1, size + 1);
 			assert(proto != NULL);
-			memset(proto, size + 1, 0);
 			memcpy(proto, key + sizeof(enum nss_lookup_type) +
 				sizeof(int), size);
 		}
@@ -247,9 +245,8 @@ init_services_agent()
 	struct common_agent	*retval;
 	TRACE_IN(init_services_agent);
 
-	retval = (struct common_agent *)malloc(sizeof(struct common_agent));
+	retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct common_agent));
 
 	retval->parent.name = strdup("services");
 	assert(retval->parent.name != NULL);
@@ -267,10 +264,9 @@ init_services_mp_agent()
 	struct multipart_agent	*retval;
 
 	TRACE_IN(init_services_mp_agent);
-	retval = (struct multipart_agent *)malloc(
+	retval = (struct multipart_agent *)calloc(1,
 		sizeof(struct multipart_agent));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct multipart_agent));
 
 	retval->parent.name = strdup("services");
 	retval->parent.type = MULTIPART_AGENT;

Modified: stable/7/usr.sbin/nscd/cachelib.c
==============================================================================
--- stable/7/usr.sbin/nscd/cachelib.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/cachelib.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -479,18 +479,15 @@ init_cache(struct cache_params const *pa
 	TRACE_IN(init_cache);
 	assert(params != NULL);
 
-	retval = (struct cache_ *)malloc(sizeof(struct cache_));
+	retval = (struct cache_ *)calloc(1, sizeof(struct cache_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_));
 
 	assert(params != NULL);
 	memcpy(&retval->params, params, sizeof(struct cache_params));
 
-	retval->entries = (struct cache_entry_ **)malloc(
+	retval->entries = (struct cache_entry_ **)calloc(1,
 		sizeof(struct cache_entry_ *) * INITIAL_ENTRIES_CAPACITY);
 	assert(retval->entries != NULL);
-	memset(retval->entries, 0, sizeof(sizeof(struct cache_entry_ *)
-		* INITIAL_ENTRIES_CAPACITY));
 
 	retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
 	retval->entries_size = 0;
@@ -541,12 +538,10 @@ register_cache_entry(struct cache_ *the_
 
 		new_capacity = the_cache->entries_capacity +
 			ENTRIES_CAPACITY_STEP;
-		new_entries = (struct cache_entry_ **)malloc(
+		new_entries = (struct cache_entry_ **)calloc(1,
 			sizeof(struct cache_entry_ *) * new_capacity);
 		assert(new_entries != NULL);
 
-		memset(new_entries, 0, sizeof(struct cache_entry_ *) *
-		    new_capacity);
 		memcpy(new_entries, the_cache->entries,
 			sizeof(struct cache_entry_ *)
 			* the_cache->entries_size);
@@ -555,26 +550,23 @@ register_cache_entry(struct cache_ *the_
 		the_cache->entries = new_entries;
 	}
 
-	entry_name_size = strlen(params->entry_name);
+	entry_name_size = strlen(params->entry_name) + 1;
 	switch (params->entry_type)
 	{
 	case CET_COMMON:
-		new_common_entry = (struct cache_common_entry_ *)malloc(
+		new_common_entry = (struct cache_common_entry_ *)calloc(1,
 			sizeof(struct cache_common_entry_));
 		assert(new_common_entry != NULL);
-		memset(new_common_entry, 0, sizeof(struct cache_common_entry_));
 
 		memcpy(&new_common_entry->common_params, params,
 			sizeof(struct common_cache_entry_params));
 		new_common_entry->params =
 		  (struct cache_entry_params *)&new_common_entry->common_params;
 
-		new_common_entry->common_params.entry_name = (char *)malloc(
-			entry_name_size+1);
+		new_common_entry->common_params.entry_name = (char *)calloc(1,
+			entry_name_size);
 		assert(new_common_entry->common_params.entry_name != NULL);
-		memset(new_common_entry->common_params.entry_name, 0,
-			entry_name_size + 1);
-		strncpy(new_common_entry->common_params.entry_name,
+		strlcpy(new_common_entry->common_params.entry_name,
 			params->entry_name, entry_name_size);
 		new_common_entry->name =
 			new_common_entry->common_params.entry_name;
@@ -588,11 +580,9 @@ register_cache_entry(struct cache_ *the_
 		else
 			policies_size = 2;
 
-		new_common_entry->policies = (struct cache_policy_ **)malloc(
+		new_common_entry->policies = (struct cache_policy_ **)calloc(1,
 			sizeof(struct cache_policy_ *) * policies_size);
 		assert(new_common_entry->policies != NULL);
-		memset(new_common_entry->policies, 0,
-			sizeof(struct cache_policy_ *) * policies_size);
 
 		new_common_entry->policies_size = policies_size;
 		new_common_entry->policies[0] = init_cache_fifo_policy();
@@ -618,22 +608,19 @@ register_cache_entry(struct cache_ *the_
 			(struct cache_entry_ *)new_common_entry;
 		break;
 	case CET_MULTIPART:
-		new_mp_entry = (struct cache_mp_entry_ *)malloc(
+		new_mp_entry = (struct cache_mp_entry_ *)calloc(1,
 			sizeof(struct cache_mp_entry_));
 		assert(new_mp_entry != NULL);
-		memset(new_mp_entry, 0, sizeof(struct cache_mp_entry_));
 
 		memcpy(&new_mp_entry->mp_params, params,
 			sizeof(struct mp_cache_entry_params));
 		new_mp_entry->params =
 			(struct cache_entry_params *)&new_mp_entry->mp_params;
 
-		new_mp_entry->mp_params.entry_name = (char *)malloc(
-			entry_name_size+1);
+		new_mp_entry->mp_params.entry_name = (char *)calloc(1,
+			entry_name_size);
 		assert(new_mp_entry->mp_params.entry_name != NULL);
-		memset(new_mp_entry->mp_params.entry_name, 0,
-			entry_name_size + 1);
-		strncpy(new_mp_entry->mp_params.entry_name, params->entry_name,
+		strlcpy(new_mp_entry->mp_params.entry_name, params->entry_name,
 			entry_name_size);
 		new_mp_entry->name = new_mp_entry->mp_params.entry_name;
 
@@ -925,10 +912,9 @@ open_cache_mp_write_session(struct cache
 		return (NULL);
 	}
 
-	retval = (struct cache_mp_write_session_ *)malloc(
+	retval = (struct cache_mp_write_session_ *)calloc(1,
 		sizeof(struct cache_mp_write_session_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_mp_write_session_));
 
 	TAILQ_INIT(&retval->items);
 	retval->parent_entry = mp_entry;
@@ -961,10 +947,9 @@ cache_mp_write(struct cache_mp_write_ses
 		return (-1);
 	}
 
-	new_item = (struct cache_mp_data_item_ *)malloc(
+	new_item = (struct cache_mp_data_item_ *)calloc(1,
 		sizeof(struct cache_mp_data_item_));
 	assert(new_item != NULL);
-	memset(new_item, 0, sizeof(struct cache_mp_data_item_));
 
 	new_item->value = (char *)malloc(data_size);
 	assert(new_item->value != NULL);
@@ -1065,10 +1050,9 @@ open_cache_mp_read_session(struct cache_
 		}
 	}
 
-	retval = (struct cache_mp_read_session_ *)malloc(
+	retval = (struct cache_mp_read_session_ *)calloc(1,
 		sizeof(struct cache_mp_read_session_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_mp_read_session_));
 
 	retval->parent_entry = mp_entry;
 	retval->current_item = TAILQ_FIRST(

Modified: stable/7/usr.sbin/nscd/cacheplcs.c
==============================================================================
--- stable/7/usr.sbin/nscd/cacheplcs.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/cacheplcs.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -82,10 +82,9 @@ cache_queue_policy_create_item()
 	struct cache_queue_policy_item_ *retval;
 
 	TRACE_IN(cache_queue_policy_create_item);
-	retval = (struct cache_queue_policy_item_ *)malloc(
+	retval = (struct cache_queue_policy_item_ *)calloc(1,
 		sizeof(struct cache_queue_policy_item_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_queue_policy_item_));
 
 	TRACE_OUT(cache_queue_policy_create_item);
 	return ((struct cache_policy_item_ *)retval);
@@ -193,10 +192,9 @@ init_cache_queue_policy(void)
 	struct cache_queue_policy_	*retval;
 
 	TRACE_IN(init_cache_queue_policy);
-	retval = (struct cache_queue_policy_ *)malloc(
+	retval = (struct cache_queue_policy_ *)calloc(1,
 		sizeof(struct cache_queue_policy_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_queue_policy_));
 
 	retval->parent_data.create_item_func = cache_queue_policy_create_item;
 	retval->parent_data.destroy_item_func = cache_queue_policy_destroy_item;
@@ -334,10 +332,9 @@ cache_lfu_policy_create_item(void)
 	struct cache_lfu_policy_item_ *retval;
 
 	TRACE_IN(cache_lfu_policy_create_item);
-	retval = (struct cache_lfu_policy_item_ *)malloc(
+	retval = (struct cache_lfu_policy_item_ *)calloc(1,
 		sizeof(struct cache_lfu_policy_item_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_lfu_policy_item_));
 
 	TRACE_OUT(cache_lfu_policy_create_item);
 	return ((struct cache_policy_item_ *)retval);
@@ -539,10 +536,9 @@ init_cache_lfu_policy()
 	struct cache_lfu_policy_ *retval;
 
 	TRACE_IN(init_cache_lfu_policy);
-	retval = (struct cache_lfu_policy_ *)malloc(
+	retval = (struct cache_lfu_policy_ *)calloc(1,
 		sizeof(struct cache_lfu_policy_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_lfu_policy_));
 
 	retval->parent_data.create_item_func = cache_lfu_policy_create_item;
 	retval->parent_data.destroy_item_func = cache_lfu_policy_destroy_item;

Modified: stable/7/usr.sbin/nscd/config.c
==============================================================================
--- stable/7/usr.sbin/nscd/config.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/config.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -119,10 +119,9 @@ create_configuration_entry(const char *n
 	assert(negative_params != NULL);
 	assert(mp_params != NULL);
 
-	retval = (struct configuration_entry *)malloc(
+	retval = (struct configuration_entry *)calloc(1,
 		sizeof(struct configuration_entry));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct configuration_entry));
 
 	res = pthread_mutex_init(&retval->positive_cache_lock, NULL);
 	if (res != 0) {
@@ -162,9 +161,8 @@ create_configuration_entry(const char *n
 		sizeof(struct mp_cache_entry_params));
 
 	size = strlen(name);
-	retval->name = (char *)malloc(size + 1);
+	retval->name = (char *)calloc(1, size + 1);
 	assert(retval->name != NULL);
-	memset(retval->name, 0, size + 1);
 	memcpy(retval->name, name, size);
 
 	memcpy(&retval->common_query_timeout, common_timeout,
@@ -268,12 +266,10 @@ add_configuration_entry(struct configura
 		struct configuration_entry **new_entries;
 
 		config->entries_capacity *= 2;
-		new_entries = (struct configuration_entry **)malloc(
+		new_entries = (struct configuration_entry **)calloc(1,
 			sizeof(struct configuration_entry *) *
 			config->entries_capacity);
 		assert(new_entries != NULL);
-		memset(new_entries, 0, sizeof(struct configuration_entry *) *
-			config->entries_capacity);
 		memcpy(new_entries, config->entries,
 			sizeof(struct configuration_entry *) *
 		        config->entries_size);
@@ -514,17 +510,14 @@ init_configuration(void)
 	struct configuration	*retval;
 
 	TRACE_IN(init_configuration);
-	retval = (struct configuration *)malloc(sizeof(struct configuration));
+	retval = (struct configuration *)calloc(1, sizeof(struct configuration));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct configuration));
 
 	retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
-	retval->entries = (struct configuration_entry **)malloc(
+	retval->entries = (struct configuration_entry **)calloc(1,
 		sizeof(struct configuration_entry *) *
 		retval->entries_capacity);
 	assert(retval->entries != NULL);
-	memset(retval->entries, 0, sizeof(struct configuration_entry *) *
-		retval->entries_capacity);
 
 	pthread_rwlock_init(&retval->rwlock, NULL);
 
@@ -544,15 +537,13 @@ fill_configuration_defaults(struct confi
 		free(config->socket_path);
 
 	len = strlen(DEFAULT_SOCKET_PATH);
-	config->socket_path = (char *)malloc(len + 1);
+	config->socket_path = (char *)calloc(1, len + 1);
 	assert(config->socket_path != NULL);
-	memset(config->socket_path, 0, len + 1);
 	memcpy(config->socket_path, DEFAULT_SOCKET_PATH, len);
 
 	len = strlen(DEFAULT_PIDFILE_PATH);
-	config->pidfile_path = (char *)malloc(len + 1);
+	config->pidfile_path = (char *)calloc(1, len + 1);
 	assert(config->pidfile_path != NULL);
-	memset(config->pidfile_path, 0, len + 1);
 	memcpy(config->pidfile_path, DEFAULT_PIDFILE_PATH, len);
 
 	config->socket_mode =  S_IFSOCK | S_IRUSR | S_IWUSR |

Modified: stable/7/usr.sbin/nscd/hashtable.h
==============================================================================
--- stable/7/usr.sbin/nscd/hashtable.h	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/hashtable.h	Sun Oct 26 09:35:08 2008	(r184289)
@@ -75,9 +75,7 @@ typedef int hashtable_index_t;
 #define HASHTABLE_INIT(table, type, field, _entries_size)		\
 	do {								\
 		hashtable_index_t var;					\
-		(table)->entries = (void *)malloc(			\
-			sizeof(*(table)->entries) * (_entries_size));	\
-		memset((table)->entries, 0, 				\
+		(table)->entries = (void *)calloc(1,			\
 			sizeof(*(table)->entries) * (_entries_size));	\
 		(table)->entries_size = (_entries_size);		\
 		for (var = 0; var < HASHTABLE_ENTRIES_COUNT(table); ++var) {\

Modified: stable/7/usr.sbin/nscd/mp_rs_query.c
==============================================================================
--- stable/7/usr.sbin/nscd/mp_rs_query.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/mp_rs_query.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -115,11 +115,9 @@ on_mp_read_session_request_read1(struct 
 			return (-1);
 		}
 
-		c_mp_rs_request->entry = (char *)malloc(
+		c_mp_rs_request->entry = (char *)calloc(1,
 			c_mp_rs_request->entry_length + 1);
 		assert(c_mp_rs_request->entry != NULL);
-		memset(c_mp_rs_request->entry, 0,
-			c_mp_rs_request->entry_length + 1);
 
 		qstate->kevent_watermark = c_mp_rs_request->entry_length;
 		qstate->process_func = on_mp_read_session_request_read2;

Modified: stable/7/usr.sbin/nscd/mp_ws_query.c
==============================================================================
--- stable/7/usr.sbin/nscd/mp_ws_query.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/mp_ws_query.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -121,11 +121,9 @@ on_mp_write_session_request_read1(struct
 			return (-1);
 		}
 
-		c_mp_ws_request->entry = (char *)malloc(
+		c_mp_ws_request->entry = (char *)calloc(1,
 			c_mp_ws_request->entry_length + 1);
 		assert(c_mp_ws_request->entry != NULL);
-		memset(c_mp_ws_request->entry, 0,
-			c_mp_ws_request->entry_length + 1);
 
 		qstate->kevent_watermark = c_mp_ws_request->entry_length;
 		qstate->process_func = on_mp_write_session_request_read2;
@@ -376,9 +374,8 @@ on_mp_write_session_write_request_read1(
 		return (-1);
 	}
 
-	write_request->data = (char *)malloc(write_request->data_size);
+	write_request->data = (char *)calloc(1, write_request->data_size);
 	assert(write_request->data != NULL);
-	memset(write_request->data, 0, write_request->data_size);
 
 	qstate->kevent_watermark = write_request->data_size;
 	qstate->process_func = on_mp_write_session_write_request_read2;

Modified: stable/7/usr.sbin/nscd/nscd.c
==============================================================================
--- stable/7/usr.sbin/nscd/nscd.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/nscd.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -77,7 +77,6 @@ static void destroy_cache_(cache);
 static void destroy_runtime_env(struct runtime_env *);
 static cache init_cache_(struct configuration *);
 static struct runtime_env *init_runtime_env(struct configuration *);
-static void print_version_info(void);
 static void processing_loop(cache, struct runtime_env *,
 	struct configuration *);
 static void process_socket_event(struct kevent *, struct runtime_env *,
@@ -90,14 +89,6 @@ static void usage(void);
 void get_time_func(struct timeval *);
 
 static void
-print_version_info(void)
-{
-	TRACE_IN(print_version_info);
-	printf("nscd v0.2 (20 Oct 2005)\nwas developed during SoC 2005\n");
-	TRACE_OUT(print_version_info);
-}
-
-static void
 usage(void)
 {
 	fprintf(stderr,
@@ -172,9 +163,8 @@ init_runtime_env(struct configuration *c
 	struct runtime_env *retval;
 
 	TRACE_IN(init_runtime_env);
-	retval = (struct runtime_env *)malloc(sizeof(struct runtime_env));
+	retval = (struct runtime_env *)calloc(1, sizeof(struct runtime_env));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct runtime_env));
 
 	retval->sockfd = socket(PF_LOCAL, SOCK_STREAM, 0);
 
@@ -183,7 +173,7 @@ init_runtime_env(struct configuration *c
 
 	memset(&serv_addr, 0, sizeof(struct sockaddr_un));
 	serv_addr.sun_family = PF_LOCAL;
-	strncpy(serv_addr.sun_path, config->socket_path,
+	strlcpy(serv_addr.sun_path, config->socket_path,
 		sizeof(serv_addr.sun_path));
 	serv_addr_len = sizeof(serv_addr.sun_family) +
 		strlen(serv_addr.sun_path) + 1;
@@ -417,10 +407,9 @@ process_socket_event(struct kevent *even
 			if (qstate->io_buffer != NULL)
 				free(qstate->io_buffer);
 
-			qstate->io_buffer = (char *)malloc(
+			qstate->io_buffer = (char *)calloc(1,
 				qstate->kevent_watermark);
 			assert(qstate->io_buffer != NULL);
-			memset(qstate->io_buffer, 0, qstate->kevent_watermark);
 
 			qstate->io_buffer_p = qstate->io_buffer;
 			qstate->io_buffer_size = qstate->kevent_watermark;
@@ -622,9 +611,6 @@ main(int argc, char *argv[])
 	/* by default all debug messages are omitted */
 	TRACE_OFF();
 
-	/* startup output */
-	print_version_info();
-
 	/* parsing command line arguments */
 	trace_mode_enabled = 0;
 	force_single_threaded = 0;
@@ -841,10 +827,8 @@ main(int argc, char *argv[])
 	}
 
 	if (s_configuration->threads_num > 1) {
-		threads = (pthread_t *)malloc(sizeof(pthread_t) *
+		threads = (pthread_t *)calloc(1, sizeof(pthread_t) *
 			s_configuration->threads_num);
-		memset(threads, 0, sizeof(pthread_t) *
-	    		s_configuration->threads_num);
 		for (i = 0; i < s_configuration->threads_num; ++i) {
 			thread_args = (struct processing_thread_args *)malloc(
 				sizeof(struct processing_thread_args));

Modified: stable/7/usr.sbin/nscd/nscdcli.c
==============================================================================
--- stable/7/usr.sbin/nscd/nscdcli.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/nscdcli.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -187,7 +187,7 @@ open_nscd_connection__(struct nscd_conne
 
 	client_socket = socket(PF_LOCAL, SOCK_STREAM, 0);
 	client_address.sun_family = PF_LOCAL;
-	strncpy(client_address.sun_path, params->socket_path,
+	strlcpy(client_address.sun_path, params->socket_path,
 		sizeof(client_address.sun_path));
 	client_address_len = sizeof(client_address.sun_family) +
 		strlen(client_address.sun_path) + 1;
@@ -201,9 +201,8 @@ open_nscd_connection__(struct nscd_conne
 	}
 	fcntl(client_socket, F_SETFL, O_NONBLOCK);
 
-	retval = malloc(sizeof(struct nscd_connection_));
+	retval = calloc(1, sizeof(struct nscd_connection_));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct nscd_connection_));
 
 	retval->sockfd = client_socket;
 

Modified: stable/7/usr.sbin/nscd/query.c
==============================================================================
--- stable/7/usr.sbin/nscd/query.c	Sun Oct 26 01:04:46 2008	(r184288)
+++ stable/7/usr.sbin/nscd/query.c	Sun Oct 26 09:35:08 2008	(r184289)
@@ -332,27 +332,21 @@ on_write_request_read1(struct query_stat
 			return (-1);
 		}
 
-		write_request->entry = (char *)malloc(
+		write_request->entry = (char *)calloc(1,
 			write_request->entry_length + 1);
 		assert(write_request->entry != NULL);
-		memset(write_request->entry, 0,
-			write_request->entry_length + 1);
 
-		write_request->cache_key = (char *)malloc(
+		write_request->cache_key = (char *)calloc(1,
 			write_request->cache_key_size +
 			qstate->eid_str_length);
 		assert(write_request->cache_key != NULL);
 		memcpy(write_request->cache_key, qstate->eid_str,
 			qstate->eid_str_length);
-		memset(write_request->cache_key + qstate->eid_str_length, 0,
-			write_request->cache_key_size);
 
 		if (write_request->data_size != 0) {
-			write_request->data = (char *)malloc(
+			write_request->data = (char *)calloc(1,
 				write_request->data_size);
 			assert(write_request->data != NULL);
-			memset(write_request->data, 0,
-				write_request->data_size);
 		}
 
 		qstate->kevent_watermark = write_request->entry_length +
@@ -611,19 +605,16 @@ on_read_request_read1(struct query_state
 			return (-1);
 		}
 
-		read_request->entry = (char *)malloc(
+		read_request->entry = (char *)calloc(1,
 			read_request->entry_length + 1);
 		assert(read_request->entry != NULL);
-		memset(read_request->entry, 0, read_request->entry_length + 1);
 
-		read_request->cache_key = (char *)malloc(
+		read_request->cache_key = (char *)calloc(1,
 			read_request->cache_key_size +
 			qstate->eid_str_length);
 		assert(read_request->cache_key != NULL);
 		memcpy(read_request->cache_key, qstate->eid_str,
 			qstate->eid_str_length);
-		memset(read_request->cache_key + qstate->eid_str_length, 0,
-			read_request->cache_key_size);
 
 		qstate->kevent_watermark = read_request->entry_length +
 			read_request->cache_key_size;
@@ -936,11 +927,9 @@ on_transform_request_read1(struct query_
 				return (-1);
 			}
 
-			transform_request->entry = (char *)malloc(
+			transform_request->entry = (char *)calloc(1,
 				transform_request->entry_length + 1);
 			assert(transform_request->entry != NULL);
-			memset(transform_request->entry, 0,
-				transform_request->entry_length + 1);
 
 			qstate->process_func = on_transform_request_read2;
 		} else
@@ -1228,9 +1217,8 @@ init_query_state(int sockfd, size_t keve
 	struct query_state	*retval;
 
 	TRACE_IN(init_query_state);
-	retval = (struct query_state *)malloc(sizeof(struct query_state));
+	retval = (struct query_state *)calloc(1, sizeof(struct query_state));
 	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct query_state));
 
 	retval->sockfd = sockfd;
 	retval->kevent_filter = EVFILT_READ;


More information about the svn-src-stable-7 mailing list