d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove casts from {c,m,re}alloc() and simplify sizeof().

Browse Source 
MFC after:	1 week
This commit is contained in:
Dag-Erling Smørgrav 2009-06-13 13:07:56 +00:00
parent b32dcb662a
commit 8eeaaffaac
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=194104
13 changed files with 87 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
usr.sbin/nscd/agent.c
View File

@ -61,7 +61,7 @@ init_agent_table(void)
struct agent_table *retval;
TRACE_IN(init_agent_table);
retval = (struct agent_table *)calloc(1, sizeof(struct agent_table));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
TRACE_OUT(init_agent_table);
@ -78,7 +78,7 @@ register_agent(struct agent_table *at, struct agent *a)
assert(at != NULL);
assert(a != NULL);
new_agents_num = at->agents_num + 1;
new_agents = (struct agent **)malloc(sizeof(struct agent *) *
new_agents = malloc(sizeof(*new_agents) *
new_agents_num);
assert(new_agents != NULL);
memcpy(new_agents, at->agents, at->agents_num * sizeof(struct agent *));

12
usr.sbin/nscd/agents/group.c
View File

@ -141,7 +141,7 @@ group_lookup_func(const char *key, size_t key_size, char **buffer,
switch (lookup_type) {
case nss_lt_name:
size = key_size - sizeof(enum nss_lookup_type) + 1;
name = (char *)calloc(1, size);
name = calloc(1, size);
assert(name != NULL);
memcpy(name, key + sizeof(enum nss_lookup_type), size - 1);
break;
@ -175,7 +175,7 @@ group_lookup_func(const char *key, size_t key_size, char **buffer,
if (result != NULL) {
group_marshal_func(result, NULL, buffer_size);
*buffer = (char *)malloc(*buffer_size);
*buffer = malloc(*buffer_size);
assert(*buffer != NULL);
group_marshal_func(result, *buffer, buffer_size);
}
@ -203,7 +203,7 @@ group_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
result = getgrent();
if (result != NULL) {
group_marshal_func(result, NULL, buffer_size);
*buffer = (char *)malloc(*buffer_size);
*buffer = malloc(*buffer_size);
assert(*buffer != NULL);
group_marshal_func(result, *buffer, buffer_size);
}
@ -225,7 +225,7 @@ init_group_agent(void)
struct common_agent *retval;
TRACE_IN(init_group_agent);
retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->parent.name = strdup("group");
@ -244,8 +244,8 @@ init_group_mp_agent(void)
struct multipart_agent *retval;
TRACE_IN(init_group_mp_agent);
retval = (struct multipart_agent *)calloc(1,
sizeof(struct multipart_agent));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent.name = strdup("group");

12
usr.sbin/nscd/agents/passwd.c
View File

@ -150,7 +150,7 @@ passwd_lookup_func(const char *key, size_t key_size, char **buffer,
switch (lookup_type) {
case nss_lt_name:
size = key_size - sizeof(enum nss_lookup_type) + 1;
login = (char *)calloc(1, size);
login = calloc(1, size);
assert(login != NULL);
memcpy(login, key + sizeof(enum nss_lookup_type), size - 1);
break;
@ -183,7 +183,7 @@ passwd_lookup_func(const char *key, size_t key_size, char **buffer,
if (result != NULL) {
passwd_marshal_func(result, NULL, buffer_size);
*buffer = (char *)malloc(*buffer_size);
*buffer = malloc(*buffer_size);
assert(*buffer != NULL);
passwd_marshal_func(result, *buffer, buffer_size);
}
@ -211,7 +211,7 @@ passwd_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
result = getpwent();
if (result != NULL) {
passwd_marshal_func(result, NULL, buffer_size);
*buffer = (char *)malloc(*buffer_size);
*buffer = malloc(*buffer_size);
assert(*buffer != NULL);
passwd_marshal_func(result, *buffer, buffer_size);
}
@ -233,7 +233,7 @@ init_passwd_agent(void)
struct common_agent *retval;
TRACE_IN(init_passwd_agent);
retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->parent.name = strdup("passwd");
@ -252,8 +252,8 @@ init_passwd_mp_agent(void)
struct multipart_agent *retval;
TRACE_IN(init_passwd_mp_agent);
retval = (struct multipart_agent *)calloc(1,
sizeof(struct multipart_agent));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent.name = strdup("passwd");

14
usr.sbin/nscd/agents/services.c
View File

@ -146,7 +146,7 @@ services_lookup_func(const char *key, size_t key_size, char **buffer,
switch (lookup_type) {
case nss_lt_name:
size = key_size - sizeof(enum nss_lookup_type);
name = (char *)calloc(1, size + 1);
name = calloc(1, size + 1);
assert(name != NULL);
memcpy(name, key + sizeof(enum nss_lookup_type), size);
@ -169,7 +169,7 @@ services_lookup_func(const char *key, size_t key_size, char **buffer,
size = key_size - sizeof(enum nss_lookup_type) - sizeof(int);
if (size > 0) {
proto = (char *)calloc(1, size + 1);
proto = calloc(1, size + 1);
assert(proto != NULL);
memcpy(proto, key + sizeof(enum nss_lookup_type) +
sizeof(int), size);
@ -196,7 +196,7 @@ services_lookup_func(const char *key, size_t key_size, char **buffer,
if (result != NULL) {
services_marshal_func(result, NULL, buffer_size);
*buffer = (char *)malloc(*buffer_size);
*buffer = malloc(*buffer_size);
assert(*buffer != NULL);
services_marshal_func(result, *buffer, buffer_size);
}
@ -224,7 +224,7 @@ services_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
result = getservent();
if (result != NULL) {
services_marshal_func(result, NULL, buffer_size);
*buffer = (char *)malloc(*buffer_size);
*buffer = malloc(*buffer_size);
assert(*buffer != NULL);
services_marshal_func(result, *buffer, buffer_size);
}
@ -246,7 +246,7 @@ init_services_agent(void)
struct common_agent *retval;
TRACE_IN(init_services_agent);
retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->parent.name = strdup("services");
@ -265,8 +265,8 @@ init_services_mp_agent(void)
struct multipart_agent *retval;
TRACE_IN(init_services_mp_agent);
retval = (struct multipart_agent *)calloc(1,
sizeof(struct multipart_agent));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent.name = strdup("services");

44
usr.sbin/nscd/cachelib.c
View File

@ -481,14 +481,14 @@ init_cache(struct cache_params const *params)
TRACE_IN(init_cache);
assert(params != NULL);
retval = (struct cache_ *)calloc(1, sizeof(struct cache_));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
assert(params != NULL);
memcpy(&retval->params, params, sizeof(struct cache_params));
retval->entries = (struct cache_entry_ **)calloc(1,
sizeof(struct cache_entry_ *) * INITIAL_ENTRIES_CAPACITY);
retval->entries = calloc(1,
sizeof(*retval->entries) * INITIAL_ENTRIES_CAPACITY);
assert(retval->entries != NULL);
retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
@ -540,8 +540,8 @@ register_cache_entry(struct cache_ *the_cache,
new_capacity = the_cache->entries_capacity +
ENTRIES_CAPACITY_STEP;
new_entries = (struct cache_entry_ **)calloc(1,
sizeof(struct cache_entry_ *) * new_capacity);
new_entries = calloc(1,
sizeof(*new_entries) * new_capacity);
assert(new_entries != NULL);
memcpy(new_entries, the_cache->entries,
@ -556,8 +556,8 @@ register_cache_entry(struct cache_ *the_cache,
switch (params->entry_type)
{
case CET_COMMON:
new_common_entry = (struct cache_common_entry_ *)calloc(1,
sizeof(struct cache_common_entry_));
new_common_entry = calloc(1,
sizeof(*new_common_entry));
assert(new_common_entry != NULL);
memcpy(&new_common_entry->common_params, params,
@ -565,7 +565,7 @@ register_cache_entry(struct cache_ *the_cache,
new_common_entry->params =
(struct cache_entry_params *)&new_common_entry->common_params;
new_common_entry->common_params.cep.entry_name = (char *)calloc(1,
new_common_entry->common_params.cep.entry_name = calloc(1,
entry_name_size);
assert(new_common_entry->common_params.cep.entry_name != NULL);
strlcpy(new_common_entry->common_params.cep.entry_name,
@ -582,8 +582,8 @@ register_cache_entry(struct cache_ *the_cache,
else
policies_size = 2;
new_common_entry->policies = (struct cache_policy_ **)calloc(1,
sizeof(struct cache_policy_ *) * policies_size);
new_common_entry->policies = calloc(1,
sizeof(*new_common_entry->policies) * policies_size);
assert(new_common_entry->policies != NULL);
new_common_entry->policies_size = policies_size;
@ -610,8 +610,8 @@ register_cache_entry(struct cache_ *the_cache,
(struct cache_entry_ *)new_common_entry;
break;
case CET_MULTIPART:
new_mp_entry = (struct cache_mp_entry_ *)calloc(1,
sizeof(struct cache_mp_entry_));
new_mp_entry = calloc(1,
sizeof(*new_mp_entry));
assert(new_mp_entry != NULL);
memcpy(&new_mp_entry->mp_params, params,
@ -619,7 +619,7 @@ register_cache_entry(struct cache_ *the_cache,
new_mp_entry->params =
(struct cache_entry_params *)&new_mp_entry->mp_params;
new_mp_entry->mp_params.cep.entry_name = (char *)calloc(1,
new_mp_entry->mp_params.cep.entry_name = calloc(1,
entry_name_size);
assert(new_mp_entry->mp_params.cep.entry_name != NULL);
strlcpy(new_mp_entry->mp_params.cep.entry_name, params->entry_name,
@ -830,10 +830,10 @@ cache_write(struct cache_entry_ *entry, const char *key, size_t key_size,
return (-1);
}
item_data.key = (char *)malloc(key_size);
item_data.key = malloc(key_size);
memcpy(item_data.key, key, key_size);
item_data.value = (char *)malloc(value_size);
item_data.value = malloc(value_size);
assert(item_data.value != NULL);
memcpy(item_data.value, value, value_size);
@ -912,8 +912,8 @@ open_cache_mp_write_session(struct cache_entry_ *entry)
return (NULL);
}
retval = (struct cache_mp_write_session_ *)calloc(1,
sizeof(struct cache_mp_write_session_));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
TAILQ_INIT(&retval->items);
@ -947,11 +947,11 @@ cache_mp_write(struct cache_mp_write_session_ *ws, char *data,
return (-1);
}
new_item = (struct cache_mp_data_item_ *)calloc(1,
sizeof(struct cache_mp_data_item_));
new_item = calloc(1,
sizeof(*new_item));
assert(new_item != NULL);
new_item->value = (char *)malloc(data_size);
new_item->value = malloc(data_size);
assert(new_item->value != NULL);
memcpy(new_item->value, data, data_size);
new_item->value_size = data_size;
@ -1050,8 +1050,8 @@ open_cache_mp_read_session(struct cache_entry_ *entry)
}
}
retval = (struct cache_mp_read_session_ *)calloc(1,
sizeof(struct cache_mp_read_session_));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent_entry = mp_entry;

16
usr.sbin/nscd/cacheplcs.c
View File

@ -86,8 +86,8 @@ cache_queue_policy_create_item(void)
struct cache_queue_policy_item_ *retval;
TRACE_IN(cache_queue_policy_create_item);
retval = (struct cache_queue_policy_item_ *)calloc(1,
sizeof(struct cache_queue_policy_item_));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
TRACE_OUT(cache_queue_policy_create_item);
@ -196,8 +196,8 @@ init_cache_queue_policy(void)
struct cache_queue_policy_ *retval;
TRACE_IN(init_cache_queue_policy);
retval = (struct cache_queue_policy_ *)calloc(1,
sizeof(struct cache_queue_policy_));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent_data.create_item_func = cache_queue_policy_create_item;
@ -336,8 +336,8 @@ 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_ *)calloc(1,
sizeof(struct cache_lfu_policy_item_));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
TRACE_OUT(cache_lfu_policy_create_item);
@ -540,8 +540,8 @@ init_cache_lfu_policy(void)
struct cache_lfu_policy_ *retval;
TRACE_IN(init_cache_lfu_policy);
retval = (struct cache_lfu_policy_ *)calloc(1,
sizeof(struct cache_lfu_policy_));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent_data.create_item_func = cache_lfu_policy_create_item;

22
usr.sbin/nscd/config.c
View File

@ -125,8 +125,8 @@ create_configuration_entry(const char *name,
assert(negative_params != NULL);
assert(mp_params != NULL);
retval = (struct configuration_entry *)calloc(1,
sizeof(struct configuration_entry));
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
res = pthread_mutex_init(&retval->positive_cache_lock, NULL);
@ -167,7 +167,7 @@ create_configuration_entry(const char *name,
sizeof(struct mp_cache_entry_params));
size = strlen(name);
retval->name = (char *)calloc(1, size + 1);
retval->name = calloc(1, size + 1);
assert(retval->name != NULL);
memcpy(retval->name, name, size);
@ -272,8 +272,8 @@ add_configuration_entry(struct configuration *config,
struct configuration_entry **new_entries;
config->entries_capacity *= 2;
new_entries = (struct configuration_entry **)calloc(1,
sizeof(struct configuration_entry *) *
new_entries = calloc(1,
sizeof(*new_entries) *
config->entries_capacity);
assert(new_entries != NULL);
memcpy(new_entries, config->entries,
@ -340,7 +340,7 @@ configuration_entry_add_mp_cache_entry(struct configuration_entry *config_entry,
TRACE_IN(configuration_entry_add_mp_cache_entry);
++config_entry->mp_cache_entries_size;
new_mp_entries = (cache_entry *)malloc(sizeof(cache_entry) *
new_mp_entries = malloc(sizeof(*new_mp_entries) *
config_entry->mp_cache_entries_size);
assert(new_mp_entries != NULL);
new_mp_entries[0] = c_entry;
@ -516,12 +516,12 @@ init_configuration(void)
struct configuration *retval;
TRACE_IN(init_configuration);
retval = (struct configuration *)calloc(1, sizeof(struct configuration));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
retval->entries = (struct configuration_entry **)calloc(1,
sizeof(struct configuration_entry *) *
retval->entries = calloc(1,
sizeof(*retval->entries) *
retval->entries_capacity);
assert(retval->entries != NULL);
@ -543,12 +543,12 @@ fill_configuration_defaults(struct configuration *config)
free(config->socket_path);
len = strlen(DEFAULT_SOCKET_PATH);
config->socket_path = (char *)calloc(1, len + 1);
config->socket_path = calloc(1, len + 1);
assert(config->socket_path != NULL);
memcpy(config->socket_path, DEFAULT_SOCKET_PATH, len);
len = strlen(DEFAULT_PIDFILE_PATH);
config->pidfile_path = (char *)calloc(1, len + 1);
config->pidfile_path = calloc(1, len + 1);
assert(config->pidfile_path != NULL);
memcpy(config->pidfile_path, DEFAULT_PIDFILE_PATH, len);

12
usr.sbin/nscd/hashtable.h
View File

@ -74,16 +74,16 @@ typedef unsigned int hashtable_index_t;
#define HASHTABLE_INIT(table, type, field, _entries_size) \
do { \
hashtable_index_t var; \
(table)->entries = (void *)calloc(1, \
(table)->entries = calloc(1, \
sizeof(*(table)->entries) * (_entries_size)); \
(table)->entries_size = (_entries_size); \
for (var = 0; var < HASHTABLE_ENTRIES_COUNT(table); ++var) {\
(table)->entries[var].field.capacity = \
HASHTABLE_INITIAL_ENTRIES_CAPACITY; \
(table)->entries[var].field.size = 0; \
(table)->entries[var].field.values = (type *)malloc(\
sizeof(type) * \
HASHTABLE_INITIAL_ENTRIES_CAPACITY); \
(table)->entries[var].field.values = malloc( \
sizeof(type) * \
HASHTABLE_INITIAL_ENTRIES_CAPACITY); \
assert((table)->entries[var].field.values != NULL);\
} \
} while (0)
@ -128,12 +128,12 @@ typedef unsigned int hashtable_index_t;
#define HASHTABLE_ENTRY_CAPACITY_INCREASE(entry, field, type) \
(entry)->field.capacity *= 2; \
(entry)->field.values = (type *)realloc((entry)->field.values, \
(entry)->field.values = realloc((entry)->field.values, \
(entry)->field.capacity * sizeof(type));
#define HASHTABLE_ENTRY_CAPACITY_DECREASE(entry, field, type) \
(entry)->field.capacity /= 2; \
(entry)->field.values = (type *)realloc((entry)->field.values, \
(entry)->field.values = realloc((entry)->field.values, \
(entry)->field.capacity * sizeof(type));
/*

4
usr.sbin/nscd/mp_rs_query.c
View File

@ -117,7 +117,7 @@ on_mp_read_session_request_read1(struct query_state *qstate)
return (-1);
}
c_mp_rs_request->entry = (char *)calloc(1,
c_mp_rs_request->entry = calloc(1,
c_mp_rs_request->entry_length + 1);
assert(c_mp_rs_request->entry != NULL);
@ -428,7 +428,7 @@ on_mp_read_session_read_request_process(struct query_state *qstate)
&read_response->data_size);
if (read_response->error_code == 0) {
read_response->data = (char *)malloc(read_response->data_size);
read_response->data = malloc(read_response->data_size);
assert(read_response != NULL);
read_response->error_code = cache_mp_read(
(cache_mp_read_session)qstate->mdata,

4
usr.sbin/nscd/mp_ws_query.c
View File

@ -122,7 +122,7 @@ on_mp_write_session_request_read1(struct query_state *qstate)
return (-1);
}
c_mp_ws_request->entry = (char *)calloc(1,
c_mp_ws_request->entry = calloc(1,
c_mp_ws_request->entry_length + 1);
assert(c_mp_ws_request->entry != NULL);
@ -375,7 +375,7 @@ on_mp_write_session_write_request_read1(struct query_state *qstate)
return (-1);
}
write_request->data = (char *)calloc(1, write_request->data_size);
write_request->data = calloc(1, write_request->data_size);
assert(write_request->data != NULL);
qstate->kevent_watermark = write_request->data_size;

10
usr.sbin/nscd/nscd.c
View File

@ -164,7 +164,7 @@ init_runtime_env(struct configuration *config)
struct runtime_env *retval;
TRACE_IN(init_runtime_env);
retval = (struct runtime_env *)calloc(1, sizeof(struct runtime_env));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->sockfd = socket(PF_LOCAL, SOCK_STREAM, 0);
@ -408,7 +408,7 @@ process_socket_event(struct kevent *event_data, struct runtime_env *env,
if (qstate->io_buffer != NULL)
free(qstate->io_buffer);
qstate->io_buffer = (char *)calloc(1,
qstate->io_buffer = calloc(1,
qstate->kevent_watermark);
assert(qstate->io_buffer != NULL);
@ -828,11 +828,11 @@ main(int argc, char *argv[])
}
if (s_configuration->threads_num > 1) {
threads = (pthread_t *)calloc(1, sizeof(pthread_t) *
threads = calloc(1, sizeof(*threads) *
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));
thread_args = malloc(
sizeof(*thread_args));
thread_args->the_cache = s_cache;
thread_args->the_runtime_env = s_runtime_env;
thread_args->the_configuration = s_configuration;

2
usr.sbin/nscd/nscdcli.c
View File

@ -205,7 +205,7 @@ open_nscd_connection__(struct nscd_connection_params const *params)
}
fcntl(client_socket, F_SETFL, O_NONBLOCK);
retval = calloc(1, sizeof(struct nscd_connection_));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->sockfd = client_socket;

18
usr.sbin/nscd/query.c
View File

@ -335,11 +335,11 @@ on_write_request_read1(struct query_state *qstate)
return (-1);
}
write_request->entry = (char *)calloc(1,
write_request->entry = calloc(1,
write_request->entry_length + 1);
assert(write_request->entry != NULL);
write_request->cache_key = (char *)calloc(1,
write_request->cache_key = calloc(1,
write_request->cache_key_size +
qstate->eid_str_length);
assert(write_request->cache_key != NULL);
@ -347,7 +347,7 @@ on_write_request_read1(struct query_state *qstate)
qstate->eid_str_length);
if (write_request->data_size != 0) {
write_request->data = (char *)calloc(1,
write_request->data = calloc(1,
write_request->data_size);
assert(write_request->data != NULL);
}
@ -608,11 +608,11 @@ on_read_request_read1(struct query_state *qstate)
return (-1);
}
read_request->entry = (char *)calloc(1,
read_request->entry = calloc(1,
read_request->entry_length + 1);
assert(read_request->entry != NULL);
read_request->cache_key = (char *)calloc(1,
read_request->cache_key = calloc(1,
read_request->cache_key_size +
qstate->eid_str_length);
assert(read_request->cache_key != NULL);
@ -723,8 +723,8 @@ on_read_request_process(struct query_state *qstate)
&read_response->data_size);
if (read_response->error_code == -2) {
read_response->data = (char *)malloc(
read_response->data_size);
read_response->data = malloc(
read_response->data_size);
assert(read_response != NULL);
read_response->error_code = cache_read(c_entry,
read_request->cache_key,
@ -930,7 +930,7 @@ on_transform_request_read1(struct query_state *qstate)
return (-1);
}
transform_request->entry = (char *)calloc(1,
transform_request->entry = calloc(1,
transform_request->entry_length + 1);
assert(transform_request->entry != NULL);
@ -1226,7 +1226,7 @@ init_query_state(int sockfd, size_t kevent_watermark, uid_t euid, gid_t egid)
struct query_state *retval;
TRACE_IN(init_query_state);
retval = (struct query_state *)calloc(1, sizeof(struct query_state));
retval = calloc(1, sizeof(*retval));
assert(retval != NULL);
retval->sockfd = sockfd;