int
main(
int argc,
char ** argv)
{
globus_xio_driver_t tcp_driver;
globus_xio_driver_t ftp_driver;
globus_xio_stack_t stack;
globus_xio_handle_t xio_handle;
char * cs;
globus_result_t res;
char line[LINE_LEN];
globus_bool_t done = GLOBUS_FALSE;
globus_size_t nbytes;
globus_xio_server_t server_handle;
globus_module_activate(GLOBUS_XIO_MODULE);
globus_xio_stack_init(&stack, NULL);
res = globus_xio_driver_load("tcp", &tcp_driver);
test_res(res, __LINE__);
res = globus_xio_stack_push_driver(stack, tcp_driver);
test_res(res, __LINE__);
res = globus_xio_driver_load("gssapi_ftp", &ftp_driver);
test_res(res, __LINE__);
res = globus_xio_stack_push_driver(stack, ftp_driver);
test_res(res, __LINE__);
globus_xio_server_create(&server_handle, NULL, stack);
globus_xio_server_get_contact_string(server_handle, &cs);
fprintf(stdout, "Contact: %s\n", cs);
globus_xio_server_accept(&xio_handle, server_handle);
res = globus_xio_open(xio_handle, NULL, NULL);
test_res(res, __LINE__);
res = globus_xio_write(xio_handle, "220 hello\r\n", strlen("220 hello\r\n"),
strlen("220 hello\r\n"), &nbytes, NULL);
test_res(res, __LINE__);
while(!done)
{
res = globus_xio_read(
xio_handle, line, LINE_LEN, 1, &nbytes, NULL);
test_res(res, __LINE__);
line[nbytes] = '\0';
fprintf(stdout, "%s", line);
}
globus_xio_close(xio_handle, NULL);
globus_module_activate(GLOBUS_XIO_MODULE);
return 0;
}
int
main(
int argc,
char ** argv)
{
unsigned char buffer[LINE_LEN];
globus_size_t nbytes;
globus_result_t res;
globus_xio_attr_t attr;
char * opts = NULL;
if(argc < 2)
{
fprintf(stderr, "usage: %s url\n", argv[0]);
return -1;
}
if(argc > 2)
{
opts = argv[2];
}
globus_module_activate(GLOBUS_XIO_MODULE);
globus_xio_attr_init(&attr);
globus_xio_handle_t myhandle;
res = globus_xio_handle_create_from_url(
&myhandle,
argv[1],
attr,
opts);
test_res(res, __LINE__);
res = globus_xio_open(myhandle, argv[1], attr);
test_res(res, __LINE__);
while(res == GLOBUS_SUCCESS)
{
res = globus_xio_read(myhandle, buffer, LINE_LEN, 1, &nbytes, NULL);
buffer[nbytes] = '\0';
printf("%s", buffer);
}
if(!globus_xio_error_is_eof(res))
{
printf("Error before EOF\n");
test_res(res, __LINE__);
}
globus_xio_close(myhandle, NULL);
globus_xio_attr_destroy(attr);
globus_module_deactivate(GLOBUS_XIO_MODULE);
return 0;
}
globus_result_t
gfork_i_make_xio_handle(
globus_xio_handle_t * xio_handle,
int fd)
{
globus_result_t res;
globus_xio_attr_t attr;
globus_xio_handle_t handle;
res = globus_xio_attr_init(&attr);
if(res != GLOBUS_SUCCESS)
{
goto error_copy;
}
res = globus_xio_attr_cntl(attr, gfork_i_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE, fd);
if(res != GLOBUS_SUCCESS)
{
goto error_attr;
}
res = globus_xio_handle_create(&handle, gfork_i_file_stack);
if(res != GLOBUS_SUCCESS)
{
goto error_create;
}
/* the way the stack is set up xio should not poll. */
res = globus_xio_open(
handle,
NULL,
attr);
if(res != GLOBUS_SUCCESS)
{
goto error_open;
}
globus_xio_attr_destroy(attr);
*xio_handle = handle;
return GLOBUS_SUCCESS;
error_open:
error_create:
error_attr:
globus_xio_attr_destroy(attr);
error_copy:
return res;
}
int
main(
int argc,
char ** argv)
{
globus_xio_driver_t tcp_driver;
globus_xio_driver_t ftp_driver;
globus_xio_stack_t stack;
globus_xio_handle_t xio_handle;
char * cs;
char * subject;
globus_result_t res;
char line[LINE_LEN];
globus_bool_t done = GLOBUS_FALSE;
globus_size_t nbytes;
globus_xio_attr_t attr;
int len;
if(argc < 2)
{
fprintf(stderr, "arg error: <contact string> <subject>\n");
return 1;
}
globus_module_activate(GLOBUS_XIO_MODULE);
globus_xio_stack_init(&stack, NULL);
res = globus_xio_driver_load("tcp", &tcp_driver);
test_res(res, __LINE__);
res = globus_xio_stack_push_driver(stack, tcp_driver);
test_res(res, __LINE__);
res = globus_xio_driver_load("gssapi_ftp", &ftp_driver);
test_res(res, __LINE__);
res = globus_xio_stack_push_driver(stack, ftp_driver);
test_res(res, __LINE__);
cs = argv[argc - 1];
subject = argv[argc - 2];
res = globus_xio_handle_create(&xio_handle, stack);
test_res(res, __LINE__);
res = globus_xio_attr_init(&attr);
test_res(res, __LINE__);
res = globus_xio_attr_cntl(attr, ftp_driver,
GLOBUS_XIO_GSSAPI_ATTR_TYPE_SUBJECT,
subject);
test_res(res, __LINE__);
res = globus_xio_open(xio_handle, cs, attr);
test_res(res, __LINE__);
while(!done)
{
if(fgets(line, LINE_LEN, stdin) == NULL)
{
done = GLOBUS_TRUE;
}
else
{
len = strlen(line);
line[len] = '\r';
len++;
line[len] = '\n';
len++;
res = globus_xio_write(
xio_handle, line, len, len, &nbytes, NULL);
test_res(res, __LINE__);
}
}
globus_xio_close(xio_handle, NULL);
globus_module_deactivate(GLOBUS_XIO_MODULE);
return 0;
}
void *mdsip_connect(char *host)
{
static int activated=0;
int status;
static globus_xio_stack_t stack_tcp;
static globus_xio_stack_t stack_gsi;
static globus_xio_driver_t tcp_driver;
static globus_xio_driver_t gsi_driver;
globus_result_t result;
globus_xio_handle_t xio_handle;
globus_xio_attr_t attr;
char *contact_string;
int is_gsi;
mdsip_message_t *m;
if (activated == 0)
{
result = globus_module_activate(GLOBUS_XIO_MODULE);
mdsip_test_status(0,result,"mdsip_connect globus_module_activate");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_driver_load("tcp",&tcp_driver);
mdsip_test_status(0,result,"mdsip_connect load tcp driver");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_driver_load("gsi",&gsi_driver);
mdsip_test_status(0,result,"mdsip_connect load gsi driver");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_stack_init(&stack_tcp, NULL);
mdsip_test_status(0,result,"mdsip_connect globus_xio_stack_init");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_stack_init(&stack_gsi, NULL);
mdsip_test_status(0,result,"mdsip_connect globus_xio_stack_init");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_stack_push_driver(stack_tcp, tcp_driver);
mdsip_test_status(0,result,"mdsip_connect globus_xio_stack_push_driver");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_stack_push_driver(stack_gsi, tcp_driver);
mdsip_test_status(0,result,"mdsip_connect globus_xio_stack_push_driver");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_stack_push_driver(stack_gsi, gsi_driver);
mdsip_test_status(0,result,"mdsip_connect globus_xio_stack_push_driver");
if (result != GLOBUS_SUCCESS) return 0;
activated = 1;
}
if (host == NULL || strlen(host) == 0)
return 0;
is_gsi = host[0] == '_';
result = globus_xio_handle_create(&xio_handle, is_gsi ? stack_gsi : stack_tcp);
mdsip_test_status(0,result,"mdsip_connect globus_xio_handle_create");
if (result != GLOBUS_SUCCESS) return 0;
contact_string = strcpy((char *)malloc(strlen(host)+10),&host[is_gsi ? 1 : 0]);
if (strstr(contact_string,":") == NULL)
strcat(contact_string,is_gsi ? ":8200" : ":8000");
result = globus_xio_attr_init(&attr);
mdsip_test_status(0,result,"mdsip_connect globus_xio_attr_init");
if (result != GLOBUS_SUCCESS) return 0;
if (is_gsi)
{
result = globus_xio_attr_cntl(attr,gsi_driver,GLOBUS_XIO_GSI_SET_DELEGATION_MODE,
GLOBUS_XIO_GSI_DELEGATION_MODE_FULL);
mdsip_test_status(0,result,"mdsip_connect globus_xio_attr_cntl");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_attr_cntl(attr,
gsi_driver,
GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
GLOBUS_XIO_GSI_HOST_AUTHORIZATION);
mdsip_test_status(0,result,"mdsip_connect globus_xio_attr_cntl");
if (result != GLOBUS_SUCCESS) return 0;
}
result = globus_xio_attr_cntl(attr,tcp_driver,GLOBUS_XIO_TCP_SET_SNDBUF,MDSIP_SNDBUF);
mdsip_test_status(0,result,"mdsip_connect SET_SNDBUF");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_attr_cntl(attr,tcp_driver,GLOBUS_XIO_TCP_SET_RCVBUF,MDSIP_RCVBUF);
mdsip_test_status(0,result,"mdsip_connect SET_RCVBUF");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_attr_cntl(attr,tcp_driver,GLOBUS_XIO_TCP_SET_NODELAY,GLOBUS_TRUE);
mdsip_test_status(0,result,"mdsip_connect SET_NODELAY");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_attr_cntl(attr,tcp_driver,GLOBUS_XIO_TCP_SET_KEEPALIVE,GLOBUS_TRUE);
mdsip_test_status(0,result,"mdsip_connect SET_KEEPALIVE");
if (result != GLOBUS_SUCCESS) return 0;
result = globus_xio_open(xio_handle, contact_string, attr);
mdsip_test_status(0,result,"mdsip_connect globus_xio_open");
if (result != GLOBUS_SUCCESS)
xio_handle = 0;
else
{
#ifdef _WIN32
static char user[128];
int bsize=128;
char *user_p = GetUserName(user,&bsize) ? user : "******";
#elif __MWERKS__
static char user[128];
int bsize=128;
char *user_p = "Macintosh User";
#elif __APPLE__
char *user_p;
struct passwd *pwd;
pwd = getpwuid(geteuid());
user_p = pwd->pw_name;
#else
char *user_p;
#ifdef HAVE_VXWORKS_H
user_p = "vxWorks";
#else
user_p = (getpwuid(geteuid()))->pw_name;
#endif
#endif
m = malloc(sizeof(mdsip_message_header_t)+strlen(user_p)+1);
memset(m,0,sizeof(mdsip_message_header_t));
m->h.length=strlen(user_p);
m->h.msglen=sizeof(mdsip_message_header_t)+m->h.length;
m->h.dtype=DTYPE_CSTRING;
m->h.status=0;
m->h.ndims=0;
strcpy(m->bytes,user_p);
mdsip_send_message(xio_handle,m,0);
free(m);
m = NULL;
m = mdsip_get_message(xio_handle,&status);
if (!(status & 1))
{
fprintf(stderr,"ERROR: mdsip_connect\n");
return NULL;
}
else
{
if (!(m->h.status & 1))
{
fprintf(stderr,"ERROR: mdsip_connect - Access Denied\n");
globus_xio_close(xio_handle,NULL);
return NULL;
}
}
if (m != NULL)
free(m);
}
return (void *)xio_handle;
}
int
main(
int argc,
char ** argv)
{
globus_xio_driver_t driver;
globus_xio_driver_t transport_driver = NULL;
globus_xio_stack_t stack;
globus_xio_handle_t xio_handle;
char * cs;
globus_result_t res;
char line[LINE_LEN];
char writeline[LINE_LEN];
int len;
int ctr;
globus_bool_t done = GLOBUS_FALSE;
globus_size_t nbytes;
globus_size_t pbytes;
globus_xio_server_t server_handle;
globus_xio_attr_t attr=NULL;
globus_size_t port;
/*if(argc < 2)
{
help();
return 1;
}*/
globus_module_activate(GLOBUS_XIO_MODULE);
globus_xio_stack_init(&stack, NULL);
for(ctr = 1; ctr < argc; ctr++)
{
if(strcmp(argv[ctr], "-h") == 0)
{
help();
return 0;
}
else if(strcmp(argv[ctr], "-p") == 0 && ctr + 1 < argc)
{
port = atoi(argv[ctr+1]);
globus_xio_driver_load("bidi", &driver);
globus_xio_attr_init(&attr);
res = globus_xio_attr_cntl(
attr,
driver,
GLOBUS_XIO_BIDI_SET_PORT,
port);
}
}
globus_xio_stack_push_driver(stack, driver);
globus_xio_server_create(&server_handle, attr, stack);
globus_xio_server_get_contact_string(server_handle, &cs);
fprintf(stdout, "\n\n %s\n\n", cs);
globus_xio_server_accept(&xio_handle, server_handle);
globus_xio_open(xio_handle, NULL, NULL);
while(!done)
{
res = globus_xio_read(
xio_handle, line, LINE_LEN, 1, &nbytes, NULL);
if(res != GLOBUS_SUCCESS)
{
done = 1;
}
line[nbytes] = '\0';
fprintf(stdout, "%s", line);
sprintf(writeline, "%s", line);
len=strlen(line);
res = globus_xio_write(
xio_handle, writeline, len, len, &pbytes, NULL);
if(res != GLOBUS_SUCCESS)
{
done = 1;
}
}
globus_xio_close(xio_handle, NULL);
globus_module_activate(GLOBUS_XIO_MODULE);
return 0;
}
int
main(
int argc,
char ** argv)
{
globus_xio_stack_t stack;
globus_xio_stack_t mode_e_stack;
globus_xio_handle_t xio_handle;
globus_xio_server_t server;
globus_xio_attr_t attr = NULL;
char * cs = NULL;
globus_result_t res;
int ctr;
int num_streams = 1;
globus_bool_t be_server = GLOBUS_FALSE;
int rc;
char filename[FILE_NAME_LEN];
FILE * fp;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
res = globus_xio_driver_load("mode_e", &mode_e_driver);
test_res(res);
res = globus_xio_driver_load("ordering", &ordering_driver);
test_res(res);
res = globus_xio_stack_init(&stack, NULL);
test_res(res);
res = globus_xio_stack_push_driver(stack, mode_e_driver);
test_res(res);
res = globus_xio_stack_push_driver(stack, ordering_driver);
test_res(res);
res = globus_xio_driver_load("tcp", &tcp_driver);
test_res(res);
res = globus_xio_stack_init(&mode_e_stack, NULL);
test_res(res);
res = globus_xio_stack_push_driver(mode_e_stack, tcp_driver);
test_res(res);
if (argc < 4)
{
help();
exit(1);
}
test_res(globus_xio_attr_init(&attr));
test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_SET_STACK,
mode_e_stack));
for(ctr = 1; ctr < argc; ctr++)
{
if(strcmp(argv[ctr], "-h") == 0)
{
help();
return 0;
}
else if(strcmp(argv[ctr], "-c") == 0)
{
if (argc < 5)
{
help();
exit(1);
}
cs = argv[ctr + 1];
ctr++;
}
else if(strcmp(argv[ctr], "-s") == 0)
{
be_server = GLOBUS_TRUE;
}
else if(strcmp(argv[ctr], "-p") == 0)
{
if (argc < 6)
{
help();
exit(1);
}
port = atoi(argv[ctr+1]);
/* test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_APPLY_ATTR_CNTLS,
attr_cntl_cb));*/
}
else if(strcmp(argv[ctr], "-P") == 0)
{
if (argc < 6)
{
help();
exit(1);
}
num_streams = atoi(argv[ctr+1]);
test_res(globus_xio_attr_init(&attr));
test_res(globus_xio_attr_cntl(
attr,
ordering_driver,
GLOBUS_XIO_ORDERING_SET_MAX_READ_COUNT,
num_streams));
test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_SET_NUM_STREAMS,
num_streams));
}
else if(strcmp(argv[ctr], "-f") == 0)
{
if (ctr + 1 < argc)
{
strcpy(filename, argv[ctr + 1]);
}
else
{
help();
exit(1);
}
}
}
if (!be_server && (!cs || !*cs))
{
help();
exit(1);
}
if(be_server)
{
globus_size_t size = CHUNK_SIZE + 1;
int i, nbytes;
res = globus_xio_server_create(&server, attr, stack);
test_res(res);
globus_xio_server_get_contact_string(server, &cs);
fprintf(stdout, "Contact: %s\n", cs);
res = globus_xio_server_accept(&xio_handle, server);
test_res(res);
res = globus_xio_open(xio_handle, NULL, attr);
test_res(res);
fp = fopen(filename, "w");
while(1)
{
char * buffer;
buffer = (char *) globus_malloc(size);
for (i=0; i<size; i++)
buffer[i] = '\0';
res = globus_xio_read(
xio_handle,
buffer,
size - 1,
1,
&nbytes,
NULL);
fputs(buffer, fp);
if (res != GLOBUS_SUCCESS)
break;
}
res = globus_xio_close(xio_handle, NULL);
test_res(res);
res = globus_xio_server_close(server);
test_res(res);
res = globus_xio_driver_unload(mode_e_driver);
test_res(res);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
}
else
{
globus_size_t size = CHUNK_SIZE + 1;
int nbytes;
int i,x;
res = globus_xio_handle_create(&xio_handle, stack);
test_res(res);
res = globus_xio_stack_destroy(stack);
test_res(res);
res = globus_xio_open(xio_handle, cs, attr);
test_res(res);
globus_mutex_init(&mutex, NULL);
globus_cond_init(&cond, NULL);
fp = fopen(filename, "r");
globus_mutex_lock(&mutex);
while(!feof(fp))
{
char * buffer;
buffer = (char *) globus_malloc(size);
for (i = 0; i < size; i++)
buffer[i] = '\0';
x = fread(buffer, CHUNK_SIZE, 1, fp);
nbytes = strlen(buffer);
res = globus_xio_register_write(
xio_handle,
buffer,
nbytes,
nbytes,
NULL,
write_cb,
NULL);
test_res(res);
++y;
}
fclose(fp);
/* test_res(globus_xio_data_descriptor_init(&dd, xio_handle));
test_res(globus_xio_data_descriptor_cntl(
dd,
mode_e_driver,
GLOBUS_XIO_MODE_E_SEND_EOD,
GLOBUS_TRUE));
res = globus_xio_write(
xio_handle,
buffer,
nbytes,
nbytes,
&nbytes,
NULL);
test_res(res); */
while(y)
{
globus_cond_wait(&mutex, &cond);
}
globus_mutex_unlock(&mutex);
res = globus_xio_close(xio_handle, attr);
test_res(res);
res = globus_xio_driver_unload(mode_e_driver);
test_res(res);
res = globus_xio_driver_unload(ordering_driver);
test_res(res);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
globus_mutex_destroy(&mutex);
globus_cond_destroy(&cond);
}
return 0;
}
int
main(
int argc,
char ** argv)
{
globus_result_t result;
int rc;
globus_byte_t buffer[GF_DYN_PACKET_LEN];
uint32_t tmp32;
char * be_cs;
char * reg_cs;
globus_size_t nbytes;
LTDL_SET_PRELOADED_SYMBOLS();
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if(rc != 0)
{
goto error_activate;
}
result = gfs_l_dynclient_master_options(argc, argv);
if(result != GLOBUS_SUCCESS)
{
goto error_opts;
}
if(argc < 3)
{
fprintf(stderr, "%s [options] <backend contact string>"
" <frontend contact string>\n", argv[0]);
fprintf(stderr, "Use -help for more information\n");
exit(0);
}
be_cs = argv[argc - 2];
reg_cs = argv[argc - 1];
result = gfs_l_dynclient_xio_setup();
if(result != GLOBUS_SUCCESS)
{
goto error_xio;
}
memset(buffer, '\0', GF_DYN_PACKET_LEN);
buffer[GF_VERSION_NDX] = GF_VERSION;
buffer[GF_MSG_TYPE_NDX] = GFS_GFORK_MSG_TYPE_DYNBE;
tmp32 = htonl(g_at_once);
memcpy(&buffer[GF_DYN_AT_ONCE_NDX], &tmp32, sizeof(uint32_t));
tmp32 = htonl(g_total_cons);
memcpy(&buffer[GF_DYN_TOTAL_NDX], &tmp32, sizeof(uint32_t));
tmp32 = htonl(1);
memcpy(&buffer[GF_DYN_ENTRY_COUNT_NDX], &tmp32, sizeof(uint32_t));
strncpy((char *) &buffer[GF_DYN_CS_NDX], be_cs, GF_DYN_CS_LEN);
result = globus_xio_open(g_xio_handle, reg_cs, NULL);
if(result != GLOBUS_SUCCESS)
{
goto error_open;
}
result = globus_xio_write(
g_xio_handle, buffer,
GF_DYN_PACKET_LEN, GF_DYN_PACKET_LEN, &nbytes, NULL);
if(result != GLOBUS_SUCCESS)
{
goto error_write;
}
/* read reply */
result = globus_xio_read(
g_xio_handle, buffer,
GF_DYN_PACKET_LEN, GF_DYN_PACKET_LEN, &nbytes, NULL);
if(result != GLOBUS_SUCCESS)
{
gfs_l_dynclient_log(GLOBUS_SUCCESS, 0,
"Read failed\n");
goto error_read;
}
result = globus_xio_close(g_xio_handle, NULL);
if(result != GLOBUS_SUCCESS)
{
gfs_l_dynclient_log(GLOBUS_SUCCESS, 0,
"Close failed\n");
goto error_close;
}
gfs_l_dynclient_log(GLOBUS_SUCCESS, 1,
"proper net commication with %s\n",
reg_cs);
if(buffer[GF_MSG_TYPE_NDX] == GFS_GFORK_MSG_TYPE_ACK)
{
gfs_l_dynclient_log(GLOBUS_SUCCESS, 0,
"SUCCESS: registered %s to %s",
be_cs, reg_cs);
rc = 0;
}
else
{
gfs_l_dynclient_log(GLOBUS_SUCCESS, 0,
"ERROR: %s rejected registration of %s",
reg_cs, be_cs);
rc = 1;
}
return rc;
error_close:
error_read:
error_write:
error_open:
error_xio:
error_opts:
error_activate:
gfs_l_dynclient_log(result, 0, "");
return 2;
}
int
main(
int argc,
char ** argv)
{
globus_xio_driver_t driver;
globus_xio_stack_t stack;
globus_xio_handle_t xio_handle;
char * cs;
globus_result_t res;
char line[LINE_LEN];
int ctr;
globus_bool_t done = GLOBUS_FALSE;
globus_size_t nbytes;
if(argc < 2)
{
help();
return 1;
}
globus_module_activate(GLOBUS_XIO_MODULE);
globus_xio_stack_init(&stack, NULL);
for(ctr = 1; ctr < argc - 1; ctr++)
{
if(strcmp(argv[ctr], "-h") == 0)
{
help();
return 0;
}
else if(strcmp(argv[ctr], "-D") == 0 && ctr + 1 < argc - 1)
{
ctr++;
globus_xio_driver_load(argv[ctr], &driver);
globus_xio_stack_push_driver(stack, driver);
}
}
cs = argv[argc - 1];
res = globus_xio_handle_create(&xio_handle, stack);
test_res(res);
globus_xio_open(xio_handle, cs, NULL);
while(!done)
{
if(fgets(line, LINE_LEN, stdin) == NULL)
{
done = GLOBUS_TRUE;
}
else
{
int len;
len = strlen(line);
res = globus_xio_write(
xio_handle, line, len, len, &nbytes, NULL);
test_res(res);
}
}
globus_xio_close(xio_handle, NULL);
globus_module_activate(GLOBUS_XIO_MODULE);
return 0;
}
static
int
globus_l_seg_stdout_activate(void)
{
globus_result_t result;
globus_xio_attr_t out_attr;
globus_xio_attr_t in_attr;
int rc;
globus_l_seg_output_handle = NULL;
globus_l_seg_input_handle = NULL;
globus_l_seg_file_stack = NULL;
globus_l_seg_file_driver = NULL;
globus_l_seg_timestamp = 0;
globus_l_seg_write_registered = GLOBUS_FALSE;
globus_l_seg_shutdown = 0;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto error;
}
rc = globus_module_activate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_common_error;
}
rc = globus_fifo_init(&globus_l_seg_buffers);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_seg_error;
}
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_fifo_error;
}
result = globus_xio_driver_load("file", &globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto deactivate_xio_error;
}
result = globus_xio_stack_init(&globus_l_seg_file_stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto unload_driver_error;
}
result = globus_xio_stack_push_driver(globus_l_seg_file_stack,
globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_init(&out_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_WRONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdout));
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_init(&in_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_RDONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdin));
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_handle_create(
&globus_l_seg_output_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_open(globus_l_seg_output_handle, "", out_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_handle_create(
&globus_l_seg_input_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_open(globus_l_seg_input_handle, "", in_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_mutex_init(&globus_l_seg_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_cond_init(&globus_l_seg_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_mutex_error;
}
result = globus_xio_register_read(
globus_l_seg_input_handle,
globus_l_seg_input_buffer,
sizeof(globus_l_seg_input_buffer),
1,
NULL,
globus_l_xio_read_eof_callback,
NULL);
if (result != GLOBUS_SUCCESS)
{
goto destroy_cond_error;
}
globus_xio_attr_destroy(in_attr);
globus_xio_attr_destroy(out_attr);
return 0;
destroy_cond_error:
globus_cond_destroy(&globus_l_seg_cond);
destroy_mutex_error:
globus_mutex_destroy(&globus_l_seg_mutex);
close_in_handle_error:
globus_xio_close(globus_l_seg_input_handle, NULL);
close_out_handle_error:
globus_xio_close(globus_l_seg_output_handle, NULL);
destroy_in_attr_error:
globus_xio_attr_destroy(in_attr);
destroy_out_attr_error:
globus_xio_attr_destroy(out_attr);
destroy_stack_error:
globus_xio_stack_destroy(globus_l_seg_file_stack);
unload_driver_error:
globus_xio_driver_unload(globus_l_seg_file_driver);
deactivate_xio_error:
globus_module_deactivate(GLOBUS_XIO_MODULE);
destroy_fifo_error:
globus_fifo_destroy(&globus_l_seg_buffers);
deactivate_seg_error:
globus_module_deactivate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
deactivate_common_error:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
error:
return 1;
}
globus_result_t
globus_usage_stats_handle_init(
globus_usage_stats_handle_t * handle,
uint16_t code,
uint16_t version,
const char * targets)
{
globus_result_t result = GLOBUS_SUCCESS;
#ifndef TARGET_ARCH_ARM
globus_i_usage_stats_handle_t * new_handle;
char * targets_env;
globus_list_t * targets_list;
char * contact;
globus_sockaddr_t addr;
int host[16];
int count;
char hostname[255];
int rc = 0;
int i;
new_handle = globus_calloc(1, sizeof(globus_i_usage_stats_handle_t));
if(!new_handle)
{
return globus_error_put(
globus_error_construct_error(
GLOBUS_USAGE_MODULE,
NULL,
GLOBUS_USAGE_STATS_ERROR_TYPE_OOM,
__FILE__,
_globus_func_name,
__LINE__,
"Out of memory"));
}
new_handle->optout = getenv("GLOBUS_USAGE_OPTOUT");
if(new_handle->optout)
{
*handle = new_handle;
return GLOBUS_SUCCESS;
}
globus_mutex_init(&new_handle->mutex, NULL);
new_handle->inuse = GLOBUS_FALSE;
new_handle->code = htons(code);
new_handle->version = htons(version);
memset(new_handle->data, 0, PACKET_SIZE);
memcpy(new_handle->data + new_handle->data_length,
(void *)&new_handle->code, 2);
new_handle->data_length += 2;
memcpy(new_handle->data + new_handle->data_length,
(void *)&new_handle->version, 2);
new_handle->data_length += 2;
rc = globus_libc_gethostaddr(&addr);
if(rc != 0)
{
return globus_error_put(
globus_error_construct_error(
GLOBUS_USAGE_MODULE,
NULL,
GLOBUS_USAGE_STATS_ERROR_TYPE_UNKNOWN_HOSTNAME,
__FILE__,
_globus_func_name,
__LINE__,
"Unable to get hostaddr."));
}
result = globus_libc_addr_to_contact_string(
&addr, GLOBUS_LIBC_ADDR_NUMERIC, &contact);
if(result != GLOBUS_SUCCESS)
{
return result;
}
result = globus_libc_contact_string_to_ints(
contact, host, &count, NULL);
if(result != GLOBUS_SUCCESS)
{
return result;
}
globus_libc_free(contact);
if(count == 4)
{
memset(new_handle->data + new_handle->data_length, 0, 12);
new_handle->data_length += 12;
}
for (i = 0; i < count; i++)
{
new_handle->data[new_handle->data_length++] = (unsigned char) host[i];
}
/* timestamp will go here */
new_handle->data_length += 4;
if(globus_libc_gethostname(hostname, 255) == 0)
{
new_handle->data_length +=
sprintf((char *) new_handle->data + new_handle->data_length,
"HOSTNAME=%s", hostname);
}
new_handle->header_length = new_handle->data_length;
if(targets)
{
globus_l_usage_stats_split_targets(targets, &new_handle->targets);
}
else if((targets_env = getenv("GLOBUS_USAGE_TARGETS"))
!= NULL)
{
globus_l_usage_stats_split_targets(
targets_env, &new_handle->targets);
}
else
{
globus_l_usage_stats_split_targets(
GLOBUS_L_USAGE_STATS_DEFAULT_TARGETS,
&new_handle->targets);
}
result = globus_xio_handle_create(
&new_handle->xio_handle,
globus_l_usage_stats_stack);
if(result != GLOBUS_SUCCESS)
{
return result;
}
result = globus_xio_open(
new_handle->xio_handle,
NULL, NULL);
if(result != GLOBUS_SUCCESS)
{
return result;
}
targets_list = new_handle->targets;
while(targets_list)
{
globus_xio_data_descriptor_t * dd;
dd = (globus_xio_data_descriptor_t *) globus_malloc(
sizeof(globus_xio_data_descriptor_t));
result = globus_xio_data_descriptor_init(
dd,
new_handle->xio_handle);
if(result != GLOBUS_SUCCESS)
{
return result;
}
result = globus_xio_data_descriptor_cntl(
*dd,
globus_l_usage_stats_udp_driver,
GLOBUS_XIO_UDP_SET_CONTACT,
(char *)globus_list_first(targets_list));
if(result != GLOBUS_SUCCESS)
{
goto exit;
}
globus_list_insert(&new_handle->xio_desc_list, dd);
targets_list = globus_list_rest(targets_list);
}
*handle = new_handle;
return GLOBUS_SUCCESS;
exit:
#endif
return result;
}
static
void *
globus_l_dsi_rest_thread(
void *arg)
{
globus_l_dsi_rest_handle_t *dsi_rest_handle = arg;
globus_xio_data_descriptor_t descriptor;
size_t buf_size = 256;
unsigned char *buf = malloc(buf_size);
globus_size_t nbytes;
char *encoded_uri;
globus_mutex_lock(&dsi_rest_handle->mutex);
while (!dsi_rest_handle->terminate)
{
char *method;
char *uri;
globus_xio_http_version_t http_version;
globus_hashtable_t headers;
globus_result_t result;
globus_mutex_unlock(&dsi_rest_handle->mutex);
result = globus_xio_server_accept(
&dsi_rest_handle->xio_handle,
dsi_rest_handle->xio_server);
globus_mutex_lock(&dsi_rest_handle->mutex);
if (result != GLOBUS_SUCCESS)
{
continue;
}
result = globus_xio_open(
dsi_rest_handle->xio_handle,
NULL,
NULL);
if (result != GLOBUS_SUCCESS)
{
goto end_this_socket;
}
result = globus_xio_data_descriptor_init(&descriptor, dsi_rest_handle->xio_handle);
if (result != GLOBUS_SUCCESS)
{
goto end_this_socket;
}
result = globus_xio_read(
dsi_rest_handle->xio_handle,
buf,
0,
0,
&nbytes,
descriptor);
if (result != GLOBUS_SUCCESS)
{
goto end_this_socket;
}
result = globus_xio_data_descriptor_cntl(
descriptor,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_GET_REQUEST,
&method,
&uri,
&http_version,
&headers);
globus_dsi_rest_uri_escape(uri, &encoded_uri);
char *uripath = globus_common_create_string("%s/%s", dsi_rest_handle->root, encoded_uri);
if (strcmp(method, "GET") == 0)
{
int fd;
fd = open(uripath, O_RDONLY);
if (fd < 0)
{
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Connection",
"Close");
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Content-Length",
"0");
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE,
404);
}
else
{
globus_size_t read_amt = 0;
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Connection",
"Close");
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE,
200);
do
{
read_amt = read(fd, buf, buf_size);
if (read_amt > 0)
{
globus_size_t written_amt = 0;
while (written_amt < read_amt)
{
globus_size_t this_write;
result = globus_xio_write(
dsi_rest_handle->xio_handle,
buf+written_amt,
read_amt-written_amt,
read_amt-written_amt,
&this_write,
NULL);
if (this_write > 0)
{
written_amt += this_write;
}
else if (result != GLOBUS_SUCCESS)
{
break;
}
}
}
}
while (read_amt > 0);
close(fd);
}
}
else
{
int fd = open(uripath, O_WRONLY|O_CREAT, 0700);
if (fd < 0)
{
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE,
500);
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Content-Length",
"0");
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Connection",
"Close");
}
else
{
off_t total_written=0;
if (nbytes > 0)
{
globus_size_t written_amt = 0;
while (written_amt < nbytes)
{
globus_size_t this_write;
this_write = write(fd, buf+written_amt, nbytes-written_amt);
if (this_write > 0)
{
written_amt += this_write;
total_written += this_write;
}
}
}
do
{
result = globus_xio_read(
dsi_rest_handle->xio_handle,
buf,
buf_size,
1,
&nbytes,
NULL);
if (nbytes > 0)
{
globus_size_t written_amt = 0;
while (written_amt < nbytes)
{
globus_size_t this_write;
this_write = write(fd, buf+written_amt, nbytes-written_amt);
if (this_write > 0)
{
written_amt += this_write;
total_written += this_write;
}
}
}
if (result != GLOBUS_SUCCESS)
{
if (globus_error_match(
globus_error_peek(result),
GLOBUS_XIO_MODULE,
GLOBUS_XIO_ERROR_EOF)
|| globus_xio_driver_error_match(
dsi_rest_handle->http_driver,
globus_error_peek(result),
GLOBUS_XIO_HTTP_ERROR_EOF))
{
result = GLOBUS_SUCCESS;
break;
}
else
{
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE,
500);
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Content-Length",
"0");
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Connection",
"Close");
goto xio_error;
}
}
}
while (nbytes > 0);
close(fd);
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE,
204);
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Content-Length",
"0");
globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER,
"Connection",
"Close");
}
}
xio_error:
free(uripath);
result = globus_xio_handle_cntl(
dsi_rest_handle->xio_handle,
dsi_rest_handle->http_driver,
GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY);
end_this_socket:
result = globus_xio_close(
dsi_rest_handle->xio_handle,
NULL);
dsi_rest_handle->xio_handle = NULL;
}
dsi_rest_handle->terminate_complete = true;
globus_cond_signal(&dsi_rest_handle->cond);
globus_mutex_unlock(&dsi_rest_handle->mutex);
return NULL;
}
