/*
* _delete_config_record - delete all configuration records
* RET 0 if no error, errno otherwise
* global: config_list - list of all configuration records
*/
static int _delete_config_record (void)
{
last_node_update = time (NULL);
(void) list_delete_all(config_list, &_list_find_config, NULL);
(void) list_delete_all(front_end_list, &list_find_frontend, NULL);
return SLURM_SUCCESS;
}
int
opt_addf (Opt o, const char *fmt, ...)
{
va_list ap;
char *csv, *item, *cpy;
char *saveptr = NULL;
int error;
NP_ASSERT (o->magic == OPT_MAGIC);
va_start (ap, fmt);
error = vasprintf (&csv, fmt, ap);
va_end (ap);
if (error < 0)
msg_exit ("out of memory");
item = strtok_r (csv, ",", &saveptr);
while (item) {
if (!(cpy = strdup (item)))
msg_exit ("out of memory");
(void)list_delete_all (o->list, (ListFindF)_match_key, cpy);
if (!list_append (o->list, cpy))
msg_exit ("out of memory");
item = strtok_r (NULL, ",", &saveptr);
}
free (csv);
return 1;
}
/* Returns number of deletions.
*/
int
opt_delete (Opt o, char *key)
{
NP_ASSERT (o->magic == OPT_MAGIC);
return list_delete_all (o->list, (ListFindF)_match_key, key);
}
int
cerebro_event_unregister(cerebro_t handle, int fd)
{
if (_cerebro_handle_check(handle) < 0)
return -1;
if (fd < 0)
{
handle->errnum = CEREBRO_ERR_PARAMETERS;
return -1;
}
if (!list_find_first(handle->event_fds, _event_fd_find, &fd))
{
handle->errnum = CEREBRO_ERR_PARAMETERS;
return -1;
}
if (!list_delete_all(handle->event_fds, _event_fd_find, &fd))
{
handle->errnum = CEREBRO_ERR_INTERNAL;
return -1;
}
/* ignore potential error, just return result */
close(fd);
handle->errnum = CEREBRO_ERR_SUCCESS;
return 0;
}
STATUS list_free(LIST_HEAD *p_head)
{
list_delete_all(p_head);
free(p_head);
return ST_SUCCESS;
}
static int _alljobids_requested (List l)
{
char *all = "all";
if (l == NULL)
return (0);
return (list_delete_all (l, (ListFindF)_find_str, all));
}
extern void *_sicp_agent(void *args)
{
static time_t last_sicp_time = 0;
time_t now;
double wait_time;
while (!sicp_stop) {
_my_sleep(1);
if (sicp_stop)
break;
now = time(NULL);
wait_time = difftime(now, last_sicp_time);
if (wait_time < sicp_interval)
continue;
last_sicp_time = now;
_load_sicp_other_cluster();
pthread_mutex_lock(&sicp_lock);
list_delete_all(sicp_job_list, &_list_find_sicp_old, "");
if (slurm_get_debug_flags() & DEBUG_FLAG_SICP)
_log_sicp_recs();
pthread_mutex_unlock(&sicp_lock);
_dump_sicp_state(); /* Has own locking */
}
return NULL;
}
/*
* _delete_part_record - delete record for partition with specified name
* IN name - name of the desired node, delete all partitions if NULL
* RET 0 on success, errno otherwise
* global: part_list - global partition list
*/
static int _delete_part_record(char *name)
{
int i;
last_part_update = time(NULL);
if (name == NULL) {
i = list_delete_all(part_list, &list_find_part,
"universal_key");
} else
i = list_delete_all(part_list, &list_find_part, name);
if ((name == NULL) || (i != 0))
return 0;
error("_delete_part_record: attempt to delete non-existent "
"partition %s", name);
return ENOENT;
}
static void *
_pstdout_func_entry(void *arg)
{
struct pstdout_thread_data *tdata = NULL;
struct pstdout_state pstate;
int rc;
tdata = (struct pstdout_thread_data *)arg;
if (_pstdout_state_init(&pstate, tdata->hostname) < 0)
goto cleanup;
if ((rc = pthread_mutex_lock(&pstdout_states_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_lock: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
if (!list_append(pstdout_states, &pstate))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "list_append: %s\n", strerror(errno));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
pthread_mutex_unlock(&pstdout_states_mutex);
goto cleanup;
}
if ((rc = pthread_mutex_unlock(&pstdout_states_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_lock: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
tdata->exit_code = (tdata->pstdout_func)(&pstate, tdata->hostname, tdata->arg);
if (_pstdout_output_finish(&pstate) < 0)
goto cleanup;
cleanup:
pthread_mutex_lock(&pstdout_states_mutex);
list_delete_all(pstdout_states, _pstdout_states_delete_pointer, &pstate);
pthread_mutex_unlock(&pstdout_states_mutex);
_pstdout_state_cleanup(&pstate);
pthread_mutex_lock(&pstdout_threadcount_mutex);
pstdout_threadcount--;
pthread_cond_signal(&pstdout_threadcount_cond);
pthread_mutex_unlock(&pstdout_threadcount_mutex);
return NULL;
}
optparse_err_t optparse_remove_option (optparse_t p, const char *name)
{
optparse_err_t rc = OPTPARSE_SUCCESS;
int n = list_delete_all (p->option_list,
(ListFindF) option_info_cmp_name,
(void *) name);
if (n != 1)
rc = OPTPARSE_FAILURE;
return (rc);
}
/* Clear active_feature_list,
* then copy avail_feature_list into active_feature_list */
static void _copy_feature_list(void)
{
node_feature_t *active_feature_ptr, *avail_feature_ptr;
ListIterator feature_iter;
(void) list_delete_all(active_feature_list, &_list_find_feature, NULL);
feature_iter = list_iterator_create(avail_feature_list);
while ((avail_feature_ptr = (node_feature_t *)list_next(feature_iter))){
active_feature_ptr = xmalloc(sizeof(node_feature_t));
active_feature_ptr->magic = FEATURE_MAGIC;
active_feature_ptr->name = xstrdup(avail_feature_ptr->name);
active_feature_ptr->node_bitmap =
bit_copy(avail_feature_ptr->node_bitmap);
list_append(active_feature_list, active_feature_ptr);
}
list_iterator_destroy(feature_iter);
}
/*
* delete_partition - delete the specified partition (actually leave
* the entry, just flag it as defunct)
* IN job_specs - job specification from RPC
*/
extern int delete_partition(delete_part_msg_t *part_desc_ptr)
{
struct part_record *part_ptr;
part_ptr = find_part_record (part_desc_ptr->name);
if (part_ptr == NULL) /* No such partition */
return ESLURM_INVALID_PARTITION_NAME;
if (partition_in_use(part_desc_ptr->name))
return ESLURM_PARTITION_IN_USE;
if (default_part_loc == part_ptr) {
error("Deleting default partition %s", part_ptr->name);
default_part_loc = NULL;
}
(void) kill_job_by_part_name(part_desc_ptr->name);
list_delete_all(part_list, list_find_part, part_desc_ptr->name);
last_part_update = time(NULL);
slurm_sched_partition_change(); /* notify sched plugin */
select_g_reconfigure(); /* notify select plugin too */
return SLURM_SUCCESS;
}
/*
* Return non-zero if jobid is in list of ids requested by user
*/
static int _jobid_requested (List l, uint32_t jobid)
{
if (l == NULL)
return (0);
return (list_delete_all (l, (ListFindF)_find_id, &jobid));
}
extern void get_bg_part(void)
{
int error_code, i, j, recs=0, count = 0, last_count = -1;
static partition_info_msg_t *part_info_ptr = NULL;
static partition_info_msg_t *new_part_ptr = NULL;
static block_info_msg_t *bg_info_ptr = NULL;
static block_info_msg_t *new_bg_ptr = NULL;
uint16_t show_flags = 0;
partition_info_t part;
db2_block_info_t *block_ptr = NULL;
db2_block_info_t *found_block = NULL;
ListIterator itr;
List nodelist = NULL;
bitstr_t *nodes_req = NULL;
if (!(params.cluster_flags & CLUSTER_FLAG_BG))
return;
if (params.all_flag)
show_flags |= SHOW_ALL;
if (part_info_ptr) {
error_code = slurm_load_partitions(part_info_ptr->last_update,
&new_part_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_partition_info_msg(part_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_part_ptr = part_info_ptr;
}
} else {
error_code = slurm_load_partitions((time_t) NULL,
&new_part_ptr, show_flags);
}
if (error_code) {
if (quiet_flag != 1) {
if (!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
"slurm_load_partitions: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_partitions: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
return;
}
if (bg_info_ptr) {
error_code = slurm_load_block_info(bg_info_ptr->last_update,
&new_bg_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_block_info_msg(bg_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_bg_ptr = bg_info_ptr;
}
} else {
error_code = slurm_load_block_info((time_t) NULL,
&new_bg_ptr, show_flags);
}
if (error_code) {
if (quiet_flag != 1) {
if (!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
"slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_block: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
return;
}
if (block_list) {
/* clear the old list */
list_delete_all(block_list, _list_match_all, NULL);
} else {
block_list = list_create(_block_list_del);
if (!block_list) {
fprintf(stderr, "malloc error\n");
return;
}
}
if (!params.commandline)
if ((new_bg_ptr->record_count - text_line_cnt)
< (text_win->_maxy-3))
text_line_cnt--;
if (params.hl)
nodes_req = get_requested_node_bitmap();
for (i = 0; i < new_bg_ptr->record_count; i++) {
if (nodes_req) {
int overlap = 0;
bitstr_t *loc_bitmap = bit_alloc(bit_size(nodes_req));
inx2bitstr(loc_bitmap,
new_bg_ptr->block_array[i].mp_inx);
overlap = bit_overlap(loc_bitmap, nodes_req);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
if (params.io_bit && new_bg_ptr->block_array[i].ionode_str) {
int overlap = 0;
bitstr_t *loc_bitmap =
bit_alloc(bit_size(params.io_bit));
inx2bitstr(loc_bitmap,
new_bg_ptr->block_array[i].ionode_inx);
overlap = bit_overlap(loc_bitmap, params.io_bit);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
block_ptr = xmalloc(sizeof(db2_block_info_t));
block_ptr->bg_block_name
= xstrdup(new_bg_ptr->block_array[i].bg_block_id);
block_ptr->mp_str = xstrdup(new_bg_ptr->block_array[i].mp_str);
block_ptr->nodelist = list_create(_nodelist_del);
_make_nodelist(block_ptr->mp_str, block_ptr->nodelist);
block_ptr->bg_user_name
= xstrdup(new_bg_ptr->block_array[i].owner_name);
block_ptr->state = new_bg_ptr->block_array[i].state;
memcpy(block_ptr->bg_conn_type,
new_bg_ptr->block_array[i].conn_type,
sizeof(block_ptr->bg_conn_type));
if (params.cluster_flags & CLUSTER_FLAG_BGL)
block_ptr->bg_node_use =
new_bg_ptr->block_array[i].node_use;
block_ptr->ionode_str
= xstrdup(new_bg_ptr->block_array[i].ionode_str);
block_ptr->cnode_cnt = new_bg_ptr->block_array[i].cnode_cnt;
itr = list_iterator_create(block_list);
while ((found_block = (db2_block_info_t*)list_next(itr))) {
if (!strcmp(block_ptr->mp_str, found_block->mp_str)) {
block_ptr->letter_num =
found_block->letter_num;
break;
}
}
list_iterator_destroy(itr);
if (!found_block) {
last_count++;
_marknodes(block_ptr, last_count);
}
block_ptr->job_running =
new_bg_ptr->block_array[i].job_running;
if (block_ptr->bg_conn_type[0] >= SELECT_SMALL)
block_ptr->size = 0;
list_append(block_list, block_ptr);
}
if (!params.no_header)
_print_header_part();
if (new_part_ptr)
recs = new_part_ptr->record_count;
else
recs = 0;
for (i = 0; i < recs; i++) {
j = 0;
part = new_part_ptr->partition_array[i];
if (!part.nodes || (part.nodes[0] == '\0'))
continue; /* empty partition */
nodelist = list_create(_nodelist_del);
_make_nodelist(part.nodes, nodelist);
if (block_list) {
itr = list_iterator_create(block_list);
while ((block_ptr = (db2_block_info_t*)
list_next(itr)) != NULL) {
if (_in_slurm_partition(nodelist,
block_ptr->nodelist)) {
block_ptr->slurm_part_name
= xstrdup(part.name);
}
}
list_iterator_destroy(itr);
}
list_destroy(nodelist);
}
/* Report the BG Blocks */
if (block_list) {
itr = list_iterator_create(block_list);
while ((block_ptr = (db2_block_info_t*)
list_next(itr)) != NULL) {
if (params.commandline)
block_ptr->printed = 1;
else {
if (count>=text_line_cnt)
block_ptr->printed = 1;
}
_print_rest(block_ptr);
count++;
}
list_iterator_destroy(itr);
}
if (params.commandline && params.iterate)
printf("\n");
part_info_ptr = new_part_ptr;
bg_info_ptr = new_bg_ptr;
return;
}
void list_free(list *listo)
{
list_delete_all(listo);
free(listo->names);
free(listo->items);
}
static void rdl_resource_delete (struct rdl *rdl, struct resource *r)
{
if (!rdl->resource_list)
return;
list_delete_all (rdl->resource_list, (ListFindF) ptrcmp, r);
}
static void rdllib_rdl_delete (struct rdllib *l, struct rdl *rdl)
{
if (l->rdl_list)
list_delete_all (l->rdl_list, (ListFindF) ptrcmp, rdl);
}
int
pstdout_launch(const char *hostnames, Pstdout_Thread pstdout_func, void *arg)
{
struct pstdout_thread_data **tdata = NULL;
struct pstdout_state pstate;
unsigned int pstate_init = 0;
hostlist_iterator_t hitr = NULL;
hostlist_t h = NULL;
int h_count = 0;
char *host = NULL;
int exit_code = -1;
sighandler_t sighandler_save = NULL;
int sighandler_set = 0;
int rc;
int i;
if (!pstdout_initialized)
{
pstdout_errnum = PSTDOUT_ERR_UNINITIALIZED;
return -1;
}
if (!pstdout_func)
{
pstdout_errnum = PSTDOUT_ERR_PARAMETERS;
return -1;
}
if ((rc = pthread_mutex_lock(&pstdout_launch_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_lock: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
/* Special case */
if (!hostnames)
{
if (_pstdout_state_init(&pstate, NULL) < 0)
goto cleanup;
pstate_init++;
exit_code = pstdout_func(&pstate, NULL, arg);
pstdout_errnum = PSTDOUT_ERR_SUCCESS;
goto cleanup;
}
if (!(h = hostlist_create(hostnames)))
{
pstdout_errnum = PSTDOUT_ERR_OUTMEM;
goto cleanup;
}
h_count = hostlist_count(h);
/* Sanity check */
if (h_count <= 0)
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "h_count = %d\n", h_count);
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
/* Special case */
if (h_count == 1)
{
if (_pstdout_state_init(&pstate, hostnames) < 0)
goto cleanup;
pstate_init++;
exit_code = pstdout_func(&pstate, hostnames, arg);
pstdout_errnum = PSTDOUT_ERR_SUCCESS;
goto cleanup;
}
if ((sighandler_save = signal(SIGINT, _pstdout_sigint)) == SIG_ERR)
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "signal\n");
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
sighandler_set++;
if (!(hitr = hostlist_iterator_create(h)))
{
pstdout_errnum = PSTDOUT_ERR_OUTMEM;
goto cleanup;
}
if (!(tdata = (struct pstdout_thread_data **)malloc(sizeof(struct pstdout_thread_data *) * h_count)))
{
pstdout_errnum = PSTDOUT_ERR_OUTMEM;
goto cleanup;
}
memset(tdata, '\0', sizeof(struct pstdout_thread_data *) * h_count);
i = 0;
while ((host = hostlist_next(hitr)))
{
if (!(tdata[i] = (struct pstdout_thread_data *)malloc(sizeof(struct pstdout_thread_data))))
{
pstdout_errnum = PSTDOUT_ERR_OUTMEM;
goto cleanup;
}
memset(tdata[i], '\0', sizeof(struct pstdout_thread_data));
if (!(tdata[i]->hostname = strdup(host)))
{
pstdout_errnum = PSTDOUT_ERR_OUTMEM;
goto cleanup;
}
tdata[i]->pstdout_func = pstdout_func;
tdata[i]->arg = arg;
if ((rc = pthread_attr_init(&(tdata[i]->attr))))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_attr_init: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
if ((rc = pthread_attr_setdetachstate(&(tdata[i]->attr), PTHREAD_CREATE_DETACHED)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_attr_setdetachstate: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
free(host);
i++;
}
host = NULL;
hostlist_iterator_destroy(hitr);
hitr = NULL;
hostlist_destroy(h);
h = NULL;
/* Launch threads up to fanout */
for (i = 0; i < h_count; i++)
{
if ((rc = pthread_mutex_lock(&pstdout_threadcount_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_lock: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
if (pstdout_threadcount == pstdout_fanout)
{
if ((rc = pthread_cond_wait(&pstdout_threadcount_cond, &pstdout_threadcount_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_cond_wait: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
}
if ((rc = pthread_create(&(tdata[i]->tid),
&(tdata[i]->attr),
_pstdout_func_entry,
(void *) tdata[i])))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_create: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
pstdout_threadcount++;
if ((rc = pthread_mutex_unlock(&pstdout_threadcount_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_unlock: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
}
/* Wait for Threads to finish */
if ((rc = pthread_mutex_lock(&pstdout_threadcount_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_lock: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
while (pstdout_threadcount > 0)
{
if ((rc = pthread_cond_wait(&pstdout_threadcount_cond, &pstdout_threadcount_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_cond_wait: %s\n", strerror(rc));
pstdout_errnum = PSTDOUT_ERR_INTERNAL;
goto cleanup;
}
}
if (_pstdout_output_consolidated_finish() < 0)
goto cleanup;
/* Determine exit code */
exit_code = 0;
for (i = 0; i < h_count; i++)
{
if (tdata[i]->exit_code > exit_code)
exit_code = tdata[i]->exit_code;
}
cleanup:
/* Cannot pass NULL for key, so just pass dummy key */
list_delete_all(pstdout_consolidated_stdout, _pstdout_consolidated_data_delete_all, "");
list_delete_all(pstdout_consolidated_stderr, _pstdout_consolidated_data_delete_all, "");
if (pstate_init)
_pstdout_state_cleanup(&pstate);
if (tdata)
{
for (i = 0; i < h_count; i++)
{
if (tdata[i])
{
free(tdata[i]->hostname);
pthread_attr_destroy(&(tdata[i]->attr));
free(tdata[i]);
}
}
free(tdata);
}
if (hitr)
hostlist_iterator_destroy(hitr);
if (h)
hostlist_destroy(h);
free(host);
if ((rc = pthread_mutex_unlock(&pstdout_launch_mutex)))
{
if (pstdout_debug_flags & PSTDOUT_DEBUG_STANDARD)
fprintf(stderr, "pthread_mutex_unlock: %s\n", strerror(rc));
/* Don't change error code, just move on */
}
if (sighandler_set)
signal(SIGINT, sighandler_save);
return exit_code;
}
void WorkQueue::CancelScheduledWork(WorkableInterface *wi)
{
pthread_mutex_lock(&wlock);
works = list_delete_all(works, wi);
pthread_mutex_unlock(&wlock);
}
int
genders_load_data(genders_t handle, const char *filename)
{
char *temp;
if (_genders_unloaded_handle_error_check(handle) < 0)
goto cleanup;
handle->node_index_size = GENDERS_NODE_INDEX_INIT_SIZE;
__hash_create(handle->node_index,
handle->node_index_size,
(hash_key_f)hash_key_string,
(hash_cmp_f)strcmp,
NULL);
handle->attr_index_size = GENDERS_ATTR_INDEX_INIT_SIZE;
__hash_create(handle->attr_index,
handle->attr_index_size,
(hash_key_f)hash_key_string,
(hash_cmp_f)strcmp,
(hash_del_f)list_destroy);
if (_genders_open_and_parse(handle,
filename,
&handle->numattrs,
&handle->maxattrs,
&handle->maxnodelen,
&handle->maxattrlen,
&handle->maxvallen,
handle->nodeslist,
handle->attrvalslist,
handle->attrslist,
&(handle->node_index),
&(handle->node_index_size),
&(handle->attr_index),
&(handle->attr_index_size),
0,
NULL) < 0)
goto cleanup;
handle->numnodes = list_count(handle->nodeslist);
if (gethostname(handle->nodename, GENDERS_MAXHOSTNAMELEN+1) < 0)
{
handle->errnum = GENDERS_ERR_INTERNAL;
goto cleanup;
}
handle->nodename[GENDERS_MAXHOSTNAMELEN]='\0';
/* shorten hostname if necessary */
#ifndef WITH_NON_SHORTENED_HOSTNAMES
if ((temp = strchr(handle->nodename,'.')))
*temp = '\0';
#endif /* !WITH_NON_SHORTENED_HOSTNAMES */
handle->maxnodelen = GENDERS_MAX(strlen(handle->nodename), handle->maxnodelen);
/* Create a buffer for value substitutions */
__xmalloc(handle->valbuf, char *, handle->maxvallen + 1);
handle->is_loaded++;
handle->errnum = GENDERS_ERR_SUCCESS;
return 0;
cleanup:
if (handle && handle->magic == GENDERS_ERR_MAGIC)
{
free(handle->valbuf);
/* Can't pass NULL for key, so pass junk, _genders_list_is_all()
* will ensure everything is deleted
*/
list_delete_all(handle->nodeslist, _genders_list_is_all, "");
list_delete_all(handle->attrvalslist, _genders_list_is_all, "");
list_delete_all(handle->attrslist, _genders_list_is_all, "");
__hash_destroy(handle->node_index);
__hash_destroy(handle->attr_index);
_initialize_handle_info(handle);
}
return -1;
}
void obj_free_half_list(list *listo)
{
list_delete_all(listo);
free(listo->names);
}
static int _partition_requested (List l, char *partition)
{
if (l == NULL)
return (0);
return (list_delete_all (l, (ListFindF)_find_str, partition));
}
