int
fileSetQidSpace(File *f, u64int offset, u64int max)
{
int ret;
if(!fileLock(f))
return 0;
fileMetaLock(f);
f->dir.qidSpace = 1;
f->dir.qidOffset = offset;
f->dir.qidMax = max;
ret = fileMetaFlush2(f, nil)>=0;
fileMetaUnlock(f);
fileUnlock(f);
return ret;
}
DirEntryEnum *
deeOpen(File *f)
{
DirEntryEnum *dee;
File *p;
if(!fileIsDir(f)){
vtSetError(ENotDir);
fileDecRef(f);
return nil;
}
/* flush out meta data */
if(!fileLock(f))
return nil;
for(p=f->down; p; p=p->next)
fileMetaFlush2(p, nil);
fileUnlock(f);
dee = vtMemAllocZ(sizeof(DirEntryEnum));
dee->file = fileIncRef(f);
return dee;
}
int
fileSetSize(File *f, uvlong size)
{
int r;
if(!fileLock(f))
return 0;
r = 0;
if(f->dir.mode & ModeDir){
vtSetError(ENotFile);
goto Err;
}
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err;
}
if(!sourceLock(f->source, -1))
goto Err;
r = sourceSetSize(f->source, size);
sourceUnlock(f->source);
Err:
fileUnlock(f);
return r;
}
int
fileSetDir(File *f, DirEntry *dir, char *uid)
{
File *ff;
char *oelem;
u32int mask;
u64int size;
/* can not set permissions for the root */
if(fileIsRoot(f)){
vtSetError(ERoot);
return 0;
}
if(!fileLock(f))
return 0;
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
fileUnlock(f);
return 0;
}
fileMetaLock(f);
/* check new name does not already exist */
if(strcmp(f->dir.elem, dir->elem) != 0){
for(ff = f->up->down; ff; ff=ff->next){
if(strcmp(dir->elem, ff->dir.elem) == 0 && !ff->removed){
vtSetError(EExists);
goto Err;
}
}
ff = dirLookup(f->up, dir->elem);
if(ff != nil){
fileDecRef(ff);
vtSetError(EExists);
goto Err;
}
}
if(!sourceLock2(f->source, f->msource, -1))
goto Err;
if(!fileIsDir(f)){
size = sourceGetSize(f->source);
if(size != dir->size){
if(!sourceSetSize(f->source, dir->size)){
sourceUnlock(f->source);
if(f->msource)
sourceUnlock(f->msource);
goto Err;
}
/* commited to changing it now */
}
}
/* commited to changing it now */
if((f->dir.mode&ModeTemporary) != (dir->mode&ModeTemporary))
fileSetTmp(f, dir->mode&ModeTemporary);
sourceUnlock(f->source);
if(f->msource)
sourceUnlock(f->msource);
oelem = nil;
if(strcmp(f->dir.elem, dir->elem) != 0){
oelem = f->dir.elem;
f->dir.elem = vtStrDup(dir->elem);
}
if(strcmp(f->dir.uid, dir->uid) != 0){
vtMemFree(f->dir.uid);
f->dir.uid = vtStrDup(dir->uid);
}
if(strcmp(f->dir.gid, dir->gid) != 0){
vtMemFree(f->dir.gid);
f->dir.gid = vtStrDup(dir->gid);
}
f->dir.mtime = dir->mtime;
f->dir.atime = dir->atime;
//fprint(2, "mode %x %x ", f->dir.mode, dir->mode);
mask = ~(ModeDir|ModeSnapshot);
f->dir.mode &= ~mask;
f->dir.mode |= mask & dir->mode;
f->dirty = 1;
//fprint(2, "->%x\n", f->dir.mode);
fileMetaFlush2(f, oelem);
vtMemFree(oelem);
fileMetaUnlock(f);
fileUnlock(f);
fileWAccess(f->up, uid);
return 1;
Err:
fileMetaUnlock(f);
fileUnlock(f);
return 0;
}
int
fileWrite(File *f, void *buf, int cnt, vlong offset, char *uid)
{
Source *s;
ulong bn;
int off, dsize, n;
Block *b;
uchar *p;
vlong eof;
if(0)fprint(2, "fileWrite: %s %d, %lld\n", f->dir.elem, cnt, offset);
if(!fileLock(f))
return -1;
s = nil;
if(f->dir.mode & ModeDir){
vtSetError(ENotFile);
goto Err;
}
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err;
}
if(offset < 0){
vtSetError(EBadOffset);
goto Err;
}
fileWAccess(f, uid);
if(!sourceLock(f->source, -1))
goto Err;
s = f->source;
dsize = s->dsize;
eof = sourceGetSize(s);
if(f->dir.mode & ModeAppend)
offset = eof;
bn = offset/dsize;
off = offset%dsize;
p = buf;
while(cnt > 0){
n = cnt;
if(n > dsize-off)
n = dsize-off;
b = sourceBlock(s, bn, n<dsize?OReadWrite:OOverWrite);
if(b == nil){
if(offset > eof)
sourceSetSize(s, offset);
goto Err;
}
memmove(b->data+off, p, n);
off = 0;
cnt -= n;
p += n;
offset += n;
bn++;
blockDirty(b);
blockPut(b);
}
if(offset > eof && !sourceSetSize(s, offset))
goto Err;
sourceUnlock(s);
fileUnlock(f);
return p-(uchar*)buf;
Err:
if(s)
sourceUnlock(s);
fileUnlock(f);
return -1;
}
File *
fileCreate(File *f, char *elem, ulong mode, char *uid)
{
File *ff;
DirEntry *dir;
Source *pr, *r, *mr;
int isdir;
if(!fileLock(f))
return nil;
r = nil;
mr = nil;
for(ff = f->down; ff; ff=ff->next){
if(strcmp(elem, ff->dir.elem) == 0 && !ff->removed){
ff = nil;
vtSetError(EExists);
goto Err1;
}
}
ff = dirLookup(f, elem);
if(ff != nil){
vtSetError(EExists);
goto Err1;
}
pr = f->source;
if(pr->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err1;
}
if(!sourceLock2(f->source, f->msource, -1))
goto Err1;
ff = fileAlloc(f->fs);
isdir = mode & ModeDir;
r = sourceCreate(pr, pr->dsize, isdir, 0);
if(r == nil)
goto Err;
if(isdir){
mr = sourceCreate(pr, pr->dsize, 0, r->offset);
if(mr == nil)
goto Err;
}
dir = &ff->dir;
dir->elem = vtStrDup(elem);
dir->entry = r->offset;
dir->gen = r->gen;
if(isdir){
dir->mentry = mr->offset;
dir->mgen = mr->gen;
}
dir->size = 0;
if(!fsNextQid(f->fs, &dir->qid))
goto Err;
dir->uid = vtStrDup(uid);
dir->gid = vtStrDup(f->dir.gid);
dir->mid = vtStrDup(uid);
dir->mtime = time(0L);
dir->mcount = 0;
dir->ctime = dir->mtime;
dir->atime = dir->mtime;
dir->mode = mode;
ff->boff = fileMetaAlloc(f, dir, 0);
if(ff->boff == NilBlock)
goto Err;
sourceUnlock(f->source);
sourceUnlock(f->msource);
ff->source = r;
r->file = ff; /* point back */
ff->msource = mr;
if(mode&ModeTemporary){
if(!sourceLock2(r, mr, -1))
goto Err1;
fileSetTmp(ff, 1);
sourceUnlock(r);
if(mr)
sourceUnlock(mr);
}
/* committed */
/* link in and up parent ref count */
ff->next = f->down;
f->down = ff;
ff->up = f;
fileIncRef(f);
fileWAccess(f, uid);
fileUnlock(f);
return ff;
Err:
sourceUnlock(f->source);
sourceUnlock(f->msource);
Err1:
if(r){
sourceLock(r, -1);
sourceRemove(r);
}
if(mr){
sourceLock(mr, -1);
sourceRemove(mr);
}
if(ff)
fileDecRef(ff);
fileUnlock(f);
return 0;
}
File *
_fileWalk(File *f, char *elem, int partial)
{
File *ff;
fileRAccess(f);
if(elem[0] == 0){
vtSetError(EBadPath);
return nil;
}
if(!fileIsDir(f)){
vtSetError(ENotDir);
return nil;
}
if(strcmp(elem, ".") == 0){
return fileIncRef(f);
}
if(strcmp(elem, "..") == 0){
if(fileIsRoot(f))
return fileIncRef(f);
return fileIncRef(f->up);
}
if(!fileLock(f))
return nil;
for(ff = f->down; ff; ff=ff->next){
if(strcmp(elem, ff->dir.elem) == 0 && !ff->removed){
ff->ref++;
goto Exit;
}
}
ff = dirLookup(f, elem);
if(ff == nil)
goto Err;
if(ff->dir.mode & ModeSnapshot){
ff->mode = OReadOnly;
ff->issnapshot = 1;
}
if(partial){
/*
* Do nothing. We're opening this file only so we can clri it.
* Usually the sources can't be opened, hence we won't even bother.
* Be VERY careful with the returned file. If you hand it to a routine
* expecting ff->source and/or ff->msource to be non-nil, we're
* likely to dereference nil. FileClri should be the only routine
* setting partial.
*/
ff->partial = 1;
}else if(ff->dir.mode & ModeDir){
ff->source = fileOpenSource(f, ff->dir.entry, ff->dir.gen,
1, ff->mode, ff->issnapshot);
ff->msource = fileOpenSource(f, ff->dir.mentry, ff->dir.mgen,
0, ff->mode, ff->issnapshot);
if(ff->source == nil || ff->msource == nil)
goto Err;
}else{
ff->source = fileOpenSource(f, ff->dir.entry, ff->dir.gen,
0, ff->mode, ff->issnapshot);
if(ff->source == nil)
goto Err;
}
/* link in and up parent ref count */
if (ff->source)
ff->source->file = ff; /* point back */
ff->next = f->down;
f->down = ff;
ff->up = f;
fileIncRef(f);
Exit:
fileUnlock(f);
return ff;
Err:
fileUnlock(f);
if(ff != nil)
fileDecRef(ff);
return nil;
}
int CIMServerProcess::cimserver_run(
int argc,
char** argv,
Boolean shutdownOption,
Boolean debugOutputOption)
{
Boolean daemonOption = false;
#if defined (PEGASUS_OS_PASE) && !defined (PEGASUS_DEBUG)
// PASE have itself regular for checking privileged user
if (!System::isPrivilegedUser("*CURRENT "))
{
MessageLoaderParms parms(
"src.Server.cimserver.NO_AUTHORITY.PEGASUS_OS_PASE",
"The caller should be a privileged user,"
" or the server will not run.");
cerr << MessageLoader::getMessage(parms) << endl;
exit (1);
}
char jobName[11];
// this function only can be found in PASE environment
umeGetJobName(jobName, false);
if (strncmp("QUMECIMOM ", jobName, 10) != 0
&& strncmp("QUMEENDCIM", jobName, 10) != 0)
{
MessageLoaderParms parms(
"src.Server.cimserver.NOT_OFFICIAL_START.PEGASUS_OS_PASE",
"cimserver can not be started by user.\nServer will not run.");
cerr << MessageLoader::getMessage(parms) << endl;
exit (1);
}
// Direct standard input, output, and error to /dev/null,
// PASE run this job in background, any output in not allowed
freopen("/dev/null", "r", stdin);
freopen("/dev/null", "w", stdout);
freopen("/dev/null", "w", stderr);
#endif
//
// Get an instance of the Config Manager.
//
ConfigManager* configManager = ConfigManager::getInstance();
configManager->useConfigFiles = true;
try
{
//
// Get options (from command line and from configuration file); this
// removes corresponding options and their arguments from the command
// line. NOTE: If shutdownOption=true, the contents of current config
// file are not overwritten by the planned config file.
//
GetOptions(configManager, argc, argv, shutdownOption);
//
// Initialize the message home directory in the MessageLoader.
// This is the default directory where the resource bundles are found.
//
MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
ConfigManager::getInstance()->getCurrentValue("messageDir")));
#if !defined(PEGASUS_USE_SYSLOGS)
String logsDirectory = ConfigManager::getHomedPath(
configManager->getCurrentValue("logdir"));
// Set up the Logger. This does not open the logs.
// Might be more logical to clean before set.
Logger::setHomeDirectory(logsDirectory);
#endif
#ifdef PEGASUS_OS_PASE
/* write job log to tell where pegasus log is.*/
if(logsDirectory.size() > 0)
// this function only can be found in PASE environment
logPegasusDir2joblog(logsDirectory.getCString());
else
logPegasusDir2joblog(".");
// set ccsid to unicode for entire job
// ccsid is globolization mechanism in PASE environment
if (_SETCCSID(1208) == -1)
{
MessageLoaderParms parms(
"src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",
"Failed to set CCSID, server will stop.");
cerr << MessageLoader::getMessage(parms) << endl;
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::FATAL,
parms);
exit (1);
}
char fullJobName[29];
umeGetJobName(fullJobName, true);
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
Logger::INFORMATION,
MessageLoaderParms(
"src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",
"CIM Server's Job Name is: $0", fullJobName));
#endif
#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
// Make sure at least one connection is enabled
Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("enableHttpConnection"));
Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("enableHttpsConnection"));
if (!enableHttpConnection && !enableHttpsConnection)
{
MessageLoaderParms parms(
"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
"Neither HTTP nor HTTPS connection is enabled."
" CIMServer will not be started.");
Logger::put_l(
Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
parms);
cerr << MessageLoader::getMessage(parms) << endl;
return 1;
}
#endif
//
// Check to see if we should start Pegasus as a daemon
//
daemonOption = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("daemon"));
if ((Executor::detectExecutor() == 0) && (daemonOption == false))
{
MessageLoaderParms parms(
"src.Server.cimserver.PRIVSEP_REQUIRES_DAEMON",
"Warning: The configuration setting daemon=false is ignored "
"with privilege separation enabled.");
cerr << MessageLoader::getMessage(parms) << endl;
daemonOption = true;
}
//
// Check to see if we need to shutdown CIMOM
//
if (shutdownOption)
{
#if defined(PEGASUS_OS_ZOS) && defined(PEGASUS_ZOS_SECURITY)
// This checks whether user is authorized to stop the
// CIM Server. When unauthorized a message is logged to
// to the user and program exits.
shutdownCheckProfileCIMSERVclassWBEM();
// Depending on the success of the previous check we may not
// reach this code!!!
#endif
String configTimeout =
configManager->getCurrentValue("shutdownTimeout");
Uint32 timeoutValue =
strtol(configTimeout.getCString(), (char **)0, 10);
ServerShutdownClient serverShutdownClient(&_serverRunStatus);
serverShutdownClient.shutdown(timeoutValue);
MessageLoaderParms parms(
"src.Server.cimserver.SERVER_STOPPED",
"CIM Server stopped.");
cout << MessageLoader::getMessage(parms) << endl;
return 0;
}
#if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS)
// Leave this in until people get familiar with the logs.
MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",
"Logs Directory = ");
cout << MessageLoader::getMessage(parms) << logsDirectory << endl;
#endif
}
catch (Exception& e)
{
MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
"cimserver not started: $0", e.getMessage());
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
parms);
cerr << MessageLoader::getMessage(parms) << endl;
return 1;
}
#if defined(PEGASUS_OS_ZOS)
# if defined(PEGASUS_ZOS_SECURITY)
startupCheckBPXServer(true);
startupCheckProfileCIMSERVclassWBEM();
startupEnableMSC();
# endif
startupWaitForTCPIP();
#endif
#if defined(PEGASUS_DEBUG)
// Put out startup up message.
cout << _cimServerProcess->getProductName() << " " <<
_cimServerProcess->getCompleteVersion() << endl;
#endif
// Force initialization of hostname and fullyQualifiedHostName through
// retrieving current value from Configuration Manager
// - this will run getCurrentValue() in DefaultPropertyOwner.cpp
configManager->getCurrentValue("hostname");
configManager->getCurrentValue("fullyQualifiedHostName");
// reset message loading to NON-process locale
MessageLoader::_useProcessLocale = false;
// Get the parent's PID before forking
_serverRunStatus.setParentPid(System::getPID());
// Do not fork when using privilege separation (executor will daemonize
// itself later).
if (daemonOption)
{
if (-1 == _cimServerProcess->cimserver_fork())
return -1;
}
// Now we are after the fork...
// Create a dummy Thread object that can be used to store the
// AcceptLanguageList object for CIM requests that are serviced
// by this thread (initial thread of server). Need to do this
// because this thread is not in a ThreadPool, but is used
// to service CIM requests.
// The run function for the dummy Thread should never be called,
dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);
Thread::setCurrent(dummyInitialThread);
try
{
Thread::setLanguages(LanguageParser::getDefaultAcceptLanguages());
}
catch (InvalidAcceptLanguageHeader& e)
{
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
MessageLoaderParms(
"src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
"Could not convert the system process locale into a valid "
"AcceptLanguage format."));
Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
e.getMessage());
}
#ifndef PEGASUS_OS_TYPE_WINDOWS
umask(S_IRWXG|S_IRWXO);
#endif
// Start up the CIM Server
try
{
#if defined(PEGASUS_OS_TYPE_UNIX)
//
// Lock the CIMSERVER_LOCK_FILE during CIM Server start-up to prevent
// concurrent writes to this file by multiple cimserver processes
// starting at the same time.
//
CString startupLockFileName = ConfigManager::getHomedPath(
PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();
// Make sure the start-up lock file exists
FILE* startupLockFile;
if ((startupLockFile = fopen(startupLockFileName, "w")) != 0)
{
fclose(startupLockFile);
}
AutoFileLock fileLock(startupLockFileName);
#endif
#if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
//
// Check if a CIM Server is already running. If so, print an error
// message and notify the parent process (if there is one) to terminate
//
if (_serverRunStatus.isServerRunning())
{
MessageLoaderParms parms(
"src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
"Unable to start CIMServer. CIMServer is already running.");
Logger::put_l(
Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
parms);
cerr << MessageLoader::getMessage(parms) << endl;
if (daemonOption)
{
_cimServerProcess->notify_parent(1);
}
return 1;
}
//
// Declare ourselves as the running CIM Server process, and write our
// PID to the PID file.
//
_serverRunStatus.setServerRunning();
#endif
// Create and initialize the CIMServer object
_cimServer = new CIMServer();
Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("enableHttpConnection"));
Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("enableHttpsConnection"));
#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
// Make sure at least one connection is enabled
if (!enableHttpConnection && !enableHttpsConnection)
{
MessageLoaderParms parms(
"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
"Neither HTTP nor HTTPS connection is enabled.");
throw Exception(parms);
}
#endif
Boolean addIP6Acceptor = false;
Boolean addIP4Acceptor = false;
#ifdef PEGASUS_OS_TYPE_WINDOWS
addIP4Acceptor = true;
#endif
#ifdef PEGASUS_ENABLE_IPV6
// If IPv6 stack is disabled swicth to IPv4 stack.
if (System::isIPv6StackActive())
{
addIP6Acceptor = true;
}
else
{
PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4,
"IPv6 stack is not active, using IPv4 socket.");
}
#endif
if (!addIP6Acceptor)
{
addIP4Acceptor = true;
}
// The server HTTP and HTTPS ports are determined via this algorithm:
// 1) If the user explicitly specified a port, use it.
// 2) If the user did not specify a port, get the port from the
// services file.
// 3) If no value is specified in the services file, use the IANA WBEM
// default port.
// Note that 2 and 3 are done within the System::lookupPort method
// An empty string from the ConfigManager implies that the user did not
// specify a port.
if (enableHttpConnection)
{
Uint32 portNumberHttp = 0;
String httpPort = configManager->getCurrentValue("httpPort");
if (httpPort.size() == 0)
{
//
// Look up the WBEM-HTTP port number
//
portNumberHttp = System::lookupPort(
WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);
_initConfigProperty("httpPort", portNumberHttp);
}
else
{
Uint64 longNumber;
// use the current value which has been checked for validity at
// load(fct. GetOptions), see DefaultPropertyOwner::isValid()
StringConversion::decimalStringToUint64(
httpPort.getCString(),
longNumber);
portNumberHttp = longNumber & 0xffff;
}
String listenOn = configManager->getCurrentValue("listenAddress");
if(String::equalNoCase(listenOn, "All"))
{
if (addIP6Acceptor)
{
_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
portNumberHttp, false);
}
if (addIP4Acceptor)
{
_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
portNumberHttp, false);
}
}
else // Restricted listening
{
_restrictListening(
configManager, listenOn, portNumberHttp, false);
}
// The port number is converted to a string to avoid the
// addition of localized characters (e.g., "5,988").
char scratchBuffer[22];
Uint32 n;
const char * portNumberHttpStr = Uint32ToString(
scratchBuffer, portNumberHttp, n);
MessageLoaderParms parms(
"src.Server.cimserver.LISTENING_ON_HTTP_PORT",
"Listening on HTTP port $0.", portNumberHttpStr);
Logger::put_l(
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
parms);
#if defined(PEGASUS_DEBUG)
cout << MessageLoader::getMessage(parms) << endl;
#endif
}
if (enableHttpsConnection)
{
Uint32 portNumberHttps = 0;
String httpsPort = configManager->getCurrentValue("httpsPort");
if (httpsPort.size() == 0)
{
//
// Look up the WBEM-HTTPS port number
//
portNumberHttps = System::lookupPort(
WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);
_initConfigProperty("httpsPort", portNumberHttps);
}
else
{
Uint64 longNumber;
// use the current value which has been checked for validity at
// load(fct. GetOptions), see DefaultPropertyOwner::isValid()
StringConversion::decimalStringToUint64(
httpsPort.getCString(),
longNumber);
portNumberHttps = longNumber & 0xffff;
}
String listenOn = configManager->getCurrentValue("listenAddress");
if(String::equalNoCase(listenOn, "All"))
{
if (addIP6Acceptor)
{
_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
portNumberHttps, true);
}
if (addIP4Acceptor)
{
_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
portNumberHttps, true);
}
}
else //Restricted
{
_restrictListening(
configManager, listenOn, portNumberHttps, true);
}
// The port number is converted to a string to avoid the
// addition of localized characters (e.g., "5,989").
char scratchBuffer[22];
Uint32 n;
const char * portNumberHttpsStr = Uint32ToString(
scratchBuffer, portNumberHttps, n);
MessageLoaderParms parms(
"src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
"Listening on HTTPS port $0.", portNumberHttpsStr);
Logger::put_l(
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
parms);
#if defined(PEGASUS_DEBUG)
cout << MessageLoader::getMessage(parms) << endl;
#endif
}
#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
{
_cimServer->addAcceptor(HTTPAcceptor::LOCAL_CONNECTION, 0, false);
MessageLoaderParms parms(
"src.Server.cimserver.LISTENING_ON_LOCAL",
"Listening on local connection socket.");
Logger::put_l(
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
parms);
# if defined(PEGASUS_DEBUG)
cout << MessageLoader::getMessage(parms) << endl;
# endif
}
#endif
_cimServer->bind();
// notify parent process (if there is a parent process) to terminate
// so user knows that there is cimserver ready to serve CIM requests.
if (daemonOption)
{
_cimServerProcess->notify_parent(0);
}
#if defined(PEGASUS_DEBUG)
cout << "Started. " << endl;
#endif
// Put server started message to the logger
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
Logger::INFORMATION,
MessageLoaderParms(
"src.Server.cimserver.STARTED_VERSION",
"Started $0 version $1.",
_cimServerProcess->getProductName(),
_cimServerProcess->getCompleteVersion()));
#if defined(PEGASUS_OS_TYPE_UNIX) && !defined(PEGASUS_OS_ZOS)
if (daemonOption && !debugOutputOption)
{
// Direct standard input, output, and error to /dev/null,
// since we are running as a daemon.
close(STDIN_FILENO);
open("/dev/null", O_RDONLY);
close(STDOUT_FILENO);
open("/dev/null", O_RDWR);
close(STDERR_FILENO);
open("/dev/null", O_RDWR);
}
#endif
}
catch (Exception& e)
{
MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
"cimserver not started: $0", e.getMessage());
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
parms);
cerr << MessageLoader::getMessage(parms) << endl;
deleteCIMServer();
//
// notify parent process (if there is a parent process) to terminate
//
if (daemonOption)
_cimServerProcess->notify_parent(1);
return 1;
}
// Run the main CIM Server loop
try
{
#if defined(PEGASUS_OS_ZOS)
// ARM is a z/OS internal restart facility.
// This is a z/OS specific change.
// Instatiating the automatic restart manager for zOS
ARM_zOS automaticRestartManager;
// register to zOS ARM
automaticRestartManager.Register();
#endif
#ifdef PEGASUS_ENABLE_SLP
_cimServer->startSLPProvider();
#endif
_cimServer->initComplete();
//
// Loop to call CIMServer's runForever() method until CIMServer
// has been shutdown
//
while (!_cimServer->terminated())
{
_cimServer->runForever();
}
//
// normal termination
//
#if defined(PEGASUS_OS_ZOS)
// ARM is a z/OS internal restart facility.
// This is a z/OS specific change.
// register to zOS ARM
automaticRestartManager.DeRegister();
#endif
// Put server shutdown message to the logger
Logger::put_l(
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
MessageLoaderParms(
"src.Server.cimserver.STOPPED",
"$0 stopped.", _cimServerProcess->getProductName()));
}
catch (Exception& e)
{
MessageLoaderParms parms(
"src.Server.cimserver.ERROR",
"Error: $0",
e.getMessage());
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
parms);
cerr << MessageLoader::getMessage(parms) << endl;
deleteCIMServer();
return 1;
}
deleteCIMServer();
return 0;
}
// Actual logging is done in this routine
void log(Logger::LogFileType logFileType,
const String& systemId,
Uint32 logLevel,
const String localizedMsg)
{
// Prepend the systemId to the incoming message
String messageString(systemId);
messageString.append(": ");
messageString.append(localizedMsg); // l10n
// Get the logLevel String
// This converts bitmap to string based on highest order
// bit set
// ATTN: KS Fix this more efficiently.
const char* tmp = "";
if (logLevel & Logger::TRACE) tmp = "TRACE ";
if (logLevel & Logger::INFORMATION) tmp = "INFO ";
if (logLevel & Logger::WARNING) tmp = "WARNING ";
if (logLevel & Logger::SEVERE) tmp = "SEVERE ";
if (logLevel & Logger::FATAL) tmp = "FATAL ";
# ifndef PEGASUS_OS_VMS
// Acquire AutoMutex (for thread sync)
// and AutoFileLock (for Process Sync).
AutoMutex am(_mutex);
AutoFileLock fileLock(_loggerLockFileName);
Uint32 logFileSize = 0;
// Read logFileSize to check if the logfile needs to be pruned.
FileSystem::getFileSize(String(_logFileNames[logFileType]),
logFileSize);
// Check if the size of the logfile is exceeding _maxLogFileSizeBytes.
if ( logFileSize > _maxLogFileSizeBytes)
{
// Prepare appropriate file name based on the logFileType.
// Eg: if Logfile name is PegasusStandard.log, pruned logfile name
// will be PegasusStandard-062607-122302.log,where 062607-122302
// is the time stamp.
String prunedLogfile(_logFileNames[logFileType],
(Uint32)strlen(_logFileNames[logFileType]) - 4);
prunedLogfile.append('-');
// Get timestamp,remove illegal chars in file name'/' and ':'
// (: is illegal Open VMS) from the time stamp. Append the time
// info to the file name.
String timeStamp = System::getCurrentASCIITime();
for (unsigned int i=0; i<=timeStamp.size(); i++)
{
if(timeStamp[i] == '/' || timeStamp[i] == ':')
{
timeStamp.remove(i, 1);
}
}
prunedLogfile.append(timeStamp);
// Append '.log' to the file
prunedLogfile.append( ".log");
// Rename the logfile
FileSystem::renameFile(String(_logFileNames[logFileType]),
prunedLogfile);
} // Check if the logfile needs to be pruned.
# endif // ifndef PEGASUS_OS_VMS
// Open Logfile. Based on the value of logFileType, one of the five
// Logfiles will be opened.
ofstream logFileStream;
logFileStream.open(_logFileNames[logFileType], ios::app);
logFileStream << System::getCurrentASCIITime()
<< " " << tmp << (const char *)messageString.getCString() << endl;
logFileStream.close();
}
void LidarProcessOctree::subdivide(LidarProcessOctree::Node& node)
{
{
#if ALLOW_THREADING
Threads::Mutex::Lock lruLock(lruMutex);
#endif
++numSubdivideCalls;
}
#if ALLOW_THREADING
Threads::Mutex::Lock nodeLock(node.mutex);
#endif
/* Bail out if the node's children have magically appeared since the last check: */
if(node.children!=0)
return;
/* Check if the node cache is full: */
{
#if ALLOW_THREADING
Threads::Mutex::Lock lruLock(lruMutex);
#endif
if(numCachedNodes+8>cacheSize)
{
/* Find an unused leaf node parent and remove its children: */
Node* coarsenNode;
#if ALLOW_THREADING
for(coarsenNode=lruHead;coarsenNode!=0;coarsenNode=coarsenNode->lruSucc)
{
/* Check if the leaf parent is currently unused: */
coarsenNode->mutex.lock();
if(coarsenNode->processCounter==0)
break;
coarsenNode->mutex.unlock();
}
#else
for(coarsenNode=lruHead;coarsenNode!=0&&coarsenNode->processCounter!=0;coarsenNode=coarsenNode->lruSucc)
;
#endif
/* Remove the found node's children: */
delete[] coarsenNode->children;
coarsenNode->children=0;
#if ALLOW_THREADING
coarsenNode->mutex.unlock();
#endif
/* Remove the found node from the lru list: */
if(coarsenNode->lruPred!=0)
coarsenNode->lruPred->lruSucc=coarsenNode->lruSucc;
else
lruHead=coarsenNode->lruSucc;
if(coarsenNode->lruSucc!=0)
coarsenNode->lruSucc->lruPred=coarsenNode->lruPred;
else
lruTail=coarsenNode->lruPred;
coarsenNode->lruPred=0;
coarsenNode->lruSucc=0;
/* Update the node cache: */
numCachedNodes-=8;
/* Check if the found node's parent is now a leaf parent node: */
Node* parent=coarsenNode->parent;
if(parent!=0)
{
/* Check if all children of the parent are leaves: */
bool leafParent=true;
for(int childIndex=0;childIndex<8&&leafParent;++childIndex)
leafParent=parent->children[childIndex].children==0;
if(leafParent)
{
/* Add the parent to the end of the leaf parent node list: */
parent->lruPred=lruTail;
parent->lruSucc=0;
if(lruTail!=0)
lruTail->lruSucc=parent;
else
lruHead=parent;
lruTail=parent;
}
}
}
/* Check if the node's parent was a leaf parent: */
Node* parent=node.parent;
if(parent!=0&&(parent->lruPred!=0||parent->lruSucc!=0||lruHead==parent))
{
/* Remove the node's parent from the leaf parent node list: */
if(parent->lruPred!=0)
parent->lruPred->lruSucc=parent->lruSucc;
else
lruHead=parent->lruSucc;
if(parent->lruSucc!=0)
parent->lruSucc->lruPred=parent->lruPred;
else
lruTail=parent->lruPred;
parent->lruPred=0;
parent->lruSucc=0;
}
/* Add the node to the leaf parent node list: */
node.lruPred=lruTail;
node.lruSucc=0;
if(lruTail!=0)
lruTail->lruSucc=&node;
else
lruHead=&node;
lruTail=&node;
/* Update the node cache: */
numCachedNodes+=8U;
}
/* Create and load the node's children: */
{
#if ALLOW_THREADING
Threads::Mutex::Lock fileLock(fileMutex);
#endif
Node* children=new Node[8];
indexFile.setReadPosAbs(node.childrenOffset);
for(int childIndex=0;childIndex<8;++childIndex)
{
Node& child=children[childIndex];
/* Read the child node's structure: */
LidarOctreeFileNode ofn;
ofn.read(indexFile);
child.parent=&node;
child.childrenOffset=ofn.childrenOffset;
child.domain=Cube(node.domain,childIndex);
child.numPoints=ofn.numPoints;
child.dataOffset=ofn.dataOffset;
child.detailSize=ofn.detailSize;
if(child.numPoints>0)
{
/* Load the child node's points: */
child.points=new LidarPoint[maxNumPointsPerNode]; // Always allocate maximum to prevent memory fragmentation
pointsFile.setReadPosAbs(LidarDataFileHeader::getFileSize()+pointsRecordSize*child.dataOffset);
pointsFile.read(child.points,child.numPoints);
}
++numLoadedNodes;
}
/* Install the node's children array: */
node.children=children;
}
}
