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; }
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); }