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; }