static
globus_result_t
gfork_l_get_env_fd(
char * env,
int * out_fd)
{
globus_result_t res;
char * tmp_str;
int sc;
int fd;
GForkFuncName(gfork_l_get_env_fd);
tmp_str = globus_libc_getenv(env);
if(tmp_str == NULL)
{
res = GForkErrorStr("Env not set");
goto error_env;
}
sc = sscanf(tmp_str, "%d", &fd);
if(sc != 1)
{
res = GForkErrorStr("Env not and integer");
goto error_scan;
}
*out_fd = fd;
return GLOBUS_SUCCESS;
error_scan:
error_env:
return res;
}
int gsi_authorization_callback(struct soap *soap, char *distinguished_name)
{
char buf[256] = { '\0' };
char *auth;
char *auth_file;
FILE *fd;
struct gsi_plugin_data *data;
data = (struct gsi_plugin_data *) soap_lookup_plugin(soap, GSI_PLUGIN_ID);
auth = globus_libc_getenv("AUTHORIZATION_FILE");
if (auth != NULL) {
auth_file = strdup(auth);
} else {
auth_file = strdup(AUTHORIZATION_FILE);
}
fd = fopen(auth_file, "r");
if (!fd) {
globus_libc_printf("Can not read file: %s\n", auth_file);
return 1;
}
while (fgets(buf, 512, fd) != NULL) {
buf[strlen(buf) - 1] = '\0';
if (!strcmp(distinguished_name, buf)) {
if (auth)
free(auth);
if (auth_file)
free(auth_file);
fclose(fd);
return 0;
}
}
if (auth)
free(auth);
if (auth_file)
free(auth_file);
fclose(fd);
globus_libc_printf("Sorry, service %s is not authorized\n", distinguished_name);
return 1;
}
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;
}
/**
* Initialize an instance of the GridFTP restart plugin
* @ingroup globus_ftp_client_restart_plugin
*
* This function will initialize the plugin-specific instance data
* for this plugin, and will make the plugin usable for ftp
* client handle attribute and handle creation.
*
* @param plugin
* A pointer to an uninitialized plugin. The plugin will be
* configured as a restart plugin.
* @param max_retries
* The maximum number of times to retry the operation before giving
* up on the transfer. If this value is less than or equal to 0,
* then the restart plugin will keep trying to restart the operation
* until it completes or the deadline is reached with an unsuccessful
* operation.
* @param interval
* The interval to wait after a failures before retrying the transfer.
* If the interval is 0 seconds or GLOBUS_NULL, then an exponential
* backoff will be used.
* @param deadline
* An absolute timeout. If the deadline is GLOBUS_NULL then the retry
* will never timeout.
*
* @return This function returns an error if
* - plugin is null
*
* @see globus_ftp_client_restart_plugin_destroy(),
* globus_ftp_client_handleattr_add_plugin(),
* globus_ftp_client_handleattr_remove_plugin(),
* globus_ftp_client_handle_init()
*/
globus_result_t
globus_ftp_client_restart_plugin_init(
globus_ftp_client_plugin_t * plugin,
int max_retries,
globus_reltime_t * interval,
globus_abstime_t * deadline)
{
char * env_str;
globus_l_ftp_client_restart_plugin_t * d;
globus_result_t result;
GlobusFuncName(globus_ftp_client_restart_plugin_init);
if(plugin == GLOBUS_NULL)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] NULL plugin at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
d =
globus_libc_calloc(1, sizeof(globus_l_ftp_client_restart_plugin_t));
if(! d)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] Out of memory at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
result = globus_ftp_client_plugin_init(plugin,
GLOBUS_L_FTP_CLIENT_RESTART_PLUGIN_NAME,
GLOBUS_FTP_CLIENT_CMD_MASK_ALL,
d);
if(result != GLOBUS_SUCCESS)
{
globus_libc_free(d);
return result;
}
d->max_retries = max_retries > 0 ? max_retries : -1;
if(interval)
{
GlobusTimeReltimeCopy(d->interval, *interval);
}
if((!interval) || (interval->tv_sec == 0 && interval->tv_usec == 0))
{
d->backoff = GLOBUS_TRUE;
d->interval.tv_sec = 1;
d->interval.tv_usec = 0;
}
else
{
d->backoff = GLOBUS_FALSE;
}
if(deadline)
{
GlobusTimeAbstimeCopy(d->deadline, *deadline);
}
else
{
GlobusTimeAbstimeCopy(d->deadline, globus_i_abstime_infinity);
}
d->dest_url = GLOBUS_NULL;
d->source_url = GLOBUS_NULL;
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, copy);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, destroy);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, chmod);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, cksm);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, delete);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, modification_time);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, size);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, feat);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, mkdir);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, rmdir);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, move);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, verbose_list);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, machine_list);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, mlst);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, stat);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, list);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, get);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, put);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, third_party_transfer);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, fault);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, abort);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, complete);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, data);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin,
response);
env_str = globus_libc_getenv("GUC_STALL_TIMEOUT");
if(env_str != NULL)
{
int sc;
int to_secs;
sc = sscanf(env_str, "%d", &to_secs);
if(sc == 1)
{
globus_ftp_client_restart_plugin_set_stall_timeout(
plugin, to_secs);
}
}
return GLOBUS_SUCCESS;
result_exit:
globus_ftp_client_plugin_destroy(plugin);
return result;
}
void
test_parse_args(int argc,
char **argv,
globus_ftp_client_handleattr_t * handle_attr,
globus_ftp_client_operationattr_t * operation_attr,
char **src,
char **dst)
{
int c;
extern char * optarg;
extern int opterr;
globus_reltime_t timeout;
globus_ftp_client_plugin_t *plugin;
globus_ftp_control_dcau_t dcau;
globus_abstime_t deadline_time;
globus_reltime_t interval_time;
int max_retries;
long interval;
long deadline;
char * subject;
*src = GLOBUS_NULL;
*dst = GLOBUS_NULL;
setvbuf(stdout, 0, _IONBF, 0);
#ifdef WIN32
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
_setmode(_fileno(stderr), _O_BINARY);
#endif
opterr = 0;
while((c = getopt(argc, argv, "-f:a:ps:d:r:zMTc:t:i")) != -1)
{
switch(c)
{
case 'a':
globus_module_activate(GLOBUS_FTP_CLIENT_TEST_ABORT_PLUGIN_MODULE);
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_ftp_client_test_abort_plugin_init(plugin);
if(atoi(optarg) >= FTP_ABORT_LAST ||
atoi(optarg) < 0)
{
printf("Abort plugin argument out of range\n");
globus_module_deactivate_all();
exit(1);
}
globus_ftp_client_test_abort_plugin_set_abort_point(plugin,
atoi(optarg));
globus_ftp_client_test_abort_plugin_set_abort_counter(
plugin,
&test_abort_count);
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
break;
case 'p':
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_module_activate(GLOBUS_FTP_CLIENT_DEBUG_PLUGIN_MODULE);
globus_ftp_client_debug_plugin_init(plugin, stderr, "[Debug Plugin]");
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
break;
case 'M':
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_module_activate(GLOBUS_FTP_CLIENT_TEST_PERF_PLUGIN_MODULE);
globus_ftp_client_test_perf_plugin_init(plugin);
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
break;
case 'T':
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_module_activate(GLOBUS_FTP_CLIENT_TEST_THROUGHPUT_PLUGIN_MODULE);
globus_ftp_client_test_throughput_plugin_init(plugin);
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
break;
case 'z':
globus_module_activate(GLOBUS_FTP_CLIENT_TEST_PAUSE_PLUGIN_MODULE);
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_ftp_client_test_pause_plugin_init(plugin);
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
break;
case 'r':
globus_module_activate(GLOBUS_FTP_CLIENT_TEST_RESTART_PLUGIN_MODULE);
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_ftp_client_test_restart_plugin_init(plugin);
if(atoi(optarg) >= FTP_RESTART_LAST ||
atoi(optarg) < 0)
{
printf("Restart plugin argument out of range\n");
globus_module_deactivate_all();
exit(1);
}
else
{
char *p;
p = strchr(optarg, ',');
if(p)
{
GlobusTimeReltimeSet(timeout, atoi(p+1),0);
}
else
{
GlobusTimeReltimeSet(timeout, 0, 0);
}
globus_ftp_client_test_restart_plugin_set_restart_point(
plugin,
atoi(optarg),
&timeout);
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
}
break;
case 's':
*src = optarg;
break;
case 'd':
*dst = optarg;
break;
case 'c':
if(!strcmp(optarg, "none"))
{
dcau.mode = GLOBUS_FTP_CONTROL_DCAU_NONE;
globus_ftp_client_operationattr_set_dcau(operation_attr,
&dcau);
}
else if(!strcmp(optarg, "self"))
{
dcau.mode = GLOBUS_FTP_CONTROL_DCAU_SELF;
globus_ftp_client_operationattr_set_dcau(operation_attr,
&dcau);
}
else
{
dcau.mode = GLOBUS_FTP_CONTROL_DCAU_SUBJECT;
dcau.subject.subject = optarg;
globus_ftp_client_operationattr_set_dcau(operation_attr,
&dcau);
}
break;
case 't':
if(!strcmp(optarg, "clear"))
{
globus_ftp_client_operationattr_set_data_protection(
operation_attr,
GLOBUS_FTP_CONTROL_PROTECTION_CLEAR);
}
else if(!strcmp(optarg, "safe"))
{
globus_ftp_client_operationattr_set_data_protection(
operation_attr,
GLOBUS_FTP_CONTROL_PROTECTION_SAFE);
}
else if(!strcmp(optarg, "private"))
{
globus_ftp_client_operationattr_set_data_protection(
operation_attr,
GLOBUS_FTP_CONTROL_PROTECTION_PRIVATE);
}
break;
case 'f':
globus_module_activate(GLOBUS_FTP_CLIENT_RESTART_PLUGIN_MODULE);
sscanf(optarg, "%d,%ld,%ld", &max_retries, &interval, &deadline);
if(interval < 0.1)
{
GlobusTimeReltimeSet(interval_time, 0, 0);
}
else
{
GlobusTimeReltimeSet(interval_time, interval, 0);
}
deadline_time.tv_sec = deadline;
deadline_time.tv_nsec = 0;
plugin = globus_libc_malloc(sizeof(globus_ftp_client_plugin_t));
globus_ftp_client_restart_plugin_init(plugin,
max_retries,
&interval_time,
&deadline_time);
globus_ftp_client_handleattr_add_plugin(handle_attr, plugin);
break;
case 'i':
globus_ftp_client_operationattr_set_control_protection(
operation_attr,
GLOBUS_FTP_CONTROL_PROTECTION_SAFE);
break;
case '?':
/* globus_module_deactivate_all();
exit(0);
*/
break;
}
}
subject = globus_libc_getenv("GLOBUS_FTP_CLIENT_TEST_SUBJECT");
if(subject)
{
globus_ftp_client_operationattr_set_authorization(
operation_attr,
GSS_C_NO_CREDENTIAL,
":globus-mapping:",
"",
GLOBUS_NULL,
subject);
}
}
