/* Check that using globus_gram_client_get_jobmanager_version() to talk * to the resource management contact specified on the command line yields * a response that can be parsed out to include the version and toolkit-version * attributes. */ static int version_test(void) { int rc; globus_gram_protocol_extension_t * extension; globus_hashtable_t extensions; rc = globus_gram_client_get_jobmanager_version( rm_contact, &extensions); test_assert( rc == GLOBUS_SUCCESS, ("globus_gram_client_get_jobmanager_version() failed: %d (%s)", rc, globus_gram_protocol_error_string(rc))); extension = globus_hashtable_lookup(&extensions, "toolkit-version"); test_assert( extension != NULL, ("toolkit-version attribute not present in response")); extension = globus_hashtable_lookup(&extensions, "version"); test_assert( extension != NULL, ("version attribute not present in response")); globus_gram_protocol_hash_destroy(&extensions); return rc; }
void globus_i_module_dump( FILE * out_f) { globus_list_t * module_list; globus_libc_fprintf(out_f, "==========\nModule List\n----------\n"); module_list = globus_l_module_list; while(!globus_list_empty(module_list)) { globus_list_t * client_list; globus_l_module_entry_t * module_entry; module_entry = globus_list_first(module_list); module_list = globus_list_rest(module_list); globus_libc_fprintf(out_f, "%s; cnt=%d", module_entry->descriptor->module_name, module_entry->reference_count); client_list = module_entry->clients; if (!globus_list_empty(client_list)) { void * client_entry; globus_l_module_entry_t * client_module_entry; client_entry = globus_list_first(client_list); client_list = globus_list_rest(client_list); client_module_entry = globus_hashtable_lookup(&globus_l_module_table, client_entry); globus_libc_fprintf(out_f, "; clients=%s", client_module_entry->descriptor->module_name); while(!globus_list_empty(client_list)) { client_entry = globus_list_first(client_list); client_list = globus_list_rest(client_list); client_module_entry = globus_hashtable_lookup(&globus_l_module_table, client_entry); globus_libc_fprintf(out_f, ",%s", client_module_entry->descriptor->module_name); } } globus_libc_fprintf(out_f, "\n"); } globus_libc_fprintf(out_f, "==========\n"); }
/* * 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; }
void gw_em_mad_poll_callback(void *arg, const char * job_contact, globus_gram_client_job_info_t *job_info) { globus_gram_protocol_extension_t *entry; int *jid; jid = (int *) arg; if (job_info->protocol_error_code == GLOBUS_SUCCESS) { if (job_info->job_state == GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE) if (job_info->extensions) { entry = globus_hashtable_lookup(&job_info->extensions, "exit-code"); if (entry != NULL) printf("POLL %d SUCCESS DONE:%s\n", *jid, entry->value); else printf("POLL %d SUCCESS DONE\n", *jid); } else printf("POLL %d SUCCESS DONE\n", *jid); else printf("POLL %d SUCCESS %s\n", *jid, get_job_state_name(job_info->job_state)); } else printf("POLL %d FAILURE %s (%i)\n", *jid, globus_gram_client_error_string(job_info->protocol_error_code), job_info->protocol_error_code); free(jid); }
void * globus_extension_registry_remove( globus_extension_registry_t * registry, void * symbol) { globus_l_extension_handle_t * entry; void * datum = NULL; GlobusFuncName(globus_extension_registry_remove); GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol); globus_rmutex_lock(&globus_l_extension_mutex); { if(registry->initialized) { entry = (globus_l_extension_handle_t *) globus_hashtable_lookup(®istry->table, (void *) symbol); if(entry && entry->datum) { datum = entry->datum; globus_hashtable_remove(®istry->table, (void *) symbol); if(--entry->ref == 0) { globus_free(entry); } } } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return datum; }
/* * Test case: * * PURPOSE: * Check that * globus_gram_protocol_unpack_message() * correctly unpacks standard GRAM2 messages * * STEPS: * - Creates a message using server-side API. * - Parses message to hash. * - Verifies that all attributes we expect in the message are present in * the parsed values. * - Verifies that the number of attributes in the message match the count * of ones we expect. */ static int unpack_test(void) { globus_byte_t * message; globus_size_t message_size; globus_hashtable_t hashtable; globus_gram_protocol_extension_t * entry; int rc; char * expected[] = { "protocol-version", "job-manager-url", "status", "failure-code" }; int i; rc = globus_gram_protocol_pack_status_update_message( job_id, GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE, 0, &message, &message_size); test_assert( rc == GLOBUS_SUCCESS, ("# Error constructing test message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); rc = globus_gram_protocol_unpack_message( message, message_size, &hashtable); test_assert( rc == GLOBUS_SUCCESS, ("# Error parsing test message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); /* check that expected attributes were parsed */ for (i = 0; i < ARRAY_LEN(expected); i++) { entry = globus_hashtable_lookup(&hashtable, expected[i]); test_assert( entry != NULL, ("# Missing expected attribute %s\n", expected[i])); } test_assert(ARRAY_LEN(expected) == globus_hashtable_size(&hashtable), ("# Hash table contains %d entries, expected %d", globus_hashtable_size(&hashtable), ARRAY_LEN(expected))); globus_gram_protocol_hash_destroy(&hashtable); free(message); return 0; }
/* * Test case: * * PURPOSE: * Check that * globus_gram_protocol_unpack_job_request_reply_with_extensions() * correctly unpacks standard GRAM2 messages * * STEPS: * - Creates a message using server-side API. * - Parses message to extensions hash. * - Verifies that all attributes we expect in the message are present in * the parsed values. * - Verifies that the number of attributes in the message match the count * of ones we expect. */ int test_unpack_with_extensions(void) { globus_byte_t * message; globus_size_t message_size; globus_hashtable_t hashtable; globus_gram_protocol_extension_t * entry; int rc; char * expected[] = { "protocol-version", "status", "job-manager-url", }; int status; char * job_contact; int i; rc = globus_gram_protocol_pack_job_request_reply( GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE, "https://example.org:123/1/2/", &message, &message_size); test_assert( rc == GLOBUS_SUCCESS, ("Error constructing test message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); rc = globus_gram_protocol_unpack_job_request_reply_with_extensions( message, message_size, &status, &job_contact, &hashtable); test_assert( rc == GLOBUS_SUCCESS, ("Error parsing test message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); /* check that expected attributes were parsed */ for (i = 0; i < ARRAY_LEN(expected); i++) { entry = globus_hashtable_lookup(&hashtable, expected[i]); test_assert( entry != NULL, ("Missing expected attribute %s\n", expected[i])); } test_assert(ARRAY_LEN(expected) == globus_hashtable_size(&hashtable), ("Hash table contains %d entries, expected %d", globus_hashtable_size(&hashtable), ARRAY_LEN(expected))); globus_gram_protocol_hash_destroy(&hashtable); free(message); return 0; }
char * globus_module_getenv( const char * name) { char * entry; if((globus_l_environ_initialized == GLOBUS_TRUE)) { if((globus_i_module_initialized == GLOBUS_TRUE) &&(globus_l_environ_mutex_initialized == GLOBUS_TRUE)) { globus_mutex_lock(&globus_l_environ_hashtable_mutex); } entry = globus_hashtable_lookup( &globus_l_environ_table, (void *) name); if((globus_i_module_initialized == GLOBUS_TRUE) &&(globus_l_environ_mutex_initialized == GLOBUS_TRUE)) { globus_mutex_unlock(&globus_l_environ_hashtable_mutex); } } else { entry=GLOBUS_NULL; } /* * If we have found an entry, return it */ if (entry!=GLOBUS_NULL) { return(entry); } /* * otherwise check system environment */ entry=getenv(name); if (entry!=NULL) { return(entry); } return(GLOBUS_NULL); }
int globus_extension_deactivate( const char * extension_name) { globus_l_extension_module_t * extension; globus_l_extension_module_t * owner = NULL; GlobusFuncName(globus_extension_deactivate); GlobusExtensionDebugEnterSymbol(extension_name); if(!extension_name) { goto error_param; } globus_rmutex_lock(&globus_l_extension_mutex); { extension = (globus_l_extension_module_t *) globus_hashtable_lookup( &globus_l_extension_loaded, (void *) extension_name); if(!extension || extension->module_ref <= 0) { goto error_lookup; } extension->module_ref--; if(--extension->ref == 0) { if(extension->owner && --extension->owner->ref == 0) { owner = extension->owner; } globus_l_extension_shutdown_extension(extension, GLOBUS_FALSE); if(owner) { globus_l_extension_shutdown_extension(owner, GLOBUS_FALSE); } } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return GLOBUS_SUCCESS; error_lookup: globus_rmutex_unlock(&globus_l_extension_mutex); error_param: GlobusExtensionDebugExitWithError(); return GLOBUS_FAILURE; }
static int globus_l_module_reference_count( globus_module_descriptor_t * module_descriptor) { 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 0; } else { return entry->reference_count; } }
/** * Unregister protocol. * @ingroup globus_gass_transfer_protocol * * This function unregisters a protocol module handler from the GASS Transfer * library. If this succeeds, then users of the library may no longer * user URLs with the protocol scheme implemented by this module descriptor * in GASS Transfer operations. * * @param proto_desc * The protocol module descriptor. See the "@ref * globus_gass_transfer_protocol" section of the manual for information * on this structure. * * @retval GLOBUS_SUCCESS * The protocol module was successfully registered with GASS. * @retval GLOBUS_GASS_TRANSFER_ERROR_NULL_POINTER * The @a proto_desc parameter was @a GLOBUS_NULL. * @retval GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE * A protocol module has not been registered with GASS to * handle this URL scheme. */ int globus_gass_transfer_proto_unregister_protocol( globus_gass_transfer_proto_descriptor_t * proto_desc) { globus_gass_transfer_proto_descriptor_t * tmp; if(proto_desc == GLOBUS_NULL) { return GLOBUS_GASS_TRANSFER_ERROR_NULL_POINTER; } tmp = globus_hashtable_lookup(&globus_i_gass_transfer_protocols, proto_desc->url_scheme); if(tmp) { tmp = globus_hashtable_remove(&globus_i_gass_transfer_protocols, proto_desc->url_scheme); return GLOBUS_SUCCESS; } else { return GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE; } }
/* 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_l_module_increment() */ static globus_bool_t globus_l_module_increment( globus_module_descriptor_t * module_descriptor, globus_l_module_key_t parent_key, globus_module_deactivate_proxy_cb_t deactivate_cb, void * user_arg) { globus_l_module_entry_t * entry; entry = globus_hashtable_lookup( &globus_l_module_table, (void *) module_descriptor->activation_func); if (entry != GLOBUS_NULL) { /* * The module has already been registered. Increment its reference * counter and add any new clients to the dependency list */ entry->reference_count++; if (parent_key != GLOBUS_NULL && globus_list_search(entry->clients, (void *) parent_key) == GLOBUS_NULL) { globus_list_insert(&entry->clients, (void *) parent_key); } if(entry->reference_count == 1) { entry->deactivate_cb = deactivate_cb; entry->user_arg = user_arg; return GLOBUS_TRUE; } else { return GLOBUS_FALSE; } } else { /* * This is the first time this module has been registered. Create a * new entry in the modules table. */ entry = (globus_l_module_entry_t *) globus_malloc(sizeof(globus_l_module_entry_t)); globus_assert(entry != GLOBUS_NULL); entry->descriptor = module_descriptor; entry->reference_count = 1; entry->clients = GLOBUS_NULL; entry->deactivate_cb = deactivate_cb; entry->user_arg = user_arg; if (parent_key != GLOBUS_NULL) { globus_list_insert(&entry->clients, (void *) parent_key); } globus_hashtable_insert( &globus_l_module_table, (void *) module_descriptor->activation_func, entry); globus_list_insert(&globus_l_module_list, entry); return GLOBUS_TRUE; } }
void gw_em_mad_state_callback(void *arg, const char *job_contact, globus_gram_client_job_info_t *job_info) { globus_gram_protocol_extension_t *entry; int jid = -1; int done = 0; int job_state; jid = get_jid(job_contact); if (jid == -1) { return; } job_state = job_info->job_state; switch (job_state) { case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING: printf("CALLBACK %d SUCCESS PENDING\n", jid); if (job_pool.cancel_state[jid] == 1) { globus_gram_client_job_cancel(job_contact); job_pool.cancel_state[jid] = 0; } break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_SUSPENDED: printf("CALLBACK %d SUCCESS SUSPENDED\n", jid); if (job_pool.cancel_state[jid] == 1) { globus_gram_client_job_cancel(job_contact); job_pool.cancel_state[jid] = 0; } break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE: printf("CALLBACK %d SUCCESS ACTIVE\n", jid); if (job_pool.cancel_state[jid] == 1) { globus_gram_client_job_cancel(job_contact); job_pool.cancel_state[jid] = 0; } break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED: if (job_info->protocol_error_code == GLOBUS_GRAM_PROTOCOL_ERROR_USER_CANCELLED ) printf("CALLBACK %d SUCCESS FAILED\n", jid); else printf("CALLBACK %d FAILURE %s (error %d)\n", jid, globus_gram_client_error_string(job_info->protocol_error_code), job_info->protocol_error_code); done = 1; job_pool.cancel_state[jid] = 0; break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE: if (job_info->extensions) { entry = globus_hashtable_lookup(&job_info->extensions, "exit-code"); if (entry != NULL) printf("CALLBACK %d SUCCESS DONE:%s\n", jid, entry->value); else printf("CALLBACK %d SUCCESS DONE\n", jid); } else printf("CALLBACK %d SUCCESS DONE\n", jid); done = 1; job_pool.cancel_state[jid] = 0; break; } if (done && (jid != -1)) del_job(jid); }
/* * globus_l_gass_cache_config_get() * * Retrieves a config entry * * Parameters: * - config the config structure * - key the config parameter * * Returns: * the value associated with 'key', or GLOBUS_NULL */ char* globus_l_gass_cache_config_get(globus_l_gass_cache_config_t *config, char* key) { return globus_hashtable_lookup(&config->table, key); }
/** * Set the value of a header in a hashtable * @ingroup globus_i_xio_http_header * * Adds a new header to a header info structure, or updates the value of an * existing header. Copies of the name and value will be stored in a * #globus_xio_http_header_t in a hashtable in the header info structure. * * @param headers * Pointer to the header info structure. * @param header_name * Name of the header. * @param header_value * Value of the header. * * @retval GLOBUS_SUCCESS * Header successfully added to the hashtable. * @retval GLOBUS_XIO_ERROR_MEMORY * Unable to add header due to memory constraints. */ globus_result_t globus_i_xio_http_header_info_set_header( globus_i_xio_http_header_info_t * headers, const char * header_name, const char * header_value) { char * save_header; globus_result_t result = GLOBUS_SUCCESS; globus_xio_http_header_t * header; int rc; unsigned long length; GlobusXIOName(globus_l_xio_http_header_set); /* Special cases for entity-body handling headers */ if (strcmp(header_name, "Content-Length") == 0) { rc = sscanf(header_value, "%lu", &length); if (rc < 1) { result = GlobusXIOHttpErrorInvalidHeader(header_name, header_value); goto error_exit; } headers->content_length = length; headers->flags |= GLOBUS_I_XIO_HTTP_HEADER_CONTENT_LENGTH_SET; } else if (strcmp(header_name, "Transfer-Encoding") == 0) { if (strcmp(header_value, "identity") == 0) { headers->transfer_encoding = GLOBUS_XIO_HTTP_TRANSFER_ENCODING_IDENTITY; } else if (strcmp(header_value, "chunked") == 0) { headers->transfer_encoding = GLOBUS_XIO_HTTP_TRANSFER_ENCODING_CHUNKED; } else { result = GlobusXIOHttpErrorInvalidHeader(header_name, header_value); goto error_exit; } } else if (strcmp(header_name, "Connection") == 0) { if (strcmp(header_value, "close") == 0) { headers->flags |= GLOBUS_I_XIO_HTTP_HEADER_CONNECTION_CLOSE; } else if (strcmp(header_value, "keep-alive") == 0) { headers->flags &= ~GLOBUS_I_XIO_HTTP_HEADER_CONNECTION_CLOSE; } else { result = GlobusXIOHttpErrorInvalidHeader(header_name, header_value); goto error_exit; } } else { /* * Either modify the header's value in the hashtable, if it's a * duplicate, or create a new entry in the hashtable */ header = globus_hashtable_lookup( &headers->headers, (void *) header_name); if (header != NULL) { /* Replace current header's value */ save_header = header->value; header->value = globus_libc_strdup(header_value); if (header->value == NULL) { header->value = save_header; result = GlobusXIOErrorMemory("header"); goto error_exit; } globus_libc_free(save_header); } else { header = globus_libc_malloc(sizeof(globus_xio_http_header_t)); if (header == NULL) { result = GlobusXIOErrorMemory("header"); goto error_exit; } header->name = globus_libc_strdup(header_name); if (header->name == NULL) { result = GlobusXIOErrorMemory("header"); goto free_header_exit; } header->value = globus_libc_strdup(header_value); if (header->value == NULL) { result = GlobusXIOErrorMemory("header"); goto free_header_name_exit; } rc = globus_hashtable_insert( &headers->headers, header->name, header); if (rc != GLOBUS_SUCCESS) { result = GlobusXIOErrorMemory("header"); goto free_header_value_exit; } } } return result; free_header_value_exit: globus_libc_free(header->value); free_header_name_exit: globus_libc_free(header->name); free_header_exit: globus_libc_free(header); error_exit: return result; }
/** * Call a callout of specified abstract type * @ingroup globus_callout_call * * This function looks up the callouts corresponding to the given type and * invokes them with the passed arguments. If a invoked callout returns an * error it will be chained to a error of the type * GLOBUS_CALLOUT_ERROR_CALLOUT_ERROR and no more callouts will be called. * * @param handle * A configured callout handle * @param type * The abstract type of the callout that is to be invoked * @return * GLOBUS_SUCCESS * A Globus error object on failure: * GLOBUS_CALLOUT_ERROR_TYPE_NOT_REGISTERED * GLOBUS_CALLOUT_ERROR_CALLOUT_ERROR * GLOBUS_CALLOUT_ERROR_WITH_DL * GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE * GLOBUS_CALLOUT_ERROR_OUT_OF_MEMORY */ globus_result_t globus_callout_call_type( globus_callout_handle_t handle, char * type, ...) { globus_i_callout_data_t * current_datum; #ifdef BUILD_STATIC_ONLY void * function; #else lt_ptr function; lt_dlhandle * dlhandle; #endif globus_result_t result = GLOBUS_SUCCESS; va_list ap; int rc; char * dlerror; char * flavor_start; char * file; char library[1024]; char ** save_env; int i; globus_i_callout_data_t * tmp_datum; int mandatory_callouts_remaining = 0; static char * _function_name_ = "globus_callout_handle_call_type"; GLOBUS_I_CALLOUT_DEBUG_ENTER; current_datum = globus_hashtable_lookup(&handle->symbol_htable, type); if(current_datum == NULL) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_TYPE_NOT_REGISTERED, ("unknown type: %s\n", type)); goto exit; } tmp_datum = current_datum; while(tmp_datum) { if(tmp_datum->mandatory) { mandatory_callouts_remaining++; } tmp_datum = tmp_datum->next; } do { #ifdef BUILD_STATIC_ONLY GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_WITH_DL, ("couldn't dlopen %s: %s\n", current_datum->file, "(null)")); goto exit; #else dlhandle = globus_hashtable_lookup(&handle->library_htable, current_datum->file); if(dlhandle == NULL) { dlhandle = malloc(sizeof(lt_dlhandle)); if(dlhandle == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); } *dlhandle = NULL; rc = globus_hashtable_insert(&handle->library_htable, current_datum->file, dlhandle); if(rc < 0) { free(dlhandle); GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE, ("globus_hashtable_insert retuned %d", rc)); goto exit; } } if(*dlhandle == NULL) { /* first time a symbol is referenced in this library -> * need to open it */ *dlhandle = lt_dlopenext(current_datum->file); if(*dlhandle == NULL) { /* older libtools dont search the extensions correctly */ snprintf(library, 1024, "%s" MY_LIB_EXT, current_datum->file); library[1023] = 0; *dlhandle = lt_dlopenext(library); } if(*dlhandle == NULL) { /* try again with flavor string removed */ flavor_start = strrchr(current_datum->file, '_'); if (flavor_start) { file = strdup(current_datum->file); if(file == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto exit; } file[flavor_start - current_datum->file] = '\0'; *dlhandle = lt_dlopenext(file); if(*dlhandle == NULL) { /* older libtools dont search the extensions correctly */ snprintf(library, 1024, "%s" MY_LIB_EXT, file); library[1023] = 0; *dlhandle = lt_dlopenext(library); } free(file); } } if(*dlhandle == NULL) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_WITH_DL, ("couldn't dlopen %s: %s\n", library, (dlerror = lt_dlerror()) ? dlerror : "unknown error, possibly file not found.")); goto exit; } } function = lt_dlsym(*dlhandle, current_datum->symbol); if(function == NULL) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_WITH_DL, ("symbol %s could not be found in %s: %s\n", current_datum->symbol, current_datum->file, (dlerror = lt_dlerror()) ? dlerror : "(null)")); goto exit; } if(current_datum->env_args) { save_env = globus_calloc( current_datum->num_env_args*2+1, sizeof(char *)); i = 0; while(current_datum->env_args[i] != NULL && current_datum->env_args[i+1] != NULL) { save_env[i] = current_datum->env_args[i]; save_env[i+1] = globus_libc_strdup(getenv(current_datum->env_args[i])); setenv(current_datum->env_args[i], current_datum->env_args[i+1], 1); i += 2; } save_env[i] = NULL; } va_start(ap,type); result = ((globus_callout_function_t) function)(ap); va_end(ap); if(current_datum->env_args) { i = 0; while(save_env[i] != NULL) { if(save_env[i+1] == NULL) { unsetenv(save_env[i]); } else { setenv(save_env[i], save_env[i+1], 1); globus_free(save_env[i+1]); } i += 2; } globus_free(save_env); } if(result == GLOBUS_SUCCESS) { if(current_datum->mandatory) { mandatory_callouts_remaining--; } if(!mandatory_callouts_remaining) { goto exit; } } if(result != GLOBUS_SUCCESS) { if(current_datum->mandatory) { GLOBUS_CALLOUT_ERROR_CHAIN_RESULT( result, GLOBUS_CALLOUT_ERROR_CALLOUT_ERROR); goto exit; } else if(current_datum->next == NULL) { /* chain error with stored error */ GLOBUS_CALLOUT_ERROR_CHAIN_RESULT( result, GLOBUS_CALLOUT_ERROR_CALLOUT_ERROR); goto exit; } else { /* store error */ result = GLOBUS_SUCCESS; } } current_datum = current_datum->next; #endif } while(current_datum); exit: GLOBUS_I_CALLOUT_DEBUG_EXIT; return result; }/*globus_callout_call_type*/
/** * Read callout configuration from file. * @ingroup globus_callout_config * * This function read a configuration file with the following format: * - Anything after a '#' is assumed to be a comment * - Blanks lines are ignored * - Lines specifying callouts have the format * abstract type library symbol * where "abstract type" denotes the type of callout, * e.g. globus_gram_jobmanager_authz, "library" denotes the library the * callout can be found in and "symbol" denotes the function name of the * callout. The library argument can be specified in two forms, libfoo or * libfoo_<flavor>. When using the former version the current flavor will * automatically be added to the library name. * * @param handle * The handle that is to be configured * @param filename * The file to read configuration from * @return * GLOBUS_SUCCESS * A Globus error object on failure: * GLOBUS_CALLOUT_ERROR_OPENING_CONF_FILE * GLOBUS_CALLOUT_ERROR_PARSING_CONF_FILE * GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE * GLOBUS_CALLOUT_ERROR_OUT_OF_MEMORY */ globus_result_t globus_callout_read_config( globus_callout_handle_t handle, char * filename) { FILE * conf_file; char buffer[GLOBUS_I_CALLOUT_LINEBUF]; char type[128]; char library[256]; char symbol[128]; char * env_argstr; char ** env_args; int numpairs = 0; char * flavor_start; char * pound; int index; int rc; globus_result_t result; globus_i_callout_data_t * datum = NULL; globus_i_callout_data_t * existing_datum; static char * _function_name_ = "globus_callout_read_config"; GLOBUS_I_CALLOUT_DEBUG_ENTER; conf_file = fopen(filename, "r"); if(conf_file == NULL) { GLOBUS_CALLOUT_ERRNO_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_OPENING_CONF_FILE, ("filename %s", filename)); goto error_exit; } while(fgets(buffer,GLOBUS_I_CALLOUT_LINEBUF,conf_file)) { if(!strchr(buffer, '\n')) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_PARSING_CONF_FILE, ("malformed line, line too long or missing newline")); goto error_exit; } /* strip any comments */ pound = strchr(buffer, '#'); if(pound != NULL) { *pound = '\0'; } /* strip white space from start */ index = 0; while(buffer[index] == '\t' || buffer[index] == ' ') { index++; } /* if blank line continue */ if(buffer[index] == '\0' || buffer[index] == '\n') { continue; } if(sscanf(&buffer[index],"%127s%255s%127s",type,library,symbol) < 3) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_PARSING_CONF_FILE, ("malformed line: %s", &buffer[index])); goto error_exit; } /* check for ENV vars to set */ env_argstr = strstr(buffer, "ENV:"); if(env_argstr && strchr(env_argstr, '=')) { int i; char * ptr; char * start; numpairs = 0; ptr = strchr(env_argstr, '='); while(ptr) { numpairs++; ptr++; if(*ptr == '"') { ptr = strchr(ptr + 1, '"'); if(!ptr) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_PARSING_CONF_FILE, ("malformed line, unmatched quote: %s", buffer)); goto error_exit; } } ptr = strchr(ptr + 1, '='); } if(numpairs > 0) { env_args = globus_calloc(numpairs*2+1, sizeof(char *)); start = env_argstr + 4; i = 0; while(start) { /* skip initial space */ while(isspace(*start)) { start++; } /* find var name */ ptr = strchr(start, '='); *ptr = '\0'; if(strcspn(start, " \"=") != strlen(start)) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_PARSING_CONF_FILE, ("malformed line, invalid character in ENV var: %s", start)); goto error_exit; } env_args[i] = globus_libc_strdup(start); /* find value in quotes or before a space or end of line */ start = ++ptr; if(*start == '"') { start++; ptr = strchr(start, '"'); *ptr = '\0'; } else { ptr = strchr(start, ' '); if(!ptr) { ptr = strchr(start, '\n'); } *ptr = '\0'; } env_args[i+1] = globus_libc_strdup(start); ptr++; while(*ptr && isspace(*ptr)) { ptr++; } if(*ptr && strchr(ptr, '=')) { start = ptr; } else { start = NULL; } i += 2; } env_args[i] = NULL; } } else { env_args = NULL; } /* push values into hash */ datum = malloc(sizeof(globus_i_callout_data_t)); if(datum == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } memset(datum,'\0',sizeof(globus_i_callout_data_t)); /* check if library is flavored already */ if((flavor_start = strrchr(library,'_')) && (strstr(flavor_start, "32") || strstr(flavor_start, "64"))) { datum->file = strdup(library); if(datum->file == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } } else { datum->file = malloc(strlen(library) + 2 + strlen(flavor)); if(datum->file == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } datum->file[0] = '\0'; strcat(datum->file, library); strcat(datum->file, "_"); strcat(datum->file, flavor); } datum->symbol = strdup(symbol); if(datum->symbol == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } if(*type == '|') { datum->mandatory = GLOBUS_FALSE; datum->type = strdup(type + 1); } else { datum->mandatory = GLOBUS_TRUE; datum->type = strdup(type); } if(datum->type == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } datum->env_args = env_args; datum->num_env_args = numpairs; if((rc = globus_hashtable_insert(&handle->symbol_htable, datum->type, datum)) == -1) { existing_datum = globus_hashtable_lookup(&handle->symbol_htable, datum->type); while(existing_datum->next) { existing_datum = existing_datum->next; } existing_datum->next = datum; } else if(rc < 0) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE, ("globus_hashtable_insert retuned %d", rc)); goto error_exit; } } fclose(conf_file); GLOBUS_I_CALLOUT_DEBUG_EXIT; return GLOBUS_SUCCESS; error_exit: if(datum != NULL) { globus_l_callout_data_free(datum); } if(conf_file != NULL) { fclose(conf_file); } return result; }/*globus_callout_read_config*/
/** * Register callout configuration * @ingroup globus_callout_config * * This function registers a callout type in the given handle. * * @param handle * The handle that is to be configured * @param type * The abstract type of the callout * @param library * The location of the library containing the callout * @param symbol * The symbol (ie function name) for the callout * @return * GLOBUS_SUCCESS * A Globus error object on failure: * GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE * GLOBUS_CALLOUT_ERROR_OUT_OF_MEMORY */ globus_result_t globus_callout_register( globus_callout_handle_t handle, char * type, char * library, char * symbol) { int rc; globus_result_t result; globus_i_callout_data_t * datum = NULL; globus_i_callout_data_t * existing_datum; char * flavor_start; static char * _function_name_ = "globus_callout_register"; GLOBUS_I_CALLOUT_DEBUG_ENTER; /* push values into hash */ datum = malloc(sizeof(globus_i_callout_data_t)); if(datum == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } memset(datum,'\0',sizeof(globus_i_callout_data_t)); if((flavor_start = strrchr(library,'_')) && (strstr(flavor_start, "32") || strstr(flavor_start, "64"))) { datum->file = strdup(library); if(datum->file == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } } else { datum->file = malloc(strlen(library) + 2 + strlen(flavor)); if(datum->file == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } datum->file[0] = '\0'; strcat(datum->file, library); strcat(datum->file, "_"); strcat(datum->file, flavor); } datum->symbol = strdup(symbol); if(datum->symbol == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } datum->type = strdup(type); if(datum->type == NULL) { GLOBUS_CALLOUT_MALLOC_ERROR(result); goto error_exit; } if((rc = globus_hashtable_insert(&handle->symbol_htable, datum->type, datum)) == -1) { existing_datum = globus_hashtable_lookup(&handle->symbol_htable, datum->type); while(existing_datum->next) { existing_datum = existing_datum->next; } existing_datum->next = datum; } else if(rc < 0) { GLOBUS_CALLOUT_ERROR_RESULT( result, GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE, ("globus_hashtable_insert retuned %d", rc)); goto error_exit; } GLOBUS_I_CALLOUT_DEBUG_EXIT; return GLOBUS_SUCCESS; error_exit: GLOBUS_I_CALLOUT_DEBUG_EXIT; if(datum != NULL) { globus_l_callout_data_free(datum); } return result; }/*globus_callout_register*/
int globus_extension_activate( const char * extension_name) { globus_l_extension_module_t * extension; globus_l_extension_module_t * last_extension; globus_l_extension_builtin_t * builtin; int rc; globus_result_t result = GLOBUS_FAILURE; GlobusFuncName(globus_extension_activate); GlobusExtensionDebugEnterSymbol(extension_name); if(!extension_name) { goto error_param; } globus_rmutex_lock(&globus_l_extension_mutex); { extension = (globus_l_extension_module_t *) globus_hashtable_lookup( &globus_l_extension_loaded, (void *) extension_name); if(!extension) { extension = (globus_l_extension_module_t *) globus_malloc(sizeof(globus_l_extension_module_t)); if(!extension) { goto error_alloc; } extension->module_ref = 1; extension->ref = 1; extension->name = globus_libc_strdup(extension_name); if(!extension->name) { goto error_strdup; } builtin = (globus_l_extension_builtin_t *) globus_hashtable_lookup( &globus_l_extension_builtins, (void *) extension_name); if(builtin && (!builtin->owner || builtin->owner->module_ref > 0)) { # if !defined(BUILD_STATIC_ONLY) { extension->dlhandle = NULL; } # endif extension->module = builtin->module; extension->owner = builtin->owner; if(extension->owner) { extension->owner->ref++; } } else { extension->owner = NULL; # if !defined(BUILD_STATIC_ONLY) { result = globus_l_extension_dlopen( extension->name, &extension->dlhandle); if(result != GLOBUS_SUCCESS) { goto error_dll; } result = globus_l_extension_get_module( extension->dlhandle, extension_name, &extension->module); } # else { globus_assert(BUILD_STATIC_ONLY == 0); result = globus_error_put( globus_error_construct_error( GLOBUS_EXTENSION_MODULE, NULL, GLOBUS_EXTENSION_ERROR_OPEN_FAILED, __FILE__, _globus_func_name, __LINE__, "No support for dynamically loading %s\n", extension->name)); } # endif /* !defined(BUILD_STATIC_ONLY) */ if(result != GLOBUS_SUCCESS) { goto error_module; } } globus_hashtable_insert( &globus_l_extension_loaded, extension->name, extension); last_extension = (globus_l_extension_module_t *) globus_thread_getspecific(globus_l_extension_owner_key); globus_thread_setspecific(globus_l_extension_owner_key, extension); #if USE_SYMBOL_LABELS { int pre_warned = WARNING_USING_MIXED_THREAD_MODELS; #endif rc = globus_module_activate_proxy( extension->module, globus_l_extension_deactivate_proxy, extension); #if USE_SYMBOL_LABELS if ((!pre_warned) && WARNING_USING_MIXED_THREAD_MODELS) { GlobusExtensionDebugPrintf( GLOBUS_L_EXTENSION_DEBUG_VERBOSE, (_GCSL("[%s] Warning: extension %s was compiled with pthreads for GT 5.0.x and may not work correctly\n"), _globus_func_name, extension->name)); } } #endif globus_thread_setspecific( globus_l_extension_owner_key, last_extension); if(rc != GLOBUS_SUCCESS) { goto error_activate; } } else { extension->module_ref++; extension->ref++; } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return GLOBUS_SUCCESS; error_activate: globus_hashtable_remove( &globus_l_extension_loaded, extension->name); if(builtin && builtin->owner) { builtin->owner->ref--; } error_module: #ifndef BUILD_STATIC_ONLY if(extension->dlhandle) { lt_dlclose(extension->dlhandle); } error_dll: #endif /* !BUILD_STATIC_ONLY */ globus_free(extension->name); error_strdup: globus_free(extension); error_alloc: globus_rmutex_unlock(&globus_l_extension_mutex); error_param: GlobusExtensionDebugExitWithError(); return result; }
void * globus_extension_lookup( globus_extension_handle_t * handle, globus_extension_registry_t * registry, void * symbol) { globus_l_extension_handle_t * entry; void * datum = NULL; GlobusFuncName(globus_extension_lookup); GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol); if(!handle) { goto error_param; } *handle = NULL; if(!registry || !symbol) { goto error_param; } globus_rmutex_lock(&globus_l_extension_mutex); { if(registry->initialized) { entry = (globus_l_extension_handle_t *) globus_hashtable_lookup(®istry->table, (void *) symbol); if(entry && (!entry->owner || entry->owner->module_ref > 0)) { datum = entry->datum; entry->ref++; if(entry->owner) { entry->owner->ref++; globus_assert( (entry->owner != (globus_l_extension_module_t *) globus_thread_getspecific( globus_l_extension_owner_key)) && "You can not lookup something owned by the calling module"); GlobusExtensionDebugPrintf( GLOBUS_L_EXTENSION_DEBUG_VERBOSE, (_GCSL("[%s] Accessing entry %s within %s\n"), _globus_func_name, registry->user_hashing ? "" : symbol, entry->owner->name)); } *handle = entry; } } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return datum; error_param: GlobusExtensionDebugExitWithError(); return NULL; }
int main(int argc, char *argv[]) { int rc; globus_hashtable_t extensions = NULL; globus_gram_protocol_extension_t * extension_value; if (argc != 2) { fprintf(stderr, "Usage: %s RESOURCE-MANAGER-CONTACT\n", argv[0]); rc = 1; goto out; } printf("Checking version of GRAM resource: %s\n", argv[1]); /* * Always activate the GLOBUS_GRAM_CLIENT_MODULE prior to using any * functions from the GRAM Client API or behavior is undefined. */ rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error activating %s because %s (Error %d)\n", GLOBUS_GRAM_CLIENT_MODULE->module_name, globus_gram_client_error_string(rc), rc); goto out; } /* * Contact the service passed as our first command-line option and perform * a version check. If successful, * this function will return GLOBUS_SUCCESS, otherwise an integer * error code. Old versions of the job manager will return * GLOBUS_GRAM_PROTOCOL_ERROR_HTTP_UNPACK_FAILED as they do not support * the version operation. */ rc = globus_gram_client_get_jobmanager_version(argv[1], &extensions); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Unable to get service version from %s because %s " "(Error %d)\n", argv[1], globus_gram_client_error_string(rc), rc); } else { /* The version information is returned in the extensions hash table */ extension_value = globus_hashtable_lookup( &extensions, "toolkit-version"); if (extension_value == NULL) { printf("Unknown toolkit version\n"); } else { printf("Toolkit Version: %s\n", extension_value->value); } extension_value = globus_hashtable_lookup( &extensions, "version"); if (extension_value == NULL) { printf("Unknown package version\n"); } else { printf("Package Version: %s\n", extension_value->value); } /* Free the extensions hash and its values */ globus_gram_protocol_hash_destroy(&extensions); } /* * Deactivating the module allows it to free memory and close network * connections. */ rc = globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE); out: return rc; }
static void globus_l_gass_server_ez_register_accept_callback( void * listener, globus_gass_transfer_request_t request ) { int rc; char * subjectname; char * path=GLOBUS_NULL; char * url; globus_url_t parsed_url; globus_l_gass_server_ez_t * s; globus_gass_server_ez_request_t *r; struct stat statstruct; globus_byte_t * buf; int amt; int flags=0; subjectname=globus_gass_transfer_request_get_subject(request); /* lookup our options */ s=(globus_l_gass_server_ez_t *)globus_hashtable_lookup( &globus_l_gass_server_ez_listeners, listener); /* Check for valid URL */ url=globus_gass_transfer_request_get_url(request); rc = globus_url_parse(url, &parsed_url); if(rc != GLOBUS_SUCCESS || parsed_url.url_path == GLOBUS_NULL || strlen(parsed_url.url_path) == 0U) { globus_gass_transfer_deny(request, 404, "File Not Found"); globus_gass_transfer_request_destroy(request); if (rc == GLOBUS_SUCCESS) globus_url_destroy(&parsed_url); goto reregister_nourl; } if(globus_gass_transfer_request_get_type(request) == GLOBUS_GASS_TRANSFER_REQUEST_TYPE_APPEND) { flags = O_CREAT | O_WRONLY | O_APPEND; } else if(globus_gass_transfer_request_get_type(request) == GLOBUS_GASS_TRANSFER_REQUEST_TYPE_PUT) { flags = O_CREAT | O_WRONLY | O_TRUNC; } switch(globus_gass_transfer_request_get_type(request)) { case GLOBUS_GASS_TRANSFER_REQUEST_TYPE_APPEND: case GLOBUS_GASS_TRANSFER_REQUEST_TYPE_PUT: /* Check to see if this is a request we are allowed to handle */ if(((s->options & GLOBUS_GASS_SERVER_EZ_WRITE_ENABLE) == 0UL) && ((s->options & GLOBUS_GASS_SERVER_EZ_STDOUT_ENABLE) == 0UL) && ((s->options & GLOBUS_GASS_SERVER_EZ_STDERR_ENABLE) == 0UL) && ((s->options & GLOBUS_GASS_SERVER_EZ_CLIENT_SHUTDOWN_ENABLE) == 0UL)) { goto deny; } /* Expand ~ and ~user prefix if enaabled in options */ rc = globus_l_gass_server_ez_tilde_expand(s->options, parsed_url.url_path, &path); if(strncmp(path, "/dev/saga", 9) == 0 && (s->options & GLOBUS_GASS_SERVER_EZ_STDOUT_ENABLE)) { rc = s->fd; // the pipe handle! goto authorize; } else if(strncmp(path, "/dev/saga/", 9) == 0) { goto deny; } else if(strcmp(path, "/dev/globus_gass_client_shutdown") == 0) { if(s->options & GLOBUS_GASS_SERVER_EZ_CLIENT_SHUTDOWN_ENABLE && s->callback != GLOBUS_NULL) { s->callback(); } goto deny; } #ifdef TARGET_ARCH_WIN32 // The call to open() in Windows defaults to text mode, so // we to override it. flags |= O_BINARY; #endif rc = globus_libc_open(path, flags, 0600); if(rc < 0) { goto deny; } authorize: globus_gass_transfer_authorize(request, 0); if(s->options & GLOBUS_GASS_SERVER_EZ_LINE_BUFFER) { r=(globus_gass_server_ez_request_t *)globus_malloc( sizeof(globus_gass_server_ez_request_t)); r->fd=rc; r->line_buffer=globus_malloc(80); r->line_buffer_used= 0UL; r->line_buffer_length = 80UL; r->linebuffer = GLOBUS_TRUE; globus_gass_transfer_receive_bytes(request, globus_malloc(1024), 1024, 1, globus_gass_server_ez_put_memory_done, r); } else { globus_gass_transfer_receive_bytes(request, globus_malloc(1024), 1024, 1, globus_l_gass_server_ez_put_callback, (void *) rc); } break; case GLOBUS_GASS_TRANSFER_REQUEST_TYPE_GET: flags = O_RDONLY; /* Expand ~ and ~user prefix if enaabled in options */ rc = globus_l_gass_server_ez_tilde_expand(s->options, parsed_url.url_path, &path); if((s->options & GLOBUS_GASS_SERVER_EZ_READ_ENABLE) == 0UL) { goto deny; } if(stat(path, &statstruct)==0) { #ifdef TARGET_ARCH_WIN32 // The call to open() in Windows defaults to text mode, // so we to override it. flags |= O_BINARY; #endif rc = globus_libc_open(path, flags, 0600); fstat(rc, &statstruct); } else { globus_gass_transfer_deny(request, 404, "File Not Found"); globus_gass_transfer_request_destroy(request); goto reregister; } buf = globus_malloc(1024); amt = read(rc, buf, 1024); if(amt == -1) { globus_free(buf); goto deny; } globus_gass_transfer_authorize(request, statstruct.st_size); globus_gass_transfer_send_bytes(request, buf, amt, GLOBUS_FALSE, globus_l_gass_server_ez_get_callback, (void *) rc); break; default: deny: globus_gass_transfer_deny(request, 400, "Bad Request"); globus_gass_transfer_request_destroy(request); } reregister: globus_url_destroy(&parsed_url); reregister_nourl: globus_gass_transfer_register_listen( (globus_gass_transfer_listener_t) listener, globus_l_gass_server_ez_listen_callback, s->reqattr); if (path != GLOBUS_NULL) globus_free(path); } /*globus_l_gass_server_ez_register_accept_callback*/
/* * PURPOSE: * Verify that * globus_gram_protocol_unpack_job_request_reply_with_extensions() * deals with messages containing extension attributes not defined in the * GRAM2 * protocol. * TEST STEPS: * - Construct a status update message with the * globus_gram_protocol_pack_job_request_reply_with_extensions() * function. * - Call globus_gram_protocol_unpack_job_request_reply_with_extensions() and * expect a GLOBUS_SUCCESS * - Check that our new attribute is in the hash */ int test_extra_attributes(void) { globus_byte_t * message; globus_size_t message_size; globus_hashtable_t hashtable; globus_gram_protocol_extension_t * entry; int rc; char * expected[] = { "protocol-version", "status", "job-manager-url", "attribute" }; int i; int status; char * job_contact; rc = globus_hashtable_init( &hashtable, 89, globus_hashtable_string_hash, globus_hashtable_string_keyeq); test_assert( rc == GLOBUS_SUCCESS, ("Error initializing hashtable (out of memory?)\n")); entry = malloc(sizeof(globus_gram_protocol_extension_t)); test_assert(entry != NULL, ("Error allocating hash entry (out of memory?)\n")); entry->attribute = "attribute"; entry->value = "value"; rc = globus_hashtable_insert(&hashtable, entry->attribute, entry); rc = globus_gram_protocol_pack_job_request_reply_with_extensions( GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE, "https://example.org:123/12/34", &hashtable, &message, &message_size); test_assert(rc == GLOBUS_SUCCESS, ("Error packing status message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); globus_hashtable_destroy(&hashtable); free(entry); hashtable = NULL; test_assert( rc == GLOBUS_SUCCESS, ("Error constructing test message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); rc = globus_gram_protocol_unpack_job_request_reply_with_extensions( message, message_size, &status, &job_contact, &hashtable); test_assert( rc == GLOBUS_SUCCESS, ("Error parsing test message: %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); /* check that expected attributes were parsed */ for (i = 0; i < ARRAY_LEN(expected); i++) { entry = globus_hashtable_lookup(&hashtable, expected[i]); test_assert( entry != NULL, ("Missing expected attribute %s\n", expected[i])); } test_assert(ARRAY_LEN(expected) == globus_hashtable_size(&hashtable), ("Hash table contains %d entries, expected %d", globus_hashtable_size(&hashtable), ARRAY_LEN(expected))); globus_gram_protocol_hash_destroy(&hashtable); free(message); return 0; }
static globus_result_t globus_l_python_module( const globus_net_manager_attr_t *attrs, globus_l_python_modref_t **pymod) { globus_result_t result = GLOBUS_SUCCESS; int rc = 0; globus_l_python_modref_t *modref = NULL; PyObject *pymodname = NULL; for (int i = 0; attrs != NULL && attrs[i].scope != NULL; i++) { if (strcmp(attrs[i].scope, "python") == 0) { if (strcmp(attrs[i].name, "pymod") == 0) { modref = globus_hashtable_lookup( &globus_l_python_modules, attrs[i].value); if (!modref) { modref = malloc(sizeof(globus_l_python_modref_t)); if (!modref) { result = GLOBUS_FAILURE; goto modref_malloc_fail; } modref->key = strdup(attrs[i].value); if (!modref->key) { result = GLOBUS_FAILURE; goto strdup_modref_key_fail; } pymodname = PyString_FromString(modref->key); if (!pymodname) { result = GLOBUS_FAILURE; goto modref_key_to_pystring_fail; } modref->module = PyImport_Import(pymodname); if (!modref->module) { result = GLOBUS_FAILURE; goto module_import_fail; } modref->pre_listen = globus_l_python_resolve_func( modref->module, "pre_listen"); modref->post_listen = globus_l_python_resolve_func( modref->module, "post_listen"); modref->end_listen = globus_l_python_resolve_func( modref->module, "end_listen"); modref->pre_accept = globus_l_python_resolve_func( modref->module, "pre_accept"); modref->post_accept = globus_l_python_resolve_func( modref->module, "post_accept"); modref->pre_connect = globus_l_python_resolve_func( modref->module, "pre_connect"); modref->post_connect = globus_l_python_resolve_func( modref->module, "post_connect"); modref->pre_close = globus_l_python_resolve_func( modref->module, "pre_close"); modref->post_close = globus_l_python_resolve_func( modref->module, "post_close"); rc = globus_hashtable_insert( &globus_l_python_modules, modref->key, modref); if (rc != GLOBUS_SUCCESS) { result = GLOBUS_FAILURE; goto hashtable_insert_fail; } } Py_XDECREF(pymodname); break; } } } hashtable_insert_fail: if (result != GLOBUS_SUCCESS) { Py_XDECREF(modref->pre_listen); Py_XDECREF(modref->post_listen); Py_XDECREF(modref->end_listen); Py_XDECREF(modref->pre_accept); Py_XDECREF(modref->post_accept); Py_XDECREF(modref->pre_connect); Py_XDECREF(modref->post_connect); Py_XDECREF(modref->pre_close); Py_XDECREF(modref->post_close); Py_XDECREF(modref->module); } module_import_fail: modref_key_to_pystring_fail: if (result != GLOBUS_SUCCESS) { free(modref->key); strdup_modref_key_fail: free(modref); modref = NULL; } modref_malloc_fail: *pymod = modref; return result; }
static FILE * globus_l_net_manager_logging_get_logfile( const globus_net_manager_attr_t *attrs) { int rc = 0; FILE * handle = NULL; globus_l_nm_logging_logref_t * logref = NULL; for (int i = 0; attrs != NULL && attrs[i].scope != NULL; i++) { if (strcmp(attrs[i].scope, "logging") == 0) { if (strcmp(attrs[i].name, "file") == 0) { logref = globus_hashtable_lookup( &globus_l_nm_logging_logfiles, attrs[i].value); if (!logref) { handle = fopen(attrs[i].value, "a"); if (!handle) { goto fopen_fail; } logref = malloc(sizeof(globus_l_nm_logging_logref_t)); if (logref == NULL) { goto logref_malloc_fail; } logref->key = strdup(attrs[i].value); if (logref->key == NULL) { goto logref_key_fail; } logref->handle = handle; handle = NULL; rc = globus_hashtable_insert( &globus_l_nm_logging_logfiles, logref->key, logref); if (rc != GLOBUS_SUCCESS) { goto hashtable_insert_fail; } } break; } } } return logref ? logref->handle : stdout; hashtable_insert_fail: logref_key_fail: logref_malloc_fail: if (handle) { fclose(handle); handle = NULL; } fopen_fail: if (logref) { free(logref->key); free(logref); logref = NULL; } return stdout; }