void *
globus_fifo_dequeue(
globus_fifo_t * fifo)
{
void * datum;
struct globus_fifo_s * s_fifo;
assert(fifo != GLOBUS_NULL);
s_fifo = *fifo;
assert(s_fifo != GLOBUS_NULL);
if(globus_list_empty(s_fifo->head))
return GLOBUS_NULL;
datum = globus_list_remove ((globus_list_t **) &(s_fifo->head),
(globus_list_t *) s_fifo->head);
if(globus_list_empty (s_fifo->head))
{
s_fifo->tail = s_fifo->head;
}
s_fifo->size--;
return datum;
}
globus_result_t
globus_xio_driver_safe_table_from_string(
char * driver_string,
globus_hashtable_t * safe_table)
{
globus_result_t result;
globus_xio_driver_list_ent_t * d_ent;
globus_list_t * driver_list = NULL;
/* take advantage of xio function to load drivers */
result = globus_xio_driver_list_from_string(
driver_string, &driver_list, NULL);
if(result != GLOBUS_SUCCESS)
{
goto error;
}
while(!globus_list_empty(driver_list))
{
d_ent = (globus_xio_driver_list_ent_t *)
globus_list_remove(&driver_list, driver_list);
globus_hashtable_insert(safe_table, d_ent->driver_name, d_ent);
}
return GLOBUS_SUCCESS;
error:
return result;
}
/*
* globus_l_module_decrement()
*/
static globus_l_module_entry_t *
globus_l_module_decrement(
globus_module_descriptor_t * module_descriptor,
globus_l_module_key_t parent_key)
{
globus_l_module_entry_t * entry;
entry =
globus_hashtable_lookup(
&globus_l_module_table,
(void *) module_descriptor->activation_func);
if (entry == GLOBUS_NULL || entry->reference_count <= 0)
{
return NULL;
}
entry->reference_count--;
if (parent_key != GLOBUS_NULL)
{
globus_list_t * client_entry;
client_entry = globus_list_search(entry->clients,
(void *) parent_key);
if(client_entry != GLOBUS_NULL)
{
globus_list_remove(&entry->clients, client_entry);
}
/* else module was activated outside this parent */
}
return entry;
}
static
void
globus_l_gss_free_test_cases()
{
compare_name_test_case_t *test_case, *tmp_case;
gss_name_t name1, name2;
globus_list_t * tmp;
OM_uint32 minor_status;
while (!globus_list_empty(test_cases))
{
test_case = globus_list_first(test_cases);
free(test_case->test_name);
name1 = test_case->name1;
name2 = test_case->name2;
for (tmp = test_cases;
!globus_list_empty(tmp);
tmp = globus_list_rest(tmp))
{
tmp_case = globus_list_first(tmp);
if (name1 == tmp_case->name1 ||
name2 == tmp_case->name1)
{
tmp_case->name1 = NULL;
}
if (name1 == tmp_case->name2 ||
name2 == tmp_case->name2)
{
tmp_case->name2 = NULL;
}
}
gss_release_name(&minor_status, &name1);
if (name1 != name2)
{
gss_release_name(&minor_status, &name2);
}
if (test_case->name_token1)
{
free(test_case->name_token1);
}
if (test_case->name_token2)
{
free(test_case->name_token2);
}
free(test_case);
globus_list_remove(&test_cases, test_cases);
}
}
static
void
globus_l_gram_staging_list_free(
globus_list_t ** staging_list)
{
globus_gram_job_manager_staging_info_t *
info;
while (!globus_list_empty(*staging_list))
{
info = globus_list_remove(staging_list, *staging_list);
globus_rsl_value_free_recursive(info->from);
globus_rsl_value_free_recursive(info->to);
free(info->evaled_from);
free(info->evaled_to);
free(info);
}
}
void
globus_args_option_instance_list_free( globus_list_t ** list )
{
globus_args_option_instance_t * t;
while(!globus_list_empty(*list))
{
t = (globus_args_option_instance_t *)
globus_list_remove(list, *list);
globus_assert(t);
if (t->values)
free( t->values );
globus_free(t);
}
return;
}
void *
globus_fifo_remove(
globus_fifo_t * fifo,
void * datum)
{
globus_list_t * iter_prev;
globus_list_t * iter;
struct globus_fifo_s * s_fifo;
assert(fifo != GLOBUS_NULL);
s_fifo = *fifo;
assert(s_fifo != GLOBUS_NULL);
if(globus_list_empty(s_fifo->head))
return GLOBUS_NULL;
iter_prev = GLOBUS_NULL;
iter = s_fifo->head;
while((!globus_list_empty(iter))
&& (globus_list_first(iter) != datum))
{
iter_prev = iter;
iter = globus_list_rest(iter);
}
if(!globus_list_empty(iter))
{
/* iter is the element to remove, iter_prev is the previous */
if(iter == s_fifo->tail)
{
/* make sure tail doesn't dangle */
s_fifo->tail = iter_prev;
}
globus_list_remove (&(s_fifo->head), iter);
s_fifo->size--;
return datum;
}
else
{
return GLOBUS_NULL;
}
}
void
globus_i_gass_transfer_keyvalue_destroy(
globus_list_t ** list)
{
globus_list_t * tmp;
globus_gass_transfer_keyvalue_t * kv;
tmp = *list;
while(!globus_list_empty(tmp))
{
kv = globus_list_remove(list,
tmp);
tmp = *list;
globus_free(kv->key);
globus_free(kv->value);
globus_free(kv);
}
}
void
globus_usage_stats_handle_destroy(
globus_usage_stats_handle_t vhandle)
{
#ifndef TARGET_ARCH_ARM
globus_i_usage_stats_handle_t * handle =
(globus_i_usage_stats_handle_t *) vhandle;
if(handle)
{
if(handle->targets)
{
globus_list_destroy_all(handle->targets, globus_libc_free);
}
if(handle->xio_desc_list)
{
globus_xio_data_descriptor_t * dd;
while (!globus_list_empty (handle->xio_desc_list))
{
if((dd = globus_list_remove(
&handle->xio_desc_list, handle->xio_desc_list)) != NULL)
{
globus_xio_data_descriptor_destroy(*dd);
globus_free(dd);
}
}
}
if(handle->xio_handle)
{
globus_xio_close(handle->xio_handle, NULL);
}
globus_mutex_destroy(&handle->mutex);
globus_free(handle);
}
#endif
}
static
void
globus_l_gss_read_test_cases(char * filename)
{
int fd;
int rc;
struct stat st;
char * buffer;
char * line;
compare_name_test_case_t * test_case;
globus_list_t * rline_list = NULL;
static char name_type1[32], name_type2[32];
static char name_token1[128], name_token2[128];
static char expectation[16];
rc = stat(filename, &st);
if (rc != 0)
{
perror("stat");
exit(1);
}
buffer = malloc(st.st_size + 1);
if (buffer == NULL)
{
perror("malloc");
exit(1);
}
fd = open(filename, O_RDONLY, 0);
if (fd < 0)
{
perror("open");
exit(1);
}
rc = read(fd, buffer, st.st_size);
if (rc != st.st_size)
{
perror("read");
exit(1);
}
buffer[st.st_size] = '\0';
/* reversed order list */
rline_list = globus_list_from_string(buffer, '\n', " \t\r\n");
while (! globus_list_empty(rline_list))
{
line = globus_list_remove(&rline_list, rline_list);
if (strlen(line) != 0)
{
test_case = calloc(1, sizeof(compare_name_test_case_t));
sscanf(line, "%[^,], %[^,], %[^,], %[^,], %[^,]",
name_type1, name_token1,
name_type2, name_token2,
expectation);
test_case->test_name = strdup(line);
compare_l_parse_name_type(
name_type1, name_token1,
&test_case->name_type1, &test_case->name_token1);
compare_l_parse_name_type(
name_type2, name_token2,
&test_case->name_type2, &test_case->name_token2);
if (strcmp(expectation, "GLOBUS_TRUE") == 0)
{
test_case->expectation = GLOBUS_TRUE;
}
else if (strcmp(expectation, "GLOBUS_FALSE") == 0)
{
test_case->expectation = GLOBUS_FALSE;
}
else
{
globus_assert((strcmp(expectation, "GLOBUS_FALSE") == 0) ||
(strcmp(expectation, "GLOBUS_FALSE") == 0));
}
globus_list_insert(&test_cases, test_case);
}
free(line);
}
free(buffer);
}
/**
* Dereference a request handle.
*
* This function decreases the reference count on an GASS Transfer
* request handle. If the reference count becomes zero, then the
* #globus_gass_transfer_request_struct_t associated with the handle
* is destroyed.
*
* @note This function must be called with the request handle mutex locked.
*
* @param request
* The request to destroy.
*
* @retval GLOBUS_SUCCESS
* The request handle's reference count was decremented. The request
* structure is freed if this was the final reference to the handle.
* @retval GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE
* The request handle was not valid.
* @see globus_gass_transfer_request_destroy()
*/
int
globus_i_gass_transfer_request_destroy(
globus_gass_transfer_request_t request)
{
globus_bool_t referenced;
globus_gass_transfer_request_struct_t * req;
req =
globus_handle_table_lookup(&globus_i_gass_transfer_request_handles,
request);
if(req == GLOBUS_NULL)
{
return GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE;
}
referenced =
globus_handle_table_decrement_reference(&globus_i_gass_transfer_request_handles,
request);
if(!referenced)
{
int i;
globus_list_t * tmp;
tmp = globus_list_search(globus_i_gass_transfer_requests,
(void *) (intptr_t) request);
#if DEBUG_GASS_TRANSFER
printf(_GTSL("removing from list\n"));
#endif
if (tmp)
{
globus_list_remove(&globus_i_gass_transfer_requests,
tmp);
globus_cond_signal(&globus_i_gass_transfer_shutdown_cond);
if(req->attr)
{
globus_object_free(req->attr);
}
globus_fifo_destroy(&req->pending_data);
if (req->url)
{
globus_free(req->url);
}
/* free referral */
for(i = 0; i < req->referral_count; i++)
{
globus_free(req->referral_url[i]);
}
if(req->referral_url)
{
globus_free(req->referral_url);
}
req->referral_url = GLOBUS_NULL;
req->referral_count = 0;
/* free deny message */
if(req->denial_message)
{
globus_free(req->denial_message);
}
/* free subject name */
if(req->subject)
{
globus_free(req->subject);
}
globus_free(req);
request = GLOBUS_NULL_HANDLE;
}
return GLOBUS_SUCCESS;
}
else
{
return GLOBUS_SUCCESS;
}
}
static
globus_result_t
globus_l_xio_net_manager_attr_set_string_options(
globus_l_xio_net_manager_attr_t *attr,
const char *options_string)
{
globus_result_t result = GLOBUS_SUCCESS;
globus_list_t *options = NULL;
globus_list_t *rev_options;
int num_options;
globus_net_manager_attr_t *new_attrs;
globus_net_manager_context_t new_context = NULL;
char *scope = NULL;
char *new_task_id = NULL;
size_t attrnum = 0;
rev_options = globus_list_from_string(options_string, ';', NULL);
/* dislike that this func produces a reversed list */
while (!globus_list_empty(rev_options))
{
globus_list_insert(
&options, globus_list_remove(&rev_options, rev_options));
}
num_options = globus_list_size(options);
if (num_options == 0)
{
goto no_options;
}
new_attrs = calloc(num_options+1, sizeof(globus_net_manager_attr_t));
if (!new_attrs)
{
result = GlobusNetManagerErrorMemory("attr_array");
goto new_attrs_calloc_fail;
}
while (!globus_list_empty(options))
{
char *opt, *val;
opt = globus_list_remove(&options, options);
if (*opt == '\0')
{
free(opt);
continue;
}
val = strchr(opt, '=');
if (!val)
{
result = GlobusNetManagerErrorParameter("Invalid option string.");
free(opt);
goto no_equals;
}
*val++ = '\0';
if (strcmp(opt, "manager") == 0)
{
result = globus_net_manager_attr_init(
&new_attrs[attrnum++],
"net_manager",
opt,
val);
if (result)
{
free(opt);
new_attrs[attrnum-1] = globus_net_manager_null_attr;
goto new_attr_init_fail;
}
free(scope);
scope = strdup(val);
if (!scope)
{
result = GlobusNetManagerErrorMemory("scope");
free(opt);
new_attrs[attrnum++] = globus_net_manager_null_attr;
goto strdup_scope_fail;
}
}
else if (strcmp(opt, "task-id") == 0)
{
free(new_task_id);
new_task_id = strdup(val);
if (!new_task_id)
{
result = GlobusNetManagerErrorMemory("task-id");
free(opt);
new_attrs[attrnum++] = globus_net_manager_null_attr;
goto strdup_task_id_fail;
}
}
else
{
result = globus_net_manager_attr_init(
&new_attrs[attrnum++],
scope ? scope : "global",
opt,
val);
if (result)
{
free(opt);
new_attrs[attrnum-1] = globus_net_manager_null_attr;
goto new_attr_init_fail;
}
}
free(opt);
}
new_attrs[attrnum++] = globus_net_manager_null_attr;
if (new_attrs)
{
result = globus_net_manager_context_init(
&new_context,
new_attrs);
if (result)
{
goto new_context_fail;
}
globus_net_manager_context_destroy(attr->context);
attr->context = new_context;
}
if (new_task_id)
{
free(attr->task_id);
attr->task_id = new_task_id;
new_task_id = NULL;
}
if (new_attrs)
{
globus_net_manager_attr_array_delete(attr->attr_array);
attr->attr_array = new_attrs;
new_attrs = NULL;
}
new_context_fail:
new_attr_init_fail:
strdup_task_id_fail:
strdup_scope_fail:
no_equals:
free(new_task_id);
free(scope);
globus_net_manager_attr_array_delete(new_attrs);
new_attrs_calloc_fail:
globus_list_destroy_all(options, free);
no_options:
return result;
}
/* STRING PARSING ATTR SETTING */
globus_result_t
globus_i_xio_string_cntl_parser(
const char * env_str,
globus_xio_string_cntl_table_t * table,
void * attr,
globus_xio_driver_attr_cntl_t cntl_func)
{
int i;
char * key;
char * val;
char * tmp_s;
globus_list_t * list;
globus_object_t * error = NULL;
globus_result_t res = GLOBUS_SUCCESS;
GlobusXIOName(globus_i_xio_string_cntl_parser);
list = globus_list_from_string(env_str, ';', NULL);
while(!globus_list_empty(list))
{
key = (char *) globus_list_remove(&list, list);
tmp_s = strchr(key, '=');
if(tmp_s != NULL)
{
*tmp_s = '\0';
val = tmp_s + 1;
for(i = 0; table[i].key != NULL; i++)
{
/* if we have a match */
if(strcmp(table[i].key, key) == 0)
{
res = table[i].parse_func(
attr, key, val, table[i].cmd, cntl_func);
if(res != GLOBUS_SUCCESS)
{
/* restore '=' */
*tmp_s = '=';
res = GlobusXIOErrorWrapFailedWithMessage(
res, "String cntl '%s' failed", key);
}
break;
}
}
if(!table[i].key)
{
res = GlobusXIOErrorParameter(key);
}
}
else
{
res = GlobusXIOErrorParameter(key);
}
if(res != GLOBUS_SUCCESS)
{
if(!error)
{
error = globus_error_construct_multiple(
GLOBUS_XIO_MODULE,
GLOBUS_XIO_ERROR_PARAMETER,
"One or more of the string cntls failed");
}
globus_error_mutliple_add_chain(
error, globus_error_get(res), NULL);
}
globus_free(key);
}
return globus_error_put(error);
}
int
globus_gram_job_manager_staging_remove(
globus_gram_jobmanager_request_t * request,
globus_gram_job_manager_staging_type_t
type,
char * from,
char * to)
{
globus_gram_job_manager_staging_info_t
query;
globus_gram_job_manager_staging_info_t *
item;
globus_list_t ** list;
globus_list_t * node;
const char * typestr = "";
switch(type)
{
case GLOBUS_GRAM_JOB_MANAGER_STAGE_IN:
typestr = "file_stage_in";
break;
case GLOBUS_GRAM_JOB_MANAGER_STAGE_IN_SHARED:
typestr = "file_stage_in_shared";
break;
case GLOBUS_GRAM_JOB_MANAGER_STAGE_OUT:
typestr = "file_stage_out";
break;
case GLOBUS_GRAM_JOB_MANAGER_STAGE_STREAMS:
typestr = "file_stream_out";
break;
}
globus_gram_job_manager_request_log(
request,
GLOBUS_GRAM_JOB_MANAGER_LOG_DEBUG,
"event=gram.staging_remove.start "
"level=DEBUG "
"gramid=%s "
"src=\"%s\" "
"dst=\"%s\" "
"type=%s "
"\n",
request->job_contact_path,
from,
to,
typestr);
query.evaled_from = from;
query.evaled_to = to;
query.type = type;
switch(type)
{
case GLOBUS_GRAM_JOB_MANAGER_STAGE_IN:
list = &request->stage_in_todo;
break;
case GLOBUS_GRAM_JOB_MANAGER_STAGE_IN_SHARED:
list = &request->stage_in_shared_todo;
break;
case GLOBUS_GRAM_JOB_MANAGER_STAGE_OUT:
list = &request->stage_out_todo;
break;
case GLOBUS_GRAM_JOB_MANAGER_STAGE_STREAMS:
list = &request->stage_stream_todo;
break;
}
node = globus_list_search_pred(
*list,
globus_l_gram_job_manager_staging_match,
&query);
if(node)
{
item = globus_list_remove(list, node);
globus_gram_job_manager_request_log(
request,
GLOBUS_GRAM_JOB_MANAGER_LOG_TRACE,
"event=gram.staging_remove.end "
"level=TRACE "
"gramid=%s "
"msg=\"%s\" "
"src=\"%s\" "
"dst=\"%s\" "
"type=%s "
"status=%d "
"\n",
request->job_contact_path,
"File staged",
from,
to,
typestr,
0);
if (item->type == GLOBUS_GRAM_JOB_MANAGER_STAGE_IN)
{
if (strncmp(item->evaled_from, "http://", 7) == 0)
{
request->job_stats.file_stage_in_http_count++;
}
else if (strncmp(item->evaled_from, "https://", 8) == 0)
{
request->job_stats.file_stage_in_https_count++;
}
else if (strncmp(item->evaled_from, "ftp://", 6) == 0)
{
request->job_stats.file_stage_in_ftp_count++;
}
else if (strncmp(item->evaled_from, "gsiftp://", 6) == 0)
{
request->job_stats.file_stage_in_gsiftp_count++;
}
}
else if (item->type == GLOBUS_GRAM_JOB_MANAGER_STAGE_IN_SHARED)
{
if (strncmp(item->evaled_from, "http://", 7) == 0)
{
request->job_stats.file_stage_in_shared_http_count++;
}
else if (strncmp(item->evaled_from, "https://", 8) == 0)
{
request->job_stats.file_stage_in_shared_https_count++;
}
else if (strncmp(item->evaled_from, "ftp://", 6) == 0)
{
request->job_stats.file_stage_in_shared_ftp_count++;
}
else if (strncmp(item->evaled_from, "gsiftp://", 6) == 0)
{
request->job_stats.file_stage_in_shared_gsiftp_count++;
}
}
else if (item->type == GLOBUS_GRAM_JOB_MANAGER_STAGE_OUT ||
item->type == GLOBUS_GRAM_JOB_MANAGER_STAGE_STREAMS)
{
if (strncmp(item->evaled_to, "http://", 7) == 0)
{
request->job_stats.file_stage_out_http_count++;
}
else if (strncmp(item->evaled_to, "https://", 8) == 0)
{
request->job_stats.file_stage_out_https_count++;
}
else if (strncmp(item->evaled_to, "ftp://", 6) == 0)
{
request->job_stats.file_stage_out_ftp_count++;
}
else if (strncmp(item->evaled_to, "gsiftp://", 6) == 0)
{
request->job_stats.file_stage_out_gsiftp_count++;
}
}
globus_rsl_value_free_recursive(item->from);
globus_rsl_value_free_recursive(item->to);
free(item->evaled_from);
free(item->evaled_to);
free(item);
}
else
{
globus_gram_job_manager_request_log(
request,
GLOBUS_GRAM_JOB_MANAGER_LOG_WARN,
"event=gram.staging_remove.end "
"level=WARN "
"gramid=%s "
"msg=\"%s\" "
"src=\"%s\" "
"dst=\"%s\" "
"type=%s "
"status=%d "
"msg=\"%s\" "
"\n",
request->job_contact_path,
"File staged",
from,
to,
typestr,
0,
"Unexpected staging completion");
}
return GLOBUS_SUCCESS;
}
/* driver list stuff */
globus_result_t
globus_xio_driver_list_from_string(
char * driver_string,
globus_list_t ** driver_list,
globus_hashtable_t * safe_table)
{
globus_result_t result;
globus_bool_t done = GLOBUS_FALSE;
globus_bool_t loaded;
char * opts;
char * ptr;
char * driver_str;
char * driver_name;
char * tmp_str;
globus_xio_driver_t driver;
globus_list_t * list = NULL;
globus_xio_driver_list_ent_t * list_ent;
GlobusXIOName(globus_xio_driver_list_from_string);
*driver_list = NULL;
if(driver_string == NULL)
{
result = GlobusXIOErrorParameter("driver_string");
goto error_param;
}
driver_str = globus_libc_strdup(driver_string);
tmp_str = driver_str;
while(!done)
{
loaded = GLOBUS_FALSE;
driver_name = tmp_str;
ptr = strchr(driver_name, ',');
if(ptr != NULL)
{
*ptr = '\0';
tmp_str = ptr+1;
}
else
{
done = GLOBUS_TRUE;
}
opts = strchr(driver_name, ':');
if(opts != NULL)
{
*opts = '\0';
opts++;
/* decode the string */
globus_url_string_hex_decode(opts);
}
/* check against the safe list */
if(safe_table != NULL)
{
char * err_str;
list_ent = (globus_xio_driver_list_ent_t *)
globus_hashtable_lookup(safe_table, driver_name);
if(list_ent == NULL)
{
err_str = globus_common_create_string(
"%s driver not whitelisted", driver_name);
result = GlobusXIOErrorParameter(err_str);
globus_free(err_str);
goto error_load;
}
driver = list_ent->driver;
}
else
{
result = globus_xio_driver_load(driver_name, &driver);
if(result != GLOBUS_SUCCESS)
{
goto error_load;
}
loaded = GLOBUS_TRUE;
}
list_ent = (globus_xio_driver_list_ent_t *)
globus_calloc(1, sizeof(globus_xio_driver_list_ent_t));
list_ent->opts = globus_libc_strdup(opts);
list_ent->driver = driver;
list_ent->driver_name = globus_libc_strdup(driver_name);
list_ent->loaded = loaded;
globus_list_insert(&list, list_ent);
}
globus_free(driver_str);
/* reverse list */
while(!globus_list_empty(list))
{
globus_list_insert(driver_list, globus_list_first(list));
globus_list_remove(&list, list);
}
return GLOBUS_SUCCESS;
error_load:
globus_free(driver_str);
while(!globus_list_empty(list))
{
list_ent = (globus_xio_driver_list_ent_t *)
globus_list_remove(&list, list);
if(list_ent->loaded)
{
globus_xio_driver_unload(list_ent->driver);
}
globus_free(list_ent->driver_name);
if(list_ent->opts != NULL)
{
globus_free(list_ent->opts);
}
globus_free(list_ent);
}
error_param:
return result;
}
globus_result_t
globus_xio_attr_destroy(
globus_xio_attr_t attr)
{
int ctr;
globus_result_t res = GLOBUS_SUCCESS;
globus_result_t tmp_res;
GlobusXIOName(globus_xio_attr_destroy);
GlobusXIODebugEnter();
if(attr == NULL)
{
res = GlobusXIOErrorParameter("attr");
goto err;
}
globus_mutex_lock(&globus_i_xio_mutex);
{
if(!attr->unloaded)
{
for(ctr = 0; ctr < attr->ndx; ctr++)
{
GlobusXIODebugPrintf(
GLOBUS_XIO_DEBUG_INFO_VERBOSE,
(_XIOSL("[globus_xio_attr_destroy]: destroying attr @0x%x "
"driver @0x%x, %s\n"),
attr,
attr->entry[ctr].driver,
attr->entry[ctr].driver->name));
/* report the last seen error but be sure to attempt to clean
them all */
tmp_res = attr->entry[ctr].driver->attr_destroy_func(
attr->entry[ctr].driver_data);
if(tmp_res != GLOBUS_SUCCESS)
{
res = tmp_res;
}
}
globus_list_remove(
&globus_i_xio_outstanding_attrs_list,
globus_list_search(
globus_i_xio_outstanding_attrs_list, attr));
}
}
globus_mutex_unlock(&globus_i_xio_mutex);
if(attr->user_open_sbj)
{
globus_free(attr->user_open_sbj);
}
if(attr->user_open_username)
{
globus_free(attr->user_open_username);
}
if(attr->user_open_pw)
{
globus_free(attr->user_open_pw);
}
globus_callback_space_destroy(attr->space);
globus_free(attr->entry);
globus_free(attr);
if(res != GLOBUS_SUCCESS)
{
goto err;
}
GlobusXIODebugExit();
return GLOBUS_SUCCESS;
err:
GlobusXIODebugExitWithError();
return res;
}
/** @brief Globus List Test Cases*/
int
list_test(void)
{
globus_list_t *list = GLOBUS_NULL;
int rc;
void *ptr;
int x1 = 1;
int x2 = 2;
int x3 = 3;
int x4 = 4;
int search_item;
globus_list_t *sub_list;
int size;
printf("1..25\n");
globus_module_activate(GLOBUS_COMMON_MODULE);
/**
* @test
* Call globus_list_size() with an empty list
*/
size = globus_list_size(list);
ok(size == 0, "size_of_empty_list");
/**
* @test
* Insert a datum into a globus_list_t with globus_list_insert()
*/
rc = globus_list_insert(&list, &x1);
ok(rc == 0, "insert_item_into_empty_list");
/**
* @test
* Add a datum to a globus_list_t with globus_list_cons()
*/
list = globus_list_cons(&x2, list);
ok(list != NULL, "globus_list_cons");
/**
* @test
* Verify that globus_list_size() returns 2 after adding two data
* items to a list.
*/
size = globus_list_size(list);
ok(size == 2, "size_of_list_after_insert_and_cons");
/**
* @test
* Insert x3 into a list with globus_list_insert()
*/
ok(globus_list_insert(&list, &x3) == 0, "insert_x3");
/**
* @test
* Insert x4 into a list with globus_list_insert()
*/
ok(globus_list_insert(&list, &x4) == 0, "insert_x4");
/**
* @test
* Verify that the size of the list is now 4 with globus_list_size()
*/
ok(globus_list_size(list) == 4, "check_new_size");
/**
* @test
* Search for the first item in a list with globus_list_search()
*/
sub_list = globus_list_search(list, &x1);
ok(sub_list != NULL, "search_first");
/**
* @test
* Use globus_list_first() to return the datum from the returned list node.
* Verify that the search result matches the value searched for.
*/
ptr = globus_list_first(sub_list);
ok(*((int *)ptr) == x1, "search_first_value");
/**
* @test
* Search for the third item in a list with globus_list_search()
*/
sub_list = globus_list_search(list, &x3);
ok(sub_list != NULL, "search_third");
/**
* @test
* Use globus_list_first() to return the datum from the returned list node.
* Verify that the search result matches the value searched for.
*/
ptr = globus_list_first(sub_list);
ok(*((int *)ptr) == x3, "search_third_value");
/**
* @test
* Search for the fourth item in a list with globus_list_search()
*/
sub_list = globus_list_search(list, &x4);
ok(sub_list != NULL, "search_last");
/**
* @test
* Use globus_list_first() to return the datum from the returned list node.
* Verify that the search result matches the value searched for.
*/
ptr = globus_list_first(sub_list);
ok(*((int *)ptr) == x4, "search_last_value");
/**
* @test
* Search for the second item in a list with globus_list_search()
*/
sub_list = globus_list_search(list, &x2);
ok(sub_list != NULL, "search_second");
/**
* @test
* Use globus_list_first() to return the datum from the returned list node.
* Verify that the search result matches the value searched for.
*/
ptr = globus_list_first(sub_list);
ok(*((int *)ptr) == x2, "search_second_value");
/**
* @test
* Search for the fourth item in a list with globus_list_search_pred()
*/
search_item = 4;
sub_list = globus_list_search_pred(list, matches, &search_item);
ok(sub_list != NULL, "search_pred_4");
/**
* @test
* Search for the second item in a list with globus_list_search_pred()
*/
search_item = 2;
sub_list = globus_list_search_pred(list, matches, &search_item);
ok(sub_list != NULL, "search_pred_2");
/**
* @test
* Search for the third item in a list with globus_list_search_pred()
*/
search_item = 3;
sub_list = globus_list_search_pred(list, matches, &search_item);
ok(sub_list != NULL, "search_pred_3");
/**
* @test
* Search for the first item in a list with globus_list_search_pred()
*/
search_item = 1;
sub_list = globus_list_search_pred(list, matches, &search_item);
ok(sub_list != NULL, "search_pred_1");
/**
* @test
* Search for the second item in the list with globus_list_search()
*/
sub_list = globus_list_search(list, &x2);
ok(sub_list != NULL, "search_2");
/**
* @test
* Remove the second item in the list with globus_list_remove()
*/
ok(globus_list_remove(&list, sub_list) == &x2, "remove_2");
/**
* @test
* Remove the first item in the list with globus_list_remove()
*/
ok(globus_list_remove(&list, list) == &x4, "remove_first");
/**
* @test
* Remove the first item in the list with globus_list_remove()
*/
ok(globus_list_remove(&list, list) == &x3, "remove_first_again");
/**
* @test
* Remove the first item in the list with globus_list_remove()
*/
ok(globus_list_remove(&list, list) == &x1, "remove_first_again");
/**
* @test
* Verify that the list is empty with globus_list_empty()
*/
ok(globus_list_empty(list), "empty_list");
globus_list_free(list);
globus_module_deactivate(GLOBUS_COMMON_MODULE);
return TEST_EXIT_CODE;
}
globus_result_t
globus_xio_data_descriptor_destroy(
globus_xio_data_descriptor_t data_desc)
{
globus_result_t res = GLOBUS_SUCCESS;
globus_i_xio_op_t * op;
globus_i_xio_handle_t * handle;
globus_bool_t destroy_handle = GLOBUS_FALSE;
globus_list_t * node;
GlobusXIOName(globus_xio_data_descriptor_destroy);
GlobusXIODebugEnter();
if(data_desc == NULL)
{
res = GlobusXIOErrorParameter("data_desc");
goto err;
}
op = (globus_i_xio_op_t *) data_desc;
globus_mutex_lock(&globus_i_xio_mutex);
{
/* make sure we haven't destroyed it already */
node = globus_list_search(globus_i_xio_outstanding_dds_list, op);
if(node)
{
globus_list_remove(&globus_i_xio_outstanding_dds_list, node);
}
}
globus_mutex_unlock(&globus_i_xio_mutex);
if(node == NULL)
{
res = GlobusXIOErrorParameter("data_desc already destroyed");
goto err;
}
handle = op->_op_handle;
globus_mutex_lock(&handle->context->mutex);
{
GlobusXIOOpDec(op);
if(op->ref == 0)
{
globus_i_xio_op_destroy(op, &destroy_handle);
}
}
globus_mutex_unlock(&handle->context->mutex);
if(destroy_handle)
{
globus_i_xio_handle_destroy(handle);
}
GlobusXIODebugExit();
return GLOBUS_SUCCESS;
err:
GlobusXIODebugExitWithError();
return res;
}
globus_result_t
globus_gridftp_server_control_attr_destroy(
globus_gridftp_server_control_attr_t in_attr)
{
globus_i_gsc_module_func_t * mod_func;
globus_list_t * list;
globus_i_gsc_attr_t * attr;
globus_result_t res;
GlobusGridFTPServerName(globus_gridftp_server_control_attr_destroy);
GlobusGridFTPServerDebugEnter();
if(in_attr == NULL)
{
res = GlobusGridFTPServerErrorParameter("in_attr");
goto err;
}
attr = in_attr;
if(attr->version_ctl != GLOBUS_GRIDFTP_VERSION_CTL)
{
res = GlobusGridFTPServerErrorParameter("in_attr");
goto err;
}
if(attr->pre_auth_banner != NULL)
{
globus_free(attr->pre_auth_banner);
}
if(attr->post_auth_banner != NULL)
{
globus_free(attr->post_auth_banner);
}
globus_hashtable_to_list(&attr->funcs.recv_cb_table, &list);
while(!globus_list_empty(list))
{
mod_func = (globus_i_gsc_module_func_t *)
globus_list_remove(&list, list);
globus_free(mod_func->key);
globus_free(mod_func);
}
globus_hashtable_to_list(&attr->funcs.send_cb_table, &list);
while(!globus_list_empty(list))
{
mod_func = (globus_i_gsc_module_func_t *)
globus_list_remove(&list, list);
globus_free(mod_func->key);
globus_free(mod_func);
}
globus_hashtable_destroy(&attr->funcs.send_cb_table);
globus_hashtable_destroy(&attr->funcs.recv_cb_table);
globus_free(attr->base_dir);
globus_free(attr->modes);
globus_free(attr->types);
globus_free(attr);
GlobusGridFTPServerDebugExit();
return GLOBUS_SUCCESS;
err:
GlobusGridFTPServerDebugExitWithError();
return res;
}
