int CLIB_ROUTINE main(int argc, char* argv[])
{
/**************************************
*
* m a i n
*
**************************************
*
* Functional description
* Invoke real gsec main function
*
**************************************/
#ifdef HAVE_LOCALE_H
// Pick up the system locale to allow SYSTEM<->UTF8 conversions
setlocale(LC_CTYPE, "");
#endif
int exitCode = 1;
try
{
Firebird::AutoPtr<Firebird::UtilSvc> uSvc(Firebird::UtilSvc::createStandalone(argc, argv));
exitCode = gsec(uSvc);
}
catch (const Firebird::Exception& ex)
{
Firebird::StaticStatusVector st;
ex.stuffException(st);
isc_print_status(st.begin());
}
fb_shutdown(0, fb_shutrsn_app_stopped);
return exitCode;
}
void iscLogException(const char* text, const Firebird::Exception& e)
{
/**************************************
*
* i s c L o g E x c e p t i o n
*
**************************************
*
* Functional description
* Add record about an exception to firebird.log
*
**************************************/
Firebird::StaticStatusVector s;
e.stuffException(s);
iscLogStatus(text, s.begin());
}
int CLIB_ROUTINE main(int argc, char* argv[])
{
/**************************************
*
* m a i n
*
**************************************
*
* Functional description
* Invoke real trace main function
*
**************************************/
#ifdef HAVE_LOCALE_H
// Pick up the system locale to allow SYSTEM<->UTF8 conversions
setlocale(LC_CTYPE, "");
#endif
#ifdef WIN_NT
int binout = fileno(stdout);
_setmode(binout, _O_BINARY);
#endif
atexit(&atexit_fb_shutdown);
AutoPtr<UtilSvc> uSvc(UtilSvc::createStandalone(argc, argv));
try
{
TraceSvcUtil traceUtil;
fbtrace(uSvc, &traceUtil);
}
catch (const Firebird::Exception& ex)
{
Firebird::StaticStatusVector temp;
ex.stuffException(temp);
isc_print_status(temp.begin());
return FINI_ERROR;
}
return FINI_OK;
}
//____________________________________________________________
//
// An error returned has been trapped. If the user specified
// a status vector, return a status code. Otherwise print the
// error code(s) and abort.
//
static ISC_STATUS error(const Firebird::Exception& ex)
{
Firebird::StaticStatusVector v;
ex.stuffException(v);
makePermanentVector(v.begin());
if (UDSQL_error->dsql_user_status)
{
fb_utils::copyStatus(UDSQL_error->dsql_user_status, ISC_STATUS_LENGTH, v.begin(), v.getCount());
return UDSQL_error->dsql_user_status[1];
}
fb_utils::copyStatus(UDSQL_error->dsql_status, ISC_STATUS_LENGTH, v.begin(), v.getCount());
gds__print_status(UDSQL_error->dsql_status);
exit(UDSQL_error->dsql_status[1]);
return 0; // suppress compiler warning
}
int main(int ac, char** av)
{
#ifdef HAVE_LOCALE_H
// Pick up the system locale to allow SYSTEM<->UTF8 conversions
setlocale(LC_CTYPE, "");
#endif
if (ac < 2 || (ac == 2 && strcmp(av[1], "-?") == 0))
{
usage(ac == 2);
return 1;
}
if (ac == 2 && (strcmp(av[1], "-z") == 0 || strcmp(av[1], "-Z") == 0))
{
printMessage(51, SafeArg() << FB_VERSION);
return 0;
}
os_utils::CtrlCHandler ctrlCHandler;
atexit(&atexit_fb_shutdown);
ISC_STATUS_ARRAY status;
try {
const int maxbuf = 16384;
av++;
const char* name = *av;
if (name)
{
av++;
}
ClumpletWriter spbAtt(ClumpletWriter::spbList, maxbuf);
while (populateSpbFromSwitches(av, spbAtt, attSwitch, 0))
;
ClumpletWriter spbStart(ClumpletWriter::SpbStart, maxbuf);
ClumpletWriter spbItems(ClumpletWriter::SpbReceiveItems, 256);
// single action per one utility run, it may populate info items also
populateSpbFromSwitches(av, spbStart, actionSwitch, &spbItems);
if (spbStart.getBufferLength() == 0)
{
while (populateSpbFromSwitches(av, spbItems, infSwitch, 0))
;
}
// Here we are over with av parse, look - may be unknown switch left
if (*av)
{
if (strcmp(av[0], "-z") == 0 || strcmp(av[0], "-Z") == 0)
{
printMessage(51, SafeArg() << FB_VERSION);
++av;
}
}
if (*av)
{
status_exception::raise(Arg::Gds(isc_fbsvcmgr_switch_unknown) << Arg::Str(*av));
}
isc_svc_handle svc_handle = 0;
if (isc_service_attach(status, 0, name, &svc_handle,
static_cast<USHORT>(spbAtt.getBufferLength()),
reinterpret_cast<const char*>(spbAtt.getBuffer())))
{
isc_print_status(status);
return 1;
}
if (spbStart.getBufferLength() > 0)
{
if (isc_service_start(status, &svc_handle, 0,
static_cast<USHORT>(spbStart.getBufferLength()),
reinterpret_cast<const char*>(spbStart.getBuffer())))
{
isc_print_status(status);
isc_service_detach(status, &svc_handle);
return 1;
}
}
if (spbItems.getBufferLength() > 0)
{
if (fb_utils::isRunningCheck(spbItems.getBuffer(), spbItems.getBufferLength()))
{
// running service may request stdin data
spbItems.insertTag(isc_info_svc_stdin);
}
// use one second timeout to poll service
char send[16];
char* p = send;
*p++ = isc_info_svc_timeout;
ADD_SPB_LENGTH(p, 4);
ADD_SPB_NUMERIC(p, 1);
*p++ = isc_info_end;
char results[maxbuf];
UserPrint uPrint;
ULONG stdinRequest = 0;
Array<char> stdinBuffer;
do
{
char* sendBlock = send;
USHORT sendSize = p - send;
if (stdinRequest)
{
--sendSize;
FB_SIZE_T len = sendSize;
len += (1 + 2 + stdinRequest);
if (len > MAX_USHORT - 1)
{
len = MAX_USHORT - 1;
stdinRequest = len - (1 + 2) - sendSize;
}
sendBlock = stdinBuffer.getBuffer(len + 1);
memcpy(sendBlock, send, sendSize);
static int binIn = -1;
if (binIn == -1)
{
#ifdef WIN_NT
binIn = fileno(stdin);
_setmode(binIn, _O_BINARY);
#else
binIn = 0;
#endif
}
int n = read(binIn, &sendBlock[sendSize + 1 + 2], stdinRequest);
if (n < 0)
{
perror("stdin");
break;
}
stdinRequest = n;
sendBlock[sendSize] = isc_info_svc_line;
sendBlock[sendSize + 1] = stdinRequest;
sendBlock[sendSize + 2] = stdinRequest >> 8;
sendBlock[sendSize + 1 + 2 + stdinRequest] = isc_info_end;
sendSize += (1 + 2 + stdinRequest + 1);
stdinRequest = 0;
}
if (isc_service_query(status, &svc_handle, 0, sendSize, sendBlock,
static_cast<USHORT>(spbItems.getBufferLength()),
reinterpret_cast<const char*>(spbItems.getBuffer()),
sizeof(results), results))
{
if (!ctrlCHandler.getTerminated())
isc_print_status(status);
isc_service_detach(status, &svc_handle);
return 1;
}
} while (printInfo(results, sizeof(results), uPrint, stdinRequest) && !ctrlCHandler.getTerminated());
}
if (isc_service_detach(status, &svc_handle))
{
if (!ctrlCHandler.getTerminated())
isc_print_status(status);
return 1;
}
return 0;
}
catch (const Exception& e)
{
Firebird::StaticStatusVector st;
e.stuffException(st);
isc_print_status(st.begin());
}
return 2;
}
int CLIB_ROUTINE main( int argc, char** argv)
{
/**************************************
*
* m a i n
*
**************************************
*
* Functional description
* Run the server with apollo mailboxes.
*
**************************************/
try
{
RemPortPtr port;
// We should support 3 modes:
// 1. Standalone single-process listener (like SS).
// 2. Standalone listener, forking on each packet accepted (look -s switch in CS).
// 3. Process spawned by (x)inetd (like CS).
bool classic = false;
bool standaloneClassic = false;
bool super = false;
// It's very easy to detect that we are spawned - just check fd 0 to be a socket.
const int channel = 0;
struct stat stat0;
if (fstat(channel, &stat0) == 0 && S_ISSOCK(stat0.st_mode))
{
// classic server mode
classic = true;
}
const TEXT* const* const end = argc + argv;
argv++;
bool debug = false;
USHORT INET_SERVER_flag = 0;
protocol[0] = 0;
bool done = false;
while (argv < end)
{
TEXT c;
const TEXT* p = *argv++;
if (*p++ == '-')
{
while (c = *p++)
{
switch (UPPER(c))
{
case 'D':
debug = true;
break;
case 'E':
if (argv < end)
{
if (ISC_set_prefix(p, *argv) == -1)
printf("Invalid argument Ignored\n");
else
argv++; // do not skip next argument if this one is invalid
}
else
{
printf("Missing argument, switch -E ignored\n");
}
done = true;
break;
case 'P':
if (argv < end)
{
if (!classic)
{
fb_utils::snprintf(protocol, sizeof(protocol), "/%s", *argv++);
}
else
{
gds__log("Switch -P ignored in CS mode\n");
}
}
else
{
printf("Missing argument, switch -P ignored\n");
}
break;
case 'H':
case '?':
printf("Firebird TCP/IP server options are:\n");
printf(" -d : debug on\n");
printf(" -p <port> : specify port to listen on\n");
printf(" -z : print version and exit\n");
printf(" -h|? : print this help\n");
printf("\n");
printf(" (The following -e options used to be -h options)\n");
printf(" -e <firebird_root_dir> : set firebird_root path\n");
printf(" -el <firebird_lock_dir> : set runtime firebird_lock dir\n");
printf(" -em <firebird_msg_dir> : set firebird_msg dir path\n");
exit(FINI_OK);
case 'Z':
printf("Firebird TCP/IP server version %s\n", FB_VERSION);
exit(FINI_OK);
default:
printf("Unknown switch '%c', ignored\n", c);
break;
}
if (done)
break;
}
}
}
if (Config::getServerMode() == MODE_CLASSIC)
{
if (!classic)
standaloneClassic = true;
}
else
{
if (classic)
{
gds__log("Server misconfigured - to start it from (x)inetd add ServerMode=Classic to firebird.conf");
Firebird::Syslog::Record(Firebird::Syslog::Error, "Server misconfigured - add ServerMode=Classic to firebird.conf");
exit(STARTUP_ERROR);
}
INET_SERVER_flag |= SRVR_multi_client;
super = true;
}
{ // scope
Firebird::MasterInterfacePtr master;
master->serverMode(super ? 1 : 0);
}
if (debug)
{
INET_SERVER_flag |= SRVR_debug;
}
// activate paths set with -e family of switches
ISC_set_prefix(0, 0);
// ignore some signals
set_signal(SIGPIPE, signal_handler);
set_signal(SIGUSR1, signal_handler);
set_signal(SIGUSR2, signal_handler);
// First of all change directory to tmp
if (chdir(TEMP_DIR))
{
// error on changing the directory
gds__log("Could not change directory to %s due to errno %d", TEMP_DIR, errno);
}
#ifdef FB_RAISE_LIMITS
#ifdef RLIMIT_NPROC
raiseLimit(RLIMIT_NPROC);
#endif
#if !(defined(DEV_BUILD))
if (Config::getBugcheckAbort())
#endif
{
// try to force core files creation
raiseLimit(RLIMIT_CORE);
}
#if (defined SOLARIS || defined HPUX || defined LINUX)
if (super)
{
// Increase max open files to hard limit for Unix
// platforms which are known to have low soft limits.
raiseLimit(RLIMIT_NOFILE);
}
#endif // Unix platforms
#endif // FB_RAISE_LIMITS
#ifdef HAVE_LOCALE_H
// Pick up the system locale to allow SYSTEM<->UTF8 conversions inside the engine
setlocale(LC_CTYPE, "");
#endif
if (!(debug || classic))
{
int mask = 0; // FD_ZERO(&mask);
mask |= 1 << 2; // FD_SET(2, &mask);
divorce_terminal(mask);
}
// check firebird.conf presence - must be for server
if (Config::missFirebirdConf())
{
Firebird::Syslog::Record(Firebird::Syslog::Error, "Missing master config file firebird.conf");
exit(STARTUP_ERROR);
}
if (super || standaloneClassic)
{
try
{
port = INET_connect(protocol, 0, INET_SERVER_flag, 0, NULL);
}
catch (const Firebird::Exception& ex)
{
iscLogException("startup:INET_connect:", ex);
Firebird::StaticStatusVector st;
ex.stuffException(st);
gds__print_status(st.begin());
exit(STARTUP_ERROR);
}
}
if (classic)
{
port = INET_server(channel);
if (!port)
{
gds__log("Unable to start INET_server");
Firebird::Syslog::Record(Firebird::Syslog::Error, "Unable to start INET_server");
exit(STARTUP_ERROR);
}
}
{ // scope for interface ptr
Firebird::PluginManagerInterfacePtr pi;
Auth::registerSrpServer(pi);
}
if (super)
{
// Server tries to attach to security2.fdb to make sure everything is OK
// This code fixes bug# 8429 + all other bug of that kind - from
// now on the server exits if it cannot attach to the database
// (wrong or no license, not enough memory, etc.
ISC_STATUS_ARRAY status;
isc_db_handle db_handle = 0L;
const Firebird::RefPtr<Config> defConf(Config::getDefaultConfig());
const char* path = defConf->getSecurityDatabase();
const char dpb[] = {isc_dpb_version1, isc_dpb_sec_attach, 1, 1, isc_dpb_address_path, 0};
isc_attach_database(status, strlen(path), path, &db_handle, sizeof dpb, dpb);
if (status[0] == 1 && status[1] > 0)
{
logSecurityDatabaseError(path, status);
}
isc_detach_database(status, &db_handle);
if (status[0] == 1 && status[1] > 0)
{
logSecurityDatabaseError(path, status);
}
} // end scope
fb_shutdown_callback(NULL, closePort, fb_shut_exit, port);
SRVR_multi_thread(port, INET_SERVER_flag);
#ifdef DEBUG_GDS_ALLOC
// In Debug mode - this will report all server-side memory leaks due to remote access
Firebird::PathName name = fb_utils::getPrefix(
Firebird::IConfigManager::DIR_LOG, "memdebug.log");
FILE* file = os_utils::fopen(name.c_str(), "w+t");
if (file)
{
fprintf(file, "Global memory pool allocated objects\n");
getDefaultMemoryPool()->print_contents(file);
fclose(file);
}
#endif
// perform atexit shutdown here when all globals in embedded library are active
// also sync with possibly already running shutdown in dedicated thread
fb_shutdown(10000, fb_shutrsn_exit_called);
return FINI_OK;
}
catch (const Firebird::Exception& ex)
{
Firebird::StaticStatusVector st;
ex.stuffException(st);
char s[100];
const ISC_STATUS* status = st.begin();
fb_interpret(s, sizeof(s), &status);
iscLogException("Firebird startup error:", ex);
Firebird::Syslog::Record(Firebird::Syslog::Error, "Firebird startup error");
Firebird::Syslog::Record(Firebird::Syslog::Error, s);
exit(STARTUP_ERROR);
}
}
void iscLogStatus(const TEXT* text, const Firebird::IStatus* status)
{
Firebird::StaticStatusVector tmp;
tmp.mergeStatus(status);
iscLogStatus(text, tmp.begin());
}