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;
}
/******************************************************************************
Function: globus_gass_server_ez_init()
Description:
Parameters:
Returns:
******************************************************************************/
int
globus_gass_server_ez_init(globus_gass_transfer_listener_t * listener,
globus_gass_transfer_listenerattr_t * attr,
char * scheme,
globus_gass_transfer_requestattr_t * reqattr,
unsigned long options,
globus_gass_server_ez_client_shutdown_t callback,
int fd)
{
int rc;
globus_l_gass_server_ez_t *server;
globus_bool_t free_scheme=GLOBUS_FALSE;
if(scheme==GLOBUS_NULL)
{
scheme=globus_malloc(6); /* https/0 is the default */
if(scheme == GLOBUS_NULL)
{
rc = GLOBUS_GASS_TRANSFER_ERROR_MALLOC_FAILED;
goto error_exit;
}
free_scheme=GLOBUS_TRUE;
globus_libc_lock();
sprintf(scheme, "https");
globus_libc_unlock();
}
if(reqattr==GLOBUS_NULL)
{
reqattr=(globus_gass_transfer_requestattr_t *)globus_malloc(sizeof(globus_gass_transfer_requestattr_t));
globus_gass_transfer_requestattr_init(reqattr,
scheme);
globus_gass_transfer_secure_requestattr_set_authorization(reqattr,
GLOBUS_GASS_TRANSFER_AUTHORIZE_SELF,
scheme);
}
rc=globus_gass_transfer_create_listener(listener,
attr,
scheme);
if(rc!=GLOBUS_SUCCESS)
{
goto error_exit;
}
server=(globus_l_gass_server_ez_t *)globus_malloc(
sizeof (globus_l_gass_server_ez_t));
if(server==GLOBUS_NULL)
{
rc = GLOBUS_GASS_TRANSFER_ERROR_MALLOC_FAILED;
goto error_exit;
}
server->options=options;
server->listener=*listener;
server->reqattr=reqattr;
server->callback=callback;
server->fd=fd;
globus_hashtable_insert(&globus_l_gass_server_ez_listeners,
(void *)*listener,
server);
rc=globus_gass_transfer_register_listen(*listener,
globus_l_gass_server_ez_listen_callback,
(void *)reqattr);
/* insert error handling here*/
error_exit:
if (free_scheme) globus_free(scheme);
return rc;
} /* globus_gass_server_ez_init() */