static
globus_result_t
globus_l_xio_pipe_handle_init(
xio_l_pipe_handle_t ** handle,
xio_l_pipe_attr_t * attr)
{
globus_result_t result;
GlobusXIOName(globus_l_xio_pipe_handle_init);
GlobusXIOPipeDebugEnter();
*handle = (xio_l_pipe_handle_t *)
globus_calloc(1, sizeof(xio_l_pipe_handle_t));
if(!*handle)
{
result = GlobusXIOErrorMemory("handle");
goto error_handle;
}
globus_mutex_init(&(*handle)->lock, NULL);
(*handle)->use_blocking_io = attr->use_blocking_io;
(*handle)->infd = attr->infd;
(*handle)->outfd = attr->outfd;
GlobusXIOPipeDebugExit();
return GLOBUS_SUCCESS;
error_handle:
GlobusXIOPipeDebugExitWithError();
return result;
}
globus_result_t
list_init(list_t ** List)
{
globus_result_t result = GLOBUS_SUCCESS;
GlobusGFSName(__func__);
GlobusGFSHpssDebugEnter();
/* Allocate the list. */
*List = (list_t *) globus_calloc(1, sizeof(list_t));
if (*List == NULL)
{
result = GlobusGFSErrorMemory("list_t");
goto cleanup;
}
/* Initialize the list. */
globus_mutex_init(&(*List)->Lock, NULL);
cleanup:
if (result != GLOBUS_SUCCESS)
{
GlobusGFSHpssDebugExitWithError();
return result;
}
GlobusGFSHpssDebugExit();
return SUCCESS;
}
static
globus_result_t
globus_l_xio_popen_handle_init(
xio_l_popen_handle_t ** handle)
{
globus_result_t result;
GlobusXIOName(globus_l_xio_popen_handle_init);
GlobusXIOPOpenDebugEnter();
*handle = (xio_l_popen_handle_t *)
globus_calloc(1, sizeof(xio_l_popen_handle_t));
if(!*handle)
{
result = GlobusXIOErrorMemory("handle");
goto error_handle;
}
globus_mutex_init(&(*handle)->lock, NULL);
GlobusXIOPOpenDebugExit();
return GLOBUS_SUCCESS;
error_handle:
GlobusXIOPOpenDebugExitWithError();
return result;
}
/**
* @brief Initialize a recursive mutex
* @ingroup globus_mutex
*
* @details
* The globus_rmutex_init() function initializes a recursive mutex,
* that is, one which may be locked multiple times by a single thread
* without causing deadlock.
* @param rmutex
* A pointer to the mutex to initialize
* @param rattr
* IGNORED
*
* @return
* On success, globus_rmutex_init() initializes the mutex and returns
* GLOBUS_SUCCESS; otherwise, it returns a non-zero error code.
*/
int
globus_rmutex_init(
globus_rmutex_t * rmutex,
globus_rmutexattr_t * rattr)
{
int rc;
rc = globus_mutex_init(&rmutex->mutex, GLOBUS_NULL);
if(rc)
{
goto err_init;
}
rc = globus_cond_init(&rmutex->cond, GLOBUS_NULL);
if(rc)
{
goto err_cond;
}
rmutex->level = 0;
memset(&rmutex->thread_id,0,sizeof(rmutex->thread_id));
rmutex->waiting = 0;
return 0;
err_cond:
globus_mutex_destroy(&rmutex->mutex);
err_init:
return rc;
}
/******************************************************************************
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() */
static
int
bad_contact_test(void)
{
int rc;
struct monitor monitor;
globus_mutex_init(&monitor.mutex, NULL);
globus_cond_init(&monitor.cond, NULL);
monitor.done = GLOBUS_FALSE;
monitor.job_state = GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED;
monitor.protocol_error_code = GLOBUS_SUCCESS;
rc = globus_gram_client_register_job_status_with_info(
"https://grid.example.org:123/1234/1234/",
NULL /* can be NULL, optional param */,
info_callback,
&monitor);
test_assert(rc == GLOBUS_GRAM_PROTOCOL_ERROR_CONTACTING_JOB_MANAGER,
("Unexpected response to bad job contact \"%s\" (%d)",
globus_gram_protocol_error_string(rc),
rc));
rc = GLOBUS_SUCCESS;
return rc;
}
static
int
job_status_with_info_test(void)
{
int rc;
char * job_contact = NULL;
struct monitor monitor;
globus_mutex_init(&monitor.mutex, NULL);
globus_cond_init(&monitor.cond, NULL);
monitor.done = GLOBUS_FALSE;
monitor.job_state = GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED;
monitor.protocol_error_code = GLOBUS_SUCCESS;
rc = globus_gram_client_job_request(
rm_contact,
"&(executable=/bin/sleep)(arguments=60)",
0,
NULL,
&job_contact);
test_assert(rc == GLOBUS_SUCCESS,
("Failed submitting sleep job because %s (%d)",
globus_gram_protocol_error_string(rc),
rc));
rc = globus_gram_client_register_job_status_with_info(
job_contact,
NULL,
info_callback,
&monitor);
free(job_contact);
test_assert(rc == GLOBUS_SUCCESS,
("Failed registering job_status because %s (%d)",
globus_gram_protocol_error_string(rc),
rc));
globus_mutex_lock(&monitor.mutex);
while (!monitor.done)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
test_assert(monitor.protocol_error_code == GLOBUS_SUCCESS,
("Failed to determine job status because %s (%d)",
globus_gram_protocol_error_string(
monitor.protocol_error_code),
monitor.protocol_error_code));
test_assert(monitor.job_state != 0,
("Failed to determine job status"));
rc = GLOBUS_SUCCESS;
return rc;
}
/*
* globus_l_module_mutex_init()
*/
static void
globus_l_module_mutex_init(
globus_l_module_mutex_t * mutex)
{
globus_mutex_init(&mutex->mutex, (globus_mutexattr_t *) GLOBUS_NULL);
globus_cond_init(&mutex->cond, (globus_condattr_t *) GLOBUS_NULL);
mutex->level = 0;
}
int main(int argc, char * argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src;
char * dst;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_ftp_client_operationattr_set_type(&attr,
GLOBUS_FTP_CONTROL_TYPE_ASCII);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_symlink(&handle,
src,
dst,
&attr,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
}
globus_mutex_lock(&lock);
while(!done)
{
globus_cond_wait(&cond, &lock);
}
globus_mutex_unlock(&lock);
globus_ftp_client_handle_destroy(&handle);
globus_module_deactivate_all();
if(test_abort_count && error)
{
return 0;
}
return error;
}
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 },
globus_result_t
gfs_i_xio_cp_start(
gfs_i_xio_cp_handle_t ** cp_h_out,
globus_fifo_t * read_handle_fifo,
globus_fifo_t * write_handle_fifo,
globus_callback_func_t complete_cb,
globus_callback_func_t update_cb,
void * user_arg)
{
globus_fifo_t * read_q;
gfs_i_xio_cp_handle_t * cp_h;
cp_h = (gfs_i_xio_cp_handle_t *)
globus_calloc(1, sizeof(gfs_i_xio_cp_handle_t));
cp_h->read_all_q = globus_fifo_copy(net_handle_fifo);
cp_h->write_all_q = globus_fifo_copy(net_handle_fifo);
cp_h->write_q = globus_fifo_copy(net_handle_fifo);
globus_fifo_init(&cp_h->read_buffer_q);
cp_h->block_size = block_size;
cp_h->cb = complete_cb;
cp_h->user_arg = user_arg;
globus_mutex_init(&cp_h->mutex, NULL);
cp_h->state = GFS_XIO_CP_STATE_OPEN;
read_q = globus_fifo_copy(net_handle_fifo);
cp_h->read_handle_count = globus_fifo_size(cp_h->read_all_q);
cp_h->write_handle_count = globus_fifo_size(cp_h->write_all_q);
*cp_h_out = cp_h;
globus_mutex_lock(&cp_h->mutex);
{
while(!globus_fifo_empty(read_q))
{
xio_h = (globus_xio_handle_t) globus_fifo_dequeue(cp_h->read_q);
read_buf = (gfs_l_xio_read_buffer_t *)
globus_calloc(sizeof(gfs_l_xio_read_buffer_t)+block_size, 1);
read_buf->block_size = block_size;
read_buf->whos_my_daddy = cp_h;
gfs_l_xio_cp_post_read(xio_h, read_buf);
}
}
globus_mutex_unlock(&cp_h->mutex);
globus_fifo_destroy(read_q);
return GLOBUS_SUCCESS;
}
void
test_monitor_initialize(
test_monitor_t * monitor,
void * user_data)
{
globus_mutex_init(&monitor->mutex, GLOBUS_NULL);
globus_cond_init(&monitor->cond, GLOBUS_NULL);
monitor->err = GLOBUS_NULL;
monitor->use_err = GLOBUS_FALSE;
monitor->done = GLOBUS_FALSE;
monitor->ready = GLOBUS_FALSE;
monitor->nbytes = 0;
monitor->user_data = user_data;
}
static globus_result_t
transfer_control_common_init(transfer_control_msg_type_t OpType,
msg_handle_t * MsgHandle,
transfer_control_t ** TransferControl)
{
globus_result_t result = GLOBUS_SUCCESS;
GlobusGFSName(__func__);
GlobusGFSHpssDebugEnter();
/* Allocate the handle. */
*TransferControl = (transfer_control_t *) globus_calloc(1, sizeof(transfer_control_t));
if (*TransferControl == NULL)
{
result = GlobusGFSErrorMemory("transfer_control_t");
goto cleanup;
}
/* Initialize the entries. */
globus_mutex_init(&(*TransferControl)->Lock, NULL);
(*TransferControl)->OpType = OpType;
(*TransferControl)->MsgHandle = MsgHandle;
(*TransferControl)->State = TRANSFER_CONTROL_WAIT_FOR_DATA_READY;
(*TransferControl)->MsgRegisterID = MSG_REGISTER_ID_NONE;
/* Intialize the range list. Fill it later. */
result = range_list_init(&(*TransferControl)->TransferRangeList);
if (result != GLOBUS_SUCCESS)
goto cleanup;
/* Register to receive messages. */
result = msg_register(MsgHandle,
MSG_COMP_ID_IPC_CONTROL,
MSG_COMP_ID_TRANSFER_CONTROL,
transfer_control_msg_recv,
*TransferControl,
&(*TransferControl)->MsgRegisterID);
cleanup:
if (result != GLOBUS_SUCCESS)
{
GlobusGFSHpssDebugExitWithError();
return result;
}
GlobusGFSHpssDebugExit();
return GLOBUS_SUCCESS;
}
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 activation
*/
static
int
globus_l_gsi_gss_assist_activate(void)
{
int result;
char * tmp_string;
static char * _function_name_ =
"globus_l_gsi_gss_assist_activate";
tmp_string = getenv("GLOBUS_GSI_GSS_ASSIST_DEBUG_LEVEL");
if(tmp_string != GLOBUS_NULL)
{
globus_i_gsi_gss_assist_debug_level = atoi(tmp_string);
if(globus_i_gsi_gss_assist_debug_level < 0)
{
globus_i_gsi_gss_assist_debug_level = 0;
}
}
tmp_string = getenv("GLOBUS_GSI_GSS_ASSIST_DEBUG_FILE");
if(tmp_string != GLOBUS_NULL)
{
globus_i_gsi_gss_assist_debug_fstream = fopen(tmp_string, "w");
if(globus_i_gsi_gss_assist_debug_fstream == NULL)
{
result = GLOBUS_FAILURE;
goto exit;
}
}
else
{
globus_i_gsi_gss_assist_debug_fstream = stderr;
}
GLOBUS_I_GSI_GSS_ASSIST_DEBUG_ENTER;
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_module_activate(GLOBUS_CALLOUT_MODULE);
globus_module_activate(GLOBUS_GSI_SYSCONFIG_MODULE);
globus_module_activate(GLOBUS_GSI_GSSAPI_MODULE);
globus_mutex_init(&globus_i_gsi_gss_assist_mutex, NULL);
exit:
GLOBUS_I_GSI_GSS_ASSIST_DEBUG_EXIT;
return GLOBUS_SUCCESS;
}
globus_bool_t
async_control_test(
globus_ftp_control_handle_t * handle)
{
globus_ftp_control_handle_t control_handle;
globus_result_t result;
globus_mutex_init(&end_mutex, GLOBUS_NULL);
globus_cond_init(&end_cond, GLOBUS_NULL);
end_done = GLOBUS_FALSE;
result = globus_ftp_control_handle_init(&control_handle);
if (result != GLOBUS_SUCCESS)
{
printf("error: could not initialize\n");
exit(1);
}
result = globus_ftp_control_connect(
&control_handle,
login_info.hostname,
login_info.port,
connect_callback,
GLOBUS_NULL);
if (result != GLOBUS_SUCCESS)
{
printf("error: could not connect\n");
return GLOBUS_FALSE;
}
globus_mutex_lock(&end_mutex);
{
while(!end_done)
{
globus_cond_wait(&end_cond, &end_mutex);
}
}
globus_mutex_unlock(&end_mutex);
globus_ftp_control_handle_destroy(&control_handle);
return GLOBUS_TRUE;
}
/**
* Operator: Initialize
*/
ngemResult_t
ngrcOperatorInitialize(
ngrcOperator_t *op,
globus_xio_handle_t handle)
{
globus_result_t gResult;
ngLog_t *log;
bool mutexInitialized = false;
NGEM_FNAME(ngrcOperatorInitialize);
log = ngemLogGetDefault();
NGEM_ASSERT(op != NULL);
NGEM_ASSERT(handle != NULL);
op->ngo_handle = handle;
op->ngo_canceled = false;
gResult = globus_mutex_init(&op->ngo_mutex, NULL);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_init", gResult);
goto error;
}
mutexInitialized = true;
globus_cond_init(&op->ngo_cond, NULL);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_cond_init", gResult);
goto error;
}
return NGEM_SUCCESS;
error:
if (mutexInitialized) {
gResult = globus_mutex_destroy(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_destroy", gResult);
}
}
return NGEM_FAILED;
}
int main(int argc,
char *argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_byte_t buffer[1024];
globus_size_t buffer_length = sizeof(buffer);
globus_result_t result;
char * src;
char * dst;
globus_ftp_client_handleattr_t handle_attr;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_get(&handle,
src,
&attr,
GLOBUS_NULL,
done_cb,
0);
globus_module_deactivate_all();
return done;
}
globus_result_t
globus_l_xio_bounce_open(
const globus_xio_contact_t * contact_info,
void * driver_link,
void * driver_attr,
globus_xio_operation_t op)
{
bounce_info_t * info;
globus_result_t res;
GlobusXIOName(globus_l_xio_bounce_open);
GlobusXIOTestDebugInternalEnter();
info = (bounce_info_t *)
globus_malloc(sizeof(bounce_info_t));
memset(info, '\0', sizeof(bounce_info_t));
info->next_op = TEST_READ;
info->bounce_count = 0;
info->max_count = MAX_COUNT;
info->start_op = TEST_OPEN;
info->handle = (bounce_handle_t *) globus_malloc(sizeof(bounce_handle_t));
globus_mutex_init(&info->handle->mutex, NULL);
info->handle->closed_iface = GLOBUS_FALSE;
info->handle->closed_cb = GLOBUS_FALSE;
info->handle->open_cb = GLOBUS_FALSE;
res = globus_xio_driver_pass_open(
op, contact_info, open_bounce_cb, (void*)info);
if(res != GLOBUS_SUCCESS)
{
bounce_handle_destroy(info->handle);
globus_free(info);
goto err;
}
GlobusXIOTestDebugInternalExit();
return GLOBUS_SUCCESS;
err:
GlobusXIOTestDebugInternalExitWithError();
return res;
}
/**
* Module activation
*/
static
int
globus_l_openssl_activate(void)
{
int i;
int pci_NID;
int pci_old_NID;
X509V3_EXT_METHOD * pci_x509v3_ext_meth = NULL;
X509V3_EXT_METHOD * pci_old_x509v3_ext_meth = NULL;
SSL_library_init();
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_module_activate(GLOBUS_GSI_OPENSSL_ERROR_MODULE);
mutex_pool = malloc(CRYPTO_num_locks() * sizeof(globus_mutex_t));
for(i=0;i<CRYPTO_num_locks();i++)
{
globus_mutex_init(&(mutex_pool[i]),NULL);
}
if (!CRYPTO_get_locking_callback())
{
CRYPTO_set_locking_callback(globus_l_openssl_locking_cb);
}
if (!CRYPTO_get_id_callback())
{
CRYPTO_set_id_callback(globus_l_openssl_thread_id);
}
if (OBJ_txt2nid(ANY_LANGUAGE_OID) == 0)
{
OBJ_create(ANY_LANGUAGE_OID,
ANY_LANGUAGE_SN,
ANY_LANGUAGE_LN);
}
if (OBJ_txt2nid(IMPERSONATION_PROXY_OID) == 0)
{
OBJ_create(IMPERSONATION_PROXY_OID,
IMPERSONATION_PROXY_SN,
IMPERSONATION_PROXY_LN);
}
if (OBJ_txt2nid(INDEPENDENT_PROXY_OID) == 0)
{
OBJ_create(INDEPENDENT_PROXY_OID,
INDEPENDENT_PROXY_SN,
INDEPENDENT_PROXY_LN);
}
if (OBJ_txt2nid(LIMITED_PROXY_OID) == 0)
{
OBJ_create(LIMITED_PROXY_OID,
LIMITED_PROXY_SN,
LIMITED_PROXY_LN);
}
pci_NID = OBJ_txt2nid(PROXYCERTINFO_OID);
if (pci_NID == 0)
{
pci_NID = OBJ_create(PROXYCERTINFO_OID,
PROXYCERTINFO_SN,
PROXYCERTINFO_LN);
}
pci_old_NID = OBJ_txt2nid(PROXYCERTINFO_OLD_OID);
if (pci_old_NID == 0)
{
pci_old_NID = OBJ_create(PROXYCERTINFO_OLD_OID,
PROXYCERTINFO_OLD_SN,
PROXYCERTINFO_OLD_LN);
}
/* this sets the pci NID in the static X509V3_EXT_METHOD struct */
if (X509V3_EXT_get_nid(pci_NID) == NULL)
{
pci_x509v3_ext_meth = PROXYCERTINFO_x509v3_ext_meth();
pci_x509v3_ext_meth->ext_nid = pci_NID;
X509V3_EXT_add(pci_x509v3_ext_meth);
}
if (X509V3_EXT_get_nid(pci_old_NID) == NULL)
{
pci_old_x509v3_ext_meth = PROXYCERTINFO_OLD_x509v3_ext_meth();
pci_old_x509v3_ext_meth->ext_nid = pci_old_NID;
X509V3_EXT_add(pci_old_x509v3_ext_meth);
}
return GLOBUS_SUCCESS;
}
void
globus_l_gsi_gssapi_activate_once(void)
{
globus_mutex_init(&globus_i_gssapi_activate_mutex, NULL);
}
int
space_main(
int argc,
char ** argv)
{
int rc;
globus_xio_stack_t stack;
globus_xio_handle_t handle;
globus_result_t res;
globus_xio_attr_t attr;
globus_condattr_t condattr;
globus_l_closed = GLOBUS_FALSE;
globus_l_close_called = GLOBUS_FALSE;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
res = globus_xio_attr_init(&attr);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_stack_init(&stack, NULL);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
parse_parameters(argc, argv, stack, attr);
globus_callback_space_init(&globus_l_space, NULL);
globus_condattr_init(&condattr);
globus_condattr_setspace(&condattr, globus_l_space);
globus_mutex_init(&globus_l_mutex, NULL);
globus_cond_init(&globus_l_cond, &condattr);
res = globus_xio_handle_create(&handle, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_attr_cntl(attr, NULL, GLOBUS_XIO_ATTR_SET_SPACE, globus_l_space);
res = globus_xio_register_open(
handle,
"whatever",
attr,
open_cb,
argv[argc-1]);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_closed)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
globus_xio_attr_destroy(attr);
globus_xio_stack_destroy(stack);
test_common_end();
globus_callback_space_destroy(globus_l_space);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
fprintf(stdout, "Success.\n");
return 0;
}
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);
}
}
void ADIOI_GRIDFTP_Open(ADIO_File fd, int *error_code)
{
static char myname[]="ADIOI_GRIDFTP_Open";
int myrank, nprocs, keyfound;
char hintval[MPI_MAX_INFO_VAL+1];
globus_ftp_client_handleattr_t hattr;
globus_result_t result;
MPI_Comm_size(fd->comm, &nprocs);
MPI_Comm_rank(fd->comm, &myrank);
/* activate Globus ftp client module -- can be called multiple times, so
it's safest to call once per file/connection */
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
fd->fd_sys = num_gridftp_handles;
/* No shared file pointers for now */
fd->shared_fp_fname = NULL;
*error_code = MPI_SUCCESS;
/* Access modes here mean something very different here than they
would on a "real" filesystem... As a result, the amode and hint
processing here is intermingled and a little weird because many
of them have to do with the connection rather than the file itself.
The thing that sucks about this is that read and write ops will
have to check themselves if the file is being accessed rdonly, rdwr,
or wronly.
*/
result=globus_ftp_client_handleattr_init(&hattr);
if ( result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_handleattr_init",
myname,result);
fd->fd_sys = -1;
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
result = globus_ftp_client_operationattr_init(&(oattr[fd->fd_sys]));
if ( result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_operationattr_init",
myname,result);
fd->fd_sys = -1;
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
/* Always use connection caching unless told otherwise */
result=globus_ftp_client_handleattr_set_cache_all(&hattr,GLOBUS_TRUE);
if ( result !=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_handleattr_set_cache_all",myname,result);
/* Assume that it's safe to cache a file if it's read-only */
if ( (fd->access_mode&ADIO_RDONLY) &&
(result=globus_ftp_client_handleattr_add_cached_url(&hattr,fd->filename))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_handleattr_add_cached_url",myname,result);
/* Since we're (almost by definition) doing things that FTP S (stream)
control mode can't handle, default to E (extended block) control mode
for gsiftp:// URLs. ftp:// URLs use standard stream control mode
by default. This behavior can be overridden by the ftp_control_mode
hint. */
/*
if ( !strncmp(fd->filename,"gsiftp:",7) &&
(result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result);
else if ( !strncmp(fd->filename,"ftp:",4) &&
(result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_STREAM))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result);
*/
/* Set append mode if necessary */
if ( (fd->access_mode&ADIO_APPEND) &&
((result=globus_ftp_client_operationattr_set_append(&(oattr[fd->fd_sys]),GLOBUS_TRUE))!=GLOBUS_SUCCESS) )
globus_err_handler("globus_ftp_client_operationattr_set_append",myname,result);
/* Other hint and amode processing that would affect hattr and/or
oattr[] (eg. parallelism, striping, etc.) goes here */
if ( fd->info!=MPI_INFO_NULL )
{
ADIOI_Info_get(fd->info,"ftp_control_mode",MPI_MAX_INFO_VAL,hintval,&keyfound);
if ( keyfound )
{
if ( ( !strcmp(hintval,"extended") || !strcmp(hintval,"extended_block") ) &&
(result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result);
else if ( !strcmp(hintval,"block") &&
(result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_BLOCK))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result);
else if ( !strcmp(hintval,"compressed") &&
(result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_COMPRESSED))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result);
else if ( !strcmp(hintval,"stream") &&
(result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_STREAM))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result);
}
ADIOI_Info_get(fd->info,"parallelism",MPI_MAX_INFO_VAL,hintval,&keyfound);
if ( keyfound )
{
int nftpthreads;
if ( sscanf(hintval,"%d",&nftpthreads)==1 )
{
globus_ftp_control_parallelism_t parallelism;
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED;
parallelism.fixed.size = nftpthreads;
if ( (result=globus_ftp_client_operationattr_set_parallelism(&(oattr[fd->fd_sys]),
¶llelism))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_parallelism",myname,result);
}
}
ADIOI_Info_get(fd->info,"striped_ftp",MPI_MAX_INFO_VAL,hintval,&keyfound);
if ( keyfound )
{
/* if set to "true" or "enable", set up round-robin block layout */
if ( !strncmp("true",hintval,4) || !strncmp("TRUE",hintval,4) ||
!strncmp("enable",hintval,4) || !strncmp("ENABLE",hintval,4) )
{
ADIOI_Info_get(fd->info,"striping_factor",MPI_MAX_INFO_VAL,hintval,&keyfound);
if ( keyfound )
{
int striping_factor;
if ( sscanf(hintval,"%d",&striping_factor)==1 )
{
globus_ftp_control_layout_t layout;
layout.mode = GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN;
layout.round_robin.block_size = striping_factor;
if ( (result=globus_ftp_client_operationattr_set_layout(&(oattr[fd->fd_sys]),
&layout))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_layout",
myname,result);
}
}
}
}
ADIOI_Info_get(fd->info,"tcp_buffer",MPI_MAX_INFO_VAL,hintval,&keyfound);
if ( keyfound )
{
/* set tcp buffer size */
int buffer_size;
if ( sscanf(hintval,"%d",&buffer_size)==1 )
{
globus_ftp_control_tcpbuffer_t tcpbuf;
tcpbuf.mode = GLOBUS_FTP_CONTROL_TCPBUFFER_FIXED;
tcpbuf.fixed.size = buffer_size;
if ( (result=globus_ftp_client_operationattr_set_tcp_buffer(&(oattr[fd->fd_sys]),
&tcpbuf))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_tcp_buffer",myname,result);
}
}
ADIOI_Info_get(fd->info,"transfer_type",MPI_MAX_INFO_VAL,hintval,&keyfound);
if ( keyfound )
{
globus_ftp_control_type_t filetype;
/* set transfer type (i.e. ASCII or binary) */
if ( !strcmp("ascii",hintval) || !strcmp("ASCII",hintval) )
{
filetype=GLOBUS_FTP_CONTROL_TYPE_ASCII;
}
else
{
filetype=GLOBUS_FTP_CONTROL_TYPE_IMAGE;
}
if ( (result=globus_ftp_client_operationattr_set_type(&(oattr[fd->fd_sys]),filetype))!=GLOBUS_SUCCESS )
globus_err_handler("globus_ftp_client_operationattr_set_type",myname,result);
}
}
else
FPRINTF(stderr,"no MPI_Info object associated with %s\n",fd->filename);
/* Create the ftp handle */
result=globus_ftp_client_handle_init(&(gridftp_fh[fd->fd_sys]),&hattr);
if ( result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_handle_init",myname,result);
fd->fd_sys = -1;
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
/* Check for existence of the file */
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
file_exists=GLOBUS_FALSE;
exists_done=GLOBUS_FALSE;
if ( myrank==0 )
{
if ( (result=globus_ftp_client_exists(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
exists_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_exists",myname,result);
fd->fd_sys = -1;
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
/* wait till the callback completes */
globus_mutex_lock(&lock);
while ( exists_done!=GLOBUS_TRUE )
globus_cond_wait(&cond,&lock);
globus_mutex_unlock(&lock);
}
MPI_Barrier(fd->comm);
MPI_Bcast(&file_exists,1,MPI_INT,0,fd->comm);
/* It turns out that this is handled by MPI_File_open() directly */
if ( (file_exists!=GLOBUS_TRUE) && (fd->access_mode&ADIO_CREATE) &&
!(fd->access_mode&ADIO_EXCL) && !(fd->access_mode&ADIO_RDONLY) )
{
if ( myrank==0 )
{
/* if the file doesn't exist, write a single NULL to it */
globus_byte_t touchbuf=(globus_byte_t)'\0';
touch_ctl_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_put(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
GLOBUS_NULL,
touch_ctl_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_put",myname,result);
fd->fd_sys = -1;
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
result=globus_ftp_client_register_write(&(gridftp_fh[fd->fd_sys]),
(globus_byte_t *)&touchbuf, 0,
(globus_off_t)0, GLOBUS_TRUE,
touch_data_cb, GLOBUS_NULL);
if ( result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_register_write",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
globus_mutex_lock(&lock);
while ( touch_ctl_done!=GLOBUS_TRUE )
globus_cond_wait(&cond,&lock);
globus_mutex_unlock(&lock);
}
MPI_Barrier(fd->comm);
}
else if ( (fd->access_mode&ADIO_EXCL) && (file_exists==GLOBUS_TRUE) )
{
fd->fd_sys = -1;
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", 0);
return;
}
else if ( (fd->access_mode&ADIO_RDONLY) && (file_exists!=GLOBUS_TRUE) )
{
if ( myrank==0 )
{
FPRINTF(stderr,"WARNING: read-only file %s does not exist!\n",fd->filename);
}
}
num_gridftp_handles++;
}
static globus_result_t
globus_l_xio_telnet_open(
const globus_xio_contact_t * contact_info,
void * driver_link,
void * driver_attr,
globus_xio_operation_t op)
{
globus_result_t res;
globus_l_xio_telnet_attr_t * attr;
globus_l_xio_telnet_handle_t * handle;
GlobusXIOName(globus_l_xio_telnet_open);
/* decide what attr to use */
if(driver_attr != NULL)
{
attr = (globus_l_xio_telnet_attr_t *) driver_attr;
}
else if(driver_link != NULL)
{
attr = (globus_l_xio_telnet_attr_t *) driver_link;
}
else
{
/* default */
attr = NULL;
}
handle = (globus_l_xio_telnet_handle_t *) globus_calloc(
sizeof(globus_l_xio_telnet_handle_t), 1);
if(handle == NULL)
{
res = GlobusXIOErrorMemory("handle");
goto error_handle_alloc;
}
if(attr != NULL && attr->force_server)
{
handle->client = GLOBUS_FALSE;
}
else
{
handle->client = driver_link ? GLOBUS_FALSE : GLOBUS_TRUE;
}
handle->read_buffer_length = GLOBUS_L_XIO_TELNET_DEFAULT_BUFFER_SIZE;
handle->read_buffer = globus_malloc(handle->read_buffer_length);
if(handle->read_buffer == NULL)
{
res = GlobusXIOErrorMemory("buffer");
goto error_buffer_alloc;
}
globus_mutex_init(&handle->mutex, NULL);
globus_fifo_init(&handle->write_q);
handle->create_buffer_mode = attr
? attr->create_buffer_mode : GLOBUS_FALSE;
res = globus_xio_driver_pass_open(
op,
contact_info,
globus_l_xio_telnet_open_cb,
handle);
if(res != GLOBUS_SUCCESS)
{
goto error_pass;
}
return GLOBUS_SUCCESS;
error_pass:
globus_free(handle->read_buffer);
globus_mutex_destroy(&handle->mutex);
globus_fifo_destroy(&handle->write_q);
error_buffer_alloc:
globus_free(handle);
error_handle_alloc:
return res;
}
int
globus_args_scan(
int * argc,
char *** argv,
int option_count,
globus_args_option_descriptor_t * options,
const char * name,
const globus_version_t * version,
const char * oneline_usage,
const char * long_usage,
globus_list_t ** options_found,
char ** error_msg )
{
static globus_mutex_t args_mutex;
static globus_bool_t args_mutex_initialized = GLOBUS_FALSE;
int rc;
int my_argc;
char * my_arg;
int len;
int i;
char ** alias;
char ** arglist;
globus_fifo_t fifo;
globus_bool_t done;
globus_bool_t found;
globus_libc_lock();
if (!args_mutex_initialized)
{
globus_mutex_init(&args_mutex,
(globus_mutexattr_t *) GLOBUS_NULL);
args_mutex_initialized = GLOBUS_TRUE;
}
globus_libc_unlock();
globus_mutex_lock(&args_mutex);
rc = GLOBUS_SUCCESS;
globus_fifo_init(&fifo);
*options_found = GLOBUS_NULL;
if (error_msg)
*error_msg = GLOBUS_NULL;
/* precheck : are the options correct? */
rc = globus_l_args_check_options(option_count, options, error_msg);
done = (rc==GLOBUS_SUCCESS) ? GLOBUS_FALSE : GLOBUS_TRUE;
my_argc=1;
while (!done)
{
/* any more options? */
if (my_argc == *argc)
{
done=GLOBUS_TRUE;
continue;
}
my_arg = (*argv)[my_argc];
len = strlen(my_arg);
if (my_arg[0]!='-' || len<2)
{
/* unrecognized option */
done=GLOBUS_TRUE;
continue;
}
/* '--*' is a special case : if '*' is non-null, it's an error.
Otherwise, it signals end of parsing. */
if (!strncmp(my_arg,"--",2))
{
if (len == 2) /* end of parsing */
{
/* next argument is first "unrecognized" option */
my_argc++;
}
else
{
rc = GLOBUS_FAILURE;
globus_l_args_create_error_msg(
error_msg,
my_argc,
my_arg,
_GCSL("double-dashed option syntax is not allowed"),
oneline_usage );
}
done = GLOBUS_TRUE;
continue;
}
/* four specials : -help, -usage, -version, -versions */
if (!strcmp("-help",my_arg))
{
globus_l_args_create_msg( error_msg ,
(char *) long_usage );
rc = GLOBUS_ARGS_HELP;
done = GLOBUS_TRUE;
continue;
}
if(!strcmp("-usage",my_arg))
{
globus_l_args_create_msg( error_msg ,
(char *) oneline_usage );
rc = GLOBUS_ARGS_HELP;
done = GLOBUS_TRUE;
continue;
}
if (!strcmp("-version",my_arg))
{
globus_version_print(
name,
version,
stderr,
GLOBUS_FALSE);
rc = GLOBUS_ARGS_VERSION;
done = GLOBUS_TRUE;
continue;
}
if (!strcmp("-versions",my_arg))
{
globus_version_print(
name,
version,
stderr,
GLOBUS_TRUE);
globus_module_print_activated_versions(stderr, GLOBUS_TRUE);
rc = GLOBUS_ARGS_VERSION;
done = GLOBUS_TRUE;
continue;
}
/* is it a known flag? */
found=GLOBUS_FALSE;
for (i=0; !found && !rc && i<option_count; i++)
{
for (alias=options[i].names; !found && !rc && *alias; alias++)
{
if (!strcmp(my_arg, *alias))
{
found = GLOBUS_TRUE;
arglist = GLOBUS_NULL;
if (options[i].arity > 0)
{
if (my_argc+options[i].arity >= *argc)
{
globus_l_args_create_error_msg(
error_msg,
my_argc,
my_arg,
_GCSL("not enough arguments"),
oneline_usage );
rc = GLOBUS_FAILURE;
continue;
}
rc = globus_l_args_validate( &options[i],
my_argc,
(*argv),
&arglist,
oneline_usage,
error_msg );
} /* if */
if (rc==GLOBUS_SUCCESS)
{
/* option successfully detected: add it */
globus_l_args_add_instance( &fifo,
&options[i],
arglist );
my_argc += 1+options[i].arity;
}
} /* strcmp(my_arg,*alias)) */
} /* alias */
} /* i */
if (!found)
{
/* my_arg contains an unregistered option */
rc = GLOBUS_FAILURE;
globus_l_args_create_error_msg( error_msg,
my_argc,
my_arg,
_GCSL("unknown option"),
oneline_usage );
}
if (rc!=GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
continue;
}
} /* while (!done) */
if (rc==GLOBUS_SUCCESS)
{
/* if successful, return number of options found */
rc = globus_fifo_size(&fifo);
*options_found = globus_fifo_convert_to_list( &fifo );
/* modify argc/argv */
if (my_argc>1)
{
for (i = my_argc; i < *argc; i++)
(*argv)[i-my_argc+1] = (*argv)[i];
*argc -= my_argc - 1;
}
}
globus_fifo_destroy(&fifo);
globus_mutex_unlock(&args_mutex);
return rc;
}
static
int
globus_l_job_manager_module_activate(void)
{
time_t timestamp_val;
globus_l_job_manager_logfile_state_t *
logfile_state;
int rc;
globus_reltime_t delay;
globus_result_t result;
char * scheduler;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto activate_common_failed;
}
rc = globus_mutex_init(&globus_l_job_manager_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto mutex_init_failed;
}
rc = globus_cond_init(&globus_l_job_manager_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto cond_init_failed;
}
shutdown_called = GLOBUS_FALSE;
callback_count = 0;
GlobusDebugInit(
SEG_JOB_MANAGER,
SEG_JOB_MANAGER_DEBUG_INFO
SEG_JOB_MANAGER_DEBUG_WARN
SEG_JOB_MANAGER_DEBUG_ERROR
SEG_JOB_MANAGER_DEBUG_TRACE);
logfile_state = calloc(1, sizeof(globus_l_job_manager_logfile_state_t));
if (logfile_state == NULL)
{
goto calloc_state_failed;
}
/* Configuration info */
result = globus_scheduler_event_generator_get_timestamp(×tamp_val);
if (result != GLOBUS_SUCCESS)
{
goto get_timestamp_failed;
}
if (timestamp_val != 0)
{
if (globus_libc_gmtime_r(
×tamp_val,
&logfile_state->start_timestamp) == NULL)
{
goto gmtime_failed;
}
}
scheduler = globus_libc_getenv(JOB_MANAGER_SEG_SCHEDULER);
if (scheduler == NULL)
{
SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR,
("Error: %s not set\n", JOB_MANAGER_SEG_SCHEDULER));
result = GLOBUS_FAILURE;
goto get_scheduler_failed;
}
if (getenv(JOB_MANAGER_SEG_LOG_PATH))
{
logfile_state->log_dir = strdup(getenv(JOB_MANAGER_SEG_LOG_PATH));
}
else
{
char * log_dir_pattern = globus_common_create_string(
"${localstatedir}/lib/globus/globus-seg-%s", scheduler);
globus_eval_path(log_dir_pattern, &logfile_state->log_dir);
free(log_dir_pattern);
}
if (logfile_state->log_dir == NULL)
{
SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR,
("Error: out of memory\n"));
goto get_path_failed;
}
/* Convert timestamp to filename */
rc = globus_l_job_manager_find_logfile(logfile_state);
if (rc == GLOBUS_SUCCESS)
{
logfile_state->fp = fopen(logfile_state->path, "r");
if (logfile_state->fp == NULL)
{
rc = SEG_JOB_MANAGER_ERROR_OUT_OF_MEMORY;
goto fopen_failed;
}
GlobusTimeReltimeSet(delay, 0, 0);
}
else if(rc == SEG_JOB_MANAGER_ERROR_LOG_NOT_PRESENT)
{
GlobusTimeReltimeSet(delay, 1, 0);
}
else
{
goto bad_log_path;
}
result = globus_callback_register_oneshot(
&logfile_state->callback,
&delay,
globus_l_job_manager_poll_callback,
logfile_state);
if (result != GLOBUS_SUCCESS)
{
goto oneshot_failed;
}
callback_count++;
return 0;
oneshot_failed:
if (logfile_state->fp)
{
fclose(logfile_state->fp);
}
fopen_failed:
if (logfile_state->path)
{
free(logfile_state->path);
}
bad_log_path:
free(logfile_state->log_dir);
get_path_failed:
get_scheduler_failed:
get_timestamp_failed:
gmtime_failed:
free(logfile_state);
calloc_state_failed:
globus_cond_destroy(&globus_l_job_manager_cond);
cond_init_failed:
globus_mutex_destroy(&globus_l_job_manager_mutex);
mutex_init_failed:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
activate_common_failed:
return 1;
}
int main(int argc, char * argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src = NULL;
char * dst = NULL;
struct tm modtime;
extern char * optarg;
extern int optind;
int c;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
optind = 1;
while((c = getopt(argc, argv, "T:")) != -1)
{
switch(c)
{
case 'T':
memset(&modtime, 0, sizeof(modtime));
if (sscanf(optarg, "%4d%2d%2d%2d%2d%2d",
&modtime.tm_year, &modtime.tm_mon, &modtime.tm_mday,
&modtime.tm_hour, &modtime.tm_min, &modtime.tm_sec) != 6)
{
printf("Invalid time format\n");
return GLOBUS_TRUE;
}
modtime.tm_year -= 1900;
modtime.tm_mon -= 1;
break;
}
}
globus_ftp_client_operationattr_set_type(&attr,
GLOBUS_FTP_CONTROL_TYPE_ASCII);
globus_ftp_client_handleattr_set_cache_all(&handle_attr,
GLOBUS_TRUE);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_utime(&handle,
src,
&modtime,
&attr,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
}
globus_mutex_lock(&lock);
while(!done)
{
globus_cond_wait(&cond, &lock);
}
globus_mutex_unlock(&lock);
globus_ftp_client_handle_destroy(&handle);
globus_module_deactivate_all();
if(test_abort_count && error)
{
return 0;
}
return error;
}
mutex()
: mutex_()
{
globus_mutex_init(&mutex_, NULL);
}
int
framework_main(
int argc,
char ** argv)
{
int rc;
globus_xio_stack_t stack;
globus_xio_handle_t handle;
globus_xio_attr_t attr;
globus_result_t res;
globus_xio_server_t server;
globus_l_closed = GLOBUS_FALSE;
globus_l_accepted = GLOBUS_FALSE;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
globus_mutex_init(&globus_l_mutex, NULL);
globus_cond_init(&globus_l_cond, NULL);
res = globus_xio_attr_init(&attr);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_stack_init(&stack, NULL);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
parse_parameters(argc, argv, stack, attr);
if(globus_l_test_info.server)
{
res = globus_xio_server_create(&server, attr, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_server_register_accept(
server,
accept_cb,
&handle);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_ACCEPT, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_accepted)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
}
else
{
res = globus_xio_handle_create(&handle, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
res = globus_xio_register_open(
handle,
"whatever",
attr,
open_cb,
(void *)&globus_l_test_info);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_OPEN, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_closed)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
globus_xio_attr_destroy(attr);
globus_xio_stack_destroy(stack);
if(globus_l_test_info.server)
{
res = globus_xio_server_close(server);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
test_common_end();
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
fprintf(stdout, "Success.\n");
return 0;
}
