static int get_function_option(const SCHAR* prog_name,
gsplit_option* sw_replace,
const SCHAR* string,
const Switches& switches)
{
/********************************************************************
**
** g e t _ f u n c t i o n _ o p t i o n
**
*********************************************************************
**
** Functional description:
**
** processing command line option and set proper function switch
**
*********************************************************************
*/
if (strlen(string) == 1)
{
fprintf(stderr, "%s: invalid option '%s'\n", prog_name, string);
print_clo(prog_name);
return FB_FAILURE;
}
//gsplit_option op_specified = *sw_replace; Commented, where is it used here???
const Switches::in_sw_tab_t* op = switches.findSwitch(string);
if (!op)
{
fprintf(stderr, "%s: invalid option '%s'\n", prog_name, string);
print_clo(prog_name);
return FB_FAILURE;
}
if (*sw_replace == IN_SW_SPIT_0)
{
*sw_replace = (gsplit_option) op->in_sw;
return FB_SUCCESS;
}
if (*sw_replace != op->in_sw)
{
fprintf(stderr, "%s: invalid option '%s', incompatible option\n", prog_name, string);
print_clo(prog_name);
return FB_FAILURE;
}
return FB_SUCCESS;
}
static void usage(const Switches& switches)
{
/**************************************
*
* u s a g e
*
**************************************
*
* Functional description
* Print help about command-line arguments.
*
**************************************/
ERRQ_msg_put(513);
ERRQ_msg_put(514);
ERRQ_msg_put(515);
for (const Switches::in_sw_tab_t* p = switches.getTable(); p->in_sw; ++p)
{
if (p->in_sw_msg)
ERRQ_msg_put(p->in_sw_msg);
}
ERRQ_msg_put(527);
ERRQ_msg_put(528);
}
void fbtrace(UtilSvc* uSvc, TraceSvcIntf* traceSvc)
{
const char* const* end = uSvc->argv.end();
bool version = false, help = false;
// search for "action" switch, set NULL into recognized argv
const Switches actSwitches(trace_action_in_sw_table, FB_NELEM(trace_action_in_sw_table),
false, true);
const Switches::in_sw_tab_t* action_sw = NULL;
const char** argv = uSvc->argv.begin();
for (++argv; argv < end; argv++)
{
if (!uSvc->isService() && strcmp(argv[0], "-?") == 0)
{
help = true;
*argv = NULL;
break;
}
const Switches::in_sw_tab_t* sw = actSwitches.findSwitch(*argv);
if (sw)
{
if (sw->in_sw == IN_SW_TRACE_VERSION)
{
version = true;
*argv = NULL;
continue;
}
if (action_sw)
usage(uSvc, isc_trace_conflict_acts, action_sw->in_sw_name, sw->in_sw_name);
else
action_sw = sw;
*argv = NULL;
}
}
if (version)
{
printMsg(1, SafeArg() << FB_VERSION);
if (!action_sw)
exit(FINI_OK);
}
if (!action_sw)
{
if (help)
usage(uSvc, 0);
else
usage(uSvc, isc_trace_act_notfound);
}
// search for action's parameters, set NULL into recognized argv
const Switches optSwitches(trace_option_in_sw_table, FB_NELEM(trace_option_in_sw_table),
false, true);
TraceSession session(*getDefaultMemoryPool());
argv = uSvc->argv.begin();
for (++argv; argv < end; argv++)
{
if (!*argv)
continue;
const Switches::in_sw_tab_t* sw = optSwitches.findSwitch(*argv);
if (!sw)
continue;
*argv = NULL;
switch (sw->in_sw)
{
case IN_SW_TRACE_CONFIG:
switch (action_sw->in_sw)
{
case IN_SW_TRACE_STOP:
case IN_SW_TRACE_SUSPEND:
case IN_SW_TRACE_RESUME:
case IN_SW_TRACE_LIST:
usage(uSvc, isc_trace_param_act_notcompat, sw->in_sw_name, action_sw->in_sw_name);
break;
}
if (!session.ses_config.empty())
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
session.ses_config = *argv;
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
case IN_SW_TRACE_NAME:
switch (action_sw->in_sw)
{
case IN_SW_TRACE_STOP:
case IN_SW_TRACE_SUSPEND:
case IN_SW_TRACE_RESUME:
case IN_SW_TRACE_LIST:
usage(uSvc, isc_trace_param_act_notcompat, sw->in_sw_name, action_sw->in_sw_name);
break;
}
if (!session.ses_name.empty())
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
session.ses_name = *argv;
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
case IN_SW_TRACE_ID:
switch (action_sw->in_sw)
{
case IN_SW_TRACE_START:
case IN_SW_TRACE_LIST:
usage(uSvc, isc_trace_param_act_notcompat, sw->in_sw_name, action_sw->in_sw_name);
break;
}
if (session.ses_id)
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
{
session.ses_id = atol(*argv);
if (!session.ses_id)
usage(uSvc, isc_trace_param_invalid, *argv, sw->in_sw_name);
}
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
default:
fb_assert(false);
}
*argv = NULL;
}
// search for authentication parameters
const Switches authSwitches(trace_auth_in_sw_table, FB_NELEM(trace_auth_in_sw_table),
false, true);
string svc_name, user, pwd;
bool adminRole = false;
argv = uSvc->argv.begin();
for (++argv; argv < end; argv++)
{
if (!*argv)
continue;
const Switches::in_sw_tab_t* sw = authSwitches.findSwitch(*argv);
if (!sw) {
usage(uSvc, isc_trace_switch_unknown, *argv);
}
switch (sw->in_sw)
{
case IN_SW_TRACE_USERNAME:
if (!user.empty())
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
user = *argv;
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
case IN_SW_TRACE_PASSWORD:
if (!pwd.empty())
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
pwd = *argv;
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
case IN_SW_TRACE_FETCH_PWD:
if (uSvc->isService())
usage(uSvc, isc_trace_switch_user_only, sw->in_sw_name);
if (!pwd.empty())
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
{
const PathName fileName(*argv);
const char *s = NULL;
switch (fb_utils::fetchPassword(fileName, s))
{
case fb_utils::FETCH_PASS_OK:
pwd = s;
break;
case fb_utils::FETCH_PASS_FILE_OPEN_ERROR:
(Arg::Gds(isc_io_error) << Arg::Str("open") << Arg::Str(fileName) <<
Arg::Gds(isc_io_open_err) << Arg::OsError()).raise();
break;
case fb_utils::FETCH_PASS_FILE_READ_ERROR:
case fb_utils::FETCH_PASS_FILE_EMPTY:
(Arg::Gds(isc_io_error) << Arg::Str("read") << Arg::Str(fileName) <<
Arg::Gds(isc_io_read_err) << Arg::OsError()).raise();
break;
}
}
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
case IN_SW_TRACE_TRUSTED_AUTH:
if (uSvc->isService())
usage(uSvc, isc_trace_switch_user_only, sw->in_sw_name);
adminRole = true;
break;
case IN_SW_TRACE_SERVICE_NAME:
if (uSvc->isService())
continue;
if (!svc_name.empty())
usage(uSvc, isc_trace_switch_once, sw->in_sw_name);
argv++;
if (argv < end && *argv)
svc_name = *argv;
else
usage(uSvc, isc_trace_param_val_miss, sw->in_sw_name);
break;
default:
fb_assert(false);
}
}
// validate missed action's parameters and perform action
if (!uSvc->isService() && svc_name.isEmpty()) {
usage(uSvc, isc_trace_mandatory_switch_miss, "SERVICE");
}
if (!session.ses_id)
{
switch (action_sw->in_sw)
{
case IN_SW_TRACE_STOP:
case IN_SW_TRACE_SUSPEND:
case IN_SW_TRACE_RESUME:
usage(uSvc, isc_trace_switch_param_miss, "ID", action_sw->in_sw_name);
break;
}
}
if (session.ses_config.empty())
{
if (action_sw->in_sw == IN_SW_TRACE_START) {
usage(uSvc, isc_trace_switch_param_miss, "CONFIG", action_sw->in_sw_name);
}
}
AuthReader::AuthBlock authBlock;
const unsigned char* bytes;
unsigned int authBlockSize = uSvc->getAuthBlock(&bytes);
if (authBlockSize)
{
authBlock.add(bytes, authBlockSize);
pwd = "";
user = "";
adminRole = false;
}
traceSvc->setAttachInfo(svc_name, user, pwd, authBlock, adminRole);
switch (action_sw->in_sw)
{
case IN_SW_TRACE_START:
traceSvc->startSession(session, true);
break;
case IN_SW_TRACE_STOP:
traceSvc->stopSession(session.ses_id);
break;
case IN_SW_TRACE_SUSPEND:
traceSvc->setActive(session.ses_id, false);
break;
case IN_SW_TRACE_RESUME:
traceSvc->setActive(session.ses_id, true);
break;
case IN_SW_TRACE_LIST:
traceSvc->listSessions();
break;
default:
fb_assert(false);
}
}
int CLIB_ROUTINE main(int argc, char** argv)
{
/**************************************
*
* m a i n
*
**************************************
*
* Functional description
* Top level routine.
*
**************************************/
// Look at options, if any
Firebird::PathName startup_file = STARTUP_FILE;
#ifdef UNIX
// If a Unix system, get home directory from environment
SCHAR home_directory[MAXPATHLEN];
if (!fb_utils::readenv("HOME", startup_file))
startup_file = ".qli_startup";
else
startup_file.append("/.qli_startup");
#endif
#ifdef HAVE_LOCALE_H
// Pick up the system locale to allow SYSTEM<->UTF8 conversions
setlocale(LC_CTYPE, "");
#endif
atexit(&atexit_fb_shutdown);
const TEXT* application_file = NULL;
ALLQ_init();
LEX_init();
bool version_flag = false;
bool banner_flag = true;
sw_buffers = 0;
strcpy(QLI_prompt_string, "QLI> ");
strcpy(QLI_cont_string, "CON> ");
// Let's define the default number of columns on a machine by machine basis
QLI_columns = 80;
#ifdef TRUSTED_AUTH
QLI_trusted = false;
#endif
QLI_nodb_triggers = false;
QLI_lines = 60;
QLI_name_columns = 0;
QLI_prompt = QLI_prompt_string;
QLI_matching_language = 0;
QLI_default_user[0] = 0;
QLI_default_password[0] = 0;
QLI_charset[0] = 0;
QLI_quit_flag = false;
bool help_flag = false;
#ifdef DEV_BUILD
QLI_hex_output = false;
#endif
SLONG debug_value; // aparently unneeded, see usage below.
const Switches switches(qli_in_sw_table, FB_NELEM(qli_in_sw_table), false, true);
const TEXT* const* const arg_end = argv + argc;
argv++;
while (argv < arg_end)
{
const TEXT* const p = *argv++;
if (*p != '-')
{
banner_flag = false;
LEX_pop_line();
LEX_push_string(p);
continue;
}
if (!p[1])
continue;
const Switches::in_sw_tab_t* option = switches.findSwitch(p);
const int in_sw = option ? option->in_sw : IN_SW_QLI_0;
switch (in_sw)
{
case IN_SW_QLI_APP_SCRIPT:
if (argv >= arg_end)
{
ERRQ_msg_put(23); // Msg23 Please retry, supplying an application script file name
exit(FINI_ERROR);
}
application_file = *argv++;
break;
case IN_SW_QLI_BUFFERS:
if (argv < arg_end && **argv != '-')
sw_buffers = atoi(*argv++);
break;
case IN_SW_QLI_EXIT:
QLI_quit_flag = true;
break;
case IN_SW_QLI_FETCH_PASSWORD:
{
if (argv >= arg_end || **argv == '-')
break;
const char* pwd = NULL;
if (fb_utils::fetchPassword(*argv++, pwd) != fb_utils::FETCH_PASS_OK)
break;
fb_utils::copy_terminate(QLI_default_password, pwd, sizeof(QLI_default_password));
}
break;
case IN_SW_QLI_INITIAL_SCRIPT:
if (argv >= arg_end || **argv == '-')
startup_file = "";
else
startup_file = *argv++;
break;
#ifdef TRUSTED_AUTH
case IN_SW_QLI_TRUSTED_AUTH:
QLI_trusted = true;
break;
#endif
case IN_SW_QLI_NOBANNER:
banner_flag = false;
break;
case IN_SW_QLI_NODBTRIGGERS:
QLI_nodb_triggers = true;
break;
case IN_SW_QLI_PASSWORD:
if (argv >= arg_end || **argv == '-')
break;
fb_utils::copy_terminate(QLI_default_password, fb_utils::get_passwd(*argv++),
sizeof(QLI_default_password));
break;
case IN_SW_QLI_TRACE:
sw_trace = true;
break;
case IN_SW_QLI_USER:
if (argv >= arg_end || **argv == '-')
break;
fb_utils::copy_terminate(QLI_default_user, *argv++, sizeof(QLI_default_user));
break;
case IN_SW_QLI_VERIFY:
sw_verify = true;
break;
case IN_SW_QLI_X:
debug_value = 1;
isc_set_debug(debug_value);
break;
// This switch's name is arbitrary; since it is an internal
// mechanism it can be changed at will
case IN_SW_QLI_Y:
QLI_trace = true;
break;
case IN_SW_QLI_Z:
version_flag = true;
break;
case IN_SW_QLI_HELP:
help_flag = true;
break;
default:
ERRQ_msg_put(529, SafeArg() << p);
// Msg469 qli: ignoring unknown switch %c
break;
}
}
enable_signals();
if (help_flag)
{
usage(switches);
HELP_fini();
MET_shutdown();
LEX_fini();
ALLQ_fini();
return FINI_OK;
}
if (banner_flag)
ERRQ_msg_put(24); // Msg24 Welcome to QLI Query Language Interpreter
if (version_flag)
ERRQ_msg_put(25, SafeArg() << FB_VERSION); // Msg25 qli version %s
if (application_file)
LEX_push_file(application_file, true);
else
QLI_quit_flag = false; // Silently ignore -E switch when no script is given
if (startup_file.length())
LEX_push_file(startup_file.c_str(), false);
#if defined(_MSC_VER) && _MSC_VER >= 1400
_set_output_format(_TWO_DIGIT_EXPONENT);
#endif
for (bool got_started = false; !got_started;)
{
got_started = true;
try {
PAR_token();
}
catch (const Firebird::Exception&)
{
// try again
got_started = false;
ERRQ_pending();
}
}
QLI_error = NULL;
// Loop until end of file or forced exit
bool flush_flag = false;
while (QLI_line)
{
qli_plb* temp = QLI_default_pool = ALLQ_pool();
flush_flag = process_statement(flush_flag);
ERRQ_pending();
ALLQ_rlpool(temp);
}
HELP_fini();
MET_shutdown();
LEX_fini();
ALLQ_fini();
#ifdef DEBUG_GDS_ALLOC
// Report any memory leaks noticed.
// We don't particularly care about QLI specific memory leaks, so all
// QLI allocations have been marked as "don't report". However, much
// of the test-base uses QLI so having a report when QLI finishes
// could find leaks within the engine.
gds_alloc_report(0 ALLOC_ARGS);
#endif
return (FINI_OK);
}
TEST(DISABLED_Switches,State) {
digitalReadMockInit();
digitalReadMock(2, 1);
ASSERT_TRUE(switches.States());
}
