globus_result_t
globus_gridftp_server_control_attr_init(
globus_gridftp_server_control_attr_t * in_attr)
{
globus_i_gsc_attr_t * attr;
globus_result_t res;
GlobusGridFTPServerName(globus_gridftp_server_control_attr_init);
GlobusGridFTPServerDebugEnter();
if(in_attr == NULL)
{
res = GlobusGridFTPServerErrorParameter("in_attr");
goto err;
}
attr = (globus_i_gsc_attr_t *) globus_calloc(
1, sizeof(globus_i_gsc_attr_t));
if(attr == NULL)
{
res = GlobusGridFTPServerControlErrorSytem();
goto err;
}
globus_hashtable_init(
&attr->funcs.send_cb_table,
GLOBUS_GRIDFTP_SERVER_HASHTABLE_SIZE,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_hashtable_init(
&attr->funcs.recv_cb_table,
GLOBUS_GRIDFTP_SERVER_HASHTABLE_SIZE,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
attr->funcs.resource_cb = NULL;
attr->version_ctl = GLOBUS_GRIDFTP_VERSION_CTL;
attr->modes = globus_libc_strdup("ES");
attr->types = globus_libc_strdup("AI");
attr->base_dir = globus_libc_strdup("/");
*in_attr = attr;
GlobusGridFTPServerDebugExit();
return GLOBUS_SUCCESS;
err:
GlobusGridFTPServerDebugExitWithError();
return res;
}
/**
* Initialize a Globus Callout Handle
* @ingroup globus_callout_handle
*
* @param handle
* Pointer to the handle that is to be initialized
* @return
* GLOBUS_SUCCESS if successful
* A Globus error object on failure:
* GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE
*/
globus_result_t
globus_callout_handle_init(
globus_callout_handle_t * handle)
{
int rc;
globus_result_t result = GLOBUS_SUCCESS;
static char * _function_name_ =
"globus_callout_handle_init";
GLOBUS_I_CALLOUT_DEBUG_ENTER;
*handle = malloc(sizeof(globus_i_callout_handle_t));
if(*handle == NULL)
{
GLOBUS_CALLOUT_MALLOC_ERROR(result);
goto exit;
}
if((rc = globus_hashtable_init(&((*handle)->symbol_htable),
GLOBUS_I_CALLOUT_HASH_SIZE,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq)) < 0)
{
free(*handle);
GLOBUS_CALLOUT_ERROR_RESULT(
result,
GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE,
("globus_hashtable_init retuned %d", rc));
goto exit;
}
if((rc = globus_hashtable_init(&((*handle)->library_htable),
GLOBUS_I_CALLOUT_HASH_SIZE,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq)) < 0)
{
globus_hashtable_destroy(&((*handle)->symbol_htable));
free(*handle);
GLOBUS_CALLOUT_ERROR_RESULT(
result,
GLOBUS_CALLOUT_ERROR_WITH_HASHTABLE,
("globus_hashtable_init retuned %d", rc));
goto exit;
}
GLOBUS_I_CALLOUT_DEBUG_EXIT;
exit:
return result;
}/*globus_callout_handle_init*/
/*
* globus_l_module_initialize()
*/
static void
globus_l_module_initialize()
{
/*
* Initialize the threads package (can't use the standard interface since
* it depends on threads)
*/
globus_i_thread_pre_activate();
globus_i_memory_pre_activate();
/*
* Initialize the registered module table and list
*/
globus_hashtable_init(&globus_l_module_table,
GLOBUS_L_MODULE_TABLE_SIZE,
globus_hashtable_voidp_hash,
globus_hashtable_voidp_keyeq);
globus_l_module_list = GLOBUS_NULL;
/*
* Initialize the recursive mutex
*/
globus_l_module_mutex_init(&globus_l_module_mutex);
globus_thread_key_create(&globus_l_activate_parent_key, NULL);
globus_thread_key_create(&globus_l_deactivate_parent_key, NULL);
/*
* Now finish initializing the threads package
*/
globus_module_activate(GLOBUS_THREAD_MODULE);
}
/******************************************************************************
Function: globus_l_gass_server_ez_activate()
Description:
Parameters:
Returns:
******************************************************************************/
static int
globus_l_gass_server_ez_activate(void)
{
int rc;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if(rc != GLOBUS_SUCCESS)
{
return rc;
}
rc = globus_module_activate(GLOBUS_GASS_TRANSFER_MODULE);
if(rc != GLOBUS_SUCCESS)
{
return rc;
}
globus_mutex_init(&globus_l_gass_server_ez_mutex,
GLOBUS_NULL);
globus_hashtable_init(&globus_l_gass_server_ez_listeners,
16,
globus_hashtable_int_hash,
globus_hashtable_int_keyeq);
return GLOBUS_SUCCESS;
} /* globus_l_gass_server_ez_activate() */
globus_result_t
globus_dsi_rest_test_server_init(
char **contact)
{
globus_result_t result = GLOBUS_SUCCESS;
globus_thread_t thread;
globus_xio_attr_t xio_attr;
server_done = false;
globus_mutex_init(&server_done_mutex, NULL);
globus_cond_init(&server_done_cond, NULL);
result = globus_hashtable_init(
&server_routes,
43,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
if (result != GLOBUS_SUCCESS)
{
goto hashtable_init_fail;
}
result = globus_xio_driver_load("tcp", &tcp_driver);
if (result != GLOBUS_SUCCESS)
{
goto tcp_load_fail;
}
result = globus_xio_driver_load("http", &http_driver);
if (result != GLOBUS_SUCCESS)
{
goto http_load_fail;
}
result = globus_xio_stack_init(&xio_stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto stack_init_fail;
}
result = globus_xio_stack_push_driver(xio_stack, tcp_driver);
if (result != GLOBUS_SUCCESS)
{
goto stack_push_fail;
}
result = globus_xio_stack_push_driver(xio_stack, http_driver);
if (result != GLOBUS_SUCCESS)
{
goto stack_push_fail;
}
result = globus_xio_attr_init(
&xio_attr);
result = globus_xio_attr_cntl(
xio_attr,
NULL,
GLOBUS_XIO_ATTR_SET_TIMEOUT_ACCEPT,
NULL,
&(globus_reltime_t) { .tv_sec = 1 },
static
int
globus_l_net_manager_python_activate(void)
{
Py_Initialize();
globus_mutex_init(&globus_l_python_modules_lock, NULL);
globus_hashtable_init(
&globus_l_python_modules,
7,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_module_activate(GLOBUS_NET_MANAGER_MODULE);
return globus_net_manager_register(
&globus_l_net_manager_python,
GlobusExtensionMyModule(globus_net_manager_python));
}
//! [Module Descriptor and Activation]
static
int
globus_l_net_manager_logging_activate(void)
{
globus_hashtable_init(
&globus_l_nm_logging_logfiles,
7,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
int rc = globus_module_activate(GLOBUS_NET_MANAGER_MODULE);
if (rc == 0)
{
rc = globus_net_manager_register(
&globus_l_net_manager_logging,
GlobusExtensionMyModule(globus_net_manager_logging));
}
return rc;
}
/**
* Initialize an HTTP header info structure
* @ingroup globus_i_xio_http_header_info
*
* All fields of the @a header_info structure will be initialized to their
* default values. If this function returns a failre, the header_info
* should be considered uninitialized.
*
* @param header_info
* Header information structure to initialize.
*
* @retval GLOBUS_SUCCESS
* Header initialized successfully.
* @retval GLOBUS_XIO_ERROR_MEMORY
* Initialization failed due to memory constraints.
*/
globus_result_t
globus_i_xio_http_header_info_init(
globus_i_xio_http_header_info_t * header_info)
{
int rc;
globus_result_t result = GLOBUS_SUCCESS;
GlobusXIOName(globus_i_xio_http_header_info_init);
memset(header_info, '\0', sizeof(globus_i_xio_http_header_info_t));
rc = globus_hashtable_init(
&header_info->headers,
16,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
if (rc != GLOBUS_SUCCESS)
{
result = GlobusXIOErrorMemory("hashtable");
}
return result;
}
int
globus_extension_registry_set_hashing(
globus_extension_registry_t * registry,
globus_hashtable_hash_func_t hash_func,
globus_hashtable_keyeq_func_t keyeq_func)
{
int rc = GLOBUS_SUCCESS;
GlobusFuncName(globus_extension_registry_remove);
GlobusExtensionDebugEnter();
globus_rmutex_lock(&globus_l_extension_mutex);
{
/* if registry->initialized == true,
* can't detect if this is misuse or just the result of being
* activated after a deactivate, so just return success
*/
if(!registry->initialized)
{
rc = globus_hashtable_init(
®istry->table,
20,
hash_func,
keyeq_func);
if(rc == GLOBUS_SUCCESS)
{
registry->initialized = GLOBUS_TRUE;
registry->user_hashing = GLOBUS_TRUE;
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return rc;
}
void
globus_module_setenv(
const char * name,
const char * value)
{
int rc;
/*
* First, check to see if the environment mutex has been initialized
*/
if(globus_l_environ_mutex_initialized == GLOBUS_FALSE)
{
if(globus_i_module_initialized == GLOBUS_TRUE)
{
rc = globus_mutex_init(&globus_l_environ_hashtable_mutex,
(globus_mutexattr_t *) GLOBUS_NULL);
globus_assert (rc == 0);
globus_l_environ_mutex_initialized = GLOBUS_TRUE;
}
}
/*
* then, check to see if the environment hash table has been initialized
*/
if((globus_l_environ_initialized == GLOBUS_FALSE))
{
if(globus_i_module_initialized==GLOBUS_TRUE)
{
globus_mutex_lock(&globus_l_environ_hashtable_mutex);
}
globus_hashtable_init(&globus_l_environ_table,
GLOBUS_L_ENVIRON_TABLE_SIZE,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_l_environ_initialized = GLOBUS_TRUE;
if(globus_i_module_initialized == GLOBUS_TRUE)
{
globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
}
}
/*
* Then actually put the name and value into the hash table
*/
if(globus_i_module_initialized == GLOBUS_TRUE)
{
globus_mutex_lock(&globus_l_environ_hashtable_mutex);
}
globus_hashtable_remove(
&globus_l_environ_table,
(void *) name);
globus_hashtable_insert(
&globus_l_environ_table,
(void *) name,
(void *) value);
if(globus_i_module_initialized == GLOBUS_TRUE)
{
globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
}
}
/*
* 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;
}
int
globus_extension_registry_add(
globus_extension_registry_t * registry,
void * symbol,
globus_module_descriptor_t * module,
void * data)
{
globus_l_extension_handle_t * entry;
GlobusFuncName(globus_extension_registry_add);
GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol);
if(!data || !symbol || !registry)
{
goto error_params;
}
entry = (globus_l_extension_handle_t *)
globus_malloc(sizeof(globus_l_extension_handle_t));
if(!entry)
{
goto error_malloc;
}
entry->owner = (globus_l_extension_module_t *)
globus_thread_getspecific(globus_l_extension_owner_key);
entry->module = module;
entry->datum = data;
entry->ref = 1;
entry->symbol = symbol;
entry->user_hashing = registry->user_hashing;
globus_rmutex_lock(&globus_l_extension_mutex);
{
if(!registry->initialized)
{
if(globus_hashtable_init(
®istry->table,
20,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq) != GLOBUS_SUCCESS)
{
goto error_init;
}
registry->initialized = GLOBUS_TRUE;
}
if(globus_hashtable_insert(
®istry->table, entry->symbol, entry) != GLOBUS_SUCCESS)
{
goto error_insert;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_insert:
error_init:
globus_rmutex_unlock(&globus_l_extension_mutex);
globus_free(entry);
error_malloc:
error_params:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
}
/**
* load config file. substitute $BUILD_FLAVOR for build_flavor,
*/
static
int
globus_l_extension_activate(void)
{
static globus_bool_t initialized = GLOBUS_FALSE;
globus_result_t result = GLOBUS_SUCCESS;
GlobusFuncName(globus_l_extension_activate);
if(!initialized)
{
GlobusDebugInit(GLOBUS_EXTENSION, TRACE VERBOSE DLL);
GlobusExtensionDebugEnter();
globus_rmutex_init(&globus_l_libtool_mutex, NULL);
globus_thread_key_create(&globus_l_libtool_key, NULL);
# ifndef BUILD_STATIC_ONLY
if(lt_dlinit() != 0)
{
goto error_dlinit;
}
# if HAVE_LT_DLMUTEX_REGISTER
if(lt_dlmutex_register(
globus_l_libtool_mutex_lock,
globus_l_libtool_mutex_unlock,
globus_l_libtool_set_error,
globus_l_libtool_get_error) != 0)
{
goto error_dlmutex;
}
# endif
# endif /* !BUILD_STATIC_ONLY */
globus_hashtable_init(
&globus_l_extension_loaded,
32,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_hashtable_init(
&globus_l_extension_builtins,
32,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_rmutex_init(&globus_l_extension_mutex, NULL);
globus_thread_key_create(&globus_l_extension_owner_key, NULL);
result = globus_eval_path("${libdir}", &globus_l_globus_location);
if(result != GLOBUS_SUCCESS)
{
goto error_path;
}
initialized = GLOBUS_TRUE;
GlobusExtensionDebugExit();
}
return GLOBUS_SUCCESS;
error_path:
globus_hashtable_destroy(&globus_l_extension_builtins);
globus_hashtable_destroy(&globus_l_extension_loaded);
# ifndef BUILD_STATIC_ONLY
# if HAVE_LT_DLMUTEX_REGISTER
error_dlmutex:
# endif
lt_dlexit();
error_dlinit:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
# endif /* !BUILD_STATIC_ONLY */
}
/*
* globus_l_gass_cache_config_init()
*
* Inits the config structure by reading from a file.
*
* Parameters:
* - directory the GASS cache directory
* - config the config structure
*
* Returns:
* - GLOBUS_SUCCESS upon success
*/
int
globus_l_gass_cache_config_init(
char * file,
globus_l_gass_cache_config_t * config)
{
globus_off_t length;
struct stat st;
int i, n, fd, rc, status;
char *p, *q, *r;
char *key, *value;
memset(config, '\0', sizeof(globus_l_gass_cache_config_t));
status = GLOBUS_SUCCESS;
config->buf = GLOBUS_NULL;
/* open the config file, figure out size, then read the file into
a buffer */
fd = open(file, O_RDONLY);
if (fd < 0)
{
status = GLOBUS_L_ERROR_CONFIG_FILE_NOT_FOUND;
goto cleanup;
}
rc = fstat(fd, &st);
if (rc < 0)
{
status = GLOBUS_L_ERROR_CONFIG_FILE_READ;
goto cleanup;
}
length = st.st_size;
config->buf = malloc(length+1);
if (config->buf == NULL)
{
status = GLOBUS_GASS_CACHE_ERROR_NO_MEMORY;
goto cleanup;
}
for (i=0; i<length; i+=n)
{
n = read(fd, config->buf+i, length-i);
if (n <= 0)
{
status = GLOBUS_L_ERROR_CONFIG_FILE_READ;
goto free_config_buf;
}
}
*(config->buf+length) = '\0';
rc = globus_hashtable_init(&config->table, 16,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
if (rc != GLOBUS_SUCCESS)
{
status = GLOBUS_GASS_CACHE_ERROR_NO_MEMORY;
goto free_config_buf;
}
for (p=config->buf; (p-config->buf)<length; p=q+1)
{
if (!(q = strchr(p, '\n')))
q = config->buf+length;
*q = 0;
strtrimhead(&p);
strtrimtail(p);
if (*p=='#' || !strlen(p)) /* a comment or empty line */
continue;
r = strchr(p, '=');
if (r == NULL)
{
status = GLOBUS_L_ERROR_CONFIG_FILE_PARSE_ERROR;
goto destroy_hashtable;
}
*r = 0;
key = p;
value = r+1;
strtrimtail(key);
strtrimhead(&value);
globus_hashtable_insert(&config->table,
(void *) key,
(void *) value);
}
if (fd >= 0)
{
close(fd);
}
return status;
destroy_hashtable:
globus_hashtable_destroy(&config->table);
free_config_buf:
free(config->buf);
config->buf = NULL;
cleanup:
if (fd >= 0)
{
close(fd);
}
return status;
}
