Remove casts from {c,m,re}alloc() and simplify sizeof().
MFC after: 1 week
This commit is contained in:
parent
b32dcb662a
commit
8eeaaffaac
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=194104
@ -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 *));
|
||||
|
@ -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");
|
||||
|
@ -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");
|
||||
|
@ -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");
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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));
|
||||
|
||||
/*
|
||||
|
@ -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,
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
Loading…
Reference in New Issue
Block a user