void interpret_command(ostream &out, istream &in, FrBool allow_bench)
{
FrObject *cmd ;
in >> cmd ;
if (cmd && cmd->symbolp())
{
FrSymbol *cmdsym = (FrSymbol*)cmd ;
FramepaC_bgproc() ; // handle any asynchronous operations
FrBool found = False ;
for (CommandDef *def = commands ; def->name ; def++)
{
if (*cmdsym == def->name)
{
if (!allow_bench && strcmp(def->name,"BENCH") == 0)
break ;
found = True ;
def->func(out,in) ;
break ;
}
}
if (!found)
{
if (cmdsym == findSymbol("BENCH") && allow_bench)
benchmarks_menu(out,in) ;
else if (cmdsym == findSymbol("?"))
list_commands(out,allow_bench) ;
else
{
out << cmd << " is an unknown command." << endl ;
list_commands(out,allow_bench) ;
}
}
}
else
{
out << cmd << " is not a valid command, because it is not a symbol."
<< endl ;
if (cmd) cmd->freeObject() ;
FramepaC_bgproc() ; // handle any asynchronous operations
}
}
static void
syntax_error (char *err)
{
if (err) {
printf("Error: '%s'\n",err);
exit(1);
}
printf ("Sytax:\n");
printf (" ole <ole-file> [-i] [commands...]\n\n");
printf (" -i: Interactive, queries for fresh commands\n\n");
list_commands ();
exit(1);
}
/*
* m_help - HELP message handler
* parv[0] = sender prefix
*/
static void
m_help(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
static time_t last_used = 0;
/* HELP is always local */
if ((last_used + ConfigFileEntry.pace_wait_simple) > CurrentTime)
{
/* safe enough to give this on a local connect only */
sendto_one(source_p,form_str(RPL_LOAD2HI),
me.name, source_p->name);
return;
}
else
last_used = CurrentTime;
list_commands(source_p);
}
static int do_help(int argc, char *argv[])
{
const struct futil_cmd_t *cmd;
const char *vstr = "";
/* Help about a known command? */
if (argc > 1) {
cmd = find_command(argv[1]);
if (cmd) {
/* Let the command provide its own help */
argv[0] = argv[1];
argv[1] = "--help";
return run_command(cmd, argc, argv);
}
}
fputs(usage, stdout);
if (vboot_version == VBOOT_VERSION_ALL)
fputs(options, stdout);
switch (vboot_version) {
case VBOOT_VERSION_1_0:
vstr = "version 1.0 ";
break;
case VBOOT_VERSION_2_1:
vstr = "version 2.1 ";
break;
case VBOOT_VERSION_ALL:
vstr = "";
break;
}
printf("The following %scommands are built-in:\n\n", vstr);
list_commands();
printf("\nUse \"" MYNAME " help COMMAND\" for more information.\n\n");
return 0;
}
static int do_help(int argc, char *argv[])
{
const struct futil_cmd_t *cmd;
const char *vstr;
if (argc >= 2) {
cmd = find_command(argv[1]);
if (cmd) {
printf("\n%s - %s\n", argv[1], cmd->shorthelp);
if (cmd->longhelp)
cmd->longhelp(argv[1]);
return 0;
}
}
fputs(usage, stdout);
if (vboot_version == VBOOT_VERSION_ALL)
fputs(options, stdout);
switch (vboot_version) {
case VBOOT_VERSION_1_0:
vstr = "version 1.0 ";
break;
case VBOOT_VERSION_2_1:
vstr = "version 2.1 ";
break;
case VBOOT_VERSION_ALL:
vstr = "";
break;
}
printf("The following %scommands are built-in:\n\n", vstr);
list_commands();
printf("\nUse \"" MYNAME " help COMMAND\" for more information.\n\n");
return 0;
}
int
main (int argc, char **argv)
{
MsOle *ole;
int lp, exit = 0, interact = 0;
char *buffer = g_new (char, 1024) ;
if (argc<2)
syntax_error(0);
if (!g_strcasecmp (argv [1], "regression")) {
do_regression_tests ();
return 0;
}
printf ("Ole file '%s'\n", argv[1]);
if (ms_ole_open_vfs (&ole, argv[1], TRUE, NULL)
!= MS_OLE_ERR_OK) {
printf ("Creating new file '%s'\n", argv[1]);
if (ms_ole_create_vfs (&ole, argv[1], TRUE, NULL)
!= MS_OLE_ERR_OK)
syntax_error ("Can't open file or create new one");
}
if (argc<=2)
syntax_error ("Need command or -i");
if (argc>2 && argv[argc-1][0]=='-'
&& argv[argc-1][1]=='i')
interact=1;
else {
char *str=g_strdup(argv[2]) ;
for (lp=3;lp<argc;lp++)
str = g_strconcat(str," ",argv[lp],NULL); /* FIXME Mega leak :-) */
buffer = str; /* and again */
}
cur_dir = g_strdup ("/");
do
{
char *ptr;
if (interact) {
fprintf (stdout,"> ");
fflush (stdout);
fgets (buffer, 1023, stdin);
}
arg_data = g_strsplit (g_strchomp (buffer), delim, -1);
arg_cur = 0;
if (!arg_data && interact) continue;
if (!interact)
printf ("Command : '%s'\n", arg_data[0]);
ptr = arg_data[arg_cur++];
if (!ptr)
continue;
if (g_strcasecmp (ptr, "ls") == 0)
list_files (ole);
else if (g_strcasecmp (ptr, "cd") == 0)
enter_dir (ole);
else if (g_strcasecmp (ptr, "dump") == 0)
do_dump (ole);
else if (g_strcasecmp (ptr, "biff") == 0)
do_biff (ole);
else if (g_strcasecmp (ptr, "biffraw") == 0)
do_biff_raw (ole);
else if (g_strcasecmp (ptr, "get") == 0)
do_get (ole);
else if (g_strcasecmp (ptr, "put") == 0)
do_put (ole);
else if (g_strcasecmp (ptr, "copyin") == 0)
do_copyin (ole);
else if (g_strcasecmp (ptr, "copyout") == 0)
do_copyout (ole);
else if (g_strcasecmp (ptr, "summary") == 0)
do_summary (ole);
else if (g_strcasecmp (ptr, "docsummary") == 0)
do_docsummary (ole);
else if (g_strcasecmp (ptr, "debug") == 0)
ms_ole_debug (ole, 1);
else if (g_strcasecmp (ptr, "tree") == 0)
ms_ole_debug (ole, 2);
else if (g_strcasecmp (ptr, "vba") == 0)
dump_vba (ole);
else if (g_strcasecmp (ptr, "help") == 0 ||
g_strcasecmp (ptr, "?") == 0 ||
g_strcasecmp (ptr, "info") == 0 ||
g_strcasecmp (ptr, "man") == 0)
list_commands ();
else if (g_strcasecmp (ptr, "exit") == 0 ||
g_strcasecmp (ptr, "quit") == 0 ||
g_strcasecmp (ptr, "q") == 0 ||
g_strcasecmp (ptr, "bye") == 0)
exit = 1;
}
while (!exit && interact);
ms_ole_destroy (&ole);
return 0;
}
/**
* @brief Shell thread function.
*
* @param[in] p pointer to a @p BaseSequentialStream object
* @return Termination reason.
* @retval RDY_OK terminated by command.
* @retval RDY_RESET terminated by reset condition on the I/O channel.
*/
static msg_t shell_thread(void *p) {
int n;
msg_t msg = RDY_OK;
BaseSequentialStream *chp = ((ShellConfig *)p)->sc_channel;
const ShellCommand *scp = ((ShellConfig *)p)->sc_commands;
char *lp, *cmd, *tokp, line[SHELL_MAX_LINE_LENGTH];
char *args[SHELL_MAX_ARGUMENTS + 1];
chRegSetThreadName("shell");
chprintf(chp, "\r\nChibiOS/RT Shell\r\n");
while (TRUE) {
chprintf(chp, "ch> ");
if (shellGetLine(chp, line, sizeof(line))) {
chprintf(chp, "\r\nlogout");
break;
}
lp = _strtok(line, " \009", &tokp);
cmd = lp;
n = 0;
while ((lp = _strtok(NULL, " \009", &tokp)) != NULL) {
if (n >= SHELL_MAX_ARGUMENTS) {
chprintf(chp, "too many arguments\r\n");
cmd = NULL;
break;
}
args[n++] = lp;
}
args[n] = NULL;
if (cmd != NULL) {
if (strcasecmp(cmd, "exit") == 0) {
if (n > 0) {
usage(chp, "exit");
continue;
}
break;
}
else if (strcasecmp(cmd, "help") == 0) {
if (n > 0) {
usage(chp, "help");
continue;
}
chprintf(chp, "Commands: help exit ");
list_commands(chp, local_commands);
if (scp != NULL)
list_commands(chp, scp);
chprintf(chp, "\r\n");
}
else if (cmdexec(local_commands, chp, cmd, n, args) &&
((scp == NULL) || cmdexec(scp, chp, cmd, n, args))) {
chprintf(chp, "%s", cmd);
chprintf(chp, " ?\r\n");
}
}
}
/* Atomically broadcasting the event source and terminating the thread,
there is not a chSysUnlock() because the thread terminates upon return.*/
chSysLock();
chEvtBroadcastI(&shell_terminated);
chThdExitS(msg);
return 0; /* Never executed.*/
}
static void execute_user_command(client_t *c, int narg, char **args)
{
const char *cmd;
cmd = args[0];
narg--;
args++;
switch (narg) {
case 0:
if (!strcmp(cmd, "register")) register_client(c);
else if (!strcmp(cmd, "unregister")) unregister_client(c);
else if (!strcmp(cmd, "exit")) quit_mainloop(c, 0);
else if (!strcmp(cmd, "quit")) quit_mainloop(c, 0);
else if (!strcmp(cmd, "help")) {
print(c, "Available commands:");
print(c, " register - register to server");
print(c, " unregister - unregister from server");
print(c, " focus none|shared|exclusive - request voice focus");
print(c, " add command <command> - add new command");
print(c, " del command <command> - delete a command");
print(c, " render tts '<msg>' \\ - request TTS of <msg>");
print(c, " [-voice:<voice>] \\");
print(c, " [-timeout:<timeout>]\\");
print(c, " [-events]");
print(c, " cancel tts '<id>' - cancel given TTS "
"request");
print(c, " list commands - list commands set");
print(c, " list voices - list available voices");
print(c, " help - show this help");
print(c, " exit - exit from client");
}
else
print(c, "Unknown command '%s'.", cmd);
break;
case 1:
if (!strcmp(cmd, "focus")) {
if (strcmp(args[0], "none") &&
strcmp(args[0], "shared") &&
strcmp(args[0], "exclusive")) {
print(c, "Invalid focus '%s', valid foci are: "
"none, shared, and exclusive.", args[0]);
}
else
request_focus(c, args[0]);
}
else if (!strcmp(cmd, "reset") && !strcmp(args[0], "commands"))
reset_commands(c);
else if (!strcmp(cmd, "list" ) && !strcmp(args[0], "commands"))
list_commands(c);
else if (!strcmp(cmd, "list" ) && !strcmp(args[0], "voices"))
query_voices(c, NULL);
else if (!strcmp(cmd, "cancel" ) && !strcmp(args[0], "tts"))
cancel_tts(c, 0, NULL);
else
print(c, "Invalid command.");
break;
case 2:
if (!strcmp(cmd, "list" ) && !strcmp(args[0], "voices"))
query_voices(c, args[1]);
else if (!strcmp(cmd, "cancel"))
cancel_tts(c, narg-1, args+1);
else
print(c, "Invalid command.");
break;
default:
if (!strcmp(args[0], "command")) {
if (!strcmp(cmd, "add" ))
add_command(c, narg-1, args+1);
else if (!strcmp(cmd, "del" ) || !strcmp(cmd, "delete"))
del_command(c, narg-1, args+1);
else
print(c, "Invalid command.");
}
else if (!strcmp(args[0], "tts")) {
if (!strcmp(cmd, "render"))
request_tts(c, narg-1, args+1);
else
print(c, "Invalid TTS command.");
}
else
print(c, "Invalid command.");
break;
}
}
int main(int argc, char** argv) {
return parse_options(argc, argv) ||
list_commands(get_config_file()) || show_gui(&argc, &argv);
}
/*
* Parse command line arguments.
*
* Return 0 if OK, else -1
*/
static int parse_args(int argc, char **argv)
{
int opt, ret;
char *user;
if (argc < 2) {
usage(stderr);
clean_exit(EXIT_FAILURE);
}
while ((opt = getopt_long(argc, argv, "+Vhnvqg:m:", long_options, NULL)) != -1) {
switch (opt) {
case 'V':
version(stdout);
ret = 0;
goto end;
case 'h':
usage(stdout);
ret = 0;
goto end;
case 'v':
/* There is only 3 possible level of verbosity. (-vvv) */
if (lttng_opt_verbose < 3) {
lttng_opt_verbose += 1;
}
break;
case 'q':
lttng_opt_quiet = 1;
break;
case 'm':
lttng_opt_mi = mi_output_type(optarg);
if (lttng_opt_mi < 0) {
ret = lttng_opt_mi;
goto error;
}
break;
case 'g':
lttng_set_tracing_group(optarg);
break;
case 'n':
opt_no_sessiond = 1;
break;
case OPT_SESSION_PATH:
opt_sessiond_path = strdup(optarg);
break;
case OPT_RELAYD_PATH:
opt_relayd_path = strdup(optarg);
break;
case OPT_DUMP_OPTIONS:
list_options(stdout);
ret = 0;
goto end;
case OPT_DUMP_COMMANDS:
list_commands(commands, stdout);
ret = 0;
goto end;
default:
usage(stderr);
ret = 1;
goto error;
}
}
/* If both options are specified, quiet wins */
if (lttng_opt_verbose && lttng_opt_quiet) {
lttng_opt_verbose = 0;
}
/* Spawn session daemon if needed */
if (opt_no_sessiond == 0 && check_args_no_sessiond(argc, argv) == 0 &&
(check_sessiond() < 0)) {
ret = 1;
goto error;
}
/* No leftovers, print usage and quit */
if ((argc - optind) == 0) {
usage(stderr);
ret = 1;
goto error;
}
/* For Mathieu Desnoyers a.k.a. Dr. Tracing */
user = getenv("USER");
if (user != NULL && ((strncmp(progname, "drtrace", 7) == 0 ||
strncmp("compudj", user, 7) == 0))) {
MSG("%c[%d;%dmWelcome back Dr Tracing!%c[%dm\n", 27,1,33,27,0);
}
/* Thanks Mathieu */
/*
* Handle leftovers which is a first level command with the trailing
* options.
*/
ret = handle_command(argc - optind, argv + optind);
switch (ret) {
case CMD_WARNING:
WARN("Some command(s) went wrong");
break;
case CMD_ERROR:
ERR("Command error");
break;
case CMD_UNDEFINED:
ERR("Undefined command");
break;
case CMD_FATAL:
ERR("Fatal error");
break;
case CMD_UNSUPPORTED:
ERR("Unsupported command");
break;
case -1:
usage(stderr);
ret = 1;
break;
case 0:
break;
default:
if (ret < 0) {
ret = -ret;
}
break;
}
end:
error:
return ret;
}
int do_upcalls_help(void)
{
puts("Upcalls commands list:\n");
list_commands(upcalls_subcommands);
return (0);
}
/*
* mo_uhelp - HELP message handler
* This is used so that opers can view the user help file without deopering
* parv[0] = sender prefix
*/
static void
mo_uhelp(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
list_commands(source_p);
}
int do_drivers_help(void)
{
puts("Drivers subcommands list:\n");
list_commands(drivers_subcommands);
return (0);
}
int
main(int argc, char* argv[])
{
char *procd_address = NULL;
myDistro->Init(argc, argv);
if (argc < 2) {
fprintf(stderr,
"Usage: %s <options w/arguments> <command> [<arg> ...]\n",
argv[0]);
list_commands();
return 1;
}
config();
Termlog = 1;
dprintf_config("TOOL", get_param_functions());
int cmd_argc = argc - 1;
char** cmd_argv = argv + 1;
// Process the first set of options.
while(cmd_argv[0] != NULL && cmd_argv[0][0] == '-')
{
if (strcmp(cmd_argv[0], "-A") == MATCH) {
cmd_argc--;
cmd_argv++;
if (cmd_argc == 0) {
fprintf(stderr, "error: -A needs an argument\n");
list_commands();
return 1;
}
// store the argument to -A as the file we'll use.
procd_address = cmd_argv[0];
cmd_argc--;
cmd_argv++;
continue;
} else if (strcmp(cmd_argv[0], "-h") == MATCH) {
cmd_argc--;
cmd_argv++;
fprintf(stderr,
"Usage: %s <options w/arguments> <command> [<arg> ...]\n",
argv[0]);
list_commands();
return 1;
continue;
}
// This is the failure case if we manage to pass all checks above.
fprintf(stderr, "error: Don't understand option %s\n", cmd_argv[0]);
list_commands();
return 1;
}
// If there are no command line arguments left, then there is no
// command specified after the options, which is a failure.
if (cmd_argc == 0) {
fprintf(stderr,
"Please specify a command.\n"
"Usage: %s <options w/arguments> <command> [<arg> ...]\n",
argv[0]);
list_commands();
return 1;
}
// If a procd address wasn't specified on the command line, see if we
// have an entry in a config file to use.
if (procd_address == NULL) {
procd_address = param("PROCD_ADDRESS");
if (procd_address == NULL) {
fprintf(stderr, "error: PROCD_ADDRESS not defined\n");
return 1;
}
}
ProcFamilyClient pfc;
if (!pfc.initialize(procd_address)) {
fprintf(stderr, "error: failed to initialize ProcD client\n");
return 1;
}
// Process this single command we should be performing
if (strcasecmp(cmd_argv[0], "REGISTER_FAMILY") == 0) {
return register_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "TRACK_BY_ASSOCIATED_GID") == 0) {
return track_by_associated_gid(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "TRACK_BY_ASSOCIATED_CGROUP") == 0) {
return track_by_associated_cgroup(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "GET_USAGE") == 0) {
return get_usage(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "DUMP") == 0) {
return dump(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "LIST") == 0) {
return list(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "SIGNAL_PROCESS") == 0) {
return signal_process(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "SUSPEND_FAMILY") == 0) {
return suspend_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "CONTINUE_FAMILY") == 0) {
return continue_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "KILL_FAMILY") == 0) {
return kill_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "UNREGISTER_FAMILY") == 0) {
return unregister_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "SNAPSHOT") == 0) {
return snapshot(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "QUIT") == 0) {
return quit(pfc, cmd_argc, cmd_argv);
}
else {
fprintf(stderr, "error: invalid command: %s\n", cmd_argv[0]);
list_commands();
return 1;
}
}
int do_video_help(void)
{
puts("Video commands:\n");
list_commands(video_subcommands);
return (0);
}
/**
* @brief Shell thread function.
*
* @param[in] p pointer to a @p BaseSequentialStream object
*/
THD_FUNCTION(shellThread, p) {
int n;
ShellConfig *scfg = p;
BaseSequentialStream *chp = scfg->sc_channel;
const ShellCommand *scp = scfg->sc_commands;
char *lp, *cmd, *tokp, line[SHELL_MAX_LINE_LENGTH];
char *args[SHELL_MAX_ARGUMENTS + 1];
#if SHELL_USE_HISTORY == TRUE
*(scfg->sc_histbuf) = 0;
ShellHistory hist = {
scfg->sc_histbuf,
scfg->sc_histsize,
0,
0,
0
};
ShellHistory *shp = &hist;
#else
ShellHistory *shp = NULL;
#endif
chprintf(chp, SHELL_NEWLINE_STR);
chprintf(chp, "ChibiOS/RT Shell"SHELL_NEWLINE_STR);
while (true) {
chprintf(chp, SHELL_PROMPT_STR);
if (shellGetLine(scfg, line, sizeof(line), shp)) {
#if (SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_)
chprintf(chp, SHELL_NEWLINE_STR);
chprintf(chp, "logout");
break;
#else
/* Putting a delay in order to avoid an endless loop trying to read
an unavailable stream.*/
osalThreadSleepMilliseconds(100);
#endif
}
lp = parse_arguments(line, &tokp);
cmd = lp;
n = 0;
while ((lp = parse_arguments(NULL, &tokp)) != NULL) {
if (n >= SHELL_MAX_ARGUMENTS) {
chprintf(chp, "too many arguments"SHELL_NEWLINE_STR);
cmd = NULL;
break;
}
args[n++] = lp;
}
args[n] = NULL;
if (cmd != NULL) {
if (strcmp(cmd, "help") == 0) {
if (n > 0) {
shellUsage(chp, "help");
continue;
}
chprintf(chp, "Commands: help ");
list_commands(chp, shell_local_commands);
if (scp != NULL)
list_commands(chp, scp);
chprintf(chp, SHELL_NEWLINE_STR);
}
else if (cmdexec(shell_local_commands, chp, cmd, n, args) &&
((scp == NULL) || cmdexec(scp, chp, cmd, n, args))) {
chprintf(chp, "%s", cmd);
chprintf(chp, " ?"SHELL_NEWLINE_STR);
}
}
}
shellExit(MSG_OK);
}
void load_plugins( string path, map<string, Command_Rights>& plugins, list<Plugin*>& liste)
{
void(*sendMsg)(void(*)(const string, const string));
void(*setColor)(string(*)(const string, const string));
void(*setRegister)(void(*)(ScheduleDetails));
void(*setGenerate)(ScheduleDetails(*)(vector<string>));
void(*setCall)(void(*)(string,vector<string>, string));
void(*setSay)(void(*)(string));
void(*setCreateTable)(bool(*)(string));
void(*setSqlCmd)(bool(*)(string));
struct dirent* dp;
DIR* dir = opendir( path.c_str());
if( !dir)
{
cout << "opendir() failure; terminating" << endl;
return;
}
while( (dp = readdir( dir)) != nullptr)
{
if( !strcmp( &dp->d_name[strlen(dp->d_name)-3], ".so") || !strcmp( &dp->d_name[strlen(dp->d_name)-4], ".dll"))
{
string name = path;
name += dp->d_name;
cout << "Loading: " << name << endl;
void* lib_handle = dlopen( name.c_str(), RTLD_LAZY);
if( !lib_handle)
{
cerr << dlerror() << endl;
exit(1);
}
char* error;
PluginDetails* info;
info = reinterpret_cast<PluginDetails*>(dlsym(lib_handle, "exports"));
if( (error = dlerror()) != NULL)
{
cerr << error << endl;
exit(2);
}
*(void**)(&sendMsg) = dlsym(lib_handle, "set_send_msg");
if( !sendMsg)
{
cerr << dlerror() << endl;
exit(3);
}
sendMsg(send_msg);
*(void**)(&setColor) = dlsym(lib_handle, "set_add_color");
if( !setColor)
{
cerr << dlerror() << endl;
exit(3);
}
setColor( add_color);
*(void**)(&setRegister) = dlsym(lib_handle, "set_add_reg_task");
if( !setRegister)
{
cerr << dlerror() << endl;
exit(3);
}
setRegister( register_task);
*(void**)(&setGenerate) = dlsym(lib_handle, "set_generate_schedule");
if( !setGenerate)
{
cerr << dlerror() << endl;
exit(3);
}
setGenerate( generate_task);
*(void**)(&setCall) = dlsym(lib_handle, "set_call");
if( !setCall)
{
cerr << dlerror() << endl;
exit(3);
}
setCall( call);
*(void**)(&setSay) = dlsym(lib_handle, "set_say");
if( !setSay)
{
cerr << dlerror() << endl;
exit(3);
}
setSay( say);
*(void**)(&setCreateTable) = dlsym(lib_handle, "set_create_table");
if( !setCreateTable)
{
cerr << dlerror() << endl;
exit(3);
}
setCreateTable( create_table);
*(void**)(&setSqlCmd) = dlsym(lib_handle, "set_sql");
if( !setSqlCmd)
{
cerr << dlerror() << endl;
exit(3);
}
setSqlCmd( sql_command);
cout << "Plugin info: " << "\nFile Name: " << info->file_name << endl;
cout << "Class name: " << info->class_name << endl;
cout << "plugin name: " << info->plugin_name << endl;
cout << "Command: " << info->command << endl;
Plugin* pl = info->initFunc();
pl->set_handle(lib_handle);
list_commands( info->command, pl, plugins,liste);
}
}
}
int do_fs_help(void)
{
puts("Filesystems commands list:\n");
list_commands(fs_subcommands);
return (0);
}
/***********************
Main
**********************/
int
main(int argc, char *argv[])
{
setup_home();
int g = 0;
int x = 0;
int V = 0;
int c = 0;
int l = 0;
int e = 0;
int d = 0;
int u = 0;
int h = 0;
int G = 0;
int T = 0;
int C = 0;
int M = 0;
int N = 0;
char * group;
char * label;
char * content;
int opt ;
while((opt= getopt(argc,argv, "V(verbose)g:x(execute)c(create)l(list)e(echo):d(drop):u(edit):h(help)G(group):T(template):C(command)::M(macro)::N(note)::"))!= -1)
{
switch(opt)
{
case 'g':
g=1;
group = optarg;
break;
case 'V':
V = 1;
break;
case 'x':
x = 1;
break;
case 'c':
c = 1;
break;
case 'l':
l = 1;
break;
case 'e':
e = 1;
label = argv[optind];
break;
case 'd':
d = 1;
label = argv[optind];
break;
case 'u':
u = 1;
label = argv[optind];
break;
case 'h':
h = 1;
break;
case 'G':
G = 1;
label = argv[optind];
break;
case 'T':
T = 1;
label = argv[optind];
break;
case 'C':
C = 1;
label = argv[optind];
content = argv[optind+1];
break;
case 'N':
N = 1;
label = argv[optind];
content = argv[optind+1];
break;
default:
puts("test");
break;
}
}
if(g == 1)
{
if(c == 1)
{
if(G ==1)
{
create_group(label);
//break;
}
else if(N == 1)
{
create_note(group, label, content);
//break;
}
else if(C == 1)
{
create_command(label,group,content);
//break;
}
else if(T == 1)
{
create_template_from_current(group,label);
//break;
}
else
{
puts("Invalid Command");
return -1;
}
}
if(e == 1)
{
if(N == 1)
{
echo_note(group,label);
}
else if( C == 1)
{
echo_command(label, group);
}
else if (T == 1)
{
echo_template(label, group);
}
}
else if(l == 1)
{
if(N == 1)
{
list_notes(group);
//break;
}
else if(C == 1)
{
list_commands(group);
//break;
}
else if(T == 1)
{
list_templates(group);
}
else
{
puts("Invalid Command");
return -1;
}
}
else if(x == 1)
{
if(C == 1)
{
execute_command(group,label);
//break;
}
else if(T == 1)
{
execute_template(group,label);
}
else
{
puts("Invalid Command");
return -1;
}
}
}
else if(c == 1)
{
if(G == 1)
{
create_group(label);
//break;
}
else
{
puts("Invalid Command");
return -1;
}
}
else if(e == 1)
{
if(G == 1)
{
echo_group(label);
}
}
return 0;
}
/*
* The 'snapshot <cmd> <options>' first level command
*/
int cmd_snapshot(int argc, const char **argv)
{
int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
char *session_name = NULL;
static poptContext pc;
pc = poptGetContext(NULL, argc, argv, snapshot_opts, 0);
poptReadDefaultConfig(pc, 0);
/* Mi check */
if (lttng_opt_mi) {
writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
if (!writer) {
ret = -LTTNG_ERR_NOMEM;
goto end;
}
/* Open command element */
ret = mi_lttng_writer_command_open(writer,
mi_lttng_element_command_snapshot);
if (ret) {
ret = CMD_ERROR;
goto end;
}
/* Open output element */
ret = mi_lttng_writer_open_element(writer,
mi_lttng_element_command_output);
if (ret) {
ret = CMD_ERROR;
goto end;
}
}
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_HELP:
usage(stdout);
goto end;
case OPT_LIST_OPTIONS:
list_cmd_options(stdout, snapshot_opts);
goto end;
case OPT_LIST_COMMANDS:
list_commands(actions, stdout);
goto end;
case OPT_MAX_SIZE:
{
uint64_t val;
const char *opt = poptGetOptArg(pc);
if (utils_parse_size_suffix((char *) opt, &val) < 0) {
ERR("Unable to handle max-size value %s", opt);
ret = CMD_ERROR;
goto end;
}
opt_max_size = val;
break;
}
default:
usage(stderr);
ret = CMD_UNDEFINED;
goto end;
}
}
if (!opt_session_name) {
session_name = get_session_name();
if (session_name == NULL) {
ret = CMD_ERROR;
goto end;
}
current_session_name = session_name;
} else {
current_session_name = opt_session_name;
}
command_ret = handle_command(poptGetArgs(pc));
if (command_ret) {
switch (-command_ret) {
case LTTNG_ERR_EPERM:
ERR("The session needs to be set in no output mode (--no-output)");
break;
case LTTNG_ERR_SNAPSHOT_NODATA:
WARN("%s", lttng_strerror(command_ret));
break;
default:
ERR("%s", lttng_strerror(command_ret));
break;
}
success = 0;
}
if (lttng_opt_mi) {
/* Close output element */
ret = mi_lttng_writer_close_element(writer);
if (ret) {
ret = CMD_ERROR;
goto end;
}
/* Success ? */
ret = mi_lttng_writer_write_element_bool(writer,
mi_lttng_element_command_success, success);
if (ret) {
ret = CMD_ERROR;
goto end;
}
/* Command element close */
ret = mi_lttng_writer_command_close(writer);
if (ret) {
ret = CMD_ERROR;
goto end;
}
}
end:
/* Mi clean-up */
if (writer && mi_lttng_writer_destroy(writer)) {
/* Preserve original error code */
ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL;
}
if (!opt_session_name) {
free(session_name);
}
/* Overwrite ret if an error occured during handle_command */
ret = command_ret ? command_ret : ret;
poptFreeContext(pc);
return ret;
}
int do_help(void)
{
puts("Command list:\n");
list_commands(commands);
return (0);
}
int
main (int argc, char **argv)
{
int exit = 0;
char *buffer = g_new (char, 1024) ;
GIOChannel *ioc;
guint watch_id = 0;
GOptionContext *ctx = NULL;
GError *error = NULL;
/* default to interactive on a terminal */
interactive = isatty (0);
ctx = g_option_context_new("test-vfs");
g_option_context_add_main_entries(ctx, options, NULL);
if (!g_option_context_parse(ctx, &argc, &argv, &error)) {
g_printerr("main: %s\n", error->message);
g_error_free(error);
g_option_context_free(ctx);
return 1;
}
g_option_context_free(ctx);
files = g_hash_table_new (g_str_hash, g_str_equal);
if (noninteractive)
interactive = FALSE;
if (interactive)
vfserr = stderr;
else
vfserr = stdout;
if (!mate_vfs_init ()) {
fprintf (vfserr, "Cannot initialize mate-vfs.\n");
return 1;
}
mate_vfs_module_callback_push
(MATE_VFS_MODULE_CALLBACK_AUTHENTICATION,
authentication_callback, NULL, NULL);
if (argc == 1)
cur_dir = g_get_current_dir ();
else
cur_dir = g_strdup(argv[1]);
if (cur_dir && !G_IS_DIR_SEPARATOR (cur_dir [strlen (cur_dir) - 1]))
cur_dir = g_strconcat (cur_dir, G_DIR_SEPARATOR_S, NULL);
if (interactive == TRUE) {
main_loop = g_main_loop_new (NULL, TRUE);
ioc = g_io_channel_unix_new (0 /* stdin */);
g_io_channel_set_encoding (ioc, NULL, NULL);
g_io_channel_set_buffered (ioc, FALSE);
watch_id = g_io_add_watch (ioc,
G_IO_IN | G_IO_HUP | G_IO_ERR,
callback, buffer);
g_io_channel_unref (ioc);
}
while (!exit) {
char *ptr;
if (interactive) {
fprintf (stdout,"\n%s > ", cur_dir);
fflush (stdout);
strcpy (buffer, "");
g_main_loop_run (main_loop);
} else {
/* In non-interactive mode we just do this evil
* thingie */
buffer[0] = '\0';
fgets (buffer, 1023, stdin);
if (!buffer [0]) {
exit = 1;
continue;
}
}
if (!buffer || buffer [0] == '#')
continue;
arg_data = g_strsplit (g_strchomp (buffer), delim, -1);
arg_cur = 0;
if ((!arg_data || !arg_data[0]) && interactive) continue;
if (!interactive)
printf ("Command : '%s'\n", arg_data [0]);
ptr = arg_data[arg_cur++];
if (!ptr)
continue;
if (g_ascii_strcasecmp (ptr, "ls") == 0)
do_ls ();
else if (g_ascii_strcasecmp (ptr, "cd") == 0)
do_cd ();
else if (g_ascii_strcasecmp (ptr, "dump") == 0)
do_dump ();
else if (g_ascii_strcasecmp (ptr, "type") == 0 ||
g_ascii_strcasecmp (ptr, "cat") == 0)
do_cat ();
else if (g_ascii_strcasecmp (ptr, "cp") == 0)
do_cp ();
else if (g_ascii_strcasecmp (ptr, "rm") == 0)
do_rm ();
else if (g_ascii_strcasecmp (ptr, "mkdir") == 0)
do_mkdir ();
else if (g_ascii_strcasecmp (ptr, "rmdir") == 0)
do_rmdir ();
else if (g_ascii_strcasecmp (ptr, "mv") == 0)
do_mv ();
else if (g_ascii_strcasecmp (ptr, "info") == 0 ||
g_ascii_strcasecmp (ptr, "stat") == 0)
do_info ();
else if (g_ascii_strcasecmp (ptr, "findtrash") == 0)
do_findtrash ();
else if (g_ascii_strcasecmp (ptr, "ssl") == 0)
do_ssl ();
else if (g_ascii_strcasecmp (ptr, "sync") == 0)
fprintf (vfserr, "a shell is like a boat, it lists or syncs (RMS)\n");
else if (g_ascii_strcasecmp (ptr,"help") == 0 ||
g_ascii_strcasecmp (ptr,"?") == 0 ||
g_ascii_strcasecmp (ptr,"info") == 0 ||
g_ascii_strcasecmp (ptr,"man") == 0)
list_commands ();
else if (g_ascii_strcasecmp (ptr,"exit") == 0 ||
g_ascii_strcasecmp (ptr,"quit") == 0 ||
g_ascii_strcasecmp (ptr,"q") == 0 ||
g_ascii_strcasecmp (ptr,"bye") == 0)
exit = 1;
/* File ops */
else if (g_ascii_strcasecmp (ptr, "open") == 0)
do_open ();
else if (g_ascii_strcasecmp (ptr, "create") == 0)
do_create ();
else if (g_ascii_strcasecmp (ptr, "close") == 0)
do_close ();
else if (g_ascii_strcasecmp (ptr, "handleinfo") == 0)
do_handleinfo ();
else if (g_ascii_strcasecmp (ptr, "read") == 0)
do_read ();
else if (g_ascii_strcasecmp (ptr, "seek") == 0)
do_seek ();
else
fprintf (vfserr, "Unknown command '%s'", ptr);
g_strfreev (arg_data);
arg_data = NULL;
}
if (interactive) {
g_source_remove (watch_id);
g_main_loop_unref (main_loop);
main_loop = NULL;
}
g_free (buffer);
g_free (cur_dir);
close_files ();
return 0;
}
/*
* Parse command line arguments.
*
* Return 0 if OK, else -1
*/
static int parse_args(int argc, char **argv)
{
int opt, ret;
if (argc < 2) {
usage(stderr);
clean_exit(EXIT_FAILURE);
}
while ((opt = getopt_long(argc, argv, "+Vhnvqg:", long_options, NULL)) != -1) {
switch (opt) {
case 'V':
version(stdout);
ret = 0;
goto end;
case 'h':
usage(stdout);
ret = 0;
goto end;
case 'v':
lttng_opt_verbose += 1;
break;
case 'q':
lttng_opt_quiet = 1;
break;
case 'g':
lttng_set_tracing_group(optarg);
break;
case 'n':
opt_no_sessiond = 1;
break;
case OPT_SESSION_PATH:
opt_sessiond_path = strdup(optarg);
break;
case OPT_DUMP_OPTIONS:
list_options(stdout);
ret = 0;
goto end;
case OPT_DUMP_COMMANDS:
list_commands(commands, stdout);
ret = 0;
goto end;
default:
usage(stderr);
ret = 1;
goto error;
}
}
/* If both options are specified, quiet wins */
if (lttng_opt_verbose && lttng_opt_quiet) {
lttng_opt_verbose = 0;
}
/* Spawn session daemon if needed */
if (opt_no_sessiond == 0 && check_args_no_sessiond(argc, argv) == 0 &&
(check_sessiond() < 0)) {
ret = 1;
goto error;
}
/* No leftovers, print usage and quit */
if ((argc - optind) == 0) {
usage(stderr);
ret = 1;
goto error;
}
/*
* Handle leftovers which is a first level command with the trailing
* options.
*/
ret = handle_command(argc - optind, argv + optind);
switch (ret) {
case CMD_WARNING:
WARN("Some command(s) went wrong");
break;
case CMD_ERROR:
ERR("Command error");
break;
case CMD_UNDEFINED:
ERR("Undefined command");
break;
case CMD_FATAL:
ERR("Fatal error");
break;
case CMD_UNSUPPORTED:
ERR("Unsupported command");
break;
case -1:
usage(stderr);
ret = 1;
break;
case 0:
break;
default:
if (ret < 0) {
ret = -ret;
}
break;
}
end:
error:
return ret;
}
/*
* Parse command line arguments.
*
* Return 0 if OK, else -1
*/
static int parse_args(int argc, char **argv)
{
int opt, ret;
if (lttng_is_setuid_setgid()) {
ERR("'%s' is not allowed to be executed as a setuid/setgid binary for security reasons. Aborting.", argv[0]);
clean_exit(EXIT_FAILURE);
}
if (argc < 2) {
show_basic_help();
clean_exit(EXIT_FAILURE);
}
while ((opt = getopt_long(argc, argv, "+Vhnvqg:m:", long_options, NULL)) != -1) {
switch (opt) {
case 'V':
version(stdout);
ret = 0;
goto end;
case 'h':
ret = utils_show_man_page(1, "lttng");
if (ret) {
ERR("Cannot view man page lttng(1)");
perror("exec");
}
goto end;
case 'v':
/* There is only 3 possible level of verbosity. (-vvv) */
if (lttng_opt_verbose < 3) {
lttng_opt_verbose += 1;
}
break;
case 'q':
lttng_opt_quiet = 1;
break;
case 'm':
lttng_opt_mi = mi_output_type(optarg);
if (lttng_opt_mi < 0) {
ret = lttng_opt_mi;
goto error;
}
break;
case 'g':
lttng_set_tracing_group(optarg);
break;
case 'n':
opt_no_sessiond = 1;
break;
case OPT_SESSION_PATH:
free(opt_sessiond_path);
opt_sessiond_path = strdup(optarg);
if (!opt_sessiond_path) {
ret = -1;
goto error;
}
break;
case OPT_RELAYD_PATH:
free(opt_relayd_path);
opt_relayd_path = strdup(optarg);
if (!opt_relayd_path) {
ret = -1;
goto error;
}
break;
case OPT_DUMP_OPTIONS:
list_options(stdout);
ret = 0;
goto end;
case OPT_DUMP_COMMANDS:
list_commands(commands, stdout);
ret = 0;
goto end;
default:
ret = 1;
goto error;
}
}
/* If both options are specified, quiet wins */
if (lttng_opt_verbose && lttng_opt_quiet) {
lttng_opt_verbose = 0;
}
/* No leftovers, quit */
if ((argc - optind) == 0) {
ret = 1;
goto error;
}
/*
* Handle leftovers which is a first level command with the trailing
* options.
*/
ret = handle_command(argc - optind, argv + optind);
switch (ret) {
case CMD_WARNING:
WARN("Some command(s) went wrong");
break;
case CMD_ERROR:
ERR("Command error");
break;
case CMD_UNDEFINED:
ERR("Undefined command or invalid arguments");
break;
case CMD_FATAL:
ERR("Fatal error");
break;
case CMD_UNSUPPORTED:
ERR("Unsupported command");
break;
case -1:
ret = 1;
break;
case 0:
break;
default:
if (ret < 0) {
ret = -ret;
}
break;
}
end:
error:
return ret;
}
void command_display_help(int argc, char* argv[]) {
if (argc < 2) {
printf(" _____ _____ __ \n");
printf("| __\\ \\ / / _ \\ / _|___\n");
printf("| _| \\ V / (_) | _(_-<\n");
printf("|___| \\_/ \\___/|_| /__/\n");
printf("EVOfs toolbox version 0\n\n");
toolbox_spew();
list_commands();
printf("Commands with an asterisk after them are potentially destructive, and require\n");
printf("at minimum the parameter \"confirm\" to be passed to them to be used (a notice\n");
printf("about the confirm parameter will be printed if you run the command without it.\n\n");
return;
}
if (!strcmp(argv[1], "terse")) {
list_commands();
return;
}
if (!strcmp(argv[1], "help") || !strcmp(argv[1], "?")) {
printf("help - prints help for the toolbox and its commands.\n\n");
printf("Passing a command name to help (like you've just done) will display help for\n");
printf("that command. Alternately, passing \"terse\" to the help command will display\n");
printf("just a list of commands.\n\n");
return;
}
if (!strcmp(argv[1], "quit") || !strcmp(argv[1], "exit") || !strcmp(argv[1], "ex")) {
printf("quit - exits the toolbox.\n\n");
printf("The quit command has no options.\n\n");
return;
}
if (!strcmp(argv[1], "list") || !strcmp(argv[1], "l")) {
printf("list - displays a list of partitions on the disk.\n\n");
printf("The list command has no options.\n\n");
return;
}
if (!strcmp(argv[1], "select")) {
printf("select - Selects a partition to operate on.\n\n");
printf("The select command, without any parameters, deselects the current partition.\n");
printf("Passing the number of a valid (non-empty) partition as reported by the list\n");
printf("command will select that partition for operation. The select command will not\n");
printf("warn the user about any potential data on the partition being selected.\n\n");
return;
}
if (!strcmp(argv[1], "create")) {
printf("create - Creates an EVOfs filesystem on the selected partition.\n\n");
printf("This command is potentially the most destructive of the commands in the toolbox\n");
printf("and, as a result, requires either \"confirm\" or \"test\" parameters (but not both)\n");
printf("to be passed to it. \"confirm\" will go ahead with the creation and write to the\n");
printf("partition. \"test\" will execute a \"dry run\" of the creation, doing all the math\n");
printf("and memory allocations/frees but without actually modifying the data on the\n");
printf("partition. You can also pass \"verbose\" after either command to see the really\n");
printf("technical behind-the-scenes stuff going on.\n\n");
return;
}
printf("No help available for %s (experiment at your own risk).\n", argv[1]);
}
