int compare_strings(const char *a, const char *b, int test_num, const char * label)
{
if(a == b && a == GLOBUS_NULL)
{
return GLOBUS_TRUE;
}
else if((a == GLOBUS_NULL ||
b == GLOBUS_NULL) &&
a != b)
{
globus_libc_printf(
"test %d: FAILED (%s parsed to %s instead of %s)\n",
test_num,
label,
a == GLOBUS_NULL ? "NULL" : a,
b == GLOBUS_NULL ? "NULL" : b);
return GLOBUS_FALSE;
}
else if(strcmp(a,b) != 0)
{
globus_libc_printf(
"test %d: FAILED (%s parsed to %s instead of %s)\n",
test_num,
label,
a,
b);
return GLOBUS_FALSE;
}
else
{
return GLOBUS_TRUE;
}
}
void
test4(int port)
{
globus_result_t result;
globus_object_t * err;
test_monitor_t monitor;
globus_io_handle_t handle;
globus_size_t bytes_read;
char buf[6];
struct iovec iov[6];
globus_io_attr_t attr;
globus_io_secure_authorization_data_t
auth_data;
globus_io_tcpattr_init(&attr);
globus_io_attr_set_secure_authentication_mode(
&attr,
GLOBUS_IO_SECURE_AUTHENTICATION_MODE_MUTUAL,
GSS_C_NO_CREDENTIAL);
globus_io_attr_set_secure_authorization_mode(
&attr,
GLOBUS_IO_SECURE_AUTHORIZATION_MODE_SELF,
&auth_data);
globus_io_attr_set_secure_channel_mode(
&attr,
GLOBUS_IO_SECURE_CHANNEL_MODE_CLEAR);
/* simple failed connection */
result = globus_io_tcp_connect(
"localhost",
(unsigned short) port,
&attr,
&handle);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("test 4 connect failed\n");
}
else
{
globus_libc_printf("test 4 connect succeeded\n");
globus_io_close(&handle);
}
}
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;
}
void
test3(void)
{
globus_result_t result;
globus_object_t * err;
test_monitor_t monitor;
globus_io_handle_t handle;
globus_size_t bytes_read;
char buf[6];
struct iovec iov[6];
/* simple failed connection */
result = globus_io_tcp_connect(
"antares.mcs.mcs.mcs",
25,
GLOBUS_NULL,
&handle);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("test 3 connect aborted (success)\n");
}
}
static
void
globus_l_gfs_sigint(
void * user_arg)
{
GlobusGFSName(globus_l_gfs_sigint);
GlobusGFSDebugEnter();
globus_mutex_lock(&globus_l_gfs_mutex);
{
if(globus_l_gfs_sigint_caught)
{
globus_l_gfs_server_active = 0;
}
globus_l_gfs_sigint_caught = GLOBUS_TRUE;
globus_l_gfs_terminated = GLOBUS_TRUE;
if(!globus_l_gfs_server_active)
{
globus_cond_signal(&globus_l_gfs_cond);
}
else
{
globus_libc_printf("Embedded server stopping.\n");
globus_gridftp_server_embed_stop(globus_l_gfs_server_handle);
}
}
globus_mutex_unlock(&globus_l_gfs_mutex);
GlobusGFSDebugExit();
}
static
globus_bool_t
globus_l_gfs_event_cb(
globus_gfs_embed_handle_t handle,
globus_result_t result,
globus_gfs_embed_event_t event,
void * user_arg)
{
globus_mutex_lock(&globus_l_gfs_mutex);
{
switch(event)
{
case GLOBUS_GFS_EMBED_EVENT_STOPPED:
globus_libc_printf("Embedded server stopped.\n");
globus_l_gfs_server_active = GLOBUS_FALSE;
globus_cond_signal(&globus_l_gfs_cond);
globus_gridftp_server_embed_destroy(handle);
break;
case GLOBUS_GFS_EMBED_EVENT_CONNECTION_CLOSED:
globus_libc_printf("Connection closed.\n");
break;
case GLOBUS_GFS_EMBED_EVENT_CONNECTION_OPENED:
globus_libc_printf("Connection established.\n");
break;
default:
break;
}
}
globus_mutex_unlock(&globus_l_gfs_mutex);
return GLOBUS_TRUE;
}
int compare_ints(int a, int b, int test_num, const char * label)
{
if(a != b)
{
globus_libc_printf(
"test %d: FAILED (%s parsed to %d instead of %d)\n",
test_num,
label,
a,
b);
return GLOBUS_FALSE;
}
else
{
return GLOBUS_TRUE;
}
}
int main()
{
globus_object_t * err;
char * s;
static char * myname = "main";
globus_module_activate(GLOBUS_COMMON_MODULE);
err = globus_error_construct_string(GLOBUS_COMMON_MODULE,
GLOBUS_ERROR_NO_INFO,
"[%s]: Error doing something hard at %s:%d\n",
GLOBUS_COMMON_MODULE->module_name,
myname,
__LINE__);
s = globus_object_printable_to_string(err);
globus_libc_printf("%s",s);
return globus_module_deactivate_all();
}
/*
* Function: main
*
* Description:
*
* Parameters:
*
* Returns:
*/
int
main(int argc, char **argv)
{
int rc;
globus_result_t result;
globus_object_t * error = NULL;
char * errstring;
globus_io_handle_t handle;
globus_io_handle_t stdout_handle;
globus_size_t bytes;
globus_size_t i;
globus_byte_t buf[1024];
#ifdef TARGET_ARCH_WIN32
HANDLE outputFile;
globus_io_handle_t write_handle;
if ( argc < 3 )
{
usage( argv[0] );
return -1;
}
#endif
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_module_activate(GLOBUS_IO_MODULE);
#ifndef TARGET_ARCH_WIN32
result = globus_io_file_open("/etc/group",
O_RDONLY,
0600,
GLOBUS_NULL,
&handle);
#else
result = globus_io_file_open( argv[1],
O_RDONLY,
0600,
GLOBUS_NULL,
&handle);
#endif
if(result != GLOBUS_SUCCESS)
{
error = globus_error_get(result);
errstring = globus_object_printable_to_string(error);
#ifndef TARGET_ARCH_WIN32
globus_libc_printf("test failed to open /etc/group: %s\n", errstring);
#else
globus_libc_printf("test failed to open %s: %s\n", argv[1], errstring);
#endif
goto done;
}
#ifndef TARGET_ARCH_WIN32
result = globus_io_file_posix_convert(
fileno(stdout),
GLOBUS_NULL,
&stdout_handle);
#else
outputFile= CreateFile( argv[2], GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_FLAG_OVERLAPPED, NULL );
if ( outputFile == INVALID_HANDLE_VALUE )
{
printf( "An error occurred while trying to create the output file (error is %d)...exiting\n",
GetLastError() );
return -1;
}
result= globus_io_file_windows_convert(
outputFile,
GLOBUS_NULL,
&write_handle);
#endif
if(result != GLOBUS_SUCCESS)
{
error = globus_error_get(result);
errstring = globus_object_printable_to_string(error);
globus_libc_printf("test failed to convert stdout to io handle: %s\n",
errstring);
goto done;
}
do
{
result = globus_io_read(&handle,
buf,
sizeof(buf),
sizeof(buf),
&bytes);
if(result == GLOBUS_SUCCESS ||
((error = globus_error_get(result)) &&
(globus_object_type_match(globus_object_get_type(error),
GLOBUS_IO_ERROR_TYPE_EOF))))
{
globus_size_t nbytes2;
#ifndef TARGET_ARCH_WIN32
globus_io_write(&stdout_handle,
buf,
bytes,
&nbytes2);
#else
globus_io_write( &write_handle,
buf,
bytes,
&nbytes2);
#endif
}
else
{
errstring = globus_object_printable_to_string(error);
globus_libc_printf("test failed to read /etc/group: %s\n",
errstring);
goto done;
}
}
while(result == GLOBUS_SUCCESS);
done:
if(error)
{
globus_object_free(error);
}
globus_io_close(&handle);
#ifndef TARGET_ARCH_WIN32
globus_io_close(&stdout_handle);
#else
globus_io_close( &write_handle);
#endif
globus_module_deactivate(GLOBUS_IO_MODULE);
globus_module_deactivate(GLOBUS_COMMON_MODULE);
return 0;
}
void
test2(void)
{
globus_result_t result;
globus_object_t * err;
test_monitor_t monitor;
globus_io_handle_t handle;
globus_size_t bytes_read;
char buf[6];
struct iovec iov[6];
test_monitor_initialize(&monitor, GLOBUS_NULL);
/* simple connection to known services with read and write */
result = globus_io_tcp_connect(
"antares.mcs.anl.gov",
25,
GLOBUS_NULL,
&handle);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("test 1 failed connecting\n");
goto finish;
}
result = globus_io_read(&handle,
test_buffer,
test_buffer_size,
1,
&bytes_read);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("test 1 failed reading\n");
goto finish;
}
else
{
globus_libc_printf("test 1 read message:\n%s\n",
test_buffer);
}
buf[0]='q';
buf[1]='u';
buf[2]='i';
buf[3]='t';
buf[4]='\r';
buf[5]='\n';
iov[0].iov_base=buf;
iov[0].iov_len=1;
iov[1].iov_base=buf+1;
iov[1].iov_len=1;
iov[2].iov_base=buf+2;
iov[2].iov_len=1;
iov[3].iov_base=buf+3;
iov[3].iov_len=1;
iov[4].iov_base=buf+4;
iov[4].iov_len=1;
iov[5].iov_base=buf+5;
iov[5].iov_len=1;
result = globus_io_register_writev(&handle,
iov,
6,
test2_writev_callback,
&monitor);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_lock(&monitor.mutex);
monitor.err = globus_error_get(result);
monitor.use_err = GLOBUS_TRUE;
monitor.done = GLOBUS_TRUE;
globus_mutex_unlock(&monitor.mutex);
}
globus_mutex_lock(&monitor.mutex);
while(!monitor.done)
{
globus_cond_wait(&monitor.cond,
&monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
if(monitor.use_err)
{
globus_libc_printf("test 1 failed writing\n");
globus_object_free(monitor.err);
goto finish;
}
else
{
globus_libc_printf("test 1 wrote message:\n%s\n",
test_buffer);
}
test_monitor_reset(&monitor);
result = globus_io_register_read(&handle,
test_buffer,
test_buffer_size,
1,
test1_read_callback,
&monitor);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_lock(&monitor.mutex);
monitor.err = globus_error_get(result);
monitor.use_err = GLOBUS_TRUE;
monitor.done = GLOBUS_TRUE;
globus_mutex_unlock(&monitor.mutex);
}
globus_mutex_lock(&monitor.mutex);
while(!monitor.done)
{
globus_cond_wait(&monitor.cond,
&monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
if(monitor.use_err)
{
globus_libc_printf("test 1 failed reading\n");
globus_object_free(monitor.err);
goto finish;
}
else
{
globus_libc_printf("test 1 read message:\n%s\n",
test_buffer);
}
test_monitor_reset(&monitor);
result = globus_io_close(&handle);
if(result != GLOBUS_SUCCESS)
{
err = globus_error_get(result);
globus_libc_printf("test 1 failed closing\n");
}
globus_libc_printf("test 1 successful\n");
finish:
test_monitor_destroy(&monitor);
}
void
test1(void)
{
globus_result_t result;
globus_object_t * err;
test_monitor_t monitor;
globus_io_handle_t handle;
test_monitor_initialize(&monitor, GLOBUS_NULL);
/* simple connection to known services with read and write */
result = globus_io_tcp_register_connect(
"localhost",
25,
GLOBUS_NULL,
test1_connect_callback,
(void *) &monitor,
&handle);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_lock(&monitor.mutex);
monitor.err = globus_error_get(result);
monitor.use_err = GLOBUS_TRUE;
monitor.done = GLOBUS_TRUE;
globus_mutex_unlock(&monitor.mutex);
}
globus_mutex_lock(&monitor.mutex);
while(!monitor.done)
{
globus_cond_wait(&monitor.cond,
&monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
if(monitor.use_err)
{
globus_libc_printf("test 1 failed connecting\n");
globus_object_free(monitor.err);
goto finish;
}
test_monitor_reset(&monitor);
result = globus_io_register_read(&handle,
test_buffer,
test_buffer_size,
1,
test1_read_callback,
&monitor);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_lock(&monitor.mutex);
monitor.err = globus_error_get(result);
monitor.use_err = GLOBUS_TRUE;
monitor.done = GLOBUS_TRUE;
globus_mutex_unlock(&monitor.mutex);
}
globus_mutex_lock(&monitor.mutex);
while(!monitor.done)
{
globus_cond_wait(&monitor.cond,
&monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
if(monitor.use_err)
{
globus_libc_printf("test 1 failed reading\n");
globus_object_free(monitor.err);
goto finish;
}
else
{
globus_libc_printf("test 1 read message:\n%s\n",
test_buffer);
}
test_monitor_reset(&monitor);
globus_libc_sprintf((char *) test_buffer, "quit\n");
result = globus_io_register_write(&handle,
test_buffer,
strlen((char *) test_buffer),
test1_write_callback,
&monitor);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_lock(&monitor.mutex);
monitor.err = globus_error_get(result);
monitor.use_err = GLOBUS_TRUE;
monitor.done = GLOBUS_TRUE;
globus_mutex_unlock(&monitor.mutex);
}
globus_mutex_lock(&monitor.mutex);
while(!monitor.done)
{
globus_cond_wait(&monitor.cond,
&monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
if(monitor.use_err)
{
globus_libc_printf("test 1 failed writing\n");
globus_object_free(monitor.err);
goto finish;
}
else
{
globus_libc_printf("test 1 write message:\n%s\n",
test_buffer);
}
test_monitor_reset(&monitor);
result = globus_io_register_read(&handle,
test_buffer,
test_buffer_size,
1,
test1_read_callback,
&monitor);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_lock(&monitor.mutex);
monitor.err = globus_error_get(result);
monitor.use_err = GLOBUS_TRUE;
monitor.done = GLOBUS_TRUE;
globus_mutex_unlock(&monitor.mutex);
}
globus_mutex_lock(&monitor.mutex);
while(!monitor.done)
{
globus_cond_wait(&monitor.cond,
&monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
if(monitor.use_err)
{
globus_libc_printf("test 1 failed reading\n");
globus_object_free(monitor.err);
goto finish;
}
else
{
globus_libc_printf("test 1 read message:\n%s\n",
test_buffer);
}
test_monitor_reset(&monitor);
result = globus_io_close(&handle);
if(result != GLOBUS_SUCCESS)
{
err = globus_error_get(result);
globus_libc_printf("test 1 failed closing\n");
}
globus_libc_printf("test 1 successful\n");
finish:
test_monitor_destroy(&monitor);
}
int
main(
int argc,
char * argv[])
{
globus_io_handle_t listener;
globus_io_handle_t server_handle;
globus_io_handle_t client_handle;
globus_io_attr_t attr;
unsigned short port = 0;
globus_result_t result;
globus_io_secure_authorization_data_t
auth_data;
globus_l_io_authorization_test_monitor_t
monitor;
char greeting[] = "Hello, my friend.";
char reply_buffer[256];
globus_size_t written;
globus_size_t read_amt;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_module_activate(GLOBUS_IO_MODULE);
/* Initialize monitor */
globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
globus_cond_init(&monitor.cond, GLOBUS_NULL);
monitor.connected = GLOBUS_FALSE;
/* Prepare attributes */
globus_io_secure_authorization_data_initialize(&auth_data);
globus_io_tcpattr_init(&attr);
globus_io_attr_set_secure_authentication_mode(
&attr,
GLOBUS_IO_SECURE_AUTHENTICATION_MODE_GSSAPI,
GSS_C_NO_CREDENTIAL);
if(argc >= 2)
{
if(! strcasecmp(argv[1], "self"))
{
globus_io_attr_set_secure_authorization_mode(
&attr,
GLOBUS_IO_SECURE_AUTHORIZATION_MODE_SELF,
&auth_data);
}
else if(argc > 2 && ! strcasecmp(argv[1], "identity") )
{
globus_io_secure_authorization_data_set_identity(&auth_data,
argv[2]);
globus_io_attr_set_secure_authorization_mode(
&attr,
GLOBUS_IO_SECURE_AUTHORIZATION_MODE_IDENTITY,
&auth_data);
}
else if(! strcasecmp(argv[1], "callback"))
{
globus_io_secure_authorization_data_set_callback(
&auth_data,
globus_l_io_authorization_test_callback,
GLOBUS_NULL);
globus_io_attr_set_secure_authorization_mode(
&attr,
GLOBUS_IO_SECURE_AUTHORIZATION_MODE_CALLBACK,
&auth_data);
}
else if(! strcasecmp(argv[1], "-callback"))
{
globus_io_secure_authorization_data_set_callback(
&auth_data,
globus_l_io_authorization_test_callback,
(void *) 0x1);
globus_io_attr_set_secure_authorization_mode(
&attr,
GLOBUS_IO_SECURE_AUTHORIZATION_MODE_CALLBACK,
&auth_data);
}
else
{
goto no_authorization_mode;
}
}
else
{
goto no_authorization_mode;
}
result = globus_io_tcp_create_listener(
&port,
-1,
&attr,
&listener);
if(result != GLOBUS_SUCCESS)
{
char *msg = globus_error_print_friendly(globus_error_peek(result));
globus_libc_fprintf(stderr, "# Could not create listener: %s\n", msg);
free(msg);
goto error_exit;
}
result = globus_io_tcp_register_connect(
"localhost",
port,
&attr,
globus_l_io_authorization_test_connect_callback,
&monitor,
&client_handle);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("# Could not register connect\n");
goto error_exit;
}
result = globus_io_tcp_listen(&listener);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("# Could not listen for connections\n");
goto error_exit;
}
result = globus_io_tcp_accept(&listener,
&attr,
&server_handle);
if(result != GLOBUS_SUCCESS)
{
if(strcasecmp(argv[1], "-callback") == 0)
{
globus_module_deactivate_all();
exit(0);
}
else
{
globus_libc_printf("# Could not accept connection\n");
goto error_exit;
}
}
globus_mutex_lock(&monitor.mutex);
while(! monitor.connected)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
result = globus_io_close(&listener);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("# Could not close listener\n");
goto error_exit;
}
result = globus_io_write(&server_handle,
greeting,
sizeof(greeting),
&written);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("# Could not write greeting\n");
goto error_exit;
}
result = globus_io_close(&server_handle);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("# Could not close server\n");
goto error_exit;
}
result = globus_io_read(&client_handle,
reply_buffer,
sizeof(reply_buffer),
sizeof(reply_buffer),
&read_amt);
if(result != GLOBUS_SUCCESS)
{
globus_object_t * err;
err = globus_error_get(result);
if(! globus_io_eof(err))
{
globus_libc_printf("# Could not read greeting\n");
goto error_exit;
}
}
result = globus_io_close(&client_handle);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf("# Could not close client\n");
goto error_exit;
}
if(!memcmp(greeting, reply_buffer, sizeof(greeting)) == 0)
{
result = GLOBUS_FAILURE;
goto error_exit;
}
globus_module_deactivate_all();
exit(0);
no_authorization_mode:
globus_libc_printf(
"Usage: %s AUTHORIZATION\n"
" AUTHORIZATION is one of\n"
" self use Globus I/O's self-authorization mode\n"
" identity \"subject\" use Globus I/O's subject-based authorization\n"
" callback use Globus I/O's callback authorization\n"
" -callback use Globus I/O's callback authorization with\n"
" a failure callback\n",
argv[0]);
error_exit:
globus_module_deactivate_all();
exit(1);
}
int main()
{
int i;
int successful_tests=0;
globus_reltime_t delay_time;
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_mutex_init(&mutex, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_libc_printf("Testing globus_cond_timedwait()\n\n");
for(i = 0; tests[i] != GLOBUS_NULL; i++)
{
globus_bool_t signalled = GLOBUS_FALSE;
globus_bool_t timedout = GLOBUS_FALSE;
globus_bool_t ok;
globus_libc_printf("Test %d: Signal at %d, timeout at %d\n",
i+1,
tests[i][0],
tests[i][1]);
done = GLOBUS_FALSE;
GlobusTimeReltimeSet(delay_time, tests[i][0], 0);
globus_callback_register_oneshot(GLOBUS_NULL,
&delay_time,
wakeup_func,
GLOBUS_NULL);
wait_func(tests[i][1],
&signalled,
&timedout);
ok = GLOBUS_TRUE;
if(((tests[i][0] < tests[i][1]) && signalled) ||
((tests[i][0] > tests[i][1]) && !signalled))
{
globus_libc_printf("Test %d: Signalled state as expected\n",
i+1);
}
else
{
globus_libc_printf("Test %d: Signalled state not as expected\n",
i+1);
ok = GLOBUS_FALSE;
}
if(((tests[i][0] < tests[i][1]) && !timedout) ||
((tests[i][0] > tests[i][1]) && timedout))
{
globus_libc_printf("Test %d: Timedout state as expected\n",
i+1);
}
else
{
globus_libc_printf("Test %d: Timedout state not as expected\n",
i+1);
ok = GLOBUS_FALSE;
}
globus_libc_printf("Test %d: %s\n",
i+1,
ok ? "SUCCESS" : "FAILED");
if(ok)
{
successful_tests++;
}
}
if(successful_tests == i)
{
globus_libc_printf("--------------------------------\n"
"ALL TESTS COMPLETED SUCCESSFULLY\n"
"--------------------------------\n");
}
else
{
globus_libc_printf("-----------------------\n"
"%d OF %d TESTS SUCCESSFUL\n"
"-----------------------\n",
successful_tests, i);
}
globus_module_deactivate(GLOBUS_COMMON_MODULE);
return (successful_tests == i) ? 0 : 1;
}
int main(int argc, char *argv[])
{
globus_url_t url;
int i;
int result;
globus_bool_t ok;
int num_successful = 0;
int rc;
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_libc_printf("Testing globus_url_parse()\n");
if(argc > 1)
{
globus_libc_printf("Bypassing standard tests, parsing command line arguments\n");
for(i = 1; i < argc; i++)
{
globus_libc_printf("Parsing \"%s\"\n", argv[i]);
result = globus_url_parse(argv[i], &url);
globus_libc_printf("Parse returned %d\n", result);
if(result == GLOBUS_SUCCESS)
{
#define printable_string(x) (x==GLOBUS_NULL ? "NULL" : x)
globus_libc_printf("url_scheme = \"%s\"\n"
"url_scheme_type = %d\n"
"user = \"%s\"\n"
"password = \"%s\"\n"
"host = \"%s\"\n"
"port = %u\n"
"url_path = \"%s\"\n"
"dn = \"%s\"\n"
"attributes = \"%s\"\n"
"scope = \"%s\"\n"
"filter = \"%s\"\n"
"url_specific_part = \"%s\"\n",
printable_string(url.scheme),
url.scheme_type,
printable_string(url.user),
printable_string(url.password),
printable_string(url.host),
url.port,
printable_string(url.url_path),
printable_string(url.dn),
printable_string(url.attributes),
printable_string(url.scope),
printable_string(url.filter),
printable_string(url.url_specific_part));
result = globus_url_destroy(&url);
globus_libc_printf("globus_url_destroy returned %d\n", result);
}
}
globus_module_deactivate_all();
return 0;
}
for(i = 0; i < NUM_TESTS; i++)
{
ok = GLOBUS_TRUE;
result = globus_url_parse(test_urls[i].url, &url);
if(result != test_urls[i].result)
{
globus_libc_printf(
"test %d: FAILED (url=%s, expected %d, parse returned %d)\n",
i+1,
test_urls[i].url,
test_urls[i].result,
result);
ok = GLOBUS_FALSE;
}
if(test_urls[i].result == GLOBUS_SUCCESS)
{
/* Verify that parse did what we wanted it to do */
if(!compare_strings(url.scheme,
test_urls[i].url_result.scheme,
i+1,
"scheme"))
{
ok = GLOBUS_FALSE;
}
if(!compare_ints(url.scheme_type,
test_urls[i].url_result.scheme_type,
i+1,
"scheme_type"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.user,
test_urls[i].url_result.user,
i+1,
"user"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.password,
test_urls[i].url_result.password,
i+1,
"password"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.host,
test_urls[i].url_result.host,
i+1,
"host"))
{
ok = GLOBUS_FALSE;
}
if(!compare_ints((int) url.port,
(int) test_urls[i].url_result.port,
i+1,
"port"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.url_path,
test_urls[i].url_result.url_path,
i+1,
"url_path"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.dn,
test_urls[i].url_result.dn,
i+1,
"dn"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.attributes,
test_urls[i].url_result.attributes,
i+1,
"attributes"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.scope,
test_urls[i].url_result.scope,
i+1,
"scope"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.filter,
test_urls[i].url_result.filter,
i+1,
"filter"))
{
ok = GLOBUS_FALSE;
}
if(!compare_strings(url.url_specific_part,
test_urls[i].url_result.url_specific_part,
i+1,
"url_specific_part"))
{
ok = GLOBUS_FALSE;
}
result = globus_url_destroy(&url);
if(result != GLOBUS_SUCCESS)
{
globus_libc_printf(
"test %d: FAILED (could not destroy parsed url)\n",
i+1);
ok = GLOBUS_FALSE;
}
}
if(ok)
{
num_successful++;
}
}
globus_libc_printf("------------------------------------\n");
if(num_successful == i)
{
globus_libc_printf("ALL TESTS SUCCESSFUL\n");
}
else
{
globus_libc_printf("%d OF %d TESTS FAILED\n",
i - num_successful,
i);
}
globus_libc_printf("------------------------------------\n");
rc = (num_successful == i) ? 0 : 1;
globus_module_deactivate_all();
return rc;
}
int
main(
int argc,
char ** argv)
{
int rc = 0;
globus_result_t result;
char * cs;
globus_xio_contact_t parsed_contact;
char * new_banner;
char * old_banner;
GlobusGFSName(main);
/* activte globus stuff */
if((rc = globus_module_activate(GLOBUS_COMMON_MODULE)) != GLOBUS_SUCCESS ||
(rc = globus_module_activate(
GLOBUS_GRIDFTP_SERVER_MODULE)) != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Error: Failed to initialize:\n%s",
globus_error_print_friendly(globus_error_peek(rc)));
goto error_activate;
}
/* initialize global variables */
globus_mutex_init(&globus_l_gfs_mutex, GLOBUS_NULL);
globus_cond_init(&globus_l_gfs_cond, GLOBUS_NULL);
globus_l_gfs_signal_init();
globus_libc_printf("Embedded server starting.\n");
globus_mutex_lock(&globus_l_gfs_mutex);
{
result = globus_gridftp_server_embed_init(
&globus_l_gfs_server_handle,
argv);
if(result != GLOBUS_SUCCESS)
{
rc = 1;
goto error_lock;
}
/* add our acl module */
globus_gfs_acl_add_module(&globus_gfs_acl_test_module);
/* customize some config */
old_banner = globus_gridftp_server_embed_config_get_string(
globus_l_gfs_server_handle, "banner");
new_banner = globus_common_create_string(
"%s\nEMBEDDED", old_banner);
globus_gridftp_server_embed_config_set_ptr(
globus_l_gfs_server_handle,
"banner",
new_banner);
globus_free(old_banner);
globus_gridftp_server_embed_config_set_int(
globus_l_gfs_server_handle,
"connections_max",
10);
globus_gridftp_server_embed_config_set_int(
globus_l_gfs_server_handle,
"auth_level",
1 | /* identity check */
2 | /* file access checks */
4 | /* disable setuid (not really needed with gridmap disabled)*/
8); /* disable gridmap lookup */
result = globus_gridftp_server_embed_start(
globus_l_gfs_server_handle,
globus_l_gfs_event_cb,
NULL);
if(result != GLOBUS_SUCCESS)
{
rc = 1;
goto error_lock;
}
globus_l_gfs_server_active = GLOBUS_TRUE;
cs = globus_gridftp_server_embed_config_get_string(
globus_l_gfs_server_handle, "contact_string");
globus_xio_contact_parse(&parsed_contact, cs);
globus_libc_printf(
"Server listening on port %s.\n", parsed_contact.port);
globus_xio_contact_destroy(&parsed_contact);
/* run until we are done */
while(!globus_l_gfs_terminated || globus_l_gfs_server_active)
{
globus_cond_wait(&globus_l_gfs_cond, &globus_l_gfs_mutex);
}
}
globus_mutex_unlock(&globus_l_gfs_mutex);
globus_module_deactivate_all();
GlobusGFSDebugExit();
return 0;
error_lock:
globus_mutex_unlock(&globus_l_gfs_mutex);
error_activate:
globus_module_deactivate_all();
GlobusGFSDebugExitWithError();
return rc;
}
int main(int argc, char *argv[])
{
int rc = 1;
monitor_t monitor;
char * rsl;
if (argc < 4 || (!globus_l_get_mode(&monitor, argv[2]))
|| ((monitor.timeout = atoi(argv[3])) < 0))
{
globus_libc_fprintf(stderr,
"Usage: %s RM-CONTACT MODE SAVE_STATE TIMEOUT\n"
" RM-CONTACT: resource manager contact\n"
" MODE: no-commit|no-commit-end|commit|late-commit-end\n"
" TIMEOUT: two-phase timeout in seconds\n",
argv[0]);
goto error_exit;
}
rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE);
if (rc != GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"failure activating GLOBUS_GRAM_CLIENT_MODULE: %s\n",
globus_gram_client_error_string(rc));
goto error_exit;
}
rsl = globus_common_create_string(format, monitor.timeout);
if (rsl == NULL)
{
globus_libc_fprintf(stderr, "failure allocating rsl string\n");
goto deactivate_exit;
}
globus_mutex_init(&monitor.mutex, NULL);
globus_cond_init(&monitor.cond, NULL);
monitor.job_contact = NULL;
monitor.callback_contact = NULL;
rc = globus_gram_client_callback_allow(
globus_l_state_callback,
&monitor,
&monitor.callback_contact);
if (rc != GLOBUS_SUCCESS || monitor.callback_contact == NULL)
{
globus_libc_fprintf(stderr,
"failure allowing callbacks\n");
rc = -1;
goto destroy_monitor_exit;
}
globus_mutex_lock(&monitor.mutex);
rc = globus_gram_client_job_request(
argv[1],
rsl,
GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL,
monitor.callback_contact,
&monitor.job_contact);
if (monitor.job_contact != NULL)
{
globus_libc_printf("%s\n", monitor.job_contact);
}
if (rc != GLOBUS_GRAM_PROTOCOL_ERROR_WAITING_FOR_COMMIT)
{
if (rc == GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"job manager did not return "
"GLOBUS_GRAM_PROTOCOL_ERROR_COMMIT_TIMED_OUT\n");
rc = -1;
}
else
{
globus_libc_fprintf(stderr,
"failure submitting job request [%d]: %s\n",
rc,
globus_gram_client_error_string(rc));
}
goto disallow_exit;
}
rc = 0;
if (monitor.mode == no_commit)
{
goto disallow_exit;
}
rc = globus_gram_client_job_signal(
monitor.job_contact,
GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_COMMIT_REQUEST,
NULL,
&monitor.job_status,
&monitor.failure_code);
if (rc != GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"failure sending commit signal: %s\n",
globus_gram_client_error_string(rc));
goto disallow_exit;
}
while (monitor.job_status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE &&
monitor.job_status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
if (monitor.mode == no_commit_end)
{
rc = 0;
goto disallow_exit;
}
else if (monitor.mode == late_commit_end)
{
rc = 0;
sleep(monitor.timeout + 1);
}
rc = globus_gram_client_job_signal(
monitor.job_contact,
GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_COMMIT_END,
NULL,
&monitor.job_status,
&monitor.failure_code);
if (rc != GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"failure sending commit end signal: %s\n",
globus_gram_client_error_string(rc));
goto disallow_exit;
}
disallow_exit:
if (monitor.job_contact != NULL)
{
globus_gram_client_job_contact_free(monitor.job_contact);
}
globus_mutex_unlock(&monitor.mutex);
globus_gram_client_callback_disallow(monitor.callback_contact);
destroy_monitor_exit:
if (monitor.callback_contact != NULL)
{
free(monitor.callback_contact);
}
globus_mutex_destroy(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
free(rsl);
deactivate_exit:
globus_module_deactivate_all();
error_exit:
return rc;
}
