//
//==============================================================================
//
-// Author: Humberto Rivero (hurivero@us.ibm.com)
-//
-// Modified By: Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3514
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/AcceptLanguageList.h>
Real32 qualityValue);
/**
- Removes the specified LanguageTag and quality value from the
+ Removes the specified LanguageTag and quality value from the
AcceptLanguageList object.
@param index Integer index of the element to remove.
@exception IndexOutOfBoundsException If the specified index is out of
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_AnonymousPipe_h
PEGASUS_NAMESPACE_BEGIN
-/**
+/**
The AnonymousPipe class implements an anonymous pipe.
@author Hewlett-Packard Company
Constructs an AnonymousPipe instance, given the read and/or write handle
in char form.
- NOTE: before using this form of the constructor, the pipe must already
- exist (a previous invocation of the AnonymousPipe () form of the
- constructor), and the specified handle(s) should be open for the
- specified operation (read or write). The read or write handle
- should be obtained via a call to exportReadHandle () or
+ NOTE: before using this form of the constructor, the pipe must already
+ exist (a previous invocation of the AnonymousPipe () form of the
+ constructor), and the specified handle(s) should be open for the
+ specified operation (read or write). The read or write handle
+ should be obtained via a call to exportReadHandle () or
exportWriteHandle (), respectively.
- @param readHandle char [] representation of the read handle to
+ @param readHandle char [] representation of the read handle to
the pipe
@param writeHandle char [] representation of the write handle to
the pipe
Defines symbolic constants for return values from read and write
methods.
*/
- enum Status {STATUS_INTERRUPT = -2,
- STATUS_ERROR = -1,
- STATUS_CLOSED = 0,
+ enum Status {STATUS_INTERRUPT = -2,
+ STATUS_ERROR = -1,
+ STATUS_CLOSED = 0,
STATUS_SUCCESS = 1};
/**
- Writes data from a buffer to the AnonymousPipe.
+ Writes data from a buffer to the AnonymousPipe.
@param buffer pointer to the input data buffer
@param bytesToWrite Number of bytes to write
- @return STATUS_SUCCESS on success;
- STATUS_CLOSED on closed connection;
+ @return STATUS_SUCCESS on success;
+ STATUS_CLOSED on closed connection;
STATUS_ERROR on error;
*/
Status writeBuffer (
Uint32 bytesToWrite);
/**
- Writes a CIM message to the AnonymousPipe.
+ Writes a CIM message to the AnonymousPipe.
The message is serialized, then written to the pipe.
@param message pointer to the message
- @return STATUS_SUCCESS on success;
- STATUS_CLOSED on closed connection;
+ @return STATUS_SUCCESS on success;
+ STATUS_CLOSED on closed connection;
STATUS_ERROR on error;
*/
Status writeMessage (
CIMMessage * message);
/**
- Reads data into a buffer from the AnonymousPipe.
+ Reads data into a buffer from the AnonymousPipe.
@param buffer pointer to the output data buffer
@param bytesToRead Number of bytes to read
- @return STATUS_SUCCESS on success;
- STATUS_CLOSED on closed connection;
+ @return STATUS_SUCCESS on success;
+ STATUS_CLOSED on closed connection;
STATUS_ERROR on error;
STATUS_INTERRUPT on interrupt
*/
Uint32 bytesToRead);
/**
- Reads a CIM message from the AnonymousPipe.
+ Reads a CIM message from the AnonymousPipe.
A message is read from the pipe, then de-serialized.
@param message pointer to the message (output parameter)
- @return STATUS_SUCCESS on success;
- STATUS_CLOSED on closed connection;
+ @return STATUS_SUCCESS on success;
+ STATUS_CLOSED on closed connection;
STATUS_ERROR on error;
STATUS_INTERRUPT on interrupt
*/
CIMMessage * & message);
/**
- Gets a char [] form of the pipe handle for reading from the
- AnonymousPipe instance.
+ Gets a char [] form of the pipe handle for reading from the
+ AnonymousPipe instance.
- NOTE: the caller must supply the buffer. The buffer size must be at
+ NOTE: the caller must supply the buffer. The buffer size must be at
least 32.
*/
void exportReadHandle (
char * buffer) const;
/**
- Gets a char [] form of the pipe handle for writing to the
- AnonymousPipe instance.
+ Gets a char [] form of the pipe handle for writing to the
+ AnonymousPipe instance.
- NOTE: the caller must supply the buffer. The buffer size must be at
+ NOTE: the caller must supply the buffer. The buffer size must be at
least 32.
*/
void exportWriteHandle (
char * buffer) const;
/**
- Closes the pipe handle for reading from the AnonymousPipe instance.
+ Closes the pipe handle for reading from the AnonymousPipe instance.
*/
void closeReadHandle ();
/**
- Closes the pipe handle for writing to the AnonymousPipe instance.
+ Closes the pipe handle for writing to the AnonymousPipe instance.
*/
void closeWriteHandle ();
AnonymousPipe (const AnonymousPipe & anonymousPipe);
/**
- Private, unimplemented assignment operator to avoid implicit use of
+ Private, unimplemented assignment operator to avoid implicit use of
the default assignment operator
*/
AnonymousPipe & operator= (const AnonymousPipe & anonymousPipe);
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Failed to create pipe: %s", strerror (errno));
PEG_METHOD_EXIT ();
-
+
MessageLoaderParms mlp ("Common.AnonymousPipe.CREATE_PIPE_FAILED",
"Failed to create pipe.");
throw Exception (mlp);
const char * readHandle,
const char * writeHandle)
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION,
+ PEG_METHOD_ENTER (TRC_OS_ABSTRACTION,
"AnonymousPipe::AnonymousPipe (const char *, const char *)");
_readHandle = 0;
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
PEGASUS_NAMESPACE_BEGIN
-AnonymousPipe::AnonymousPipe ()
+AnonymousPipe::AnonymousPipe()
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION, "AnonymousPipe::AnonymousPipe ()");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION, "AnonymousPipe::AnonymousPipe()");
- AnonymousPipeHandle thePipe [2];
+ AnonymousPipeHandle thePipe[2];
SECURITY_ATTRIBUTES saAttr;
- saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
+ saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
- if (!CreatePipe (&thePipe [0], &thePipe [1], &saAttr, 0))
+ if (!CreatePipe(&thePipe[0], &thePipe[1], &saAttr, 0))
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to create pipe. Error code: %d", GetLastError ());
- PEG_METHOD_EXIT ();
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to create pipe. Error code: %d", GetLastError());
+ PEG_METHOD_EXIT();
- MessageLoaderParms mlp ("Common.AnonymousPipe.CREATE_PIPE_FAILED",
+ MessageLoaderParms mlp("Common.AnonymousPipe.CREATE_PIPE_FAILED",
"Failed to create pipe.");
- throw Exception (mlp);
+ throw Exception(mlp);
}
- _readHandle = thePipe [0];
- _writeHandle = thePipe [1];
+ _readHandle = thePipe[0];
+ _writeHandle = thePipe[1];
_readOpen = true;
_writeOpen = true;
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
-AnonymousPipe::AnonymousPipe (
+AnonymousPipe::AnonymousPipe(
const char * readHandle,
const char * writeHandle)
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION,
- "AnonymousPipe::AnonymousPipe (const char *, const char *)");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION,
+ "AnonymousPipe::AnonymousPipe(const char *, const char *)");
_readHandle = 0;
_writeHandle = 0;
if (readHandle != NULL)
{
- if (sscanf (readHandle, "%p", &_readHandle) != 1)
+ if (sscanf(readHandle, "%p", &_readHandle) != 1)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Failed to create pipe: invalid read handle %s", readHandle);
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
- MessageLoaderParms mlp ("Common.AnonymousPipe.CREATE_PIPE_FAILED",
+ MessageLoaderParms mlp("Common.AnonymousPipe.CREATE_PIPE_FAILED",
"Failed to create pipe.");
- throw Exception (mlp);
+ throw Exception(mlp);
}
_readOpen = true;
}
if (writeHandle != NULL)
{
- if (sscanf (writeHandle, "%p", &_writeHandle) != 1)
+ if (sscanf(writeHandle, "%p", &_writeHandle) != 1)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Failed to create pipe: invalid write handle %s", writeHandle);
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
- MessageLoaderParms mlp ("Common.AnonymousPipe.CREATE_PIPE_FAILED",
+ MessageLoaderParms mlp("Common.AnonymousPipe.CREATE_PIPE_FAILED",
"Failed to create pipe.");
- throw Exception (mlp);
+ throw Exception(mlp);
}
_writeOpen = true;
}
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
-AnonymousPipe::~AnonymousPipe ()
+AnonymousPipe::~AnonymousPipe()
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION, "AnonymousPipe::~AnonymousPipe");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION, "AnonymousPipe::~AnonymousPipe");
if (_readOpen)
{
- closeReadHandle ();
+ closeReadHandle();
}
if (_writeOpen)
{
- closeWriteHandle ();
+ closeWriteHandle();
}
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
-AnonymousPipe::Status AnonymousPipe::writeBuffer (
+AnonymousPipe::Status AnonymousPipe::writeBuffer(
const void * buffer,
Uint32 bytesToWrite)
{
//
if (!_writeOpen)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Attempted to write to pipe whose write handle is not open");
return STATUS_CLOSED;
}
//
// Ignore SIGPIPE signals
//
- SignalHandler::ignore (PEGASUS_SIGPIPE);
+ SignalHandler::ignore(PEGASUS_SIGPIPE);
const char * writeBuffer = reinterpret_cast<const char *>(buffer);
DWORD expectedBytes = bytesToWrite;
{
BOOL returnValue;
DWORD bytesWritten = 0;
- returnValue = WriteFile (_writeHandle, writeBuffer, expectedBytes,
+ returnValue = WriteFile(_writeHandle, writeBuffer, expectedBytes,
&bytesWritten, NULL);
if (!returnValue)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to write buffer to pipe. Error code: %d",
- GetLastError ());
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to write buffer to pipe. Error code: %d",
+ GetLastError());
return STATUS_ERROR;
}
if (bytesWritten < 0)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to write buffer to pipe. Error code: %d",
- GetLastError ());
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to write buffer to pipe. Error code: %d",
+ GetLastError());
- if ((GetLastError () == ERROR_PIPE_NOT_CONNECTED) ||
- (GetLastError () == ERROR_BROKEN_PIPE))
+ if ((GetLastError() == ERROR_PIPE_NOT_CONNECTED) ||
+ (GetLastError() == ERROR_BROKEN_PIPE))
{
return STATUS_CLOSED;
}
return STATUS_SUCCESS;
}
-AnonymousPipe::Status AnonymousPipe::readBuffer (
+AnonymousPipe::Status AnonymousPipe::readBuffer(
void * buffer,
Uint32 bytesToRead)
{
//
if (!_readOpen)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Attempted to read from pipe whose read handle is not open");
return STATUS_CLOSED;
}
{
BOOL returnValue;
DWORD bytesRead;
- returnValue = ReadFile (_readHandle, buffer, bytesToRead, &bytesRead,
- NULL);
+ returnValue = ReadFile(
+ _readHandle, buffer, bytesToRead, &bytesRead, NULL);
if (!returnValue)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to read buffer from pipe. Error code: %d",
- GetLastError ());
- if ((GetLastError () == ERROR_PIPE_NOT_CONNECTED) ||
- (GetLastError () == ERROR_BROKEN_PIPE))
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to read buffer from pipe. Error code: %d",
+ GetLastError());
+ if ((GetLastError() == ERROR_PIPE_NOT_CONNECTED) ||
+ (GetLastError() == ERROR_BROKEN_PIPE))
{
return STATUS_CLOSED;
}
//
// Connection closed
//
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Failed to read buffer from pipe: connection closed");
return STATUS_CLOSED;
}
if (bytesRead < 0)
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to read buffer from pipe. Error code: %d",
- GetLastError ());
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to read buffer from pipe. Error code: %d",
+ GetLastError());
//
// Error reading from pipe
return STATUS_SUCCESS;
}
-void AnonymousPipe::exportReadHandle (char * buffer) const
+void AnonymousPipe::exportReadHandle(char * buffer) const
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION, "AnonymousPipe::exportReadHandle");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION, "AnonymousPipe::exportReadHandle");
- sprintf (buffer, "%p", _readHandle);
+ sprintf(buffer, "%p", _readHandle);
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
-void AnonymousPipe::exportWriteHandle (char * buffer) const
+void AnonymousPipe::exportWriteHandle(char * buffer) const
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION, "AnonymousPipe::exportWriteHandle");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION, "AnonymousPipe::exportWriteHandle");
- sprintf (buffer, "%p", _writeHandle);
+ sprintf(buffer, "%p", _writeHandle);
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
-void AnonymousPipe::closeReadHandle ()
+void AnonymousPipe::closeReadHandle()
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION, "AnonymousPipe::closeReadHandle");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION, "AnonymousPipe::closeReadHandle");
if (_readOpen)
{
- if (!CloseHandle (_readHandle))
+ if (!CloseHandle(_readHandle))
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to close read handle. Error code: %d",
- GetLastError ());
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to close read handle. Error code: %d",
+ GetLastError());
}
else
{
}
else
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Attempted to close read handle that was not open");
}
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
-void AnonymousPipe::closeWriteHandle ()
+void AnonymousPipe::closeWriteHandle()
{
- PEG_METHOD_ENTER (TRC_OS_ABSTRACTION, "AnonymousPipe::closeWriteHandle");
+ PEG_METHOD_ENTER(TRC_OS_ABSTRACTION, "AnonymousPipe::closeWriteHandle");
if (_writeOpen)
{
- if (!CloseHandle (_writeHandle))
+ if (!CloseHandle(_writeHandle))
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
- "Failed to close write handle. Error code: %d",
- GetLastError ());
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ "Failed to close write handle. Error code: %d",
+ GetLastError());
}
else
{
}
else
{
- Tracer::trace (TRC_OS_ABSTRACTION, Tracer::LEVEL2,
+ Tracer::trace(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
"Attempted to close write handle that was not open");
}
- PEG_METHOD_EXIT ();
+ PEG_METHOD_EXIT();
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-// Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Array.h"
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ArrayInternal_h
}
template<class PEGASUS_ARRAY_T>
-void BubbleSort(Array<PEGASUS_ARRAY_T>& x)
+void BubbleSort(Array<PEGASUS_ARRAY_T>& x)
{
Uint32 n = x.size();
}
}
-inline void BubbleSort(Array<CIMName>& x)
+inline void BubbleSort(Array<CIMName>& x)
{
Uint32 n = x.size();
}
}
-inline void BubbleSort(Array<CIMNamespaceName>& x)
+inline void BubbleSort(Array<CIMNamespaceName>& x)
{
Uint32 n = x.size();
#if 0
// Determine need for these functions
template<class PEGASUS_ARRAY_T>
-void Unique(Array<PEGASUS_ARRAY_T>& x)
+void Unique(Array<PEGASUS_ARRAY_T>& x)
{
Array<PEGASUS_ARRAY_T> result;
#define Array_capacity (Array_rep)->capacity
#define Array_refs (Array_rep)->refs
-// The OS400 platform uses this aligment directive to ensure that
+// The OS400 platform uses this aligment directive to ensure that
// ArrayRepBase is aligned an a 16 byte boundary.
#ifdef PEGASUS_OS_OS400
# define PEGASUS_ALIGN16 __align(16)
PEGASUS_NAMESPACE_BEGIN
-PEGASUS_ALIGN16
+PEGASUS_ALIGN16
struct PEGASUS_COMMON_LINKAGE ArrayRepBase
{
// We put this first to avoid gaps in this structure. Some compilers may
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "AsyncQueue.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mike-brasher@austin.rr.com) - Inova Europe
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Config.h>
Array<String> vals = attr.getValues();
for (int i = 0; i < vals.size(); i++)
{
- if(i == 0)
+ if (i == 0)
{
os << " = ";
}
//
//==============================================================================
//
-// Author: Tony Fiorentino (fiorentino_tony@emc.com)
-//
-// Modified By: Keith Petley (keithp@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Attribute_h
}
}
- return (moduleStatusValue);
+ return moduleStatusValue;
}
PEGASUS_NAMESPACE_END
#ifndef PEGASUS_DISABLE_AUDIT_LOGGER
-/**
+/**
This class provides the interfaces to construct a human readable audit
- text message and write the message to log files.
+ text message and write the message to log files.
*/
class PEGASUS_COMMON_LINKAGE AuditLogger
{
TYPE_AUTHENTICATION,
TYPE_AUTHORIZATION,
TYPE_CONFIGURATION,
- TYPE_CIMOPERATION
+ TYPE_CIMOPERATION
};
enum AuditSubType
};
/** Constructs and logs audit message of the current configurations
- @param propertyNames - All the current property names while the CIM
+ @param propertyNames - All the current property names while the CIM
Server is running
@param propertyValues - All the current property values while the CIM
Server is running
@param cimMethodName - The name of the CIM operation performed
@param eventType - The AuditEvent associated with the CIM operation
@param userName - User name for this operation
- @param ipAddr - Client IP address for this operation
+ @param ipAddr - Client IP address for this operation
@param nameSpace - The namespace for the operation
@param className - The name of the class
@param statusCode - The CIM status code for the operation
@param cimMethodName - The name of the CIM operation performed
@param eventType - The AuditEvent associated with the CIM operation
@param userName - User name for this operation
- @param ipAddr - Client IP address for this operation
+ @param ipAddr - Client IP address for this operation
@param nameSpace - The namespace for the operation
- @param name - The name of the qualifier
+ @param name - The name of the qualifier
@param statusCode - The CIM status code for the operation
*/
static void logUpdateQualifierOperation(
@param cimMethodName - The name of the CIM operation performed
@param eventType - The AuditEvent associated with the CIM operation
@param userName - The user name for this operation
- @param ipAddr - Client IP address for this operation
+ @param ipAddr - Client IP address for this operation
@param nameSpace - The namespace for the operation
@param instanceName - The name of the affected instance
@param moduleName - The provider module name that serves the request
/**
Constructs and logs audit message of a CIM InvokeMethod operation
@param userName - The user name for this operation
- @param ipAddr - Client IP address for this operation
+ @param ipAddr - Client IP address for this operation
@param nameSpace - The namespace for the operation
@param objectName - The name of the object on which the method is
invoked
- @param methodName - The name of the method to be executed
+ @param methodName - The name of the method to be executed
@param moduleName - The provider module name that serves the request
@param providerName - The provider name that serves the request
@param statusCode - The CIM status code for the operation
const String& providerName,
CIMStatusCode statusCode);
- /** Constructs and logs audit message of a provider module status change
+ /** Constructs and logs audit message of a provider module status change
@param moduleName - The name of the provider module
@param currentModuleStatus - The current status of the provider module
@param newModuleStatus - The new status of the provider module
typedef void (*PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T)();
- typedef void (*PEGASUS_AUDITLOG_CALLBACK_T) (AuditType,
- AuditSubType, AuditEvent, Uint32, MessageLoaderParms &);
+ typedef void (*PEGASUS_AUDITLOG_CALLBACK_T) (AuditType,
+ AuditSubType, AuditEvent, Uint32, MessageLoaderParms &);
/**
Registers an audit log initialize callback
- If a non-null initialize callback function is registered,
+ If a non-null initialize callback function is registered,
it will be called when the audit log is enabled.
- @param auditLogInitializeCallback - The audit log initialize
+ @param auditLogInitializeCallback - The audit log initialize
callback function
*/
static void setInitializeCallback(
PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T auditLogInitializeCallback);
- /** If the enabled is true, the audit log initialize callback function
+ /** If the enabled is true, the audit log initialize callback function
is called to communicate that the audit log is enabled.
- @param enabled - True on config property "enableAuditLog" is
+ @param enabled - True on config property "enableAuditLog" is
enabled, false otherwise
- */
+ */
static void setEnabled(Boolean enabled);
static Boolean isEnabled();
*/
static void writeAuditLogToFileCallback(
PEGASUS_AUDITLOG_CALLBACK_T writeAuditMessageCallback);
-
private:
-
+
static Boolean _auditLogFlag;
- /**
- Callback function to be called when the audit log is enabled
+ /**
+ Callback function to be called when the audit log is enabled
*/
static PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T _auditLogInitializeCallback;
@param AuditType - Type of audit record (Authentication etc)
@param AuditSubType - Sub type of audit record(Local_Authentication etc)
@param AuditEvent - Event of audit record (Start_Up etc)
- @param logLevel - Pegasus Severity (WARNING etc)
- All the audit messages are passed with pegasus severity
+ @param logLevel - Pegasus Severity (WARNING etc)
+ All the audit messages are passed with pegasus severity
"INFORMATION", except authentication attempts failed messages or
- authorization failed messages are passed with pegasus severity
+ authorization failed messages are passed with pegasus severity
"WARNING"
@param msgParms - The message loader parameters
*/
static void _writeAuditMessage(
AuditType auditType,
- AuditSubType auditSubType,
+ AuditSubType auditSubType,
AuditEvent auditEvent,
Uint32 logLevel,
MessageLoaderParms & msgParms);
inline Boolean AuditLogger::isEnabled()
{
- return (_auditLogFlag);
+ return _auditLogFlag;
}
# define PEG_AUDIT_LOG(T) \
_rep->setRemotePrivilegedUserAccessChecked();
}
- /** Get flag that shows if the isRemotePrivilegedUserAccess check has been done
- this function should only be used by OpenPegasus AuthenticationHandlers
+ /** Indicates whether the isRemotePrivilegedUserAccess check has been
+ performed. This method should only be used by OpenPegasus
+ AuthenticationHandlers
*/
Boolean getRemotePrivilegedUserAccessChecked()
{
{
_wasRemotePrivilegedUserAccessChecked = true;
}
-
+
Boolean getRemotePrivilegedUserAccessChecked()
{
return _wasRemotePrivilegedUserAccessChecked;
//
//==============================================================================
//
-// Author: Amit Arora, IBM (amita@in.ibm.com) (based on PEP101 by David Dillard)
-//
-// Modified By: Amit Arora, IBM (amita@in.ibm.com) for Bug#2168
-// Amit Arora, IBM (amita@in.ibm.com) for Bug#2480
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_AutoPtr_h
inline AutoPtr<X> get()
{
- return(_ref);
+ return _ref;
}
private:
inline AutoArrayPtr<X> get()
{
- return(_ref);
+ return _ref;
}
private:
{
if ( this != &a )
reset(a.release());
- return(*this);
+ return *this;
}
inline AutoPtr<X> &operator=(AutoPtrRef<X> &a) throw()
{
reset((a.get()).release());
- return(*this);
+ return *this;
}
// This method can be used to get the pointer to heap object encapsulated
// object of classA.
inline X *get() const throw()
{
- return(_ptr);
+ return _ptr;
}
// Returns the heap object itself (not the pointer to it)
inline X &operator*() const throw()
{
- return(*_ptr);
+ return *_ptr;
}
// A very important overloading, which allows you to directly use 'this'
// overloading only.
inline X *operator->() const throw()
{
- return(_ptr);
+ return _ptr;
}
// Relase the ownership of the memory object without deleting it !
{
X *t = _ptr;
_ptr = 0;
- return(t);
+ return t;
}
// Delete the heap object and thus release ownership
template<class Y> operator AutoPtrRef<Y>() throw()
{
- return(AutoPtrRef<Y>(*this));
+ return AutoPtrRef<Y>(*this);
}
template<class Y> operator AutoPtr<Y>() throw()
{
- return(AutoPtr<Y>(release()));
+ return AutoPtr<Y>(release());
}
private:
AutoArrayPtr<X> &operator=(AutoArrayPtr<X>& a) throw()
{
reset(a.release());
- return(*this);
+ return *this;
}
inline AutoArrayPtr<X> &operator=(AutoArrayPtrRef<X> &a) throw()
{
- if ( this != a )
+ if (this != a)
reset((a.get()).release());
- return(*this);
+ return *this;
}
inline X *get() const throw()
{
- return(_ptr);
+ return _ptr;
}
inline X &operator*() const throw()
{
- return(*_ptr);
+ return *_ptr;
}
inline X *operator->() const throw()
{
- return(_ptr);
+ return _ptr;
}
inline X* release() throw()
{
X *t = _ptr;
_ptr = 0;
- return(t);
+ return t;
}
inline void reset(X *p = 0) throw()
template<class Y> operator AutoArrayPtrRef<Y>() throw()
{
- return(AutoArrayPtrRef<Y>(*this));
+ return AutoArrayPtrRef<Y>(*this);
}
template<class Y> operator AutoArrayPtr<Y>() throw()
{
- return(AutoArrayPtr<Y>(release()));
+ return AutoArrayPtr<Y>(release());
}
//
//==============================================================================
//
-// Author: Adrian Schuur (schuur@de.ibm.com) - PEP 164
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-// Aruran, IBM (ashanmug@in.ibm.com) for BUG#3348
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef AutoStreamer_h
PEGASUS_NAMESPACE_BEGIN
-class PEGASUS_COMMON_LINKAGE AutoStreamer : public ObjectStreamer {
-
- ObjectStreamer *_primary,*_defaultReader;
- Uint16 _readerCount;
- struct _reader {
- _reader() { reader=NULL, marker=0; }
- ObjectStreamer *reader;
- Uint8 marker;
- } _readers[8];
+class PEGASUS_COMMON_LINKAGE AutoStreamer : public ObjectStreamer
+{
+ ObjectStreamer *_primary,*_defaultReader;
+ Uint16 _readerCount;
+ struct _reader
+ {
+ _reader() { reader=NULL, marker=0; }
+ ObjectStreamer *reader;
+ Uint8 marker;
+ } _readers[8];
public:
- AutoStreamer(ObjectStreamer *primary, Uint8 marker);
+ AutoStreamer(ObjectStreamer *primary, Uint8 marker);
- ~AutoStreamer();
+ ~AutoStreamer();
- void addReader(ObjectStreamer *primary, Uint8 marker);
+ void addReader(ObjectStreamer *primary, Uint8 marker);
- void encode(Buffer& out, const CIMClass& cls);
- void encode(Buffer& out, const CIMInstance& inst);
- void encode(Buffer& out, const CIMQualifierDecl& qual);
+ void encode(Buffer& out, const CIMClass& cls);
+ void encode(Buffer& out, const CIMInstance& inst);
+ void encode(Buffer& out, const CIMQualifierDecl& qual);
- void decode(const Buffer& in, unsigned int pos, CIMClass& cls);
- void decode(const Buffer& in, unsigned int pos, CIMInstance& inst);
- void decode(const Buffer& in, unsigned int pos, CIMQualifierDecl& qual);
+ void decode(const Buffer& in, unsigned int pos, CIMClass& cls);
+ void decode(const Buffer& in, unsigned int pos, CIMInstance& inst);
+ void decode(const Buffer& in, unsigned int pos, CIMQualifierDecl& qual);
- void write(PEGASUS_STD(ostream)& os, Buffer& in);
+ void write(PEGASUS_STD(ostream)& os, Buffer& in);
};
-
PEGASUS_NAMESPACE_END
#endif
//
//==============================================================================
//
-// Author: Karl Schopmeyer (k.schopmeyer@opengroup.org)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
@return Buffer with the encoded data
@exception bad_alloc Thrown if there is insufficient memory.
*/
- static Buffer encode(const Buffer& vby);
+ static Buffer encode(const Buffer& vby);
/**
Decodes an base64 array into an Buffer
UnpackQualifiers<CIMProperty>::func(in, pos, cimProperty);
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- if(cimProperty.getType() == CIMTYPE_STRING)
+ if (cimProperty.getType() == CIMTYPE_STRING)
{
CIMType realType = CIMTYPE_STRING;
- if(cimProperty.findQualifier("EmbeddedInstance") != PEG_NOT_FOUND)
+ if (cimProperty.findQualifier("EmbeddedInstance") != PEG_NOT_FOUND)
{
// Note that this condition should only happen for properties in
// class definitions, and only NULL values are recognized. We
PEGASUS_ASSERT(value.isNull());
realType = CIMTYPE_INSTANCE;
}
- else if(cimProperty.findQualifier("EmbeddedObject") != PEG_NOT_FOUND)
+ else if (cimProperty.findQualifier("EmbeddedObject") != PEG_NOT_FOUND)
{
// Note that this condition should only happen for properties in
// class definitions, and only NULL values are recognized. We
realType = CIMTYPE_OBJECT;
}
- if(realType != CIMTYPE_STRING)
+ if (realType != CIMTYPE_STRING)
{
CIMProperty tmpProperty(name, CIMValue(realType, value.isArray()),
arraySize, referenceClassName, classOrigin, propagated);
- for(unsigned int i = 0, n = cimProperty.getQualifierCount();
- i < n; ++i)
+ for (unsigned int i = 0, n = cimProperty.getQualifierCount();
+ i < n; ++i)
{
tmpProperty.addQualifier(cimProperty.getQualifier(i));
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Boolean_h
~CIMClass();
/**
- Indicates whether this class is an association class. An
- association is a relationship between two (or more) classes or
+ Indicates whether this class is an association class. An
+ association is a relationship between two (or more) classes or
instances. The Association qualifier is used to make this
determination.
@return True if this class is an association class, false otherwise.
initialized.
*/
const CIMName& getClassName() const;
-
+
/**
Gets the object path for the class.
@return A CIMObjectPath containing the object path.
in the class definition. The method arguments determine whether
qualifiers are included, the class origin attributes are included,
and which properties are included in the new instance. This method
- is designed specifically for providers to allow them to easily build
+ is designed specifically for providers to allow them to easily build
instance objects using the parameters provided with the CIM instance
- operations such as getInstance and enumerateInstances.
+ operations such as getInstance and enumerateInstances.
<p><b>Example:</b>
<pre>
CIMInstance myInstance =
myClass.buildInstance(true, true, CIMPropertyList());
</pre>
-
+
@param includeQualifiers A Boolean indicating whether qualifiers in
the class definition (and its properties) are to be added to the
instance. If false, no qualifiers are added to the instance or its
properties are added to the instance. If the propertyList is empty,
no properties are added. Note that this function does NOT generate
an error if a property name is supplied that is NOT in the class;
- it simply does not add that property to the instance.
-
+ it simply does not add that property to the instance.
+
@return CIMInstance of this class appropriately initialized.
@exception UninitializedObjectException If the object is not
~CIMConstClass();
/**
- Indicates whether this class is an association class. An
- association is a relationship between two (or more) classes or
+ Indicates whether this class is an association class. An
+ association is a relationship between two (or more) classes or
instances. The Association qualifier is used to make this
determination.
@return True if this class is an association class, false otherwise.
#include "XmlWriter.h"
#include "MofWriter.h"
#include <Pegasus/Common/Tracer.h>
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include "CIMNameUnchecked.h"
#include "StrLit.h"
#include "CIMInstanceRep.h"
throw PEGASUS_CIM_EXCEPTION(
CIM_ERR_INVALID_SUPERCLASS, _superClassName);
*/
- /*if(superclass.isTrueQualifier(CIMQualifierNames::TERMINAL)
+ /*if (superclass.isTrueQualifier(CIMQualifierNames::TERMINAL)
throw PEGASUS_CIM_EXCEPTION(
CIM_ERR_INVALID_SUPERCLASS, _superClassName);
*/
// Create new CIMInstance from CIMInstanceRep
CIMInstance newInstance(newInstanceRep);
- return(newInstance);
+ return newInstance;
}
void CIMClassRep::toXml(Buffer& out) const
static const Uint64 DAY = 24 * HOUR;
// Number of microseconds in ten thousand years.
-static const Uint64 TEN_THOUSAND_YEARS =
+static const Uint64 TEN_THOUSAND_YEARS =
PEGASUS_UINT64_LITERAL(315569520000000000);
// Number of microseconds in one million days.
-static const Uint64 HUNDRED_MILLION_DAYS =
+static const Uint64 HUNDRED_MILLION_DAYS =
PEGASUS_UINT64_LITERAL(8640000000000000000);
// Adding this to the POSIX 1970 microseconds epoch produces a 1 BCE epoch
// as used by this class.
-static const Uint64 POSIX_1970_EPOCH_OFFSET =
+static const Uint64 POSIX_1970_EPOCH_OFFSET =
PEGASUS_UINT64_LITERAL(62167201200000000);
//==============================================================================
/** Parse the integer component pointed to by s. Return WILDCARD if s consists
entirely of '*' characters. Returns the integer if it consists entirely
- of digits. Throw exception if digits and '*' are mixed. Also throw
+ of digits. Throw exception if digits and '*' are mixed. Also throw
exception if digits are encountered when priorWildcards parameter is true.
*/
static inline Uint32 _parseComponent(
}
/** Parse the microseconds component of the given string (6 characters).
- Set numSignificantMicrosecondDigits to the number of leading significant
- digits (non-asterisks). Note that once an asterisk is encountered, all
- subsequent characters must be asterisks. Returns the number of
- microseconds. Throws an exception if priorWildcards is true and any digits
+ Set numSignificantMicrosecondDigits to the number of leading significant
+ digits (non-asterisks). Note that once an asterisk is encountered, all
+ subsequent characters must be asterisks. Returns the number of
+ microseconds. Throws an exception if priorWildcards is true and any digits
are encountered or if digits occurs after asterisks.
*/
static Uint32 _parseMicroseconds(
// Format the string.
sprintf(
- buffer,
+ buffer,
"%08u%02u%02u%02u.%06u:000",
Uint32(days),
Uint32(hours),
// Format the string.
sprintf(
- buffer,
+ buffer,
"%04u%02u%02u%02u%02u%02u.%06u%c%03d",
Uint32(year),
Uint32(month),
// Parse UTF offset.
Uint32 utcOffset;
-
+
if (!_strToUint32(s, 3, utcOffset))
throw InvalidDateTimeFormatException();
if (isInterval() == dt.isInterval())
{
- // TIMESTAMP - TIMESTAMP
+ // TIMESTAMP - TIMESTAMP
// OR
// INTERVAL - INTERVAL
return CIMDateTime(x - y, true);
throw TypeMismatchException(parms);
}
- if (x == 0)
+ if (x == 0)
{
MessageLoaderParms parms(
"Common.CIMDateTime.INVALID_OPERATION_DIV_ZERO",
throw TypeMismatchException(parms);
}
- if (x._rep->usec == 0)
+ if (x._rep->usec == 0)
{
MessageLoaderParms parms(
"Common.CIMDateTime.INVALID_OPERATION_DIV_ZERO",
int tzMinutesEast;
{
# if defined(PEGASUS_OS_SOLARIS)
- tzMinutesEast =
+ tzMinutesEast =
-(int)((tmval->tm_isdst > 0 && daylight) ? altzone : timezone) / 60;
# elif defined(PEGASUS_OS_HPUX)
tzMinutesEast = - (int) timezone / 60;
if ((tmval->tm_isdst > 0) && daylight)
{
- // ATTN: It is unclear how to determine the DST offset.
+ // ATTN: It is unclear how to determine the DST offset.
// Assume 1 hour.
tzMinutesEast += 60;
}
if (tz.tz_dsttime > 0)
tzMinutesEast = -tz.tz_minuteswest;
else
- // ATTN: It is unclear how to determine the DST offset.
+ // ATTN: It is unclear how to determine the DST offset.
// Assume 1 hour.
tzMinutesEast = -tz.tz_minuteswest + 60;
# endif
// Create the representation object.
CIMDateTimeRep* rep = new CIMDateTimeRep;
- rep->usec =
+ rep->usec =
POSIX_1970_EPOCH_OFFSET + Uint64(sec) * Uint64(1000000) + Uint64(usec);
rep->sign = tzMinutesEast < 0 ? '-' : '+';
rep->utcOffset = tzMinutesEast < 0 ? -tzMinutesEast : tzMinutesEast;
TIME_ZONE_INFORMATION timezone;
::memset(&timezone, 0, sizeof(timezone));
- switch(::GetTimeZoneInformation(&timezone))
+ switch(::GetTimeZoneInformation(&timezone))
{
case TIME_ZONE_ID_UNKNOWN:
{
case TIME_ZONE_ID_STANDARD:
{
- currentTimeZone =
+ currentTimeZone =
static_cast<Sint16>(timezone.Bias + timezone.StandardBias);
break;
}
case TIME_ZONE_ID_DAYLIGHT:
{
- currentTimeZone =
+ currentTimeZone =
static_cast<Sint16>(timezone.Bias + timezone.DaylightBias);
break;
}
break;
}
- // the bias used to calculate the time zone is a factor that is used to
- // determine the UTC time from the local time. to get the UTC offset from
+ // the bias used to calculate the time zone is a factor that is used to
+ // determine the UTC time from the local time. to get the UTC offset from
// the local time, use the inverse.
- if(currentTimeZone != 0)
+ if (currentTimeZone != 0)
{
currentTimeZone *= -1;
}
Notes:
(1) The legacy implementation added the UTC offset when it was negative and
- substracted it when it was positive. I preserved this behavior but
+ substracted it when it was positive. I preserved this behavior but
suspect it may be wrong.
(2) Evenetually change getCurrentDateTime() to use constructor that takes
CIMDateTime d2 = "00000000000000.000000:000";
d1 = d2;
</PRE>
- Therefore, d1 is assigned the same "00000000000000.000000:000" value
+ Therefore, d1 is assigned the same "00000000000000.000000:000" value
as d2.
*/
CIMDateTime& operator=(const CIMDateTime& x);
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_CIMExceptionRep_h
Boolean CIMFlavor::hasFlavor (const CIMFlavor & flavor) const
{
- return ((this->cimFlavor & flavor.cimFlavor) == flavor.cimFlavor) ?
- true : false;
+ return (this->cimFlavor & flavor.cimFlavor) == flavor.cimFlavor;
}
Boolean CIMFlavor::equal (const CIMFlavor & flavor) const
{
- return (this->cimFlavor == flavor.cimFlavor) ? true : false;
+ return this->cimFlavor == flavor.cimFlavor;
}
CIMFlavor CIMFlavor::operator+ (const CIMFlavor & flavor) const
Boolean CIMInstance::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMInstance::identical(const CIMConstInstance& x) const
Boolean CIMConstInstance::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMConstInstance::identical(const CIMConstInstance& x) const
// Filter any qualifiers from this instance.
if (!includeQualifiers && _qualifiers.getCount() > 0)
{
- while( _qualifiers.getCount() )
+ while (_qualifiers.getCount())
{
_qualifiers.removeQualifier(0);
}
// remove qualifiers if required.
if (!includeQualifiers && _properties[i].getQualifierCount() > 0)
{
- while( _properties[i].getQualifierCount() > 0 )
+ while (_properties[i].getQualifierCount() > 0)
{
_properties[i].removeQualifier(0);
}
propertyList,
QueueIdStack());
- return(message);
+ return message;
}
//
instanceName,
QueueIdStack());
- return(message);
+ return message;
}
//
newInstance,
QueueIdStack());
- return(message);
+ return message;
}
//
propertyList,
QueueIdStack());
- return(message);
+ return message;
}
//
propertyList,
QueueIdStack());
- return(message);
+ return message;
}
//
CIMName(), // className
QueueIdStack());
- return(message);
+ return message;
}
//
query,
QueueIdStack());
- return(message);
+ return message;
}
//
propertyList,
QueueIdStack());
- return(message);
+ return message;
}
//
resultRole,
QueueIdStack());
- return(message);
+ return message;
}
//
propertyList,
QueueIdStack());
- return(message);
+ return message;
}
//
role,
QueueIdStack());
- return(message);
+ return message;
}
//
propertyName,
QueueIdStack());
- return(message);
+ return message;
}
//
newValue.getValue(),
QueueIdStack());
- return(message);
+ return message;
}
//
inParameters,
QueueIdStack());
- return(message);
+ return message;
}
query,
QueueIdStack());
- return(message);
+ return message;
}
//
query,
QueueIdStack());
- return(message);
+ return message;
}
//
classNames,
QueueIdStack());
- return(message);
+ return message;
}
authType,
userName);
- return(message);
+ return message;
}
//
provider,
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
authType,
userName);
- return(message);
+ return message;
}
//
authType,
userName);
- return(message);
+ return message;
}
//
String::EMPTY, // messageId
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
String::EMPTY, // messageId
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
subscriptionInitComplete,
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
currentValueModified,
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
String::EMPTY, // messageId
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
cimInstance);
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
instanceName);
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
cimNamedInstances);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
instanceNames);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
cimObjects);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
cimObjects);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
objectNames);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
cimObjects);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
objectNames);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
value.getValue());
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
outParameters,
methodName);
- return(message);
+ return message;
}
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
operationalStatus);
- return(message);
+ return message;
}
//
QueueIdStack(), // queueIds
operationalStatus);
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
//
CIMException(), // cimException
QueueIdStack()); // queueIds
- return(message);
+ return message;
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_CIMMessageDeserializer_h
// Note: OperationContext class does not allow iteration through Containers
- if(operationContext.contains(IdentityContainer::NAME))
+ if (operationContext.contains(IdentityContainer::NAME))
{
const IdentityContainer container =
operationContext.get(IdentityContainer::NAME);
XmlWriter::append(out, "</PGOCID>\n");
}
- if(operationContext.contains(SubscriptionInstanceContainer::NAME))
+ if (operationContext.contains(SubscriptionInstanceContainer::NAME))
{
const SubscriptionInstanceContainer container =
operationContext.get(SubscriptionInstanceContainer::NAME);
XmlWriter::append(out, "</PGOCSI>\n");
}
- if(operationContext.contains(SubscriptionFilterConditionContainer::NAME))
+ if (operationContext.contains(SubscriptionFilterConditionContainer::NAME))
{
const SubscriptionFilterConditionContainer container =
operationContext.get(SubscriptionFilterConditionContainer::NAME);
XmlWriter::append(out, "</PGOCSFC>\n");
}
- if(operationContext.contains(SubscriptionFilterQueryContainer::NAME))
+ if (operationContext.contains(SubscriptionFilterQueryContainer::NAME))
{
const SubscriptionFilterQueryContainer container =
operationContext.get(SubscriptionFilterQueryContainer::NAME);
XmlWriter::append(out, "</PGOCSFQ>\n");
}
- if(operationContext.contains(SubscriptionInstanceNamesContainer::NAME))
+ if (operationContext.contains(SubscriptionInstanceNamesContainer::NAME))
{
const SubscriptionInstanceNamesContainer container =
operationContext.get(SubscriptionInstanceNamesContainer::NAME);
XmlWriter::append(out, "</PGOCSIN>\n");
}
- if(operationContext.contains(TimeoutContainer::NAME))
+ if (operationContext.contains(TimeoutContainer::NAME))
{
const TimeoutContainer container =
operationContext.get(TimeoutContainer::NAME);
XmlWriter::append(out, "</PGOCTO>\n");
}
- if(operationContext.contains(AcceptLanguageListContainer::NAME))
+ if (operationContext.contains(AcceptLanguageListContainer::NAME))
{
const AcceptLanguageListContainer container =
operationContext.get(AcceptLanguageListContainer::NAME);
XmlWriter::append(out, "</PGOCALL>\n");
}
- if(operationContext.contains(ContentLanguageListContainer::NAME))
+ if (operationContext.contains(ContentLanguageListContainer::NAME))
{
const ContentLanguageListContainer container =
operationContext.get(ContentLanguageListContainer::NAME);
XmlWriter::append(out, "</PGOCCLL>\n");
}
- if(operationContext.contains(SnmpTrapOidContainer::NAME))
+ if (operationContext.contains(SnmpTrapOidContainer::NAME))
{
const SnmpTrapOidContainer container =
operationContext.get(SnmpTrapOidContainer::NAME);
XmlWriter::append(out, "</PGOCSTO>\n");
}
- if(operationContext.contains(LocaleContainer::NAME))
+ if (operationContext.contains(LocaleContainer::NAME))
{
const LocaleContainer container =
operationContext.get(LocaleContainer::NAME);
XmlWriter::append(out, "</PGOCL>\n");
}
- if(operationContext.contains(ProviderIdContainer::NAME))
+ if (operationContext.contains(ProviderIdContainer::NAME))
{
const ProviderIdContainer container =
operationContext.get(ProviderIdContainer::NAME);
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_CIMMessageSerializer_h
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMMethod.h"
Boolean CIMMethod::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMMethod::identical(const CIMConstMethod& x) const
Boolean CIMConstMethod::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMConstMethod::identical(const CIMConstMethod& x) const
<pre>
// remove all qualifiers from a class
Uint32 count = 0;
- while((count = cimClass.getQualifierCount()) > 0)
+ while ((count = cimClass.getQualifierCount()) > 0)
cimClass.removeQualifier(count - 1);
</pre>
@param index The index of the qualifier to remove.
#include "CIMScope.h"
#include "XmlWriter.h"
#include "MofWriter.h"
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include "StrLit.h"
PEGASUS_NAMESPACE_BEGIN
_classOrigin(classOrigin), _propagated(propagated)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
void CIMMethodRep::setName(const CIMName& name)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
//
//==============================================================================
//
-// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#define Pegasus_CIMNameInline_cxx
PEGASUS_CIMNAME_INLINE Boolean CIMName::isNull() const
{
- return (cimName.size() == 0);
+ return cimName.size() == 0;
}
PEGASUS_CIMNAME_INLINE void CIMName::clear()
PEGASUS_CIMNAME_INLINE Boolean CIMNamespaceName::isNull() const
{
- return (cimNamespaceName.size() == 0);
+ return cimNamespaceName.size() == 0;
}
PEGASUS_CIMNAME_INLINE void CIMNamespaceName::clear()
return _rep->getPath();
}
-void CIMObject::setPath (const CIMObjectPath & path)
+void CIMObject::setPath(const CIMObjectPath & path)
{
- _checkRep ();
- _rep->setPath (path);
+ _checkRep();
+ _rep->setPath(path);
}
CIMObject& CIMObject::addQualifier(const CIMQualifier& qualifier)
Boolean CIMObject::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
-String CIMObject::toString () const
+String CIMObject::toString() const
{
Buffer out;
-
+
_checkRep();
_rep->toXml(out);
out.append('\0');
return out.getData();
}
-Boolean CIMObject::isClass () const
+Boolean CIMObject::isClass() const
{
try
{
- const CIMClass c (*this);
+ const CIMClass c(*this);
return true;
}
catch (DynamicCastFailedException&)
}
}
-Boolean CIMObject::isInstance () const
+Boolean CIMObject::isInstance() const
{
try
{
- const CIMInstance i (*this);
+ const CIMInstance i(*this);
return true;
}
catch (DynamicCastFailedException&)
Boolean CIMConstObject::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
-String CIMConstObject::toString () const
+String CIMConstObject::toString() const
{
Buffer out;
-
+
_checkRep();
_rep->toXml(out);
out.append('\0');
catch (Exception&)
{
// If CIMObjectPath parsing fails, just compare strings
- return (String::equal(x.getValue(), y.getValue()));
+ return String::equal(x.getValue(), y.getValue());
}
break;
case CIMKeyBinding::BOOLEAN:
// Case-insensitive comparison is sufficient for booleans
- return (String::equalNoCase(x.getValue(), y.getValue()));
+ return String::equalNoCase(x.getValue(), y.getValue());
break;
case CIMKeyBinding::NUMERIC:
// Note: This comparison assumes XML syntax for integers
}
// Note: Keys may not be real values, so don't try comparing as reals
// We couldn't parse the numbers, so just compare the strings
- return (String::equal(x.getValue(), y.getValue()));
+ return String::equal(x.getValue(), y.getValue());
break;
default: // CIMKeyBinding::STRING
- return (String::equal(x.getValue(), y.getValue()));
+ return String::equal(x.getValue(), y.getValue());
break;
}
// If a non-digit is encountered, set "all-numeric"
// flag to false
if (isalpha(hostname[i]) || (hostname[i] == '-') ||
- (hostname[i] == '_')) {
+ (hostname[i] == '_'))
+ {
hostSegmentIsNumeric = false;
}
i++;
}
// If the last Host Segment is all numeric, then return false.
// RFC 1123 says "highest-level component label will be alphabetic".
- if (hostSegmentIsNumeric) {
+ if (hostSegmentIsNumeric)
+ {
return false;
}
}
: _resolved(false)
{
// ensure the class name is not null
- if(reference.getClassName().isNull())
+ if (reference.getClassName().isNull())
{
throw UninitializedObjectException();
}
{
if (name.equal(_properties[i].getName()))
{
- return(i);
+ return i;
}
}
- return(PEG_NOT_FOUND);
+ return PEG_NOT_FOUND;
}
CIMProperty CIMObjectRep::getProperty(Uint32 index)
throw IndexOutOfBoundsException();
}
- return(_properties[index]);
+ return _properties[index];
}
void CIMObjectRep::removeProperty(Uint32 index)
Uint32 CIMObjectRep::getPropertyCount() const
{
- return(_properties.size());
+ return _properties.size();
}
{
if (!_reference.identical(x->_reference))
{
- return(false);
+ return false;
}
if (!_qualifiers.identical(x->_qualifiers))
{
- return(false);
+ return false;
}
// Compare properties:
if (tmp1.size() != tmp2.size())
{
- return(false);
+ return false;
}
for (Uint32 i = 0, n = tmp1.size(); i < n; i++)
{
if (!tmp1[i].identical(tmp2[i]))
{
- return(false);
+ return false;
}
}
}
if (_resolved != x->_resolved)
{
- return(false);
+ return false;
}
- return(true);
+ return true;
}
void CIMObjectRep::setPath(const CIMObjectPath& path)
{
// ensure the class name is not null
- if(path.getClassName().isNull())
+ if (path.getClassName().isNull())
{
throw UninitializedObjectException();
}
// prevent changing the class name (type) in when updating the object path
- if(!_reference.getClassName().equal(path.getClassName()))
+ if (!_reference.getClassName().equal(path.getClassName()))
{
throw TypeMismatchException();
}
Boolean CIMParamValue::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
CIMParamValue CIMParamValue::clone() const
: _parameterName(parameterName), _value(value), _isTyped(isTyped)
{
// ensure parameterName is not null
- if(parameterName.size() == 0)
+ if (parameterName.size() == 0)
{
throw UninitializedObjectException();
}
void CIMParamValueRep::setParameterName(String& parameterName)
{
// ensure parameterName is not null
- if(parameterName.size() == 0)
+ if (parameterName.size() == 0)
{
throw UninitializedObjectException();
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMParameter.h"
Boolean CIMParameter::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMParameter::identical(const CIMConstParameter& x) const
Boolean CIMConstParameter::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMConstParameter::identical(const CIMConstParameter& x) const
_referenceClassName(referenceClassName)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
- if((_arraySize != 0) && !_isArray)
+ if ((_arraySize != 0) && !_isArray)
{
throw TypeMismatchException();
}
void CIMParameterRep::setName(const CIMName& name)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMPropertyRep.h"
_checkRep();
_rep->removeQualifier(index);
}
-
+
Uint32 CIMProperty::getQualifierCount() const
{
_checkRep();
Boolean CIMProperty::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMProperty::identical(const CIMConstProperty& x) const
Boolean CIMConstProperty::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMConstProperty::identical(const CIMConstProperty& x) const
// which has a add() method that would validate one at a time.
// ensure names are not null
- for(Uint32 i = 0, n = propertyNames.size(); i < n; i++)
+ for (Uint32 i = 0, n = propertyNames.size(); i < n; i++)
{
- if(propertyNames[i].isNull())
+ if (propertyNames[i].isNull())
{
throw UninitializedObjectException();
}
// which has a add() method that would validate one at a time.
// ensure names are not null
- for(Uint32 i = 0, n = propertyNames.size(); i < n; i++)
+ for (Uint32 i = 0, n = propertyNames.size(); i < n; i++)
{
- if(propertyNames[i].isNull())
+ if (propertyNames[i].isNull())
{
throw UninitializedObjectException();
}
_propagated(propagated)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
void CIMPropertyRep::setName(const CIMName& name)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
CIMName inheritedClassName;
Array<CIMName> classNames;
- if(isEmbeddedInst)
+ if (isEmbeddedInst)
{
Uint32 pos = inheritedProperty.findQualifier("EmbeddedInstance");
- if(pos != PEG_NOT_FOUND)
+ if (pos != PEG_NOT_FOUND)
{
String qualStr;
inheritedProperty.getQualifier(pos).getValue().get(qualStr);
inheritedClassName = qualStr;
}
- if(_value.isArray())
+ if (_value.isArray())
{
Array<CIMInstance> embeddedInstances;
_value.get(embeddedInstances);
- for(Uint32 i = 0, n = embeddedInstances.size(); i < n; ++i)
+ for (Uint32 i = 0, n = embeddedInstances.size(); i < n; ++i)
{
classNames.append(embeddedInstances[i].getClassName());
}
// very closely related types.
Array<CIMName> successTree;
successTree.append(inheritedClassName);
- for(Uint32 i = 0, n = classNames.size(); i < n; ++i)
+ for (Uint32 i = 0, n = classNames.size(); i < n; ++i)
{
Array<CIMName> traversalHistory;
CIMName currentName = classNames[i];
Boolean found = false;
- while(!found && !currentName.isNull())
+ while (!found && !currentName.isNull())
{
- for(Uint32 j = 0, m = successTree.size(); j < m; ++j)
+ for (Uint32 j = 0, m = successTree.size(); j < m; ++j)
{
- if(currentName == successTree[j])
+ if (currentName == successTree[j])
{
found = true;
break;
}
}
- if(!found)
+ if (!found)
{
traversalHistory.append(currentName);
CIMClass currentClass = declContext->lookupClass(
nameSpace, currentName);
- if(currentClass.isUninitialized())
+ if (currentClass.isUninitialized())
{
throw PEGASUS_CIM_EXCEPTION(
CIM_ERR_NOT_FOUND, currentName.getString());
}
}
- if(!found)
+ if (!found)
{
throw TypeMismatchException();
}
#endif
}
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- else if(_value.getType() == CIMTYPE_INSTANCE)
+ else if (_value.getType() == CIMTYPE_INSTANCE)
{
// If the property array type is CIMInstance, then
// encode the property in CIM-XML as a string array with the
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMQualifier.h"
Boolean CIMQualifier::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMQualifier::identical(const CIMConstQualifier& x) const
Boolean CIMConstQualifier::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMConstQualifier::identical(const CIMConstQualifier& x) const
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMQualifierDecl.h"
Boolean CIMQualifierDecl::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMQualifierDecl::identical(const CIMConstQualifierDecl& x) const
Boolean CIMConstQualifierDecl::isUninitialized() const
{
- return (_rep == 0)? true : false;
+ return _rep == 0;
}
Boolean CIMConstQualifierDecl::identical(const CIMConstQualifierDecl& x) const
@exception UninitializedObjectException If the qualifier name is null.
*/
CIMQualifierDecl(
- const CIMName& name,
- const CIMValue& value,
+ const CIMName& name,
+ const CIMValue& value,
const CIMScope & scope,
const CIMFlavor & flavor = CIMFlavor (CIMFlavor::DEFAULTS),
Uint32 arraySize = 0);
@return True if the object has not been initialized, false otherwise.
*/
Boolean isUninitialized() const;
-
+
/**
Compares the qualifier declaration with another qualifier declaration.
@param x The CIMConstQualifierDecl to be compared.
@exception UninitializedObjectException If the qualifier name is null.
*/
CIMConstQualifierDecl(
- const CIMName& name,
- const CIMValue& value,
+ const CIMName& name,
+ const CIMValue& value,
const CIMScope & scope,
const CIMFlavor & flavor = CIMFlavor (CIMFlavor::DEFAULTS),
Uint32 arraySize = 0);
_arraySize(arraySize)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
// favors restricted and disable override
//ATTN: This should become an exception in case conflicting entities are
// set.
- if(!(_flavor.hasFlavor (CIMFlavor::RESTRICTED)))
+ if (!(_flavor.hasFlavor (CIMFlavor::RESTRICTED)))
_flavor.addFlavor (CIMFlavor::TOSUBCLASS);
else
_flavor.removeFlavor (CIMFlavor::TOSUBCLASS);
- if(!(_flavor.hasFlavor (CIMFlavor::DISABLEOVERRIDE)))
+ if (!(_flavor.hasFlavor (CIMFlavor::DISABLEOVERRIDE)))
_flavor.addFlavor (CIMFlavor::ENABLEOVERRIDE);
else
_flavor.removeFlavor (CIMFlavor::ENABLEOVERRIDE);
void CIMQualifierDeclRep::setName(const CIMName& name)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
#include "XmlWriter.h"
#include "MofWriter.h"
#include <Pegasus/Common/Tracer.h>
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include "StrLit.h"
#include "ArrayIterator.h"
if (qualifier.isUninitialized())
throw UninitializedObjectException();
- if (find(qualifier.getName()) != PEG_NOT_FOUND){
+ if (find(qualifier.getName()) != PEG_NOT_FOUND)
+ {
MessageLoaderParms parms("Common.CIMQualifierList.QUALIFIER",
"qualifier \"$0\"",
qualifier.getName().getString());
// 3. If the qualifier is the EmbeddedInstance qualifier, then check
// that the class specified by the qualifier exists in the namespace.
//----------------------------------------------------------------------
- if(q.getName().equal(CIMName("EmbeddedInstance")))
+ if (q.getName().equal(CIMName("EmbeddedInstance")))
{
String className;
q.getValue().get(className);
CIMClass classDef = declContext->lookupClass(nameSpace,
CIMName(className));
- if(classDef.isUninitialized())
+ if (classDef.isUninitialized())
{
String embeddedInstType("EmbeddedInstance(\"");
embeddedInstType = embeddedInstType + className + "\")";
// keep current value. Note we have already eliminated any possibity
// that a nonoverridable qualifier can be in the list.
// Note that there is no exists() function ATTN:KS 25 Mar 2002
- if(find(iq.getName()) != PEG_NOT_FOUND)
+ if (find(iq.getName()) != PEG_NOT_FOUND)
continue;
CIMQualifier q = iq.clone();
Boolean exists(const CIMName& name) const
{
- return (((find(name)) == PEG_NOT_FOUND)? false : true);
+ return (find(name) != PEG_NOT_FOUND);
}
/** isTrue - Determines if the qualifier defined by
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMQualifierNames.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_QualifierNames_h
_propagated(propagated)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
void CIMQualifierRep::setName(const CIMName& name)
{
// ensure name is not null
- if(name.isNull())
+ if (name.isNull())
{
throw UninitializedObjectException();
}
{
Boolean b;
_value.get(b);
- if(!b)
+ if (!b)
out << STRLIT(" (false)");
}
else
//
//==============================================================================
//
-// Author: Tony Fiorentino (fiorentino_tony@emc.com)
-//
-// Modified By: Keith Petley (keithp@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMServerDescription.h"
//
//==============================================================================
//
-// Author: Tony Fiorentino (fiorentino_tony@emc.com)
-//
-// Modified By: Keith Petley (keithp@veritas.com)
-// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug 3123
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_CIMServerDescription_h
@return String that contains an attribute value.
*/
String getValue(
- const String& attributeName,
+ const String& attributeName,
const String& defaultValue) const;
/** Returns an attribute value Array
return MessageLoader::getMessage(parms);
}
-// l10n
ContentLanguageList cimStatusCodeToString_Thread(
String & message,
CIMStatusCode code)
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Dave Sudlik, IBM (dsudlik@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "CIMType.h"
static const Uint32 _NUM_TYPES = sizeof(_typeStrings) / sizeof(_typeStrings[0]);
-const char * cimTypeToString (
- const CIMType type)
+const char* cimTypeToString(const CIMType type)
{
- return _typeStrings [Uint32 (type)];
+ return _typeStrings[Uint32 (type)];
}
PEGASUS_NAMESPACE_END
#endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
};
-/**
+/**
Gets a string representation of a CIMType.
- Note: the current implementation returns a string matching the first
- column in the table above, but that is subject to change in later
+ Note: the current implementation returns a string matching the first
+ column in the table above, but that is subject to change in later
revisions.
@param type The CIMType to convert to string form.
@return The string form of the specified CIMType.
//
//==============================================================================
//
-// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#define Pegasus_ValueInline_cxx
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <cstdio>
//
//==============================================================================
//
-// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <cctype>
# error "EBCDIC unsupported"
#endif
-const Uint8 CharSet::_isAlphaUnder[256] =
+const Uint8 CharSet::_isAlphaUnder[256] =
{
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
-const Uint8 CharSet::_isAlNumUnder[256] =
+const Uint8 CharSet::_isAlNumUnder[256] =
{
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
-const Uint8 CharSet::_isSpace[256] =
+const Uint8 CharSet::_isSpace[256] =
{
0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
-const Uint8 CharSet::_isXmlWhiteSpace[256] =
+const Uint8 CharSet::_isXmlWhiteSpace[256] =
{
0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
-const Uint8 CharSet::_toUpper[256] =
+const Uint8 CharSet::_toUpper[256] =
{
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
};
-const Uint8 CharSet::_toLower[256] =
+const Uint8 CharSet::_toLower[256] =
{
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
}
} // loop
- return(0);
+ return 0;
}
message_module *temp = _modules.front();
while (temp != 0)
{
- if(temp->_q_id == msg->queue )
+ if (temp->_q_id == msg->queue )
{
temp->_capabilities = msg->capabilities;
temp->_mask = msg->mask;
}
}
- return (isValid_U8((const Uint8 *)legal, numBytes));
+ return isValid_U8((const Uint8 *)legal, numBytes);
}
Boolean isUTF8Str(const char *legal)
size_t count = 0;
const size_t size = strlen(legal);
// printf("size = %d\n",size);
- while(count<size)
+ while (count<size)
{
// printf("count = %d\n",count);
- if(isUTF8(&legal[count]) == true){
+ if (isUTF8(&legal[count]) == true)
+ {
UTF8_NEXT(legal,count);
- }else{
+ }
+ else
+ {
// printf("bad string\n");
return false;
}
printf("legal = %s\n\n", legal);
Uint32 count = 0;
Uint32 trailingBytes = 0;
- Uint32 size = strlen(legal);
+ Uint32 size = strlen(legal);
printf("size of legal is %d\n",size);
- while(count<size-1)
- {
+ while (count<size-1)
+ {
printf("count = %d\n", count);
- if(isUTF8((char*)&legal[count]) == true){
- UTF8_NEXT(legal,trailingBytes);
+ if (isUTF8((char*)&legal[count]) == true)
+ {
+ UTF8_NEXT(legal,trailingBytes);
count += trailingBytes;
- } else{
- printf("CommonUTF8:: returning false; position[%d]",count);
- return false;
}
+ else
+ {
+ printf("CommonUTF8:: returning false; position[%d]",count);
+ return false;
}
- printf("CommonUTF8:: returning false; position[%d]",count);
+ }
+ printf("CommonUTF8:: returning false; position[%d]",count);
return true;*/
}
Uint16 escChar;
char hexencoding[6];
- for(Uint32 i = 0; i < Str.size(); ++i)
+ for (Uint32 i = 0; i < Str.size(); ++i)
{
- escChar = Str[i];
- if(escChar <= 0x7F)
+ escChar = Str[i];
+ if (escChar <= 0x7F)
{
- escapeStr.append(escChar);
+ escapeStr.append(escChar);
}
- else
- {
- memset(hexencoding,0x00,sizeof(hexencoding));
+ else
+ {
+ memset(hexencoding,0x00,sizeof(hexencoding));
sprintf(hexencoding, "%%%03X%X", escChar/16, escChar%16);
escapeStr.append(hexencoding);
+ }
}
- }
- return(escapeStr);
+ return escapeStr;
}
String escapeStringDecoder(const String& Str)
//
//==============================================================================
//
-//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Condition.h"
ConditionWaiter* _get_waiter()
{
- // ATTN: since Windows Thread Local Storage does not have a cleanup
- // routine mechanism, the ConditionWaiter object (and its event) will
+ // ATTN: since Windows Thread Local Storage does not have a cleanup
+ // routine mechanism, the ConditionWaiter object (and its event) will
// be leaked when the thread exists.
static DWORD _waiter_tls = TlsAlloc();
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Condition_h
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Config.h"
# include <Pegasus/Common/Platform_LINUX_ZSERIES64_GNU.h>
#elif defined (__OS400__)
# if !defined (PEGASUS_PLATFORM_OS400_ISERIES_IBM)
-# define PEGASUS_PLATFORM_OS400_ISERIES_IBM
+# define PEGASUS_PLATFORM_OS400_ISERIES_IBM
# endif
# include <Pegasus/Common/Platform_OS400_ISERIES_IBM.h>
#elif defined (PEGASUS_PLATFORM_DARWIN_PPC_GNU)
// To test for GCC > 3.2.0:
// #if GCC_VERSION > 30200
-#endif
+#endif
#ifdef __cplusplus
** class PEGASUS_COMMON_LINKAGE MyClass
** {
** public:
-**
+**
** // Is exported (due to PEGASUS_COMMON_LINKAGE macro).
** void f();
**
#endif
#ifdef PEGASUS_HAVE_IOS_BINARY
-#if defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM)
+#if defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM)
#define PEGASUS_IOS_BINARY ,std::ios::binary,PEGASUS_STD(_CCSID_T(1208))
#else
#define PEGASUS_IOS_BINARY ,std::ios::binary
//
//==============================================================================
//
-// Author: Humberto Rivero (hurivero@us.ibm.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/ContentLanguageList.h>
#include "DeclContext.h"
#include "CIMName.h"
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
PEGASUS_NAMESPACE_BEGIN
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Rudy chuet (rudy.schuet@compaq.com) 11/12/01
-// added nsk platform support
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Dir.h"
cout << "name: " << dir.getName() << endl;
}
}
- catch(CannotOpenDirectory&)
+ catch (CannotOpenDirectory&)
{
// Error!
}
PEGASUS_NAMESPACE_BEGIN
-// the HPUX dynamic library load and unload routines do not keep a reference
-// count. this implies that if a library were loaded multiple times, a single
+// the HPUX dynamic library load and unload routines do not keep a reference
+// count. this implies that if a library were loaded multiple times, a single
// unload will release the library from the process thereby potentially leaving
-// dangling references behind. this is a tenative implementation that
+// dangling references behind. this is a tenative implementation that
// encapsulates this behavior from users of the DynamicLibrary object. the goal
-// release the library only after an equal number of loads and unloads have
+// release the library only after an equal number of loads and unloads have
// occured.
static Array<Pair<DynamicLibrary::DynamicLibraryHandle, int> > _references;
{
Uint32 n = --_references[i].second;
- if(n == 0)
+ if (n == 0)
{
_references.remove(i);
}
}
PEG_METHOD_EXIT();
- return(isLoaded());
+ return isLoaded();
}
void DynamicLibrary::_unload()
#endif
}
- return(isLoaded());
+ return isLoaded();
}
void DynamicLibrary::_unload()
{
#ifdef PEGASUS_OS_OS400
- OS400_UnloadDynamicLibrary(_handle);
+ OS400_UnloadDynamicLibrary(_handle);
#else
dlclose(_handle);
#endif
Boolean DynamicLibrary::_load()
{
_handle = LoadLibrary(_fileName.getCString());
- return(isLoaded());
+ return isLoaded();
}
void DynamicLibrary::_unload()
}
// l10n - note use this when you have an exception with a translated
// detail message
-// l10n
CIMException::CIMException(
CIMStatusCode code,
const MessageLoaderParms& msgParms)
try
{ .. Execute CIM Operation
}
- catch(CIMExcepton e)
+ catch (CIMExcepton e)
{
if (e.getCode() == CIM_ERR_ACCESS_DENIED )
....
try
{ .. Execute CIM Operation
}
- catch(CIMExcepton e)
+ catch (CIMExcepton e)
{
if (e.getErrorCount() > 0 )
{
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ExceptionRep_h
public:
String message;
String cimMessage; // Contains the message for the CIM error code
- ContentLanguageList contentLanguages;
+ ContentLanguageList contentLanguages;
// Allow subclass objects to be destructed properly
virtual ~ExceptionRep() {}
}
Boolean FileSystem::openNoCase(
- PEGASUS_STD(fstream)& fs,
+ PEGASUS_STD(fstream)& fs,
const String& path,
int mode)
{
// for files-in-directory, delete or recall removedir
for (Uint32 i = 0, n = fileList.size(); i < n; i++)
- {
+ {
String newPath = path; // extend path to subdir
newPath.append("/");
newPath.append(fileList[i]);
-
+
if (FileSystem::isDirectory(newPath))
{
// Recall ourselves with extended path
if (!FileSystem::removeDirectoryHier(newPath))
- return false;
+ return false;
}
else
}
}
- return removeDirectory(path);
+ return removeDirectory(path);
}
//
paths.clear();
try
- {
+ {
for (Dir dir(path); dir.more(); dir.next())
{
String name = dir.getName();
}
// Catch the Dir exception
- catch(CannotOpenDirectory&)
+ catch (CannotOpenDirectory&)
{
return false;
}
AutoArrayPtr<char> p_path(new char[path.size() + 1]);
String basename = System::extract_file_name(
(const char*)path.getCString(), p_path.get());
-
+
return basename;
}
AutoArrayPtr<char> p_path(new char[path.size() + 1]);
String newpath = System::extract_file_path(
(const char*)path.getCString(), p_path.get());
-
+
return newpath;
}
Boolean FileSystem::changeFilePermissions(const String& path, mode_t mode)
{
#if defined(PEGASUS_OS_OS400)
- // ATTN: If getCString() is modified to return UTF8, then handle the
+ // ATTN: If getCString() is modified to return UTF8, then handle the
// EBCDIC coversion in SystemUnix.cpp
CString tempPath = path.getCString();
#else
struct passwd *result;
char pwdBuffer[PWD_BUFF_SIZE];
- if(getpwnam_r(userName.getCString(), &pwd, pwdBuffer, PWD_BUFF_SIZE,
+ if (getpwnam_r(userName.getCString(), &pwd, pwdBuffer, PWD_BUFF_SIZE,
&userPasswd) != 0)
{
userPasswd = (struct passwd*)NULL;
@return true on success.
*/
static Boolean openNoCase(
- PEGASUS_STD(fstream)& fs,
- const String& path,
+ PEGASUS_STD(fstream)& fs,
+ const String& path,
int mode);
/** Determines whether the path refers to a directory.
/**
Return OS path specific delimiter.
-
+
@return delimiter specific to the platform
*/
static String getPathDelimiter();
/**
Returns the absolute pathname for the specified filename.
-
+
@param paths directories seperated by an OS specific delimiter to search
@param filename filename to search for in the paths
static String getAbsoluteFileName(
const String& paths,
const String& filename);
-
+
/**
Convert a library name to its corresponding file name by adding the
appropriate prefix and suffix.
return !!os;
}
-inline String FileSystem::getPathDelimiter()
+inline String FileSystem::getPathDelimiter()
{
#if defined(PEGASUS_OS_TYPE_WINDOWS)
return String(";");
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <iostream>
strings that contain variable defintions. The
variable definitions in the strings are of the form
$<int>
-
+
where <int> is a single digit integer (0 - 9).
-
+
The variable subsituted may be String, Boolean Integer, Unsigned Integer
- or real.
-
+ or real.
+
The format subsitution may be escaped by preceding the
$ with a \
-
+
usage:
Formatter::format (FormatString, variable0,.., variable9)
-
+
Example:
<pre>
int total = 4;
int count = 2;
String name = "Output"
String output = Formatter::format(
- "total $0 average $1 on $2",
+ "total $0 average $1 on $2",
total,
total/count,
name);
produces the string
"total 4 average 2 on Output"
-
+
</pre>
*/
class PEGASUS_COMMON_LINKAGE Formatter
{
public:
- enum Type { VOIDT, STRING, CSTRLIT, BOOLEAN, INTEGER,
+ enum Type { VOIDT, STRING, CSTRLIT, BOOLEAN, INTEGER,
UINTEGER, LINTEGER, ULINTEGER, REAL };
Arg() : _type(VOIDT)
#include "HTTPAcceptor.h"
#include "HTTPConnection.h"
#include "Tracer.h"
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
#include "EBCDIC_OS400.h"
{
public:
typedef MessageQueue Base;
-
+
/** Constructor.
@param monitor pointer to monitor object which this class uses to
solicit SocketMessages on the server port (socket).
/** This method is called whenever a SocketMessage is enqueued
on the input queue of the HTTPAcceptor object.
- */
+ */
virtual void handleEnqueue(Message *);
-
+
virtual void handleEnqueue();
/** Bind the specified listen socket.
_socket->getPeerCertificateChain());
}
#else
- if(_socket->isClientAuthenticated())
+ if (_socket->isClientAuthenticated())
{
_authInfo->setAuthStatus(AuthenticationInfoRep::AUTHENTICATED);
_authInfo->setAuthenticatedUser(_socket->getAuthenticatedUser());
{
PEG_METHOD_ENTER(TRC_HTTP, "HTTPConnection::handleEnqueue");
- if( ! message )
+ if (! message)
{
PEG_METHOD_EXIT();
return;
if (_isClient() == false)
{
// Check for message to close
- if(message.getCloseConnect()== true)
+ if (message.getCloseConnect()== true)
{
Tracer::trace(
TRC_HTTP,
data = (char *)_incomingBuffer.getData();
data[capacity-1] = 0;
}
- catch(const PEGASUS_STD(bad_alloc)&)
+ catch (const PEGASUS_STD(bad_alloc)&)
{
_throwEventFailure(HTTP_STATUS_REQUEST_TOO_LARGE,
"Error reserving space for non-chunked message");
}
- catch(...)
+ catch (...)
{
_throwEventFailure(
httpStatusInternal, "unexpected exception");
// remove whitespace after colon before value
char *valueStart = colon + 1;
- while(*valueStart == ' ' || *valueStart == '\t')
+ while (*valueStart == ' ' || *valueStart == '\t')
valueStart++;
// we found some non-whitespace token
// now remove whitespace from end of line back to last byte
// of value
- while(*valueEnd == ' ' || *valueEnd == '\t')
+ while (*valueEnd == ' ' || *valueEnd == '\t')
valueEnd--;
char valueSave = *(valueEnd+1);
gotContentLanguage = true;
}
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_HTTP, Tracer::LEVEL2,
"HTTPConnection: ERROR: contentLanguages had "
while (*valuesStart)
{
// strip off whitepsace from the front
- while(*valuesStart == ' ' || *valuesStart == '\t')
+ while (*valuesStart == ' ' || *valuesStart == '\t')
valuesStart++;
if (valuesStart == valueEnd)
}
v--;
// strip off whitespace from the end
- while(*v == ' ' || *v == '\t')
+ while (*v == ' ' || *v == '\t')
v--;
v++;
*v = 0;
LanguageParser::parseContentLanguageHeader(
contentLanguagesString);
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_HTTP, Tracer::LEVEL2,
"HTTPConnection: ERROR: contentLanguages had "
_socket->getPeerCertificateChain());
}
#else
- if(_socket->isClientAuthenticated())
+ if (_socket->isClientAuthenticated())
{
_authInfo->setAuthStatus(
AuthenticationInfoRep::AUTHENTICATED);
char *data = (char *)_incomingBuffer.getData();
data[size] = 0;
}
- catch(...)
+ catch (...)
{
static const char detailP[] =
"Unable to append the request to the input buffer";
_getContentLengthAndContentOffset();
_handleReadEventTransferEncoding();
}
- catch(Exception &e)
+ catch (Exception& e)
{
httpStatus = e.getMessage();
}
Uint32 HTTPConnection::getRequestCount()
{
- return(_requestCount.get());
+ return _requestCount.get();
}
Boolean HTTPConnection::run(Uint32 milliseconds)
if (events)
{
events = 0;
- if( FD_ISSET(getSocket(), &fdread))
+ if (FD_ISSET(getSocket(), &fdread))
{
events |= SocketMessage::READ;
Message *msg = new SocketMessage(getSocket(), events);
{
handleEnqueue(msg);
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
"HTTPConnection::run handleEnqueue(msg) failure");
Boolean run(Uint32 milliseconds);
- MessageQueue & get_owner(void)
+ MessageQueue& get_owner()
{
return *_ownerMessageQueue;
}
#include <iostream>
#include "Constants.h"
#include "Socket.h"
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include "Socket.h"
#include "TLS.h"
#include "HTTPConnector.h"
class PEGASUS_COMMON_LINKAGE HTTPMessage : public Message
{
public:
-
+
typedef Message Base;
-
+
HTTPMessage(
const Buffer& message_,
Uint32 queueId_ = 0,
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_IPCExceptions_h
{
public:
IPCException(ThreadType owner): _owner(owner) { }
- inline ThreadType get_owner() { return(_owner); }
+ inline ThreadType get_owner() { return _owner; }
private:
ThreadType _owner;
};
DateFormat::MEDIUM, DateFormat::MEDIUM, locale);
}
}
- catch(Exception& e)
+ catch (Exception& e)
{
PEG_TRACE_STRING(TRC_IND_FORMATTER, Tracer::LEVEL4, e.getMessage());
PEG_METHOD_EXIT();
return dateTimeValue.toString();
}
- catch(...)
+ catch (...)
{
PEG_TRACE_STRING(TRC_IND_FORMATTER, Tracer::LEVEL4,
"Caught General Exception During DateFormat::createDateTimeInstance");
return tmp;
}
-// l10n
//
// Creates a description without source file name and line number.
//
return tmp;
}
-// l10n
//
// Creates a description without source file name and line number.
//
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
NullPointer();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
UndeclaredQualifier(const String& qualifierName) ;
{
public:
- static const char MSG[];
- static const char KEY[];
+ static const char MSG[];
+ static const char KEY[];
BadQualifierScope(
- const String& qualifierName,
+ const String& qualifierName,
const String& scopeString);
virtual ~BadQualifierScope();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
BadQualifierOverride(const String& qualifierName);
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
BadQualifierType(const String& qualifierName);
virtual ~BadQualifierType();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
ClassAlreadyResolved(const String& className);
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
ClassNotResolved(const String& className);
virtual ~ClassNotResolved();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
InstanceAlreadyResolved();
virtual ~InstanceAlreadyResolved();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
InstantiatedAbstractClass(const String& className);
virtual ~InstantiatedAbstractClass();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
NoSuchProperty(const String& propertyName);
virtual ~NoSuchProperty();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
NoSuchFile(const String& fileName);
virtual ~NoSuchFile();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
FileNotReadable(const String& fileName);
virtual ~FileNotReadable();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
CannotRemoveDirectory(const String& path);
virtual ~CannotRemoveDirectory();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
CannotRemoveFile(const String& path);
virtual ~CannotRemoveFile();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
CannotRenameFile(const String& path);
virtual ~CannotRenameFile();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
NoSuchDirectory(const String& directoryName);
virtual ~NoSuchDirectory();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
CannotCreateDirectory(const String& path);
virtual ~CannotCreateDirectory();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
CannotOpenFile(const String& path);
virtual ~CannotOpenFile();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
NotImplemented(const String& method);
virtual ~NotImplemented();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
StackUnderflow();
virtual ~StackUnderflow();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
StackOverflow();
virtual ~StackOverflow();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
BadFormat();
virtual ~BadFormat();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
BadlyFormedCGIQueryString();
virtual ~BadlyFormedCGIQueryString();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
DynamicLoadFailed(const String& libraryName);
virtual ~DynamicLoadFailed();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
DynamicLookupFailed(const String& symbolName);
virtual ~DynamicLookupFailed();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
CannotOpenDirectory(const String& path);
virtual ~CannotOpenDirectory();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
ParseError(const String& message);
virtual ~ParseError();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
MissingNullTerminator();
virtual ~MissingNullTerminator();
};
-//l10n start
-
class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception
{
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
MalformedLanguageHeader(const String& error);
virtual ~MalformedLanguageHeader();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
InvalidAcceptLanguageHeader(const String& error);
virtual ~InvalidAcceptLanguageHeader();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
InvalidContentLanguageHeader(const String& error);
virtual ~InvalidContentLanguageHeader();
};
-//l10n end
-
class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception
{
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
InvalidAuthHeader();
virtual ~InvalidAuthHeader();
public:
static const char MSG[];
- static const char KEY[];
+ static const char KEY[];
UnauthorizedAccess();
virtual ~UnauthorizedAccess();
class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception
{
public:
- IncompatibleTypesException();
- virtual ~IncompatibleTypesException();
+ IncompatibleTypesException();
+ virtual ~IncompatibleTypesException();
};
class PEGASUS_COMMON_LINKAGE InternalSystemError : public Exception
#define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \
TraceableCIMException(CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
-// l10n
#define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \
TraceableCIMException( \
- LANGS, CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
-
-//l10n
+ LANGS, CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
+
#define PEGASUS_CIM_EXCEPTION_L(CODE, MSG_PARMS) \
TraceableCIMException(CODE, MSG_PARMS, String(__FILE__), __LINE__)
-/** Macro to prevent overflow of a signed int value when said value is
+/** Macro to prevent overflow of a signed int value when said value is
* doubled. If String/Array/Buffer size is greater than 0x3FFFFFFF, then
* something is suspect, throw bad_alloc exception.
*/
#include <Pegasus/Common/LanguageParser.h>
#include <Pegasus/Common/InternalException.h>
#include <Pegasus/Common/Tracer.h>
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include <cstring>
#ifdef PEGASUS_HAS_ICU
Real32 qualityValue;
LanguageParser::_parseAcceptLanguageElement(
languageElements[i], languageTagString, qualityValue);
- acceptLanguages.insert(LanguageTag(languageTagString), qualityValue);
+ acceptLanguages.insert(
+ LanguageTag(languageTagString), qualityValue);
}
}
catch (Exception& e)
//
//==============================================================================
//
-// Author: Humberto Rivero (hurivero@us.ibm.com)
-//
-// Modified By: Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3697, 3698, 3699, 3700
-// Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3701, 3702, 3703
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_LanguageParser_h
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/LanguageTag.h>
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef _Pegasus_Common_Linkable_h
{
}
- ~Linkable()
+ ~Linkable()
{
- PEGASUS_DEBUG_ASSERT(magic);
- memset(this, 0xDD, sizeof(Linkable));
+ PEGASUS_DEBUG_ASSERT(magic);
+ memset(this, 0xDD, sizeof(Linkable));
}
// ATTN: consider making private and fixing all places that have
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "List.h"
PEGASUS_NAMESPACE_BEGIN
-ListRep::ListRep(void (*destructor)(Linkable*)) :
- _front(0), _back(0), _size(0)
+ListRep::ListRep(void (*destructor)(Linkable*))
+ : _front(0), _back(0), _size(0)
{
if (destructor)
- _destructor = destructor;
+ _destructor = destructor;
else
- _destructor = 0;
+ _destructor = 0;
}
ListRep::~ListRep()
if (_destructor)
{
- // Reset _front, _back, and _size in case the destructor calls
- // a method of List.
-
- Linkable* front = _front;
- Linkable* back = _back;
- size_t size= _size;
-
- _front = 0;
- _back = 0;
- _size = 0;
-
- for (Linkable* p = front; p; )
- {
- PEGASUS_DEBUG_ASSERT(p->magic);
- Linkable* next = p->next;
- p->list = 0;
- _destructor(p);
- p = next;
- }
+ // Reset _front, _back, and _size in case the destructor calls
+ // a method of List.
+
+ Linkable* front = _front;
+ Linkable* back = _back;
+ size_t size= _size;
+
+ _front = 0;
+ _back = 0;
+ _size = 0;
+
+ for (Linkable* p = front; p; )
+ {
+ PEGASUS_DEBUG_ASSERT(p->magic);
+ Linkable* next = p->next;
+ p->list = 0;
+ _destructor(p);
+ p = next;
+ }
}
}
elem->prev = 0;
if (_front)
- _front->prev = elem;
+ _front->prev = elem;
else
- _back = elem;
+ _back = elem;
_front = elem;
_size++;
elem->next = 0;
if (_back)
- _back->next = elem;
+ _back->next = elem;
else
- _front = elem;
+ _front = elem;
_back = elem;
_size++;
}
void ListRep::insert_after(
- Linkable* pos,
+ Linkable* pos,
Linkable* elem)
{
PEGASUS_DEBUG_ASSERT(_magic);
elem->next = pos->next;
if (pos->next)
- pos->next->prev = elem;
+ pos->next->prev = elem;
pos->next = elem;
if (pos == _back)
- _back = elem;
+ _back = elem;
_size++;
}
void ListRep::insert_before(
- Linkable* pos,
+ Linkable* pos,
Linkable* elem)
{
PEGASUS_DEBUG_ASSERT(_magic);
elem->prev = pos->prev;
if (pos->prev)
- pos->prev->next = elem;
+ pos->prev->next = elem;
pos->prev = elem;
if (pos == _front)
- _front = elem;
+ _front = elem;
_size++;
}
PEGASUS_DEBUG_ASSERT(_size != 0);
if (_size == 0)
- return;
+ return;
if (pos->prev)
- pos->prev->next = pos->next;
+ pos->prev->next = pos->next;
if (pos->next)
- pos->next->prev = pos->prev;
+ pos->next->prev = pos->prev;
if (pos == _front)
- _front = pos->next;
+ _front = pos->next;
if (pos == _back)
- _back = pos->prev;
+ _back = pos->prev;
pos->list = 0;
for (const Linkable* p = _front; p; p = p->next)
{
- if (p == elem)
- return true;
+ if (p == elem)
+ return true;
}
// Not found!
PEGASUS_DEBUG_ASSERT(_magic);
if (_size == 0)
- return 0;
+ return 0;
Linkable* elem = _front;
remove(elem);
for (Linkable* p = _front; p; p = p->next)
{
- if ((*equal)(p, client_data))
- {
- PEGASUS_DEBUG_ASSERT(p->magic);
- return p;
- }
+ if ((*equal)(p, client_data))
+ {
+ PEGASUS_DEBUG_ASSERT(p->magic);
+ return p;
+ }
}
// Not found!
if (p)
{
- PEGASUS_DEBUG_ASSERT(p->magic);
- remove(p);
+ PEGASUS_DEBUG_ASSERT(p->magic);
+ remove(p);
}
return p;
PEGASUS_DEBUG_ASSERT(apply != 0);
for (Linkable* p = _front; p; p = p->next)
- (*apply)(p, client_data);
+ (*apply)(p, client_data);
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef _Pegasus_Common_List_h
PEGASUS_NAMESPACE_BEGIN
/** The NullLock class can be passed as the LockType template parameter to the
- List template class. The NullLock implements no-ops for the lock(),
+ List template class. The NullLock implements no-ops for the lock(),
try_lock() and unlock() operations.
*/
class NullLock
};
/** The List class implements an intrusive linked list. We say it is intrusive
- because the element class must derive from Linkable, which provides the
- link fields used by this implementation. An intrusive implementation has
+ because the element class must derive from Linkable, which provides the
+ link fields used by this implementation. An intrusive implementation has
two main benefits: it is more efficient and uses less memory. Recall that
a non-intrusive linked list must allocate an additional "node" object that
contains the links fields as well as a pointer to the element. This implies
The List template takes two arguments: the element type and the lock type.
Again, the element type must derive from Linkable. The lock type is used
- to synchronize access to the list operations and can be any class that
+ to synchronize access to the list operations and can be any class that
implements these methods: lock(), try_lock(), unlock(). Here are three
classes that can be used as the lock type.
- Mutex - non-recursive mutex.
- Mutex - recursive mutex.
- Now we consider an example. So you want to create a list of Person
+ Now we consider an example. So you want to create a list of Person
elements. First you must derive from the Linkable class as shown below.
- \code
- class Person : public Linkable
- {
- Person(const String& name);
- .
- .
- .
- }
- \endcode
+ \code
+ class Person : public Linkable
+ {
+ Person(const String& name);
+ .
+ .
+ .
+ }
+ \endcode
Linkable is a non-virtual base class and contains the link fields this
implementation will use to place Person elements onto the list. Second,
you must instantiate the List template. Here are three possibilities.
- \code
- List<Person, NullLink>; // Do no synchronization.
- List<Person, Mutex>; // Use Mutex class to synchronize.
- List<Person, Mutex>; // Use Mutex class to synchronize.
- \endcode
+ \code
+
List<Person, NullLink>; // Do no synchronization.
+
List<Person, Mutex>; // Use Mutex class to synchronize.
+
List<Person, Mutex>; // Use Mutex class to synchronize.
+ \endcode
Finally, use the list. The following example adds three Person objects
to the back of the list and removes one from the front.
- \code
- typedef List<Person, Mutex> PersonList;
- PersonList list;
+ \code
+
typedef List<Person, Mutex> PersonList;
+ PersonList list;
- list.insert_back(new Person("John"));
- list.insert_back(new Person("Mary"));
- list.insert_back(new Person("Jane"));
+ list.insert_back(new Person("John"));
+ list.insert_back(new Person("Mary"));
+ list.insert_back(new Person("Jane"));
- Person* person = list.remove_front();
- \endcode
+ Person* person = list.remove_front();
+ \endcode
- One recurring usage pattern is exhausting the elements of a list. For
+ One recurring usage pattern is exhausting the elements of a list. For
example (this is thread-safe).
- \code
- Person* person;
+ \code
+ Person* person;
- while ((person = list.remove_front())
- {
- // Do something with person here.
- }
- \endcode
+ while ((person = list.remove_front())
+ {
+ // Do something with person here.
+ }
+ \endcode
Another pattern is to iterate the elements of the list, which requires a
lock for the duration of the iteration. For example:
- \code
- list.lock();
+ \code
+ list.lock();
- for (Person* p = list.front(); p; p = list.next_of(p))
- {
- // Use p here!
- }
+ for (Person* p = list.front(); p; p = list.next_of(p))
+ {
+ // Use p here!
+ }
- list.unlock();
- \endcode
+ list.unlock();
+ \endcode
Beware that this pattern fails for non-recursive mutexes since the mutex
is locked once by our example and again by front(). You may have noticed
that if an exception is thrown before unlock(), that the mutex will
remain locked. For this reason, the List class contains an AutoLock class
- that will automatically release the mutex. We now rework the previous
+ that will automatically release the mutex. We now rework the previous
example to use an AutoLock object.
- \code
- {
- PersonList::AutoLock autoLock(list);
+ \code
+ {
+ PersonList::AutoLock autoLock(list);
- for (Person* p = list.front(); p; p = list.next_of(p))
- {
- // Use p here!
- }
- }
- \endcode
+ for (Person* p = list.front(); p; p = list.next_of(p))
+ {
+ // Use p here!
+ }
+ }
+ \endcode
- The List class provides a special find function to simplify recurring
+ The List class provides a special find function to simplify recurring
lookups of an element by some specific criteria. For example, lets add an
equal function to our Person class as follows:
- \code
- class Person : public Linkable
- {
- Person(const String& name);
- const String& name();
+ \code
+ class Person : public Linkable
+ {
+ Person(const String& name);
+ const String& name();
- static bool equal(const Person* person, const char* client_data)
- {
- const String& name = *((const String*)client_data);
- return person->name() == name;
- }
- }
- \endcode
+ static bool equal(const Person* person, const char* client_data)
+ {
+ const String& name = *((const String*)client_data);
+ return person->name() == name;
+ }
+ }
+ \endcode
This equal function may now be passed to the find() function to lookup
a specific person in a thread-safe way. For example:
- \code
- const String name = "John";
- Person* person = list.find(Person::equal, &name);
+ \code
+ const String name = "John";
+ Person* person = list.find(Person::equal, &name);
- if (person)
- {
- // Found John!
- }
- \endcode
+ if (person)
+ {
+ // Found John!
+ }
+ \endcode
Similary, we can delete "John" by using the equal-form of remove().
- \code
- const String name = "John";
- Person* person = list.remove(Person::equal, &name);
- \endcode
+ \code
+ const String name = "John";
+ Person* person = list.remove(Person::equal, &name);
+ \endcode
Finally, we can "apply" a function to every element of the list using
the apply method. For example:
- \code
- static void _print(Person* person, const void* client_data)
- {
- printf("%s\n", (const char*)client_data);
- person->print();
- }
+ \code
+ static void _print(Person* person, const void* client_data)
+ {
+ printf("%s\n", (const char*)client_data);
+ person->print();
+ }
- list.apply(_print, "My List");
- \endcode
+ list.apply(_print, "My List");
+ \endcode
*/
template<class ElemType, class LockType>
class List
/** Default constructor.
*/
- List() : _rep(_destructor)
+ List() : _rep(_destructor)
{
}
*/
~List()
{
- AutoLock al(*this);
- _rep.clear();
+ AutoLock al(*this);
+ _rep.clear();
}
/** Remove and delete all elements in this list. size() returns zero
- after this is called.
+ after this is called.
*/
void clear()
{
- AutoLock al(*this);
- _rep.clear();
+ AutoLock al(*this);
+ _rep.clear();
}
/** Returns the number of elements in the list.
*/
- size_t size() const
+ size_t size() const
{
- AutoLock al(*this);
- return _rep.size();
+ AutoLock al(*this);
+ return _rep.size();
}
/** Returns true if the list is empty (i.e., has zero elements).
*/
- size_t is_empty() const
- {
- AutoLock al(*this);
- return _rep.empty();
+ size_t is_empty() const
+ {
+ AutoLock al(*this);
+ return _rep.empty();
}
/** Obtains a pointer to the element at the front of the list.
*/
- ElemType* front()
- {
- AutoLock al(*this);
- return static_cast<ElemType*>(_rep.front());
+ ElemType* front()
+ {
+ AutoLock al(*this);
+ return static_cast<ElemType*>(_rep.front());
}
/** Obtains a const-pointer to the element at the front of the list.
*/
const ElemType* front() const
- {
- AutoLock al(*this);
- return static_cast<const ElemType*>(_rep.front());
+ {
+ AutoLock al(*this);
+ return static_cast<const ElemType*>(_rep.front());
}
/** Obtains a pointer to the element at the back of the list.
*/
- ElemType* back()
- {
- AutoLock al(*this);
- return static_cast<ElemType*>(_rep.back());
+ ElemType* back()
+ {
+ AutoLock al(*this);
+ return static_cast<ElemType*>(_rep.back());
}
/** Obtains a const-pointer to the element at the back of the list.
*/
const ElemType* back() const
- {
- AutoLock al(*this);
- return static_cast<const ElemType*>(_rep.back());
+ {
+ AutoLock al(*this);
+ return static_cast<const ElemType*>(_rep.back());
}
/** Returns the element after elem (used to iterate list).
*/
- ElemType* next_of(ElemType* elem)
+ ElemType* next_of(ElemType* elem)
{
- return static_cast<ElemType*>(elem->next);
+ return static_cast<ElemType*>(elem->next);
}
/** Returns the element before elem (used to iterate list).
*/
- ElemType* prev_of(ElemType* elem)
+ ElemType* prev_of(ElemType* elem)
{
- return static_cast<ElemType*>(elem->prev);
+ return static_cast<ElemType*>(elem->prev);
}
/** Insert elem at the front of the list.
*/
void insert_front(ElemType* elem)
{
- AutoLock al(*this);
- _rep.insert_front(elem);
+ AutoLock al(*this);
+ _rep.insert_front(elem);
}
/** Insert elem at the back of the list.
*/
void insert_back(ElemType* elem)
{
- AutoLock al(*this);
- _rep.insert_back(elem);
+ AutoLock al(*this);
+ _rep.insert_back(elem);
}
/** Insert elem after pos.
*/
void insert_after(ElemType* pos, ElemType* elem)
{
- AutoLock al(*this);
- _rep.insert_after(pos, elem);
+ AutoLock al(*this);
+ _rep.insert_after(pos, elem);
}
/** Insert elem before pos.
*/
void insert_before(ElemType* pos, ElemType* elem)
{
- AutoLock al(*this);
- _rep.insert_before(pos, elem);
+ AutoLock al(*this);
+ _rep.insert_before(pos, elem);
}
/** Remove the given element.
*/
void remove(ElemType* pos)
{
- AutoLock al(*this);
- _rep.remove(pos);
+ AutoLock al(*this);
+ _rep.remove(pos);
}
/** Returns true if the list contains the given element.
*/
bool contains(const ElemType* elem)
{
- AutoLock al(*this);
- return _rep.contains(elem);
+ AutoLock al(*this);
+ return _rep.contains(elem);
}
/** Removes and returns the element at the front of the list.
*/
ElemType* remove_front()
{
- AutoLock al(*this);
- return static_cast<ElemType*>(_rep.remove_front());
+ AutoLock al(*this);
+ return static_cast<ElemType*>(_rep.remove_front());
}
/** Removes and returns the element at the back of the list.
*/
ElemType* remove_back()
{
- AutoLock al(*this);
- return static_cast<ElemType*>(_rep.remove_back());
+ AutoLock al(*this);
+ return static_cast<ElemType*>(_rep.remove_back());
}
/** Attempts to find an element in the list that satisfies the equal()
*/
ElemType* find(Equal equal, const void* client_data)
{
- AutoLock al(*this);
- return static_cast<ElemType*>(
- _rep.find(ListRep::Equal(equal), client_data));
+ AutoLock al(*this);
+ return static_cast<ElemType*>(
+ _rep.find(ListRep::Equal(equal), client_data));
}
/** Attempts to remove the element in the list that satisfies the equal()
predicate. Removes and returns the first element satisfying equal() or
- null if none.
+ null if none.
*/
ElemType* remove(Equal equal, const void* client_data)
{
- AutoLock al(*this);
- return static_cast<ElemType*>(
- _rep.remove(ListRep::Equal(equal), client_data));
+ AutoLock al(*this);
+ return static_cast<ElemType*>(
+ _rep.remove(ListRep::Equal(equal), client_data));
}
/** Apply the given function to every element of the list.
*/
void apply(Apply apply, const void* client_data)
{
- AutoLock al(*this);
- _rep.apply(ListRep::Apply(apply), client_data);
+ AutoLock al(*this);
+ _rep.apply(ListRep::Apply(apply), client_data);
}
/** Lock the list.
LockType& getLock() const { return ((This*)this)->_lock; }
/** An instance of this class is used to lock this list on construction
- and later unlock it on destruction.
+ and later unlock it on destruction.
*/
class AutoLock
{
public:
- /**
- */
- AutoLock(const This& list) : _lock(list.getLock())
- {
- _lock.lock();
- }
+ /**
+ */
+ AutoLock(const This& list) : _lock(list.getLock())
+ {
+ _lock.lock();
+ }
- /**
- */
- ~AutoLock()
- {
- _lock.unlock();
- }
+ /**
+ */
+ ~AutoLock()
+ {
+ _lock.unlock();
+ }
private:
- LockType& _lock;
+ LockType& _lock;
};
private:
static void _destructor(Linkable* ptr)
{
- delete static_cast<ElemType*>(ptr);
+ delete static_cast<ElemType*>(ptr);
}
ListRep _rep;
;
;==============================================================================
;
-; Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-;
;%/////////////////////////////////////////////////////////////////////////////
;
#include <cstring>
#include "Logger.h"
#include "System.h"
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#if defined(PEGASUS_USE_SYSLOGS)
# include <syslog.h>
// KS: I put the second test in just in case some trys to create
// a completly erronous directory. At least we will get a message
- if (!System::isDirectory(lgDir)){
- //l10n
- //cerr << "Logging Disabled";
- MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",
- "Logging Disabled");
+ if (!System::isDirectory(lgDir))
+ {
+ MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",
+ "Logging Disabled");
- cerr << MessageLoader::getMessage(parms);
+ cerr << MessageLoader::getMessage(parms);
}
CString fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);
#else
#ifdef PEGASUS_OS_ZOS
- logIdendity = System::CIMSERVER.getCString();
+ logIdentity = System::CIMSERVER.getCString();
// If System Log is used open it
- System::openlog(logIdendity, LOG_PID, LOG_DAEMON);
+ System::openlog(logIdentity, LOG_PID, LOG_DAEMON);
#endif
#endif
private:
#ifdef PEGASUS_OS_ZOS
- CString logIdendity;
+ CString logIdentity;
#endif
ofstream _logs[int(Logger::NUM_LOGS)];
};
void Logger::_putInternal(
LogFileType logFileType,
const String& systemId,
- const Uint32 logComponent, // TODO: Support logComponent mask in future release
+ const Uint32 logComponent, // FUTURE: Support logComponent mask
Uint32 logLevel,
const String& formatString,
- const String& messageId, // l10n
+ const String& messageId,
const Formatter::Arg& arg0,
const Formatter::Arg& arg1,
const Formatter::Arg& arg2,
if (wouldLog(logLevel))
{
Logger::_putInternal(logFileType, systemId, 0, logLevel,
- formatString, String::EMPTY, arg0, arg1, arg2, arg3,
+ formatString, String::EMPTY, arg0, arg1, arg2, arg3,
arg4, arg5, arg6, arg7, arg8, arg9);
}
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Dave Rosckes (rosckes@us.ibm.com)
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Logger_h
PEGASUS_NAMESPACE_BEGIN
/** The Magic class implements a convenient way to use magic numbers in
- user-defined classes. Magic numbers help detect use of uninitialized,
+ user-defined classes. Magic numbers help detect use of uninitialized,
destructed, or corrupted objects.
- To instrument a class to use magic numbers simply add a class member
+ To instrument a class to use magic numbers simply add a class member
of type Magic<> as shown in thsi example:
- \code
- class MyClass
- {
- public:
+ \code
+ class MyClass
+ {
+ public:
- MyClass();
+ MyClass();
- ~MyClass();
+ ~MyClass();
- void foo();
+ void foo();
- private:
- Magic<0xC531B144> _magic;
- };
- \endcode
+ private:
+ Magic<0xC531B144> _magic;
+ };
+ \endcode
Choose whatever number you like for a magic number. The number above was
- generated by the Linux uuidgen utility (Windows has a utility with the
+ generated by the Linux uuidgen utility (Windows has a utility with the
same name).
To test magic number, add the following expression wherever necessary
(usually as the first line of every member function).
- \code
- PEGASUS_ASSERT_DEBUG(_magic);
- \endcode
+ \code
+ PEGASUS_ASSERT_DEBUG(_magic);
+ \endcode
Here's a typical example:
- \code
- MyClass::~MyClass()
- {
- PEGASUS_ASSERT_DEBUG(_magic);
- }
- \endcode
+ \code
+ MyClass::~MyClass()
+ {
+ PEGASUS_ASSERT_DEBUG(_magic);
+ }
+ \endcode
This tests whether the magic number is 0xC531B144 and asserts if it is
not.
/** Default constructor. Sets the magic number.
*/
- Magic()
+ Magic()
{
#ifdef PEGASUS_DEBUG
- _magic = MAGIC_NUMBER;
+ _magic = MAGIC_NUMBER;
#endif
}
/** Destructor. Clears the magic number (with the pattern 0xDDDDDDDD).
*/
- ~Magic()
+ ~Magic()
{
#ifdef PEGASUS_DEBUG
- _magic = 0xDDDDDDDD;
+ _magic = 0xDDDDDDDD;
#endif
}
/** Allows magic number to be used as a boolean expression. This function
- tests the magic number and return true if valid.
+ tests the magic number and return true if valid.
*/
- operator bool() const
- {
+ operator bool() const
+ {
#ifdef PEGASUS_DEBUG
- return _magic == MAGIC_NUMBER;
+ return _magic == MAGIC_NUMBER;
#else
- return true;
+ return true;
#endif
}
##
## CAUTION: the source files are divided evenly (more or less) between SOURCES1
## and SOURCES2. This avoids a command line buffer overflow on Windows 2000
-## (see bug #2754 for details). As a precaution, limit SOURCES1 and SOURCES2
+## (see bug #2754 for details). As a precaution, limit SOURCES1 and SOURCES2
## to 75 source files each.
##
else
ifneq ($(CL_MAJOR_VERSION), 12)
SYS_LIBS += secur32.lib
- endif
+ endif
endif
endif
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Memory.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Uint32 MessageMask::ha_reply = 0x00200000;
Uint32 MessageMask::ha_async = 0x00400000;
-Message::~Message()
-{
+Message::~Message()
+{
}
#ifdef PEGASUS_DEBUG
{
if (printHeader)
{
- os << "Message\n";
- os << "{";
+ os << "Message\n";
+ os << "{";
}
os << " messageType: " << MessageTypeToString(_type) << endl;
if (printHeader)
{
- os << "}";
+ os << "}";
}
}
#endif
"HTTP_MESSAGE",
"HTTP_ERROR_MESSAGE",
"CLIENT_EXCEPTION_MESSAGE",
-
+
"ASYNC::REGISTER_CIM_SERVICE", // async_message::0x00000001;
"ASYNC::DEREGISTER_CIM_SERVICE", // async_message::0x00000002;
"ASYNC::UPDATE_CIM_SERVICE", // async_message::0x00000003;
"ASYNC::ASYNC_OP_RESULT", // async_message::0x0000000a;
"ASYNC::ASYNC_LEGACY_OP_START", // async_message::0x0000000b;
"ASYNC::ASYNC_LEGACY_OP_RESULT", // async_message::0x0000000c;
-
+
"ASYNC::FIND_SERVICE_Q", // async_message::0x0000000d;
"ASYNC::FIND_SERVICE_Q_RESULT", // async_message::0x0000000e;
"ASYNC::ENUMERATE_SERVICE", // 90 async_message::0x0000000f;
"ASYNC::ENUMERATE_SERVICE_RESULT", // async_message::0x00000010;
-
+
"ASYNC::REGISTERED_MODULE", // async_message::0x00000011;
"ASYNC::DEREGISTERED_MODULE", // async_message::0x00000012;
"ASYNC::FIND_MODULE_IN_SERVICE", // async_message::0x00000013;
"ASYNC::FIND_MODULE_IN_SERVICE_RESPONSE", // async_message::0x00000014;
-
+
"ASYNC::ASYNC_MODULE_OP_START", // async_message::0x00000015;
"ASYNC::ASYNC_MODULE_OP_RESULT", // async_message::0x00000016;
-
+
"CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE",
"CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE",
const char* MessageTypeToString(Uint32 messageType)
{
if (messageType > DUMMY_MESSAGE && messageType < NUMBER_OF_MESSAGES )
- return _MESSAGE_TYPE_STRINGS[messageType - 1];
- if(messageType == 0 )
- return "HEARTBEAT/REPLY" ;
- sprintf (s, "Unknown message type ( %d ) ( 0x%04X )", messageType, messageType);
+ return _MESSAGE_TYPE_STRINGS[messageType - 1];
+ if (messageType == 0)
+ return "HEARTBEAT/REPLY";
+ sprintf(s, "Unknown message type ( %d ) ( 0x%04X )",
+ messageType, messageType);
return s;
}
CIMOperationType Message::convertMessageTypetoCIMOpType(Uint32 type)
{
-
CIMOperationType enum_type = CIMOPTYPE_GET_CLASS;
switch (type)
{
case CIM_GET_CLASS_REQUEST_MESSAGE:
case CIM_GET_CLASS_RESPONSE_MESSAGE:
enum_type = CIMOPTYPE_GET_CLASS;
- break;
-
- case CIM_GET_INSTANCE_REQUEST_MESSAGE:
- case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_GET_INSTANCE;
- break;
-
- case CIM_DELETE_CLASS_REQUEST_MESSAGE:
- case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_DELETE_CLASS;
- break;
-
- case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
- case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_DELETE_INSTANCE;
- break;
-
- case CIM_CREATE_CLASS_REQUEST_MESSAGE:
- case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_CREATE_CLASS;
- break;
-
- case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
- case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_CREATE_INSTANCE;
- break;
-
- case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
- case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_MODIFY_CLASS;
- break;
-
- case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
- case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_MODIFY_INSTANCE;
- break;
-
- case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
- case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ENUMERATE_CLASSES;
- break;
-
- case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
- case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ENUMERATE_CLASS_NAMES;
- break;
-
- case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
- case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ENUMERATE_INSTANCES;
- break;
-
- case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
- case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ENUMERATE_INSTANCE_NAMES;
- break;
-
- case CIM_EXEC_QUERY_REQUEST_MESSAGE:
- case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_EXEC_QUERY;
- break;
-
- case CIM_ASSOCIATORS_REQUEST_MESSAGE:
- case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ASSOCIATORS;
- break;
-
- case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
- case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ASSOCIATORS;
- break;
-
- case CIM_REFERENCES_REQUEST_MESSAGE:
- case CIM_REFERENCES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_REFERENCES;
- break;
-
- case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
- case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_REFERENCE_NAMES;
- break;
-
- case CIM_GET_PROPERTY_REQUEST_MESSAGE:
- case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_GET_PROPERTY;
- break;
-
- case CIM_SET_PROPERTY_REQUEST_MESSAGE:
- case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_SET_PROPERTY;
- break;
-
- case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
- case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_GET_QUALIFIER;
- break;
-
- case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
- case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_SET_QUALIFIER;
- break;
-
- case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
- case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_DELETE_QUALIFIER;
- break;
-
- case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
- case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_ENUMERATE_QUALIFIERS;
- break;
-
- case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
- case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
- enum_type = CIMOPTYPE_INVOKE_METHOD;
- break;
- default:
- // exicution should never get to this point
- PEGASUS_ASSERT(false);
-
- }
- return enum_type;
+ break;
+
+ case CIM_GET_INSTANCE_REQUEST_MESSAGE:
+ case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_GET_INSTANCE;
+ break;
+
+ case CIM_DELETE_CLASS_REQUEST_MESSAGE:
+ case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_DELETE_CLASS;
+ break;
+
+ case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
+ case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_DELETE_INSTANCE;
+ break;
+
+ case CIM_CREATE_CLASS_REQUEST_MESSAGE:
+ case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_CREATE_CLASS;
+ break;
+
+ case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
+ case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_CREATE_INSTANCE;
+ break;
+
+ case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
+ case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_MODIFY_CLASS;
+ break;
+
+ case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
+ case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_MODIFY_INSTANCE;
+ break;
+
+ case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
+ case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ENUMERATE_CLASSES;
+ break;
+
+ case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
+ case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ENUMERATE_CLASS_NAMES;
+ break;
+
+ case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
+ case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ENUMERATE_INSTANCES;
+ break;
+
+ case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
+ case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ENUMERATE_INSTANCE_NAMES;
+ break;
+
+ case CIM_EXEC_QUERY_REQUEST_MESSAGE:
+ case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_EXEC_QUERY;
+ break;
+
+ case CIM_ASSOCIATORS_REQUEST_MESSAGE:
+ case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ASSOCIATORS;
+ break;
+
+ case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
+ case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ASSOCIATORS;
+ break;
+
+ case CIM_REFERENCES_REQUEST_MESSAGE:
+ case CIM_REFERENCES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_REFERENCES;
+ break;
+
+ case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
+ case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_REFERENCE_NAMES;
+ break;
+
+ case CIM_GET_PROPERTY_REQUEST_MESSAGE:
+ case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_GET_PROPERTY;
+ break;
+
+ case CIM_SET_PROPERTY_REQUEST_MESSAGE:
+ case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_SET_PROPERTY;
+ break;
+
+ case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
+ case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_GET_QUALIFIER;
+ break;
+
+ case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
+ case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_SET_QUALIFIER;
+ break;
+
+ case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
+ case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_DELETE_QUALIFIER;
+ break;
+
+ case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
+ case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_ENUMERATE_QUALIFIERS;
+ break;
+
+ case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
+ case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
+ enum_type = CIMOPTYPE_INVOKE_METHOD;
+ break;
+
+ default:
+ // exicution should never get to this point
+ PEGASUS_ASSERT(false);
+ }
+ return enum_type;
}
StatisticalData::current()->addToValue(serverTimeMicroseconds, statType,
StatisticalData::PEGASUS_STATDATA_SERVER);
-
+
StatisticalData::current()->addToValue(_providerTimeMicroseconds, statType,
StatisticalData::PEGASUS_STATDATA_PROVIDER);
- /*This adds the number of bytes read to the total.the request size
- value must be stored (requSize) and passed to the StatisticalData
- object at the end of processing other wise it will be the ONLY vlaue
- that is passed to the client which reports the current state of the
- object, not the pevious (one command ago) state */
-
- StatisticalData::current()->addToValue(StatisticalData::current()->requSize,
- statType, StatisticalData::PEGASUS_STATDATA_BYTES_READ);
+ /* This adds the number of bytes read to the total.the request size
+ value must be stored (requSize) and passed to the StatisticalData
+ object at the end of processingm otherwise it will be the ONLY value
+ that is passed to the client which reports the current state of the
+ object, not the previous (one command ago) state */
+
+ StatisticalData::current()->addToValue(
+ StatisticalData::current()->requSize,
+ statType,
+ StatisticalData::PEGASUS_STATDATA_BYTES_READ);
}
#endif
{
if (this != &x)
{
- memcpy(_items, x._items, sizeof(_items));
- _size = x._size;
+ memcpy(_items, x._items, sizeof(_items));
+ _size = x._size;
}
return *this;
}
*/
class PEGASUS_COMMON_LINKAGE Message : public Linkable
{
- public:
+public:
- Message(
- Uint32 type,
- Uint32 destination = 0,
- Uint32 mask = MessageMask::type_legacy)
- :
- _type(type),
- _mask(mask),
- _httpMethod (HTTP_METHOD__POST),
- _serverStartTimeMicroseconds(0),
- _providerTimeMicroseconds(0),
- _totalServerTimeMicroseconds(0),
- _close_connect(false),
- _last_thread_id(Threads::self()),
- _async(0),
- dest(destination),
- _isComplete(true),
- _index(0)
- {
- }
+ Message(
+ Uint32 type,
+ Uint32 destination = 0,
+ Uint32 mask = MessageMask::type_legacy)
+ :
+ _type(type),
+ _mask(mask),
+ _httpMethod (HTTP_METHOD__POST),
+ _serverStartTimeMicroseconds(0),
+ _providerTimeMicroseconds(0),
+ _totalServerTimeMicroseconds(0),
+ _close_connect(false),
+ _last_thread_id(Threads::self()),
+ _async(0),
+ dest(destination),
+ _isComplete(true),
+ _index(0)
+ {
+ }
- virtual ~Message();
+ virtual ~Message();
- // NOTE: The compiler default implementation of the copy constructor
- // is used for this class.
+ // NOTE: The compiler default implementation of the copy constructor
+ // is used for this class.
- Boolean getCloseConnect() const { return _close_connect; }
- void setCloseConnect(Boolean close_connect)
- {
- _close_connect = close_connect;
- }
+ Boolean getCloseConnect() const { return _close_connect; }
+ void setCloseConnect(Boolean close_connect)
+ {
+ _close_connect = close_connect;
+ }
- Uint32 getType() const { return _type; }
+ Uint32 getType() const { return _type; }
- void setType(Uint32 type) { _type = type; }
+ void setType(Uint32 type) { _type = type; }
- Uint32 getMask() const { return _mask; }
+ Uint32 getMask() const { return _mask; }
- void setMask(Uint32 mask) { _mask = mask; }
+ void setMask(Uint32 mask) { _mask = mask; }
- HttpMethod getHttpMethod() const { return _httpMethod; }
+ HttpMethod getHttpMethod() const { return _httpMethod; }
- void setHttpMethod(HttpMethod httpMethod) {_httpMethod = httpMethod;}
+ void setHttpMethod(HttpMethod httpMethod) {_httpMethod = httpMethod;}
-
#ifndef PEGASUS_DISABLE_PERFINST
-//
-// Needed for performance measurement
-//
+ //
+ // Needed for performance measurement
+ //
- Uint64 getServerStartTime() const
- {
- return _serverStartTimeMicroseconds;
- }
+ Uint64 getServerStartTime() const
+ {
+ return _serverStartTimeMicroseconds;
+ }
- void setServerStartTime(Uint64 serverStartTimeMicroseconds)
- {
- _serverStartTimeMicroseconds = serverStartTimeMicroseconds;
- }
+ void setServerStartTime(Uint64 serverStartTimeMicroseconds)
+ {
+ _serverStartTimeMicroseconds = serverStartTimeMicroseconds;
+ }
- void endServer();
+ void endServer();
- Uint64 getProviderTime() const
- {
- return _providerTimeMicroseconds;
- }
+ Uint64 getProviderTime() const
+ {
+ return _providerTimeMicroseconds;
+ }
- void setProviderTime(Uint64 providerTimeMicroseconds)
- {
- _providerTimeMicroseconds = providerTimeMicroseconds;
- }
+ void setProviderTime(Uint64 providerTimeMicroseconds)
+ {
+ _providerTimeMicroseconds = providerTimeMicroseconds;
+ }
- Uint64 getTotalServerTime() const
- {
- return _totalServerTimeMicroseconds;
- }
+ Uint64 getTotalServerTime() const
+ {
+ return _totalServerTimeMicroseconds;
+ }
- void setTotalServerTime(Uint64 totalServerTimeMicroseconds)
- {
- _totalServerTimeMicroseconds = totalServerTimeMicroseconds;
- }
+ void setTotalServerTime(Uint64 totalServerTimeMicroseconds)
+ {
+ _totalServerTimeMicroseconds = totalServerTimeMicroseconds;
+ }
#endif
- static CIMOperationType convertMessageTypetoCIMOpType(Uint32 type);
+ static CIMOperationType convertMessageTypetoCIMOpType(Uint32 type);
#ifdef PEGASUS_DEBUG
- virtual void print(
- PEGASUS_STD(ostream)& os,
- Boolean printHeader = true) const;
+ virtual void print(
+ PEGASUS_STD(ostream)& os,
+ Boolean printHeader = true) const;
#endif
- Message *get_async(void)
- {
- Message *ret = _async;
- _async = 0;
- return ret;
- }
-
- void put_async(Message * msg)
- {
- _async = msg;
- }
-
- // << Tue Jul 1 11:02:49 2003 mdd >> pep_88 and helper for i18n and l10n
- Boolean thread_changed(void)
- {
- if (!Threads::equal(_last_thread_id, Threads::self()))
- {
- _last_thread_id = Threads::self();
- return true;
- }
-
- return false;
- }
-
- // set the message index indicating what piece (or sequence) this is
- // message indexes start at zero
- void setIndex(Uint32 index) { _index = index; }
-
- // increment the message index
- void incrementIndex() { _index++; }
-
- // set the complete flag indicating if this message piece is the
- // last or not
- void setComplete(Boolean isComplete)
- { _isComplete = isComplete ? true:false; }
-
- // get the message index (or sequence number)
- Uint32 getIndex() const { return _index; }
-
- // is this the first piece of the message ?
- Boolean isFirst() const { return _index == 0 ? true : false; }
-
- // is this message complete? (i.e the last in a one or more sequence)
- Boolean isComplete() const { return _isComplete; }
-
- private:
- Uint32 _type;
- Uint32 _mask;
- HttpMethod _httpMethod;
-
- // Needed for performance measurement
- Uint64 _serverStartTimeMicroseconds;
- Uint64 _providerTimeMicroseconds;
- Uint64 _totalServerTimeMicroseconds;
-
- Boolean _close_connect;
-
- // << Tue Jul 1 11:02:35 2003 mdd >> pep_88 and helper for i18n and l10n
- ThreadType _last_thread_id;
-
- public:
- Message *_async;
- Uint32 dest;
-
- private:
- Message& operator=(const Message& msg);
-
- Boolean _isComplete;
- Uint32 _index;
+ Message* get_async()
+ {
+ Message *ret = _async;
+ _async = 0;
+ return ret;
+ }
+
+ void put_async(Message* msg)
+ {
+ _async = msg;
+ }
+
+ // << Tue Jul 1 11:02:49 2003 mdd >> pep_88 and helper for i18n and l10n
+ Boolean thread_changed()
+ {
+ if (!Threads::equal(_last_thread_id, Threads::self()))
+ {
+ _last_thread_id = Threads::self();
+ return true;
+ }
+
+ return false;
+ }
+
+ // set the message index indicating what piece (or sequence) this is
+ // message indexes start at zero
+ void setIndex(Uint32 index) { _index = index; }
+
+ // increment the message index
+ void incrementIndex() { _index++; }
+
+ // set the complete flag indicating if this message piece is the
+ // last or not
+ void setComplete(Boolean isComplete)
+ {
+ _isComplete = isComplete ? true:false;
+ }
+
+ // get the message index (or sequence number)
+ Uint32 getIndex() const { return _index; }
+
+ // is this the first piece of the message ?
+ Boolean isFirst() const { return _index == 0 ? true : false; }
+
+ // is this message complete? (i.e the last in a one or more sequence)
+ Boolean isComplete() const { return _isComplete; }
+
+private:
+ Uint32 _type;
+ Uint32 _mask;
+ HttpMethod _httpMethod;
+
+ // Needed for performance measurement
+ Uint64 _serverStartTimeMicroseconds;
+ Uint64 _providerTimeMicroseconds;
+ Uint64 _totalServerTimeMicroseconds;
+
+ Boolean _close_connect;
+
+ // << Tue Jul 1 11:02:35 2003 mdd >> pep_88 and helper for i18n and l10n
+ ThreadType _last_thread_id;
+
+public:
+ Message *_async;
+ Uint32 dest;
+
+private:
+ Message& operator=(const Message& msg);
+
+ Boolean _isComplete;
+ Uint32 _index;
};
Uint32 size() const
{
- return _size;
+ return _size;
}
Boolean isEmpty() const
{
- return _size == 0;
+ return _size == 0;
}
void push(Uint32 x)
{
#ifdef PEGASUS_DEBUG
- if (_size == MAX_SIZE)
- throw StackOverflow();
+ if (_size == MAX_SIZE)
+ throw StackOverflow();
#endif
- _items[_size++] = x;
+ _items[_size++] = x;
}
Uint32& top()
{
#ifdef PEGASUS_DEBUG
- if (_size == 0)
- throw StackUnderflow();
+ if (_size == 0)
+ throw StackUnderflow();
#endif
- return _items[_size-1];
+ return _items[_size-1];
}
Uint32 top() const
{
- return ((QueueIdStack*)this)->top();
+ return ((QueueIdStack*)this)->top();
}
void pop()
{
#ifdef PEGASUS_DEBUG
- if (_size == 0)
- throw StackUnderflow();
+ if (_size == 0)
+ throw StackUnderflow();
#endif
- _size--;
+ _size--;
}
/** Make a copy of this stack and then pop the top element. */
Boolean MessageLoader::_useDefaultMsg = false;
AcceptLanguageList MessageLoader::_acceptlanguages;
-String MessageLoader::getMessage(MessageLoaderParms &parms)
+String MessageLoader::getMessage(MessageLoaderParms& parms)
{
PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::getMessage");
String msg;
msg = getMessage2(parms);
closeMessageFile(parms);
}
- catch(Exception&)
+ catch (Exception&)
{
- msg = String("AN INTERNAL ERROR OCCURED IN MESSAGELOADER: ")
- .append(parms.default_msg);
+ msg = String("AN INTERNAL ERROR OCCURED IN MESSAGELOADER: ").append(
+ parms.default_msg);
}
PEG_METHOD_EXIT();
return msg;
}
-String MessageLoader::getMessage2(MessageLoaderParms &parms)
+String MessageLoader::getMessage2(MessageLoaderParms& parms)
{
PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::getMessage2");
String msg;
if (msg.size() > 0)
{
PEG_METHOD_EXIT();
- return (msg);
+ return msg;
}
}
#endif
// 4) Did not get a message from ICU
msg = formatDefaultMessage(parms);
- }
- catch(Exception&)
+ }
+ catch (Exception&)
{
- msg = String("AN INTERNAL ERROR OCCURED IN MESSAGELOADER: ")
- .append(parms.default_msg);
+ msg = String("AN INTERNAL ERROR OCCURED IN MESSAGELOADER: ").append(
+ parms.default_msg);
}
PEG_METHOD_EXIT();
return msg;
}
-void MessageLoader::openMessageFile(MessageLoaderParms &parms)
+void MessageLoader::openMessageFile(MessageLoaderParms& parms)
{
PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::openMessageFile");
// subsequent calls to getMessage2 will call
// formatDefaultMessage() instead of using ICU.
#else
- // Set _resbundl to the "magic number" indicating there is no ICU
+ // Set _resbundl to the "magic number" indicating there is no ICU
// resource bundle to use
- parms._resbundl = NO_ICU_MAGIC;
+ parms._resbundl = NO_ICU_MAGIC;
#endif
}
- catch(Exception&)
+ catch (Exception&)
{
// Set _resbundl to the "magic number" indicating there was trouble
// during openICUMessageFile(), so there is no ICU resource bundle
// to use.
- parms._resbundl = NO_ICU_MAGIC;
+ parms._resbundl = NO_ICU_MAGIC;
}
PEG_METHOD_EXIT();
return;
}
-void MessageLoader::closeMessageFile(MessageLoaderParms &parms)
+void MessageLoader::closeMessageFile(MessageLoaderParms& parms)
{
PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::closeMessageFile");
#ifdef PEGASUS_HAS_ICU
- void MessageLoader::openICUMessageFile(MessageLoaderParms &parms) {
+void MessageLoader::openICUMessageFile(MessageLoaderParms &parms)
+{
+ PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::openICUMessageFile");
+ UErrorCode status = U_ZERO_ERROR;
+ CString resbundl_path_ICU;
+
+ const int size_locale_ICU = 50;
- PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::openICUMessageFile");
- UErrorCode status = U_ZERO_ERROR;
- //String resbundl_path_ICU;
- CString resbundl_path_ICU;
+ // the static AcceptLangauges takes precedence over what
+ // parms.acceptlangauges has
+ AcceptLanguageList acceptlanguages;
+ acceptlanguages = (_acceptlanguages.size() > 0) ?
+ _acceptlanguages : parms.acceptlanguages;
- const int size_locale_ICU = 50;
+ // get the correct path to the resource bundles
+ resbundl_path_ICU = getQualifiedMsgPath(parms.msg_src_path).getCString();
+
+ //cout << "USING PACKAGE PATH: " << endl;
+ //cout << resbundl_path_ICU << endl;
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using resource bundle path:");
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, resbundl_path_ICU);
+#ifdef PEGASUS_OS_OS400
+ const char *atoe = resbundl_path_ICU;
+ AtoE((char*)atoe);
+#endif
- // the static AcceptLangauges takes precedence over what parms.acceptlangauges has
- AcceptLanguageList acceptlanguages;
- acceptlanguages = (_acceptlanguages.size() > 0) ? _acceptlanguages : parms.acceptlanguages;
+ if (_useProcessLocale ||
+ (acceptlanguages.size() == 0 && parms.useProcessLocale))
+ {
+ // use the system default resource bundle
- // get the correct path to the resource bundles
- resbundl_path_ICU = getQualifiedMsgPath(parms.msg_src_path).getCString();
+ parms._resbundl = ures_open(
+ (const char*)resbundl_path_ICU, uloc_getDefault(), &status);
- //cout << "USING PACKAGE PATH: " << endl;
- //cout << resbundl_path_ICU << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using resource bundle path:");
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, resbundl_path_ICU);
+ if (U_SUCCESS(status))
+ {
+ UErrorCode _status = U_ZERO_ERROR;
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using process locale:");
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ ures_getLocale(parms._resbundl, &_status));
+ if (status == U_USING_FALLBACK_WARNING ||
+ status == U_USING_DEFAULT_WARNING)
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "Using process locale fallback or default");
+ }
+ const char * _locale = ures_getLocale(parms._resbundl,&status);
#ifdef PEGASUS_OS_OS400
- const char *atoe = resbundl_path_ICU;
- AtoE((char*)atoe);
+ char tmplcl[size_locale_ICU];
+ strcpy(tmplcl, _locale);
+ EtoA(tmplcl);
+ String localeStr(tmplcl);
+#else
+ String localeStr(_locale);
#endif
+ parms.contentlanguages.append(LanguageTag(
+ LanguageParser::convertLocaleIdToLanguageTag(localeStr)));
+ }
+ else
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "Using process locale. Could not open resource, "
+ "formatting default message.");
+ // magic number to indicate no ICU resource bundle to use
+ parms._resbundl = NO_ICU_MAGIC;
+ }
+ PEG_METHOD_EXIT();
+ return;
+ }
+ else if (acceptlanguages.size() == 0 && parms.useThreadLocale)
+ {
+ // get AcceptLanguageList from the current Thread
+ AcceptLanguageList *al = Thread::getLanguages();
+ if (al != NULL)
+ {
+ acceptlanguages = *al;
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "Using thread locale: got AcceptLanguageList from thread.");
+ }
+ else
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "Using thread locale: thread returned NULL for "
+ "AcceptLanguageList.");
+ }
+ }
- if(_useProcessLocale || (acceptlanguages.size() == 0 && parms.useProcessLocale)){ // use the system default resource bundle
-
- parms._resbundl = ures_open((const char*)resbundl_path_ICU, uloc_getDefault() , &status);
-
- if(U_SUCCESS(status)) {
- //cout << "PROCESS_LOCALE: opened resource bundle" << endl;
- UErrorCode _status = U_ZERO_ERROR;
- //cout << "PROCESS_LOCALE = " << ures_getLocale(resbundl, &_status) << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using process locale:");
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, ures_getLocale(parms._resbundl, &_status));
- if(status == U_USING_FALLBACK_WARNING || status == U_USING_DEFAULT_WARNING){
- //cout << "PROCESS_LOCALE: using fallback or default" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using process locale fallback or default");
- }
- const char * _locale = ures_getLocale(parms._resbundl,&status);
- #ifdef PEGASUS_OS_OS400
- char tmplcl[size_locale_ICU];
- strcpy(tmplcl, _locale);
- EtoA(tmplcl);
- String localeStr(tmplcl);
- #else
- String localeStr(_locale);
- #endif
- parms.contentlanguages.append(LanguageTag(
- LanguageParser::convertLocaleIdToLanguageTag(localeStr)));
- } else {
- //cout << "PROCESS_LOCALE: could not open resouce, formatting default message" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using process locale. Could not open resource, formatting default message.");
- parms._resbundl = NO_ICU_MAGIC; // magic number to indicate no ICU resource bundle to use
- }
- PEG_METHOD_EXIT();
- return;
- } else if (acceptlanguages.size() == 0 && parms.useThreadLocale){ // get AcceptLanguageList from the current Thread
- AcceptLanguageList *al = Thread::getLanguages();
- if(al != NULL){
- acceptlanguages = *al;
- //cout << "THREAD_LOCALE: got acceptlanguages from thread" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using thread locale: got AcceptLanguageList from thread.");
- }else {
- //cout << "THREAD_LOCALE: thread returned NULL for acceptlanguages" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using thread locale: thread returned NULL for AcceptLanguageList.");
- }
- }
-
- char locale_ICU[size_locale_ICU];
- LanguageTag languageTag;
-
- // iterate through AcceptLanguageList, use the first resource bundle match
- //cout << "LOOPING THROUGH ACCEPTLANGUAGES..." << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Looping through AcceptLanguageList...");
- for (Uint32 index = 0; index < acceptlanguages.size(); index++)
- {
- languageTag = acceptlanguages.getLanguageTag(index);
+ char locale_ICU[size_locale_ICU];
+ LanguageTag languageTag;
+
+ // iterate through AcceptLanguageList, use the first resource bundle match
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "Looping through AcceptLanguageList...");
+ for (Uint32 index = 0; index < acceptlanguages.size(); index++)
+ {
+ languageTag = acceptlanguages.getLanguageTag(index);
#ifdef PEGASUS_OS_OS400
- CString cstr = languageTag.toString().getCString();
- const char *atoe = cstr;
- AtoE((char*)atoe);
-
- uloc_getName(atoe, locale_ICU, size_locale_ICU, &status);
+ CString cstr = languageTag.toString().getCString();
+ const char *atoe = cstr;
+ AtoE((char*)atoe);
+
+ uloc_getName(atoe, locale_ICU, size_locale_ICU, &status);
#else
- uloc_getName((const char*)(languageTag.toString()).getCString(), locale_ICU, size_locale_ICU, &status);
+ uloc_getName(
+ (const char*)(languageTag.toString()).getCString(),
+ locale_ICU, size_locale_ICU, &status);
#endif
- //cout << "locale_ICU = " << locale_ICU << endl;
- // TODO: check to see if we have previously cached the resource bundle
-
- parms._resbundl = ures_open((const char*)resbundl_path_ICU, locale_ICU, &status);
-
- if(U_SUCCESS(status)) {
- //cout << "ACCEPTLANGUAGES LOOP: opened resource bundle with " << languageTag.toString() << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "ACCEPTLANGUAGES LOOP: opened resource bundle with:");
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, languageTag.toString());
- if(status == U_USING_FALLBACK_WARNING || status == U_USING_DEFAULT_WARNING){
- //we want to use the ICU fallback behaviour in the following cases ONLY
- //cout << "ACCEPTLANGUAGES LOOP: ICU warns using FALLBACK or DEFAULT" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"ACCEPTLANGUAGES LOOP: ICU warns using FALLBACK or DEFAULT");
- if((acceptlanguages.size() == 1) && (!parms.useICUfallback) && (status == U_USING_DEFAULT_WARNING)){
- // in this case we want to return messages from the root bundle
- status = U_ZERO_ERROR;
- //cout << "ML::acceptlang.size =1 && !parms.useICUfallback && U_USING_DEFAULT_WARNING" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"acceptlang.size =1 && !parms.useICUfallback && U_USING_DEFAULT_WARNING, using root bundle.");
-
- // Reopen the bundle in the root locale
- ures_close(parms._resbundl);
- parms._resbundl = ures_open((const char*)resbundl_path_ICU, "", &status);
- if(U_SUCCESS(status)) {
- PEG_METHOD_EXIT();
- return;
- }
- }
- else if(acceptlanguages.size() == 1 || parms.useICUfallback){
- //cout << "ACCEPTLANGUAGES LOOP: acceptlanguages.size == 1 or useICUfallback true, using ICU fallback behaviour..." << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"ACCEPTLANGUAGES LOOP: acceptlanguages.size == 1 or useICUfallback true, using ICU fallback behaviour...");
- const char * _locale = ures_getLocale(parms._resbundl,&status);
-
+ // TODO: check to see if we have previously cached the resource bundle
+
+ parms._resbundl =
+ ures_open((const char*)resbundl_path_ICU, locale_ICU, &status);
+
+ if (U_SUCCESS(status))
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "ACCEPTLANGUAGES LOOP: opened resource bundle with:");
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, languageTag.toString());
+ if (status == U_USING_FALLBACK_WARNING ||
+ status == U_USING_DEFAULT_WARNING)
+ {
+ // we want to use the ICU fallback behaviour in the following
+ // cases ONLY
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "ACCEPTLANGUAGES LOOP: ICU warns using FALLBACK or "
+ "DEFAULT");
+ if ((acceptlanguages.size() == 1) && (!parms.useICUfallback) &&
+ (status == U_USING_DEFAULT_WARNING))
+ {
+ // in this case we want to return messages from the root
+ // bundle
+ status = U_ZERO_ERROR;
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "acceptlang.size =1 && !parms.useICUfallback && "
+ "U_USING_DEFAULT_WARNING, using root bundle.");
+
+ // Reopen the bundle in the root locale
+ ures_close(parms._resbundl);
+ parms._resbundl = ures_open(
+ (const char*)resbundl_path_ICU, "", &status);
+ if (U_SUCCESS(status))
+ {
+ PEG_METHOD_EXIT();
+ return;
+ }
+ }
+ else if (acceptlanguages.size() == 1 || parms.useICUfallback)
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "ACCEPTLANGUAGES LOOP: acceptlanguages.size == 1 or "
+ "useICUfallback true, using ICU fallback "
+ "behaviour...");
+ const char* _locale =
+ ures_getLocale(parms._resbundl, &status);
+
#ifdef PEGASUS_OS_OS400
- char tmplcl[size_locale_ICU];
- strcpy(tmplcl, _locale);
- EtoA(tmplcl);
- String localeStr(tmplcl);
+ char tmplcl[size_locale_ICU];
+ strcpy(tmplcl, _locale);
+ EtoA(tmplcl);
+ String localeStr(tmplcl);
#else
- String localeStr(_locale);
+ String localeStr(_locale);
#endif
- parms.contentlanguages.append(LanguageTag(
- LanguageParser::convertLocaleIdToLanguageTag(
- localeStr)));
- PEG_METHOD_EXIT();
- return;
- }
- }
- else{ // we found an exact resource bundle match, extract, and set ContentLanguage
- //cout << "ACCEPTLANGUAGES LOOP: found an EXACT resource bundle MATCH" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"ACCEPTLANGUAGES LOOP: found an EXACT resource bundle MATCH:");
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,languageTag.toString());
- parms.contentlanguages.append(LanguageTag(languageTag.toString()));
- PEG_METHOD_EXIT();
- return;
- }
- } else { // possible errors, ex: message path incorrect
- // for now do nothing, let the while loop continue
- //cout << "ACCEPTLANGUAGES LOOP: could NOT open a resource for: " << languageTag.toString() << endl;
- }
- status = U_ZERO_ERROR; // reset status
- }
-
- // now if we DIDNT open a resource bundle, we want to enable ICU fallback for the highest priority language
- if(acceptlanguages.size() > 0){
- //cout << "USING ICU FALLBACK" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"No message was loaded, using ICU fallback behaviour.");
- languageTag = acceptlanguages.getLanguageTag(0);
+ parms.contentlanguages.append(LanguageTag(
+ LanguageParser::convertLocaleIdToLanguageTag(
+ localeStr)));
+ PEG_METHOD_EXIT();
+ return;
+ }
+ }
+ else
+ {
+ // we found an exact resource bundle match, extract, and set
+ // ContentLanguage
+
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "ACCEPTLANGUAGES LOOP: found an EXACT resource bundle "
+ "MATCH:");
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ languageTag.toString());
+ parms.contentlanguages.append(
+ LanguageTag(languageTag.toString()));
+ PEG_METHOD_EXIT();
+ return;
+ }
+ }
+ else
+ {
+ // possible errors, ex: message path incorrect
+ // for now do nothing, let the while loop continue
+ }
+ status = U_ZERO_ERROR; // reset status
+ }
+
+ // now if we DIDN'T open a resource bundle, we want to enable ICU
+ // fallback for the highest priority language
+ if (acceptlanguages.size() > 0)
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "No message was loaded, using ICU fallback behaviour.");
+ languageTag = acceptlanguages.getLanguageTag(0);
#ifdef PEGASUS_OS_OS400
- CString cstr = languageTag.toString().getCString();
- const char *atoe = cstr;
- AtoE((char*)atoe);
-
- uloc_getName(atoe, locale_ICU, size_locale_ICU, &status);
+ CString cstr = languageTag.toString().getCString();
+ const char *atoe = cstr;
+ AtoE((char*)atoe);
+
+ uloc_getName(atoe, locale_ICU, size_locale_ICU, &status);
#else
- uloc_getName((const char*)(languageTag.toString()).getCString(), locale_ICU, size_locale_ICU, &status);
+ uloc_getName(
+ (const char*)(languageTag.toString()).getCString(),
+ locale_ICU, size_locale_ICU, &status);
#endif
- //cout << "locale_ICU in fallback = " << locale_ICU << endl;
- status = U_ZERO_ERROR;
- parms._resbundl = ures_open((const char*)resbundl_path_ICU, locale_ICU, &status);
- const char * _locale = NULL;
- if(U_SUCCESS(status)) {
- if(status == U_USING_DEFAULT_WARNING){
- //cout << "PRIORITY ICU FALLBACK: using default resource bundle with " << languageTag.toString() << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"PRIORITY ICU FALLBACK: using default resource bundle with ");
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, languageTag.toString());
- status = U_ZERO_ERROR;
-
- // Reopen the bundle in the root locale
- ures_close(parms._resbundl);
- parms._resbundl = ures_open((const char*)resbundl_path_ICU, "", &status);
- if(U_SUCCESS(status)) {
- _locale = ures_getLocale(parms._resbundl,&status);
- }
- }else{
- _locale = ures_getLocale(parms._resbundl,&status);
- }
- String localeStr;
-
- if (_locale != NULL)
- {
+ status = U_ZERO_ERROR;
+ parms._resbundl =
+ ures_open((const char*)resbundl_path_ICU, locale_ICU, &status);
+ const char* _locale = NULL;
+ if (U_SUCCESS(status))
+ {
+ if (status == U_USING_DEFAULT_WARNING)
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "PRIORITY ICU FALLBACK: using default resource bundle "
+ "with ");
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ languageTag.toString());
+ status = U_ZERO_ERROR;
+
+ // Reopen the bundle in the root locale
+ ures_close(parms._resbundl);
+ parms._resbundl =
+ ures_open((const char*)resbundl_path_ICU, "", &status);
+ if (U_SUCCESS(status))
+ {
+ _locale = ures_getLocale(parms._resbundl,&status);
+ }
+ }
+ else
+ {
+ _locale = ures_getLocale(parms._resbundl,&status);
+ }
+
+ String localeStr;
+
+ if (_locale != NULL)
+ {
#ifdef PEGASUS_OS_OS400
- char tmplcl[size_locale_ICU];
- strcpy(tmplcl, _locale);
- EtoA(tmplcl);
- localeStr.assign(tmplcl);
+ char tmplcl[size_locale_ICU];
+ strcpy(tmplcl, _locale);
+ EtoA(tmplcl);
+ localeStr.assign(tmplcl);
#else
- localeStr.assign(_locale);
+ localeStr.assign(_locale);
#endif
- }
- if(localeStr != "root")
- {
- parms.contentlanguages.append(LanguageTag(
- LanguageParser::convertLocaleIdToLanguageTag(
- localeStr)));
- }
- if (_locale != NULL)
- {
- PEG_METHOD_EXIT();
- return;
- }
- }
- }
-
- { // else if no message, load message from root bundle explicitly
- //cout << "EXHAUSTED ACCEPTLANGUAGES: using root bundle to extract message" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"EXHAUSTED ACCEPTLANGUAGES: using root bundle to extract message");
- status = U_ZERO_ERROR;
- parms._resbundl = ures_open((const char*)resbundl_path_ICU, "", &status);
- if(U_SUCCESS(status)){
- //cout << "EXHAUSTED ACCEPTLANGUAGES: opened root resource bundle" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"EXHAUSTED ACCEPTLANGUAGES: opened root resource bundle");
- }else {
- //cout << "EXHAUSTED ACCEPTLANGUAGES: could NOT open root resource bundle" << endl;
- PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,"EXHAUSTED ACCEPTLANGUAGES: could NOT open root resource bundle");
- parms._resbundl = NO_ICU_MAGIC;
- }
-
- }
- PEG_METHOD_EXIT();
- return;
- }
-
- String MessageLoader::extractICUMessage(UResourceBundle * resbundl, MessageLoaderParms &parms){
- UErrorCode status = U_ZERO_ERROR;
- int32_t msgLen = 0;
+ }
+
+ if (localeStr != "root")
+ {
+ parms.contentlanguages.append(LanguageTag(
+ LanguageParser::convertLocaleIdToLanguageTag(
+ localeStr)));
+ }
+
+ if (_locale != NULL)
+ {
+ PEG_METHOD_EXIT();
+ return;
+ }
+ }
+ }
+
+ {
+ // else if no message, load message from root bundle explicitly
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "EXHAUSTED ACCEPTLANGUAGES: using root bundle to extract message");
+ status = U_ZERO_ERROR;
+ parms._resbundl =
+ ures_open((const char*)resbundl_path_ICU, "", &status);
+ if (U_SUCCESS(status))
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "EXHAUSTED ACCEPTLANGUAGES: opened root resource bundle");
+ }
+ else
+ {
+ PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
+ "EXHAUSTED ACCEPTLANGUAGES: could NOT open root resource "
+ "bundle");
+ parms._resbundl = NO_ICU_MAGIC;
+ }
+ }
+
+ PEG_METHOD_EXIT();
+ return;
+}
+
+String MessageLoader::extractICUMessage(
+ UResourceBundle* resbundl,
+ MessageLoaderParms& parms)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t msgLen = 0;
#ifdef PEGASUS_OS_OS400
- CString cstr = parms.msg_id.getCString();
- const char *atoe = cstr;
- AtoE((char*)atoe);
- const UChar *msg = ures_getStringByKey(resbundl, (const char*)atoe, &msgLen, &status);
+ CString cstr = parms.msg_id.getCString();
+ const char* atoe = cstr;
+ AtoE((char*)atoe);
+ const UChar* msg =
+ ures_getStringByKey(resbundl, (const char*)atoe, &msgLen, &status);
#else
- const UChar *msg = ures_getStringByKey(resbundl, (const char*)parms.msg_id.getCString(), &msgLen, &status);
+ const UChar* msg = ures_getStringByKey(
+ resbundl, (const char*)parms.msg_id.getCString(), &msgLen, &status);
#endif
- if(U_FAILURE(status)) {
- //cout << "could not extract ICU Message" << endl;
- return String::EMPTY;
- }
-
- return formatICUMessage(resbundl, msg, msgLen, parms);
- }
-
- String MessageLoader::uChar2String(UChar * uchar_str){
- return String((const Char16 *)uchar_str);
- }
-
- String MessageLoader::uChar2String(UChar * uchar_str, int len){
- return String((const Char16 *)uchar_str, len);
- }
-
- String MessageLoader::formatICUMessage(UResourceBundle * resbundl, const UChar * msg, int msg_len, MessageLoaderParms &parms){
-
- // format the message
- UnicodeString msg_pattern(msg, msg_len);
- UnicodeString msg_formatted;
- UErrorCode status = U_ZERO_ERROR;
- const int arg_count = 10;
- const char *locale;
- if(resbundl == NULL)
- locale = ULOC_US;
- else
- locale = ures_getLocale(resbundl, &status);
-
- //cout << "FORMAT ICU MESSAGE: using locale = " << locale << endl;
-
- char lang[4];
- char cc[4];
- char var[arg_count];
- uloc_getLanguage(locale, lang, 4, &status);
- uloc_getCountry(locale, cc, 4, &status);
- uloc_getVariant(locale, var, 10, &status);
- Locale localeID(lang,cc,var);
-
- status = U_ZERO_ERROR;
- MessageFormat formatter(msg_pattern, localeID, status);
-
- Formattable args[arg_count];
-
- if (parms.arg0._type != Formatter::Arg::VOIDT)
+
+ if (U_FAILURE(status))
+ {
+ return String::EMPTY;
+ }
+
+ return formatICUMessage(resbundl, msg, msgLen, parms);
+}
+
+String MessageLoader::uChar2String(UChar* uchar_str)
+{
+ return String((const Char16 *)uchar_str);
+}
+
+String MessageLoader::uChar2String(UChar* uchar_str, int len)
+{
+ return String((const Char16 *)uchar_str, len);
+}
+
+String MessageLoader::formatICUMessage(
+ UResourceBundle* resbundl,
+ const UChar* msg,
+ int msg_len,
+ MessageLoaderParms& parms)
+{
+ // format the message
+ UnicodeString msg_pattern(msg, msg_len);
+ UnicodeString msg_formatted;
+ UErrorCode status = U_ZERO_ERROR;
+ const int arg_count = 10;
+ const char *locale;
+ if (resbundl == NULL)
+ locale = ULOC_US;
+ else
+ locale = ures_getLocale(resbundl, &status);
+
+ char lang[4];
+ char cc[4];
+ char var[arg_count];
+ uloc_getLanguage(locale, lang, 4, &status);
+ uloc_getCountry(locale, cc, 4, &status);
+ uloc_getVariant(locale, var, 10, &status);
+ Locale localeID(lang,cc,var);
+
+ status = U_ZERO_ERROR;
+ MessageFormat formatter(msg_pattern, localeID, status);
+
+ Formattable args[arg_count];
+
+ if (parms.arg0._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg0, args[0]);
- if (parms.arg1._type != Formatter::Arg::VOIDT)
+ if (parms.arg1._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg1, args[1]);
- if (parms.arg2._type != Formatter::Arg::VOIDT)
+ if (parms.arg2._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg2, args[2]);
- if (parms.arg3._type != Formatter::Arg::VOIDT)
+ if (parms.arg3._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg3, args[3]);
- if (parms.arg4._type != Formatter::Arg::VOIDT)
+ if (parms.arg4._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg4, args[4]);
- if (parms.arg5._type != Formatter::Arg::VOIDT)
+ if (parms.arg5._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg5, args[5]);
- if (parms.arg6._type != Formatter::Arg::VOIDT)
+ if (parms.arg6._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg6, args[6]);
- if (parms.arg7._type != Formatter::Arg::VOIDT)
+ if (parms.arg7._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg7, args[7]);
- if (parms.arg8._type != Formatter::Arg::VOIDT)
+ if (parms.arg8._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg8, args[8]);
- if (parms.arg9._type != Formatter::Arg::VOIDT)
+ if (parms.arg9._type != Formatter::Arg::VOIDT)
xferFormattable(parms.arg9, args[9]);
- Formattable args_obj(args,arg_count);
- status = U_ZERO_ERROR;
- msg_formatted = formatter.format(args_obj, msg_formatted, status);
-
- return uChar2String(const_cast<UChar *>(msg_formatted.getBuffer()), msg_formatted.length());
- }
-
- void MessageLoader::xferFormattable(Formatter::Arg& arg, Formattable &formattable)
- {
- //cout << "arg" << " = " << arg.toString() << endl;
- switch (arg._type)
- {
- case Formatter::Arg::INTEGER:
- formattable = (int32_t)arg._integer;
- break;
- case Formatter::Arg::UINTEGER:
- // Note: the ICU Formattable class doesn't support
- // unsigned 32. Cast to signed 64.
- formattable = (int64_t)arg._uinteger;
- break;
- case Formatter::Arg::BOOLEAN:
- // Note: the ICU formattable class doesn't support
- // boolean. Turn it into a string.
- if (!arg._boolean)
- formattable = Formattable("false");
- else
- formattable = Formattable("true");
- break;
- case Formatter::Arg::REAL:
- formattable = (double)arg._real;
- break;
- case Formatter::Arg::LINTEGER:
- // Note: this uses a Formattable constructor that is
- // labelled ICU 2.8 draft. Assumes that Pegasus uses
- // at least ICU 2.8.
- formattable = (int64_t)arg._lInteger;
- break;
- case Formatter::Arg::ULINTEGER:
- // Note: the ICU Formattable class doesn't support
- // unsigned 64. If the number is too big for signed 64
- // then turn it into a string. This string will
- // not be formatted for the locale, but at least the number
- // will appear in the message.
- if (arg._lUInteger > PEGASUS_UINT64_LITERAL(0x7FFFFFFFFFFFFFFF))
- {
- char buffer[32]; // Should need 21 chars max
- sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", arg._lUInteger);
- formattable = Formattable(buffer);
- }
- else
- {
- formattable = (int64_t)arg._lUInteger;
- }
- break;
- case Formatter::Arg::STRING:
- formattable = Formattable((UChar*)arg._string.getChar16Data());
- break;
- case Formatter::Arg::VOIDT:
- default:
- formattable = "";
- break;
- }
- }
+ Formattable args_obj(args,arg_count);
+ status = U_ZERO_ERROR;
+ msg_formatted = formatter.format(args_obj, msg_formatted, status);
+
+ return uChar2String(
+ const_cast<UChar*>(msg_formatted.getBuffer()), msg_formatted.length());
+}
+
+void MessageLoader::xferFormattable(
+ Formatter::Arg &arg,
+ Formattable& formattable)
+{
+ //cout << "arg" << " = " << arg.toString() << endl;
+ switch (arg._type)
+ {
+ case Formatter::Arg::INTEGER:
+ formattable = (int32_t)arg._integer;
+ break;
+ case Formatter::Arg::UINTEGER:
+ // Note: the ICU Formattable class doesn't support
+ // unsigned 32. Cast to signed 64.
+ formattable = (int64_t)arg._uinteger;
+ break;
+ case Formatter::Arg::BOOLEAN:
+ // Note: the ICU formattable class doesn't support
+ // boolean. Turn it into a string.
+ if (!arg._boolean)
+ formattable = Formattable("false");
+ else
+ formattable = Formattable("true");
+ break;
+ case Formatter::Arg::REAL:
+ formattable = (double)arg._real;
+ break;
+ case Formatter::Arg::LINTEGER:
+ // Note: this uses a Formattable constructor that is
+ // labelled ICU 2.8 draft. Assumes that Pegasus uses
+ // at least ICU 2.8.
+ formattable = (int64_t)arg._lInteger;
+ break;
+ case Formatter::Arg::ULINTEGER:
+ // Note: the ICU Formattable class doesn't support
+ // unsigned 64. If the number is too big for signed 64
+ // then turn it into a string. This string will
+ // not be formatted for the locale, but at least the number
+ // will appear in the message.
+ if (arg._lUInteger > PEGASUS_UINT64_LITERAL(0x7FFFFFFFFFFFFFFF))
+ {
+ char buffer[32]; // Should need 21 chars max
+ sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
+ arg._lUInteger);
+ formattable = Formattable(buffer);
+ }
+ else
+ {
+ formattable = (int64_t)arg._lUInteger;
+ }
+ break;
+ case Formatter::Arg::STRING:
+ formattable = Formattable((UChar*)arg._string.getChar16Data());
+ break;
+ case Formatter::Arg::VOIDT:
+ default:
+ formattable = "";
+ break;
+ }
+}
#endif
- String MessageLoader::formatDefaultMessage(MessageLoaderParms &parms){
-
- PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::formatDefaultMessage");
- // NOTE TO PROGRAMMERS: using native substitution functions
- // ie. calling Formatter::format()
- // can result in incorrect locale handling of substitutions
-
- // locale INSENSITIVE formatting code
- //cout << "using locale INSENSITIVE formatting" << endl;
- parms.contentlanguages.clear(); // this could have previously been set by ICU
- //cout << parms.toString() << endl;
- //cout << "ml:" << parms.default_msg << endl;
- PEG_METHOD_EXIT();
- return Formatter::format(parms.default_msg,
- parms.arg0,
- parms.arg1,
- parms.arg2,
- parms.arg3,
- parms.arg4,
- parms.arg5,
- parms.arg6,
- parms.arg7,
- parms.arg8,
- parms.arg9);
-
-
- }
-
- String MessageLoader::getQualifiedMsgPath(String path){
- PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::getQualifiedMsgPath");
-
- if(pegasus_MSG_HOME.size() == 0)
- initPegasusMsgHome(String::EMPTY);
-
- if(path.size() == 0)
- {
- PEG_METHOD_EXIT();
- return pegasus_MSG_HOME + server_resbundl_name;
- }
-
- Char16 delim = '/'; // NOTE TO PROGRAMMERS: WINDOWS and non-UNIX platforms should redefine delim here
- Uint32 i;
- if(( i = path.find(delim)) != PEG_NOT_FOUND && i == 0){ // fully qualified package name
- PEG_METHOD_EXIT();
- return path;
- }
-
- PEG_METHOD_EXIT();
- return pegasus_MSG_HOME + path; // relative path and package name
-
- }
-
- void MessageLoader::setPegasusMsgHome(String home){
- PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::setPegasusMsgHome");
- //cout << "MessageLoader::setPegasusMsgHome()" << endl;
- pegasus_MSG_HOME = home + "/";
- // TODO: remove the next call once test cases are compatible with ICU messages
- checkDefaultMsgLoading();
- PEG_METHOD_EXIT();
- }
- void MessageLoader::setPegasusMsgHomeRelative(const String& argv0)
+String MessageLoader::formatDefaultMessage(MessageLoaderParms& parms)
+{
+ PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::formatDefaultMessage");
+
+ // NOTE TO PROGRAMMERS: using native substitution functions
+ // ie. calling Formatter::format()
+ // can result in incorrect locale handling of substitutions
+
+ // locale INSENSITIVE formatting code
+
+ // this could have previously been set by ICU
+ parms.contentlanguages.clear();
+
+ PEG_METHOD_EXIT();
+ return Formatter::format(
+ parms.default_msg,
+ parms.arg0,
+ parms.arg1,
+ parms.arg2,
+ parms.arg3,
+ parms.arg4,
+ parms.arg5,
+ parms.arg6,
+ parms.arg7,
+ parms.arg8,
+ parms.arg9);
+}
+
+String MessageLoader::getQualifiedMsgPath(String path)
+{
+ PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::getQualifiedMsgPath");
+
+ if (pegasus_MSG_HOME.size() == 0)
+ initPegasusMsgHome(String::EMPTY);
+
+ if (path.size() == 0)
+ {
+ PEG_METHOD_EXIT();
+ return pegasus_MSG_HOME + server_resbundl_name;
+ }
+
+ // NOTE TO PROGRAMMERS: WINDOWS and non-UNIX platforms should
+ // redefine delim here
+ Char16 delim = '/';
+ Uint32 i;
+ if ((i = path.find(delim)) != PEG_NOT_FOUND && i == 0)
{
+ // fully qualified package name
+ PEG_METHOD_EXIT();
+ return path;
+ }
+
+ PEG_METHOD_EXIT();
+ return pegasus_MSG_HOME + path; // relative path and package name
+}
+
+void MessageLoader::setPegasusMsgHome(String home)
+{
+ PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::setPegasusMsgHome");
+ pegasus_MSG_HOME = home + "/";
+
+ // TODO: remove the next call once test cases are compatible with ICU
+ // messages
+ checkDefaultMsgLoading();
+ PEG_METHOD_EXIT();
+}
+
+void MessageLoader::setPegasusMsgHomeRelative(const String& argv0)
+{
#ifdef PEGASUS_HAS_MESSAGES
- try
- {
+ try
+ {
String startingDir, pathDir;
#ifdef PEGASUS_OS_TYPE_WINDOWS
- if(PEG_NOT_FOUND == argv0.find('\\'))
+ if (PEG_NOT_FOUND == argv0.find('\\'))
{
- char exeDir[_MAX_PATH];
- HMODULE module = GetModuleHandle(NULL);
- if(NULL != module )
- {
- DWORD filename = GetModuleFileName(module,exeDir ,sizeof(exeDir));
- if(0 != filename)
- {
- String path(exeDir);
- Uint32 command = path.reverseFind('\\');
- startingDir = path.subString(0, command+1);
- }
- }
+ char exeDir[_MAX_PATH];
+ HMODULE module = GetModuleHandle(NULL);
+ if (NULL != module )
+ {
+ DWORD filename =
+ GetModuleFileName(module,exeDir ,sizeof(exeDir));
+ if (0 != filename)
+ {
+ String path(exeDir);
+ Uint32 command = path.reverseFind('\\');
+ startingDir = path.subString(0, command+1);
+ }
+ }
}
else
{
#endif
#ifdef PEGASUS_OS_TYPE_UNIX
- if(PEG_NOT_FOUND != argv0.find('/'))
+ if (PEG_NOT_FOUND != argv0.find('/'))
{
Uint32 command = argv0.reverseFind('/');
startingDir = argv0.subString(0, command+1);
}
else
{
- if(FileSystem::existsNoCase(argv0))
- {
- FileSystem::getCurrentDirectory(startingDir);
- startingDir.append("/");
- }
- else
- {
- String path;
- #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
- #pragma convert(37)
+ if (FileSystem::existsNoCase(argv0))
+ {
+ FileSystem::getCurrentDirectory(startingDir);
+ startingDir.append("/");
+ }
+ else
+ {
+ String path;
+# ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
+# pragma convert(37)
const char* env = getenv("PATH");
- if(env != NULL)
- EtoA((char*)env);
- #pragma convert(0)
- #else
+ if (env != NULL)
+ EtoA((char*)env);
+# pragma convert(0)
+# else
const char* env = getenv("PATH");
- #endif
- if (env != NULL)
- path.assign(env);
- String pathDelim = FileSystem::getPathDelimiter();
- Uint32 size = path.size();
- while(path.size() > 0)
- {
- try
- {
- Uint32 delim = path.find(pathDelim);
- if(delim != PEG_NOT_FOUND)
- {
- pathDir = path.subString(0,delim);
- path.remove(0,(delim+1));
- }
- else
- {
- pathDir = path;
- path = "";
- }
- String commandPath = pathDir.append('/');
- commandPath = commandPath.append(argv0) ;
- Boolean dirContent = FileSystem::existsNoCase(commandPath);
- if(dirContent)
- {
- startingDir = pathDir;
- break;
- }
- }
- catch(Exception &e)
- {
- //Have to do nothing.
- //Catching the exception if there is any exception while searching in the path variable
- }
- }
- }
+# endif
+ if (env != NULL)
+ path.assign(env);
+ String pathDelim = FileSystem::getPathDelimiter();
+ Uint32 size = path.size();
+ while (path.size() > 0)
+ {
+ try
+ {
+ Uint32 delim = path.find(pathDelim);
+ if (delim != PEG_NOT_FOUND)
+ {
+ pathDir = path.subString(0,delim);
+ path.remove(0,(delim+1));
+ }
+ else
+ {
+ pathDir = path;
+ path = "";
+ }
+
+ String commandPath = pathDir.append('/');
+ commandPath = commandPath.append(argv0) ;
+ Boolean dirContent =
+ FileSystem::existsNoCase(commandPath);
+ if (dirContent)
+ {
+ startingDir = pathDir;
+ break;
+ }
+ }
+ catch (Exception& e)
+ {
+ // Have to do nothing.
+ // Catching the exception if there is any exception
+ // while searching in the path variable
+ }
+ }
+ }
}
#endif
- initPegasusMsgHome(startingDir);
- }
- catch(Exception &e)
- {
- //Have to do nothing.
- //Catching the exception if there is any exception while searching in the path variable
- }
+ initPegasusMsgHome(startingDir);
+ }
+ catch (Exception& e)
+ {
+ // Have to do nothing.
+ // Catching the exception if there is any exception while searching
+ // in the path variable
+ }
#endif
}
-void MessageLoader::initPegasusMsgHome(const String & startDir)
+void MessageLoader::initPegasusMsgHome(const String& startDir)
{
- String startingDir = startDir;
+ String startingDir = startDir;
if (startingDir.size() == 0)
{
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
-#pragma convert(37)
- const char* env = getenv("PEGASUS_MSG_HOME");
- if(env != NULL)
- EtoA((char*)env);
-#pragma convert(0)
+# pragma convert(37)
+ const char* env = getenv("PEGASUS_MSG_HOME");
+ if (env != NULL)
+ EtoA((char*)env);
+# pragma convert(0)
#else
const char* env = getenv("PEGASUS_MSG_HOME");
#endif
}
#ifdef PEGASUS_DEFAULT_MESSAGE_SOURCE
- if(System::is_absolute_path(
- (const char *)PEGASUS_DEFAULT_MESSAGE_SOURCE))
- {
- pegasus_MSG_HOME = PEGASUS_DEFAULT_MESSAGE_SOURCE;
- pegasus_MSG_HOME.append('/');
- }
- else
- {
- if (startingDir.size() != 0)
- {
- pegasus_MSG_HOME = startingDir;
- pegasus_MSG_HOME.append('/');
- }
- pegasus_MSG_HOME.append(PEGASUS_DEFAULT_MESSAGE_SOURCE);
- pegasus_MSG_HOME.append('/');
- }
-#else
+ if (System::is_absolute_path(
+ (const char *)PEGASUS_DEFAULT_MESSAGE_SOURCE))
+ {
+ pegasus_MSG_HOME = PEGASUS_DEFAULT_MESSAGE_SOURCE;
+ pegasus_MSG_HOME.append('/');
+ }
+ else
+ {
if (startingDir.size() != 0)
{
pegasus_MSG_HOME = startingDir;
- pegasus_MSG_HOME.append("/");
- }
- else
- {
- // Will use current working directory
+ pegasus_MSG_HOME.append('/');
}
+ pegasus_MSG_HOME.append(PEGASUS_DEFAULT_MESSAGE_SOURCE);
+ pegasus_MSG_HOME.append('/');
+ }
+#else
+ if (startingDir.size() != 0)
+ {
+ pegasus_MSG_HOME = startingDir;
+ pegasus_MSG_HOME.append("/");
+ }
+ else
+ {
+ // Will use current working directory
+ }
#endif
- checkDefaultMsgLoading();
- }
-
- void MessageLoader::checkDefaultMsgLoading(){
- // Note: this function is a special hook for the automated tests (poststarttests)
- // Since the automated tests expect the old hardcoded default messages, an env var
- // will be used to tell this code to ignore ICU and return the default message.
- // This will allow poststarttests to run with ICU installed.
- // TODO: remove this function once test cases are compatible with ICU messages
+ checkDefaultMsgLoading();
+}
+
+void MessageLoader::checkDefaultMsgLoading()
+{
+ // Note: this function is a special hook for the automated tests
+ // (poststarttests). Since the automated tests expect the old hardcoded
+ // default messages, an env var will be used to tell this code to ignore
+ // ICU and return the default message.
+ // This will allow poststarttests to run with ICU installed.
+ // TODO: remove this function once test cases are compatible with ICU
+ // messages
#ifdef PEGASUS_OS_OS400
-#pragma convert(37)
+# pragma convert(37)
#endif
- const char* env = getenv("PEGASUS_USE_DEFAULT_MESSAGES");
+ const char* env = getenv("PEGASUS_USE_DEFAULT_MESSAGES");
#ifdef PEGASUS_OS_OS400
-#pragma convert(0)
+# pragma convert(0)
#endif
- if (env != NULL)
- _useDefaultMsg = true;
- }
+ if (env != NULL)
+ _useDefaultMsg = true;
+}
MessageLoaderParms::MessageLoaderParms()
{
- useProcessLocale = false;
- useThreadLocale = true;
+ useProcessLocale = false;
+ useThreadLocale = true;
#ifdef PEGASUS_HAS_ICU
- useICUfallback = false;
+ useICUfallback = false;
#endif
- acceptlanguages = AcceptLanguageList();
- contentlanguages = ContentLanguageList();
+ acceptlanguages = AcceptLanguageList();
+ contentlanguages = ContentLanguageList();
- _resbundl = NO_ICU_MAGIC;
+ _resbundl = NO_ICU_MAGIC;
}
MessageLoaderParms::MessageLoaderParms(
#ifdef PEGASUS_HAS_ICU
s.append("useICUfallback = " + ICUfallback + "\n");
#endif
- s.append("arg0 = " + arg0.toString() + "\n" + "arg1 = " + arg1.toString() + "\n" + "arg2 = " + arg2.toString() + "\n" + "arg3 = " + arg3.toString() + "\n" +
- "arg4 = " + arg4.toString() + "\n" + "arg5 = " + arg5.toString() + "\n" + "arg6 = " + arg6.toString() + "\n" + "arg7 = " + arg7.toString() + "\n" +
- "arg8 = " + arg8.toString() + "\n" + "arg9 = " + arg9.toString() + "\n\n");
+ s.append(
+ "arg0 = " + arg0.toString() + "\n" +
+ "arg1 = " + arg1.toString() + "\n" +
+ "arg2 = " + arg2.toString() + "\n" +
+ "arg3 = " + arg3.toString() + "\n" +
+ "arg4 = " + arg4.toString() + "\n" +
+ "arg5 = " + arg5.toString() + "\n" +
+ "arg6 = " + arg6.toString() + "\n" +
+ "arg7 = " + arg7.toString() + "\n" +
+ "arg8 = " + arg8.toString() + "\n" +
+ "arg9 = " + arg9.toString() + "\n\n");
return s;
}
#include <Pegasus/Common/AcceptLanguageList.h>
#include <Pegasus/Common/ContentLanguageList.h>
-//ICU specific
+//ICU specific
#ifdef PEGASUS_HAS_ICU
-#include <unicode/uloc.h>
-#include <unicode/ures.h>
-#include <unicode/umsg.h>
-#include <unicode/ucnv.h>
-#include <unicode/fmtable.h>
-#include <unicode/msgfmt.h>
+# include <unicode/uloc.h>
+# include <unicode/ures.h>
+# include <unicode/umsg.h>
+# include <unicode/ucnv.h>
+# include <unicode/fmtable.h>
+# include <unicode/msgfmt.h>
#endif
#ifdef PEGASUS_HAS_ICU
-#define NO_ICU_MAGIC (UResourceBundle*)0xDEADBEEF
+# define NO_ICU_MAGIC (UResourceBundle*)0xDEADBEEF
#else
-#define NO_ICU_MAGIC (void*)0xDEADBEEF
+# define NO_ICU_MAGIC (void*)0xDEADBEEF
#endif
PEGASUS_NAMESPACE_BEGIN
/**
- * MessageLoaderParms class is basically a stuct class containing public variables that control
- * the way MessageLoader behaves. MessageLoader uses the fields in this class to decide where and
- * how to load messages from the message resources.
+ MessageLoaderParms class is basically a stuct class containing public
+ variables that control the way MessageLoader behaves. MessageLoader uses
+ the fields in this class to decide where and how to load messages from
+ the message resources.
*/
+class PEGASUS_COMMON_LINKAGE MessageLoaderParms
+{
+public:
-class PEGASUS_COMMON_LINKAGE MessageLoaderParms{
+ /**
+ String msg_id: unique message identifier for a particular
+ message in a message resource
+ */
+ String msg_id;
- friend class MessageLoader;
+ /**
+ String default_msg: the default message to use if a message
+ cannot be loaded from a message resource
+ */
+ String default_msg;
+
+ /**
+ String msg_src_path: this path tells MessageLoader where to
+ find message resources.
+ It can be empty, fully qualified or relative to $PEGASUS_HOME
+ */
+ String msg_src_path;
+
+ /**
+ AcceptLanguageList acceptlanguages: This contains the languages
+ that are acceptable by the caller of MessageLoader::getMessage()
+ or openMessageFile(). That is, MessageLoader will do its best to
+ return a message in a language that was specified in this container.
+ This container is naturally ordered using the quality values
+ attached to the languages and MessageLoader iterates through this
+ container in its natural ordering. This container is used by
+ MessageLoader to load messages if it is not empty.
+ */
+ AcceptLanguageList acceptlanguages;
+
+ /**
+ ContentLanguageList contentlanguages: This is set by
+ MessageLoader::getMessage() and after a message has been loaded
+ from either a message resource or the default message, or by
+ MessageLoader::openMessageFile() after it has identified and
+ opened a message resource. After the call to
+ MessageLoader::getMessage() or MessageLoader::openMessageFile(),
+ the caller can check the MessageLoaderParms.contentlanguages
+ object to see what MessageLoader set it to. In all cases where a
+ message is returned from MessageLoader::getMessage() or will be
+ returned from MessageLoader::getMessage2(), this field will be
+ set to match the language that the message was (or will be)
+ found in.
+ */
+ ContentLanguageList contentlanguages;
+
+ /**
+ Boolean useProcessLocale: Default is false, if true, MessageLoader
+ uses the system default language to loads messages from.
+ */
+ Boolean useProcessLocale;
+
+ /**
+ Boolean useThreadLocale: Default is true, this tells
+ MessageLoader to use the AcceptLanguageList container
+ from the current Pegasus thread.
+ */
+ Boolean useThreadLocale;
+
+ /**
+ Boolean useICUfallback: Default is false. Only relevant if
+ PEGASUS_HAS_ICU is defined. MessageLoader::getMessage() default
+ behaviour is to extract messages for the langauge exactly
+ matching an available message resource. If this is set to true,
+ the MessageLoader is free to extract a message from a less
+ specific message resource according to its search algorithm.
+ */
+#ifdef PEGASUS_HAS_ICU
+ Boolean useICUfallback;
+#endif
+
+ /**
+ const Formatter::Arg&0-9: These are assigned the various
+ substitutions necessary to properly format the message being
+ extracted. MessageLoader substitutes these in the correct
+ places in the message being returned from
+ MessageLoader::getMessage()
+ */
+ Formatter::Arg arg0;
+ Formatter::Arg arg1;
+ Formatter::Arg arg2;
+ Formatter::Arg arg3;
+ Formatter::Arg arg4;
+ Formatter::Arg arg5;
+ Formatter::Arg arg6;
+ Formatter::Arg arg7;
+ Formatter::Arg arg8;
+ Formatter::Arg arg9;
-public:
-
- /*
- * String msg_id: unique message identifier for a particular message in a message resource
- */
- String msg_id;
-
- /*
- * String default_msg: the default message to use if a message cannot be loaded from a message resource
- */
- String default_msg;
-
- /*
- * String msg_src_path: this path tells MessageLoader where to find message resources
- * it can be empty, fully qualified or relative to $PEGASUS_HOME
- */
- String msg_src_path;
-
- /*
- * AcceptLanguageList acceptlanguages: This contains the languages that are acceptable by the caller
- * of MessageLoader::getMessage() or openMessageFile(). That is, MessageLoader will do its best to return
- * a message in a language that was specified in this container. This container is naturally ordered
- * using the quality values attached to the languages and MessageLoader iterates through this container
- * in its natural ordering. This container is used by MessageLoader to load messages if it is not empty.
- */
- AcceptLanguageList acceptlanguages;
-
- /*
- * ContentLanguageList contentlanguages: This is set by MessageLoader::getMessage() and after a message has
- * been loaded from either a message resource or the default message, or by MessageLoader::openMessageFile()
- * after it has identified and opened a message resource. After the call to MessageLoader::getMessage() or
- * MessageLoader::openMessageFile(), the caller can check the MessageLoaderParms.contentlanguages object to
- * see what MessageLoader set it to. In all cases where a message is returned from MessageLoader::getMessage()
- * or will be returned from MessageLoader::getMessage2(), this field will be set to match the language that
- * the message was (or will be) found in.
- */
- ContentLanguageList contentlanguages;
-
- /*
- * Boolean useProcessLocale: Default is false, if true, MessageLoader uses the system default language
- * to loads messages from.
- */
- Boolean useProcessLocale;
-
- /*
- * Boolean useThreadLocale: Default is true, this tells MessageLoader to use the AcceptLanguageList container
- * from the current Pegasus thread.
- */
- Boolean useThreadLocale;
-
- /*
- * Boolean useICUfallback: Default is false. Only relevant if PEGASUS_HAS_ICU is defined.
- * MessageLoader::getMessage() default behaviour is to extract messages for the langauge exactly
- * matching an available message resource. If this is set to true, the MessageLoader is free to extract
- * a message from a less specific message resource according to its search algorithm.
- */
- #ifdef PEGASUS_HAS_ICU
- Boolean useICUfallback;
- #endif
-
- /*
- * const Formatter::Arg&0-9: These are assigned the various substitutions necessary to properly format
- * the message being extracted. MessageLoader substitutes these in the correct places in the message
- * being returned from MessageLoader::getMessage()
- */
- Formatter::Arg arg0;
- Formatter::Arg arg1;
- Formatter::Arg arg2;
- Formatter::Arg arg3;
- Formatter::Arg arg4;
- Formatter::Arg arg5;
- Formatter::Arg arg6;
- Formatter::Arg arg7;
- Formatter::Arg arg8;
- Formatter::Arg arg9;
-
/** Constructor */
MessageLoaderParms();
/** Constructor */
MessageLoaderParms(
- const String& id,
- const String& msg,
- const Formatter::Arg& arg0,
- const Formatter::Arg& arg1,
- const Formatter::Arg& arg2,
- const Formatter::Arg& arg3,
- const Formatter::Arg& arg4,
- const Formatter::Arg& arg5 = Formatter::DEFAULT_ARG,
- const Formatter::Arg& arg6 = Formatter::DEFAULT_ARG,
- const Formatter::Arg& arg7 = Formatter::DEFAULT_ARG,
- const Formatter::Arg& arg8 = Formatter::DEFAULT_ARG,
- const Formatter::Arg& arg9 = Formatter::DEFAULT_ARG);
+ const String& id,
+ const String& msg,
+ const Formatter::Arg& arg0,
+ const Formatter::Arg& arg1,
+ const Formatter::Arg& arg2,
+ const Formatter::Arg& arg3,
+ const Formatter::Arg& arg4,
+ const Formatter::Arg& arg5 = Formatter::DEFAULT_ARG,
+ const Formatter::Arg& arg6 = Formatter::DEFAULT_ARG,
+ const Formatter::Arg& arg7 = Formatter::DEFAULT_ARG,
+ const Formatter::Arg& arg8 = Formatter::DEFAULT_ARG,
+ const Formatter::Arg& arg9 = Formatter::DEFAULT_ARG);
/** Constructor */
MessageLoaderParms(
- const String& id,
- const String& msg);
-
+ const String& id,
+ const String& msg);
+
/** Constructor */
MessageLoaderParms(
- const String& id,
- const String& msg,
- const Formatter::Arg& arg0);
+ const String& id,
+ const String& msg,
+ const Formatter::Arg& arg0);
/** Constructor */
MessageLoaderParms(
- const String& id,
- const String& msg,
- const Formatter::Arg& arg0,
- const Formatter::Arg& arg1);
+ const String& id,
+ const String& msg,
+ const Formatter::Arg& arg0,
+ const Formatter::Arg& arg1);
/** Constructor */
MessageLoaderParms(
- const String& id,
- const String& msg,
- const Formatter::Arg& arg0,
- const Formatter::Arg& arg1,
- const Formatter::Arg& arg2);
+ const String& id,
+ const String& msg,
+ const Formatter::Arg& arg0,
+ const Formatter::Arg& arg1,
+ const Formatter::Arg& arg2);
/** Constructor */
MessageLoaderParms(
- const String& id,
- const String& msg,
- const Formatter::Arg& arg0,
- const Formatter::Arg& arg1,
- const Formatter::Arg& arg2,
- const Formatter::Arg& arg3);
+ const String& id,
+ const String& msg,
+ const Formatter::Arg& arg0,
+ const Formatter::Arg& arg1,
+ const Formatter::Arg& arg2,
+ const Formatter::Arg& arg3);
MessageLoaderParms(
- const char* id,
- const char* msg);
+ const char* id,
+ const char* msg);
MessageLoaderParms(
- const char* id,
- const char* msg,
- const String& arg0);
+ const char* id,
+ const char* msg,
+ const String& arg0);
MessageLoaderParms(
- const char* id,
- const char* msg,
- const String& arg0,
- const String& arg1);
-
+ const char* id,
+ const char* msg,
+ const String& arg0,
+ const String& arg1);
+
/** Converts to string. */
String toString();
private:
#ifdef PEGASUS_HAS_ICU
- UResourceBundle* _resbundl;
+ UResourceBundle* _resbundl;
#else
- void* _resbundl;
+ void* _resbundl;
#endif
void _init();
-}; // end MessageLoaderParms
+
+ friend class MessageLoader;
+};
-/*
- * MessageLoader is a static class resposible for looking up messages in message resources.
- * For specific behaviour details of this class see the Globalization HOWTO.
+/**
+ MessageLoader is a static class resposible for looking up messages in
+ message resources.
+ For specific behaviour details of this class see the Globalization HOWTO.
*/
-
-class PEGASUS_COMMON_LINKAGE MessageLoader{
-
+class PEGASUS_COMMON_LINKAGE MessageLoader
+{
public:
-
- /*
- * Retrieves a message from a message resource
- * @param parms MessageLoaderParms - controls the behaviour of how a message is retrieved
- * @return String - the formatted message
- */
- static String getMessage(MessageLoaderParms &parms);
-
- /*
- * Opens a message resource bundle.
- * @param parms MessageLoaderParms - controls the behaviour of how a message is retrieved, this
- * parameter should be used *ONLY* on subsequent calls to getMessage2() and closeMessageFile()
- * If this method fails for some reason, it will set parms.resbundl to NO_ICU_MAGIC, and a
- * subsequent call to getMessage2() will result in the default message being formatted.
- * ATTN: Do we want *real* error codes for this?
- */
- static void openMessageFile(MessageLoaderParms &parms);
-
- /*
- * Closes a message resource bundle.
- * @param parms MessageLoaderParms - identifies a previously opened resource bundle returned
- * from openMessageFile().
- */
- static void closeMessageFile(MessageLoaderParms &parms);
-
- /*
- * Retrieves a message from a message resource previously opened by openMessageFile()
- * @param parms MessageLoaderParms - controls the behaviour of how a message is retrieved, and
- * is the same MessageLoaderParms parameter that was passed to openMessageFile().
- * @return String - the formatted message
- */
- static String getMessage2(MessageLoaderParms &parms);
-
- static void setPegasusMsgHome(String home);
+
+ /**
+ Retrieves a message from a message resource
+ @param parms MessageLoaderParms - controls the behaviour of how a
+ message is retrieved
+ @return String - the formatted message
+ */
+ static String getMessage(MessageLoaderParms& parms);
+
+ /**
+ Opens a message resource bundle.
+ If this method fails for some reason, it will set parms.resbundl
+ to NO_ICU_MAGIC, and a subsequent call to getMessage2() will
+ result in the default message being formatted.
+ ATTN: Do we want *real* error codes for this?
+ @param parms MessageLoaderParms - controls the behaviour of how a
+ message is retrieved, this parameter should be used *ONLY* on
+ subsequent calls to getMessage2() and closeMessageFile().
+ */
+ static void openMessageFile(MessageLoaderParms& parms);
+
+ /**
+ Closes a message resource bundle.
+ @param parms MessageLoaderParms - identifies a previously opened
+ resource bundle returned from openMessageFile().
+ */
+ static void closeMessageFile(MessageLoaderParms& parms);
+
+ /**
+ Retrieves a message from a message resource previously opened by
+ openMessageFile()
+ @param parms MessageLoaderParms - controls the behaviour of how a
+ message is retrieved, and is the same MessageLoaderParms
+ parameter that was passed to openMessageFile().
+ @return String - the formatted message
+ */
+ static String getMessage2(MessageLoaderParms& parms);
+
+ static void setPegasusMsgHome(String home);
static void setPegasusMsgHomeRelative(const String& argv0);
-
- static Boolean _useProcessLocale;
-
- static Boolean _useDefaultMsg;
-
- static AcceptLanguageList _acceptlanguages;
-
+
+ static Boolean _useProcessLocale;
+
+ static Boolean _useDefaultMsg;
+
+ static AcceptLanguageList _acceptlanguages;
+
private:
- static String formatDefaultMessage(MessageLoaderParms &parms);
-
- static String getQualifiedMsgPath(String path);
-
- static void initPegasusMsgHome(const String & startDir);
-
- static void checkDefaultMsgLoading();
-
- static String pegasus_MSG_HOME;
-
- #ifdef PEGASUS_HAS_ICU
- static void openICUMessageFile(MessageLoaderParms &parms);
-
- static String extractICUMessage(UResourceBundle * resbundl, MessageLoaderParms &parms);
-
- static String formatICUMessage(UResourceBundle * resbundl, const UChar *msg, int msg_len, MessageLoaderParms &parms);
-
- static String uChar2String(UChar * uchar_str);
-
- static String uChar2String(UChar * uchar_str, int len);
-
- static void xferFormattable(Formatter::Arg& arg, Formattable &formattable);
- #endif
-
-}; // end MessageLoader
+ static String formatDefaultMessage(MessageLoaderParms& parms);
+
+ static String getQualifiedMsgPath(String path);
+
+ static void initPegasusMsgHome(const String& startDir);
+
+ static void checkDefaultMsgLoading();
+
+ static String pegasus_MSG_HOME;
+
+#ifdef PEGASUS_HAS_ICU
+ static void openICUMessageFile(MessageLoaderParms& parms);
+
+ static String extractICUMessage(
+ UResourceBundle* resbundl,
+ MessageLoaderParms& parms);
+
+ static String formatICUMessage(
+ UResourceBundle* resbundl,
+ const UChar* msg,
+ int msg_len,
+ MessageLoaderParms& parms);
+
+ static String uChar2String(UChar* uchar_str);
+
+ static String uChar2String(UChar* uchar_str, int len);
+
+ static void xferFormattable(Formatter::Arg& arg, Formattable& formattable);
+#endif
+
+};
PEGASUS_NAMESPACE_END
void MessageQueue::putQueueId(Uint32 queueId)
{
if (queueId != CIMOM_Q_ID)
- _qidFactory.putID(queueId);
+ _qidFactory.putID(queueId);
}
MessageQueue::MessageQueue(
PEGASUS_ASSERT(message != 0);
- PEG_TRACE_STRING( TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
- String("Queue name: ") + getQueueName() ) ;
- Tracer::trace ( TRC_MESSAGEQUEUESERVICE,
- Tracer::LEVEL3,
- "Message: [%s]",
- MessageTypeToString(message->getType()));
+ PEG_TRACE_STRING(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
+ String("Queue name: ") + getQueueName());
+ Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
+ "Message: [%s]",
+ MessageTypeToString(message->getType()));
_messageList.insert_back(message);
MessageQueue* MessageQueue::lookup(const char *name)
{
- if(name == NULL)
+ if (name == NULL)
throw NullPointer();
AutoMutex autoMut(q_table_mut);
- for(QueueTable::Iterator i = _queueTable.start(); i; i++)
- {
+ for (QueueTable::Iterator i = _queueTable.start(); i; i++)
+ {
// ATTN: Need to decide how many characters to compare in queue names
- if(! strcmp( ((MessageQueue *)i.value())->getQueueName(), name) )
+ if (!strcmp(((MessageQueue *)i.value())->getQueueName(), name))
{
- return( (MessageQueue *)i.value());
+ return (MessageQueue *)i.value();
}
}
Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
- "MessageQueue::lookup failure - name = %s", name);
+ "MessageQueue::lookup failure - name = %s", name);
return 0;
}
// JR Wunderlich Jun 6, 2005
//
-#define MAX_THREADS_PER_SVC_QUEUE_LIMIT 5000
+#define MAX_THREADS_PER_SVC_QUEUE_LIMIT 5000
#define MAX_THREADS_PER_SVC_QUEUE_DEFAULT 5
#ifndef MAX_THREADS_PER_SVC_QUEUE
Uint32 max_threads_per_svc_queue;
-ThreadReturnType PEGASUS_THREAD_CDECL MessageQueueService::polling_routine(void *parm)
+ThreadReturnType PEGASUS_THREAD_CDECL MessageQueueService::polling_routine(
+ void* parm)
{
- Thread *myself = reinterpret_cast<Thread *>(parm);
- List<MessageQueueService, Mutex> *list =
- reinterpret_cast<List<MessageQueueService, Mutex>*>(myself->get_parm());
-
- while (_stop_polling.get() == 0)
- {
- _polling_sem.wait();
-
- if (_stop_polling.get() != 0)
- {
- break;
- }
-
- // The polling_routine thread must hold the lock on the
- // _polling_list while processing incoming messages.
- // This lock is used to give this thread ownership of
- // services on the _polling_routine list.
-
- // This is necessary to avoid confict with other threads
- // processing the _polling_list
- // (e.g., MessageQueueServer::~MessageQueueService).
-
- list->lock();
- MessageQueueService *service = list->front();
- ThreadStatus rtn = PEGASUS_THREAD_OK;
- while (service != NULL)
- {
- if ((service->_incoming.count() > 0) &&
- (service->_die.get() == 0) &&
- (service->_threads.get() < max_threads_per_svc_queue))
- {
- // The _threads count is used to track the
- // number of active threads that have been allocated
- // to process messages for this service.
-
- // The _threads count MUST be incremented while
- // the polling_routine owns the _polling_thread
- // lock and has ownership of the service object.
-
- service->_threads++;
- try
- {
- rtn = _thread_pool->allocate_and_awaken(
- service, _req_proc, &_polling_sem);
- }
- catch (...)
- {
- service->_threads--;
-
- // allocate_and_awaken should never generate an exception.
- PEGASUS_ASSERT(0);
- }
- // if no more threads available, break from processing loop
- if (rtn != PEGASUS_THREAD_OK )
- {
- service->_threads--;
- Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
- "Not enough threads to process this request. Skipping.");
-
- Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL2,
- "Could not allocate thread for %s. " \
- "Queue has %d messages waiting and %d threads servicing." \
- "Skipping the service for right now. ",
- service->getQueueName(),
- service->_incoming.count(),
- service->_threads.get());
-
- Threads::yield();
- service = NULL;
- }
- }
- if (service != NULL)
- {
- service = list->next_of(service);
- }
- }
- list->unlock();
- }
- myself->exit_self( (ThreadReturnType) 1 );
- return(0);
+ Thread *myself = reinterpret_cast<Thread *>(parm);
+ List<MessageQueueService, Mutex> *list =
+ reinterpret_cast<List<MessageQueueService, Mutex>*>(myself->get_parm());
+
+ while (_stop_polling.get() == 0)
+ {
+ _polling_sem.wait();
+
+ if (_stop_polling.get() != 0)
+ {
+ break;
+ }
+
+ // The polling_routine thread must hold the lock on the
+ // _polling_list while processing incoming messages.
+ // This lock is used to give this thread ownership of
+ // services on the _polling_routine list.
+
+ // This is necessary to avoid confict with other threads
+ // processing the _polling_list
+ // (e.g., MessageQueueServer::~MessageQueueService).
+
+ list->lock();
+ MessageQueueService *service = list->front();
+ ThreadStatus rtn = PEGASUS_THREAD_OK;
+ while (service != NULL)
+ {
+ if ((service->_incoming.count() > 0) &&
+ (service->_die.get() == 0) &&
+ (service->_threads.get() < max_threads_per_svc_queue))
+ {
+ // The _threads count is used to track the
+ // number of active threads that have been allocated
+ // to process messages for this service.
+
+ // The _threads count MUST be incremented while
+ // the polling_routine owns the _polling_thread
+ // lock and has ownership of the service object.
+
+ service->_threads++;
+ try
+ {
+ rtn = _thread_pool->allocate_and_awaken(
+ service, _req_proc, &_polling_sem);
+ }
+ catch (...)
+ {
+ service->_threads--;
+
+ // allocate_and_awaken should never generate an exception.
+ PEGASUS_ASSERT(0);
+ }
+ // if no more threads available, break from processing loop
+ if (rtn != PEGASUS_THREAD_OK )
+ {
+ service->_threads--;
+ Logger::put(
+ Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
+ "Not enough threads to process this request. "
+ "Skipping.");
+
+ Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL2,
+ "Could not allocate thread for %s. Queue has %d "
+ "messages waiting and %d threads servicing."
+ "Skipping the service for right now. ",
+ service->getQueueName(),
+ service->_incoming.count(),
+ service->_threads.get());
+
+ Threads::yield();
+ service = NULL;
+ }
+ }
+ if (service != NULL)
+ {
+ service = list->next_of(service);
+ }
+ }
+ list->unlock();
+ }
+ myself->exit_self( (ThreadReturnType) 1 );
+ return 0;
}
MessageQueueService::MessageQueueService(
- const char *name,
- Uint32 queueID,
- Uint32 capabilities,
- Uint32 mask)
- : Base(name, true, queueID),
- _mask(mask),
- _die(0),
- _threads(0),
- _incoming(),
- _incoming_queue_shutdown(0)
+ const char* name,
+ Uint32 queueID,
+ Uint32 capabilities,
+ Uint32 mask)
+ : Base(name, true, queueID),
+ _mask(mask),
+ _die(0),
+ _threads(0),
+ _incoming(),
+ _incoming_queue_shutdown(0)
{
+ _capabilities = (capabilities | module_capabilities::async);
- _capabilities = (capabilities | module_capabilities::async);
-
- _default_op_timeout.tv_sec = 30;
- _default_op_timeout.tv_usec = 100;
+ _default_op_timeout.tv_sec = 30;
+ _default_op_timeout.tv_usec = 100;
- max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE;
+ max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE;
- // if requested thread max is out of range, then set to
- // MAX_THREADS_PER_SVC_QUEUE_LIMIT
+ // if requested thread max is out of range, then set to
+ // MAX_THREADS_PER_SVC_QUEUE_LIMIT
- if ((max_threads_per_svc_queue < 1) ||
- (max_threads_per_svc_queue > MAX_THREADS_PER_SVC_QUEUE_LIMIT))
- {
- max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE_LIMIT;
- }
-
- Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL2,
- "max_threads_per_svc_queue set to %u.", max_threads_per_svc_queue);
+ if ((max_threads_per_svc_queue < 1) ||
+ (max_threads_per_svc_queue > MAX_THREADS_PER_SVC_QUEUE_LIMIT))
+ {
+ max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE_LIMIT;
+ }
- AutoMutex autoMut(_meta_dispatcher_mutex);
+ Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL2,
+ "max_threads_per_svc_queue set to %u.", max_threads_per_svc_queue);
- if (_meta_dispatcher == 0)
- {
- _stop_polling = 0;
- PEGASUS_ASSERT(_service_count.get() == 0);
- _meta_dispatcher = new cimom();
+ AutoMutex autoMut(_meta_dispatcher_mutex);
- // _thread_pool = new ThreadPool(initial_cnt, "MessageQueueService",
- // minimum_cnt, maximum_cnt, deallocateWait);
- //
- _thread_pool =
- new ThreadPool(0, "MessageQueueService", 0, 0, deallocateWait);
- }
- _service_count++;
+ if (_meta_dispatcher == 0)
+ {
+ _stop_polling = 0;
+ PEGASUS_ASSERT(_service_count.get() == 0);
+ _meta_dispatcher = new cimom();
+
+ // _thread_pool = new ThreadPool(initial_cnt, "MessageQueueService",
+ // minimum_cnt, maximum_cnt, deallocateWait);
+ //
+ _thread_pool =
+ new ThreadPool(0, "MessageQueueService", 0, 0, deallocateWait);
+ }
+ _service_count++;
- if (false == register_service(name, _capabilities, _mask))
- {
- MessageLoaderParms parms("Common.MessageQueueService.UNABLE_TO_REGISTER",
- "CIM base message queue service is unable to register with the CIMOM "
- "dispatcher.");
- throw BindFailedException(parms);
- }
+ if (false == register_service(name, _capabilities, _mask))
+ {
+ MessageLoaderParms parms(
+ "Common.MessageQueueService.UNABLE_TO_REGISTER",
+ "CIM base message queue service is unable to register with the "
+ "CIMOM dispatcher.");
+ throw BindFailedException(parms);
+ }
- _get_polling_list()->insert_back(this);
+ _get_polling_list()->insert_back(this);
}
MessageQueueService::~MessageQueueService()
{
- _die = 1;
-
- // The polling_routine locks the _polling_list while
- // processing the incoming messages for services on the
- // list. Deleting the service from the _polling_list
- // prior to processing, avoids synchronization issues
- // with the _polling_routine.
-
- // ATTN: added to prevent assertion in List in which the list does not
- // contain this element.
-
- if (_get_polling_list()->contains(this))
- _get_polling_list()->remove(this);
-
- // ATTN: The code for closing the _incoming queue
- // is not working correctly. In OpenPegasus 2.5,
- // execution of the following code is very timing
- // dependent. This needs to be fix.
- // See Bug 4079 for details.
- if (_incoming_queue_shutdown.get() == 0)
- {
- _shutdown_incoming_queue();
- }
-
- // Wait until all threads processing the messages
- // for this service have completed.
-
- while (_threads.get() > 0)
- {
- Threads::yield();
- }
-
- {
- AutoMutex autoMut(_meta_dispatcher_mutex);
- _service_count--;
- if (_service_count.get() == 0)
- {
-
- _stop_polling++;
- _polling_sem.signal();
- if (_polling_thread) {
- _polling_thread->join();
- delete _polling_thread;
- _polling_thread = 0;
- }
- _meta_dispatcher->_shutdown_routed_queue();
- delete _meta_dispatcher;
- _meta_dispatcher = 0;
-
- delete _thread_pool;
- _thread_pool = 0;
- }
- } // mutex unlocks here
- // Clean up in case there are extra stuff on the queue.
- while (_incoming.count())
- {
- try {
- delete _incoming.dequeue();
- } catch (const ListClosed&)
+ _die = 1;
+
+ // The polling_routine locks the _polling_list while
+ // processing the incoming messages for services on the
+ // list. Deleting the service from the _polling_list
+ // prior to processing, avoids synchronization issues
+ // with the _polling_routine.
+
+ // ATTN: added to prevent assertion in List in which the list does not
+ // contain this element.
+
+ if (_get_polling_list()->contains(this))
+ _get_polling_list()->remove(this);
+
+ // ATTN: The code for closing the _incoming queue
+ // is not working correctly. In OpenPegasus 2.5,
+ // execution of the following code is very timing
+ // dependent. This needs to be fix.
+ // See Bug 4079 for details.
+ if (_incoming_queue_shutdown.get() == 0)
+ {
+ _shutdown_incoming_queue();
+ }
+
+ // Wait until all threads processing the messages
+ // for this service have completed.
+
+ while (_threads.get() > 0)
+ {
+ Threads::yield();
+ }
+
+ {
+ AutoMutex autoMut(_meta_dispatcher_mutex);
+ _service_count--;
+ if (_service_count.get() == 0)
+ {
+
+ _stop_polling++;
+ _polling_sem.signal();
+ if (_polling_thread)
+ {
+ _polling_thread->join();
+ delete _polling_thread;
+ _polling_thread = 0;
+ }
+ _meta_dispatcher->_shutdown_routed_queue();
+ delete _meta_dispatcher;
+ _meta_dispatcher = 0;
+
+ delete _thread_pool;
+ _thread_pool = 0;
+ }
+ } // mutex unlocks here
+ // Clean up in case there are extra stuff on the queue.
+ while (_incoming.count())
{
- // If the list is closed, there is nothing we can do.
- break;
+ try
+ {
+ delete _incoming.dequeue();
+ }
+ catch (const ListClosed&)
+ {
+ // If the list is closed, there is nothing we can do.
+ break;
+ }
}
- }
}
void MessageQueueService::_shutdown_incoming_queue()
{
- if (_incoming_queue_shutdown.get() > 0)
- return;
-
- AsyncIoctl *msg = new AsyncIoctl(
- 0,
- _queueId,
- _queueId,
- true,
- AsyncIoctl::IO_CLOSE,
- 0,
- 0);
-
- msg->op = get_op();
- msg->op->_flags |= ASYNC_OPFLAGS_FIRE_AND_FORGET;
- msg->op->_flags &= ~(ASYNC_OPFLAGS_CALLBACK | ASYNC_OPFLAGS_SAFE_CALLBACK
- | ASYNC_OPFLAGS_SIMPLE_STATUS);
- msg->op->_state &= ~ASYNC_OPSTATE_COMPLETE;
-
- msg->op->_op_dest = this;
- msg->op->_request.reset(msg);
- try {
- _incoming.enqueue_wait(msg->op);
- _polling_sem.signal();
- } catch (const ListClosed &)
- {
+ if (_incoming_queue_shutdown.get() > 0)
+ return;
+
+ AsyncIoctl *msg = new AsyncIoctl(
+ 0,
+ _queueId,
+ _queueId,
+ true,
+ AsyncIoctl::IO_CLOSE,
+ 0,
+ 0);
+
+ msg->op = get_op();
+ msg->op->_flags |= ASYNC_OPFLAGS_FIRE_AND_FORGET;
+ msg->op->_flags &= ~(ASYNC_OPFLAGS_CALLBACK | ASYNC_OPFLAGS_SAFE_CALLBACK
+ | ASYNC_OPFLAGS_SIMPLE_STATUS);
+ msg->op->_state &= ~ASYNC_OPSTATE_COMPLETE;
+
+ msg->op->_op_dest = this;
+ msg->op->_request.reset(msg);
+ try
+ {
+ _incoming.enqueue_wait(msg->op);
+ _polling_sem.signal();
+ }
+ catch (const ListClosed&)
+ {
// This means the queue has already been shut-down (happens when there
- // are two AsyncIoctrl::IO_CLOSE messages generated and one got first
- // processed.
- delete msg;
- }
- catch (const Permission &)
- {
- delete msg;
- }
+ // are two AsyncIoctrl::IO_CLOSE messages generated and one got first
+ // processed.
+ delete msg;
+ }
+ catch (const Permission&)
+ {
+ delete msg;
+ }
}
-void MessageQueueService::enqueue(Message *msg)
+void MessageQueueService::enqueue(Message* msg)
{
- PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE, "MessageQueueService::enqueue()");
+ PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE, "MessageQueueService::enqueue()");
- Base::enqueue(msg);
+ Base::enqueue(msg);
- PEG_METHOD_EXIT();
+ PEG_METHOD_EXIT();
}
ThreadReturnType PEGASUS_THREAD_CDECL MessageQueueService::_req_proc(
- void * parm)
+ void* parm)
{
MessageQueueService* service =
- reinterpret_cast<MessageQueueService*>(parm);
+ reinterpret_cast<MessageQueueService*>(parm);
PEGASUS_ASSERT(service != 0);
try
{
-
if (service->_die.get() != 0)
{
service->_threads--;
- return (0);
+ return 0;
}
// pull messages off the incoming queue and dispatch them. then
// check pending messages that are non-blocking
{
operation = service->_incoming.dequeue();
}
- catch (ListClosed &)
+ catch (ListClosed&)
{
// ATTN: This appears to be a common loop exit path.
//PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
"Caught unrecognized exception. Exiting _req_proc.");
}
service->_threads--;
- return(0);
+ return 0;
}
void MessageQueueService::_sendwait_callback(
- AsyncOpNode *op,
- MessageQueue *q,
+ AsyncOpNode* op,
+ MessageQueue* q,
void *parm)
{
- op->_client_sem.signal();
+ op->_client_sem.signal();
}
// callback function is responsible for cleaning up all resources
// including op, op->_callback_node, and op->_callback_ptr
-void MessageQueueService::_handle_async_callback(AsyncOpNode *op)
+void MessageQueueService::_handle_async_callback(AsyncOpNode* op)
{
- if (op->_flags & ASYNC_OPFLAGS_SAFE_CALLBACK)
- {
-
- Message *msg = op->removeRequest();
- if (msg && (msg->getMask() & MessageMask::ha_async))
- {
- if (msg->getType() == async_messages::ASYNC_LEGACY_OP_START)
- {
- AsyncLegacyOperationStart *wrapper =
- static_cast<AsyncLegacyOperationStart *>(msg);
- msg = wrapper->get_action();
- delete wrapper;
- }
- else if (msg->getType() == async_messages::ASYNC_MODULE_OP_START)
- {
- AsyncModuleOperationStart *wrapper =
- static_cast<AsyncModuleOperationStart *>(msg);
- msg = wrapper->get_action();
- delete wrapper;
- }
- else if (msg->getType() == async_messages::ASYNC_OP_START)
- {
- AsyncOperationStart *wrapper =
- static_cast<AsyncOperationStart *>(msg);
- msg = wrapper->get_action();
- delete wrapper;
- }
- delete msg;
- }
-
- msg = op->removeResponse();
- if (msg && (msg->getMask() & MessageMask::ha_async))
- {
- if (msg->getType() == async_messages::ASYNC_LEGACY_OP_RESULT)
- {
- AsyncLegacyOperationResult *wrapper =
- static_cast<AsyncLegacyOperationResult *>(msg);
- msg = wrapper->get_result();
- delete wrapper;
- }
- else if (msg->getType() == async_messages::ASYNC_MODULE_OP_RESULT)
- {
- AsyncModuleOperationResult *wrapper =
- static_cast<AsyncModuleOperationResult *>(msg);
- msg = wrapper->get_result();
- delete wrapper;
- }
- }
- void (*callback)(Message *, void *, void *) = op->__async_callback;
- void *handle = op->_callback_handle;
- void *parm = op->_callback_parameter;
- op->release();
- return_op(op);
- callback(msg, handle, parm);
- }
- else if (op->_flags & ASYNC_OPFLAGS_CALLBACK)
- {
- // note that _callback_node may be different from op
- // op->_callback_response_q is a "this" pointer we can use for
- // static callback methods
- op->_async_callback(op->_callback_node, op->_callback_response_q, op->_callback_ptr);
- }
+ if (op->_flags & ASYNC_OPFLAGS_SAFE_CALLBACK)
+ {
+ Message *msg = op->removeRequest();
+ if (msg && (msg->getMask() & MessageMask::ha_async))
+ {
+ if (msg->getType() == async_messages::ASYNC_LEGACY_OP_START)
+ {
+ AsyncLegacyOperationStart *wrapper =
+ static_cast<AsyncLegacyOperationStart *>(msg);
+ msg = wrapper->get_action();
+ delete wrapper;
+ }
+ else if (msg->getType() == async_messages::ASYNC_MODULE_OP_START)
+ {
+ AsyncModuleOperationStart *wrapper =
+ static_cast<AsyncModuleOperationStart *>(msg);
+ msg = wrapper->get_action();
+ delete wrapper;
+ }
+ else if (msg->getType() == async_messages::ASYNC_OP_START)
+ {
+ AsyncOperationStart *wrapper =
+ static_cast<AsyncOperationStart *>(msg);
+ msg = wrapper->get_action();
+ delete wrapper;
+ }
+ delete msg;
+ }
+
+ msg = op->removeResponse();
+ if (msg && (msg->getMask() & MessageMask::ha_async))
+ {
+ if (msg->getType() == async_messages::ASYNC_LEGACY_OP_RESULT)
+ {
+ AsyncLegacyOperationResult *wrapper =
+ static_cast<AsyncLegacyOperationResult *>(msg);
+ msg = wrapper->get_result();
+ delete wrapper;
+ }
+ else if (msg->getType() == async_messages::ASYNC_MODULE_OP_RESULT)
+ {
+ AsyncModuleOperationResult *wrapper =
+ static_cast<AsyncModuleOperationResult *>(msg);
+ msg = wrapper->get_result();
+ delete wrapper;
+ }
+ }
+ void (*callback)(Message *, void *, void *) = op->__async_callback;
+ void *handle = op->_callback_handle;
+ void *parm = op->_callback_parameter;
+ op->release();
+ return_op(op);
+ callback(msg, handle, parm);
+ }
+ else if (op->_flags & ASYNC_OPFLAGS_CALLBACK)
+ {
+ // note that _callback_node may be different from op
+ // op->_callback_response_q is a "this" pointer we can use for
+ // static callback methods
+ op->_async_callback(
+ op->_callback_node, op->_callback_response_q, op->_callback_ptr);
+ }
}
-void MessageQueueService::_handle_incoming_operation(AsyncOpNode *operation)
+void MessageQueueService::_handle_incoming_operation(AsyncOpNode* operation)
{
- if (operation != 0)
- {
+ if (operation != 0)
+ {
// ATTN: optimization
// << Tue Feb 19 14:10:38 2002 mdd >>
- operation->lock();
+ operation->lock();
- Message *rq = operation->_request.get();
+ Message *rq = operation->_request.get();
// optimization <<< Thu Mar 7 21:04:05 2002 mdd >>>
// move this to the bottom of the loop when the majority of
// messages become async messages.
- // divert legacy messages to handleEnqueue
- if ((rq != 0) && (!(rq->getMask() & MessageMask::ha_async)))
- {
- operation->_request.release();
- operation->unlock();
- // delete the op node
- operation->release();
- return_op(operation);
-
- handleEnqueue(rq);
- return;
- }
-
- if ((operation->_flags & ASYNC_OPFLAGS_CALLBACK ||
- operation->_flags & ASYNC_OPFLAGS_SAFE_CALLBACK) &&
- (operation->_state & ASYNC_OPSTATE_COMPLETE))
- {
- operation->unlock();
- _handle_async_callback(operation);
- }
- else
- {
- PEGASUS_ASSERT(rq != 0);
- operation->unlock();
- _handle_async_request(static_cast<AsyncRequest *>(rq));
- }
- }
- return;
+ // divert legacy messages to handleEnqueue
+ if ((rq != 0) && (!(rq->getMask() & MessageMask::ha_async)))
+ {
+ operation->_request.release();
+ operation->unlock();
+ // delete the op node
+ operation->release();
+ return_op(operation);
+
+ handleEnqueue(rq);
+ return;
+ }
+
+ if ((operation->_flags & ASYNC_OPFLAGS_CALLBACK ||
+ operation->_flags & ASYNC_OPFLAGS_SAFE_CALLBACK) &&
+ (operation->_state & ASYNC_OPSTATE_COMPLETE))
+ {
+ operation->unlock();
+ _handle_async_callback(operation);
+ }
+ else
+ {
+ PEGASUS_ASSERT(rq != 0);
+ operation->unlock();
+
_handle_async_request(static_cast<AsyncRequest *>(rq));
+ }
+ }
+ return;
}
void MessageQueueService::_handle_async_request(AsyncRequest *req)
{
- if (req != 0)
- {
- req->op->processing();
-
- Uint32 type = req->getType();
- if (type == async_messages::HEARTBEAT)
- handle_heartbeat_request(req);
- else if (type == async_messages::IOCTL)
- handle_AsyncIoctl(static_cast<AsyncIoctl *>(req));
- else if (type == async_messages::CIMSERVICE_START)
- handle_CimServiceStart(static_cast<CimServiceStart *>(req));
- else if (type == async_messages::CIMSERVICE_STOP)
- handle_CimServiceStop(static_cast<CimServiceStop *>(req));
- else if (type == async_messages::CIMSERVICE_PAUSE)
- handle_CimServicePause(static_cast<CimServicePause *>(req));
- else if (type == async_messages::CIMSERVICE_RESUME)
- handle_CimServiceResume(static_cast<CimServiceResume *>(req));
- else if (type == async_messages::ASYNC_OP_START)
- handle_AsyncOperationStart(static_cast<AsyncOperationStart *>(req));
- else
- {
- // we don't handle this request message
- _make_response(req, async_results::CIM_NAK);
- }
- }
+ if (req != 0)
+ {
+ req->op->processing();
+
+ Uint32 type = req->getType();
+ if (type == async_messages::HEARTBEAT)
+ handle_heartbeat_request(req);
+ else if (type == async_messages::IOCTL)
+
handle_AsyncIoctl(static_cast<AsyncIoctl *>(req));
+ else if (type == async_messages::CIMSERVICE_START)
+ handle_CimServiceStart(static_cast<CimServiceStart *>(req));
+ else if (type == async_messages::CIMSERVICE_STOP)
+ handle_CimServiceStop(static_cast<CimServiceStop *>(req));
+ else if (type == async_messages::CIMSERVICE_PAUSE)
+ handle_CimServicePause(static_cast<CimServicePause *>(req));
+ else if (type == async_messages::CIMSERVICE_RESUME)
+ handle_CimServiceResume(static_cast<CimServiceResume *>(req));
+ else if (type == async_messages::ASYNC_OP_START)
+
handle_AsyncOperationStart(static_cast<AsyncOperationStart *>(req));
+ else
+ {
+ // we don't handle this request message
+ _make_response(req, async_results::CIM_NAK);
+ }
+ }
}
Boolean MessageQueueService::_enqueueResponse(
- Message* request,
- Message* response)
+ Message* request,
+ Message* response)
{
- PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,
- "MessageQueueService::_enqueueResponse");
-
- if (request->getMask() & MessageMask::ha_async)
- {
- if (response->getMask() & MessageMask::ha_async)
- {
- _completeAsyncResponse(static_cast<AsyncRequest *>(request),
- static_cast<AsyncReply *>(response),
- ASYNC_OPSTATE_COMPLETE, 0);
- PEG_METHOD_EXIT();
- return true;
- }
- }
-
- if (request->_async != 0)
- {
- Uint32 mask = request->_async->getMask();
- PEGASUS_ASSERT(mask & (MessageMask::ha_async | MessageMask::ha_request));
-
- AsyncRequest *async = static_cast<AsyncRequest *>(request->_async);
- AsyncOpNode *op = async->op;
- request->_async = 0;
- // the legacy request is going to be deleted by its handler
- // remove it from the op node
-
- static_cast<AsyncLegacyOperationStart *>(async)->get_action();
-
- AsyncLegacyOperationResult *async_result =
- new AsyncLegacyOperationResult(
- op,
- response);
- _completeAsyncResponse(
- async,
- async_result,
- ASYNC_OPSTATE_COMPLETE,
- 0);
- PEG_METHOD_EXIT();
- return true;
- }
-
- // ensure that the destination queue is in response->dest
- PEG_METHOD_EXIT();
- return SendForget(response);
+ PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,
+ "MessageQueueService::_enqueueResponse");
+
+ if (request->getMask() & MessageMask::ha_async)
+ {
+ if (response->getMask() & MessageMask::ha_async)
+ {
+ _completeAsyncResponse(
+ static_cast<AsyncRequest *>(request),
+ static_cast<AsyncReply *>(response),
+ ASYNC_OPSTATE_COMPLETE, 0);
+ PEG_METHOD_EXIT();
+ return true;
+ }
+ }
+
+ if (request->_async != 0)
+ {
+ Uint32 mask = request->_async->getMask();
+ PEGASUS_ASSERT(mask &
+ (MessageMask::ha_async | MessageMask::ha_request));
+
+ AsyncRequest *async = static_cast<AsyncRequest *>(request->_async);
+ AsyncOpNode *op = async->op;
+ request->_async = 0;
+ // the legacy request is going to be deleted by its handler
+ // remove it from the op node
+
+ static_cast<AsyncLegacyOperationStart *>(async)->get_action();
+
+ AsyncLegacyOperationResult *async_result =
+ new AsyncLegacyOperationResult(
+ op,
+ response);
+ _completeAsyncResponse(
+ async,
+ async_result,
+ ASYNC_OPSTATE_COMPLETE,
+ 0);
+ PEG_METHOD_EXIT();
+ return true;
+ }
+ // ensure that the destination queue is in response->dest
+ PEG_METHOD_EXIT();
+ return SendForget(response);
}
-void MessageQueueService::_make_response(Message *req, Uint32 code)
+void MessageQueueService::_make_response(Message* req, Uint32 code)
{
- cimom::_make_response(req, code);
+ cimom::_make_response(req, code);
}
void MessageQueueService::_completeAsyncResponse(
- AsyncRequest *request,
- AsyncReply *reply,
+ AsyncRequest* request,
+ AsyncReply* reply,
Uint32 state,
Uint32 flag)
{
- PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,
- "MessageQueueService::_completeAsyncResponse");
+ PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,
+ "MessageQueueService::_completeAsyncResponse");
- cimom::_completeAsyncResponse(request, reply, state, flag);
+ cimom::_completeAsyncResponse(request, reply, state, flag);
- PEG_METHOD_EXIT();
+ PEG_METHOD_EXIT();
}
void MessageQueueService::_complete_op_node(
- AsyncOpNode *op,
+ AsyncOpNode* op,
Uint32 state,
Uint32 flag,
Uint32 code)
{
- cimom::_complete_op_node(op, state, flag, code);
+ cimom::_complete_op_node(op, state, flag, code);
}
-Boolean MessageQueueService::accept_async(AsyncOpNode *op)
+Boolean MessageQueueService::accept_async(AsyncOpNode* op)
{
- if (_incoming_queue_shutdown.get() > 0)
- return false;
- if (_polling_thread == NULL)
- {
- _polling_thread = new Thread(
- polling_routine,
- reinterpret_cast<void *>(_get_polling_list()),
- false);
- ThreadStatus tr = PEGASUS_THREAD_OK;
- while ( (tr =_polling_thread->run()) != PEGASUS_THREAD_OK)
- {
- if (tr == PEGASUS_THREAD_INSUFFICIENT_RESOURCES)
- Threads::yield();
- else
- throw Exception(MessageLoaderParms("Common.MessageQueueService.NOT_ENOUGH_THREAD",
- "Could not allocate thread for the polling thread."));
- }
- }
+ if (_incoming_queue_shutdown.get() > 0)
+ return false;
+ if (_polling_thread == NULL)
+ {
+ _polling_thread = new Thread(
+ polling_routine,
+ reinterpret_cast<void *>(_get_polling_list()),
+ false);
+ ThreadStatus tr = PEGASUS_THREAD_OK;
+ while ( (tr =_polling_thread->run()) != PEGASUS_THREAD_OK)
+ {
+ if (tr == PEGASUS_THREAD_INSUFFICIENT_RESOURCES)
+ Threads::yield();
+ else
+ throw Exception(MessageLoaderParms(
+ "Common.MessageQueueService.NOT_ENOUGH_THREAD",
+ "Could not allocate thread for the polling thread."));
+ }
+ }
// ATTN optimization remove the message checking altogether in the base
// << Mon Feb 18 14:02:20 2002 mdd >>
- op->lock();
- Message *rq = op->_request.get();
- Message *rp = op->_response.get();
- op->unlock();
-
- if ((rq != 0 && (true == messageOK(rq))) ||
- (rp != 0 && (true == messageOK(rp))) && _die.get() == 0)
- {
- _incoming.enqueue_wait(op);
- _polling_sem.signal();
- return true;
- }
- return false;
+ op->lock();
+ Message *rq = op->_request.get();
+ Message *rp = op->_response.get();
+ op->unlock();
+
+ if ((rq != 0 && (true == messageOK(rq))) ||
+ (rp != 0 && (true == messageOK(rp))) && _die.get() == 0)
+ {
+ _incoming.enqueue_wait(op);
+ _polling_sem.signal();
+ return true;
+ }
+ return false;
}
-Boolean MessageQueueService::messageOK(const Message *msg)
+Boolean MessageQueueService::messageOK(const Message* msg)
{
- if (_incoming_queue_shutdown.get() > 0)
- return false;
- return true;
+ if (_incoming_queue_shutdown.get() > 0)
+ return false;
+ return true;
}
-void MessageQueueService::handle_heartbeat_request(AsyncRequest *req)
+void MessageQueueService::handle_heartbeat_request(AsyncRequest* req)
{
- // default action is to echo a heartbeat response
-
- AsyncReply *reply = new AsyncReply(
- async_messages::HEARTBEAT,
- 0,
- req->op,
- async_results::OK,
- req->resp,
- false);
- _completeAsyncResponse(req, reply, ASYNC_OPSTATE_COMPLETE, 0);
+ // default action is to echo a heartbeat response
+
+ AsyncReply *reply = new AsyncReply(
+ async_messages::HEARTBEAT,
+ 0,
+ req->op,
+ async_results::OK,
+ req->resp,
+ false);
+ _completeAsyncResponse(req, reply, ASYNC_OPSTATE_COMPLETE, 0);
}
-void MessageQueueService::handle_heartbeat_reply(AsyncReply *rep)
+void MessageQueueService::handle_heartbeat_reply(AsyncReply* rep)
{
}
-void MessageQueueService::handle_AsyncIoctl(AsyncIoctl *req)
+void MessageQueueService::handle_AsyncIoctl(AsyncIoctl* req)
{
- switch (req->ctl)
- {
- case AsyncIoctl::IO_CLOSE:
- {
- MessageQueueService *service = static_cast<MessageQueueService *>(req->op->_service_ptr);
+ switch (req->ctl)
+ {
+ case AsyncIoctl::IO_CLOSE:
+ {
+ MessageQueueService *service =
+ static_cast<MessageQueueService *>(req->op->_service_ptr);
#ifdef MESSAGEQUEUESERVICE_DEBUG
- PEGASUS_STD(cout) << service->getQueueName() << " Received AsyncIoctl::IO_CLOSE " << PEGASUS_STD(endl);
+ PEGASUS_STD(cout) << service->getQueueName() <<
+ " Received AsyncIoctl::IO_CLOSE " << PEGASUS_STD(endl);
#endif
- // respond to this message. this is fire and forget, so we don't need to delete anything.
- // this takes care of two problems that were being found
- // << Thu Oct 9 10:52:48 2003 mdd >>
- _make_response(req, async_results::OK);
- // ensure we do not accept any further messages
+ // respond to this message. this is fire and forget, so we
+ // don't need to delete anything.
+ // this takes care of two problems that were being found
+ // << Thu Oct 9 10:52:48 2003 mdd >>
+ _make_response(req, async_results::OK);
+ // ensure we do not accept any further messages
- // ensure we don't recurse on IO_CLOSE
- if (_incoming_queue_shutdown.get() > 0)
- break;
+ // ensure we don't recurse on IO_CLOSE
+ if (_incoming_queue_shutdown.get() > 0)
+ break;
- // set the closing flag
- service->_incoming_queue_shutdown = 1;
- // empty out the queue
- while (1)
- {
- AsyncOpNode *operation;
- try
+ // set the closing flag
+ service->_incoming_queue_shutdown = 1;
+ // empty out the queue
+ while (1)
{
- operation = service->_incoming.dequeue();
- }
- catch(IPCException &)
- {
- break;
- }
- if (operation)
- {
- operation->_service_ptr = service;
- service->_handle_incoming_operation(operation);
- }
- else
- break;
- } // message processing loop
-
- // shutdown the AsyncQueue
- service->_incoming.close();
- return;
- }
+ AsyncOpNode *operation;
+ try
+ {
+ operation = service->_incoming.dequeue();
+ }
+ catch (IPCException&)
+ {
+ break;
+ }
+ if (operation)
+ {
+ operation->_service_ptr = service;
+ service->_handle_incoming_operation(operation);
+ }
+ else
+ break;
+ } // message processing loop
+
+ // shutdown the AsyncQueue
+ service->_incoming.close();
+ return;
+ }
- default:
- _make_response(req, async_results::CIM_NAK);
- }
+ default:
+ _make_response(req, async_results::CIM_NAK);
+ }
}
-void MessageQueueService::handle_CimServiceStart(CimServiceStart *req)
+void MessageQueueService::handle_CimServiceStart(CimServiceStart* req)
{
-
#ifdef MESSAGEQUEUESERVICE_DEBUG
- PEGASUS_STD(cout) << getQueueName() << "received START" << PEGASUS_STD(endl);
+ PEGASUS_STD(cout) << getQueueName() << "received START" <<
+ PEGASUS_STD(endl);
#endif
- // clear the stoped bit and update
- _capabilities &= (~(module_capabilities::stopped));
- _make_response(req, async_results::OK);
- // now tell the meta dispatcher we are stopped
- update_service(_capabilities, _mask);
-
+ // clear the stoped bit and update
+ _capabilities &= (~(module_capabilities::stopped));
+ _make_response(req, async_results::OK);
+ // now tell the meta dispatcher we are stopped
+ update_service(_capabilities, _mask);
}
-void MessageQueueService::handle_CimServiceStop(CimServiceStop *req)
+
+void MessageQueueService::handle_CimServiceStop(CimServiceStop* req)
{
#ifdef MESSAGEQUEUESERVICE_DEBUG
- PEGASUS_STD(cout) << getQueueName() << "received STOP" << PEGASUS_STD(endl);
+ PEGASUS_STD(cout) << getQueueName() << "received STOP" << PEGASUS_STD(endl);
#endif
- // set the stopeed bit and update
- _capabilities |= module_capabilities::stopped;
- _make_response(req, async_results::CIM_STOPPED);
- // now tell the meta dispatcher we are stopped
- update_service(_capabilities, _mask);
+ // set the stopeed bit and update
+ _capabilities |= module_capabilities::stopped;
+ _make_response(req, async_results::CIM_STOPPED);
+ // now tell the meta dispatcher we are stopped
+ update_service(_capabilities, _mask);
}
-void MessageQueueService::handle_CimServicePause(CimServicePause *req)
+void MessageQueueService::handle_CimServicePause(CimServicePause* req)
{
- // set the paused bit and update
- _capabilities |= module_capabilities::paused;
- update_service(_capabilities, _mask);
- _make_response(req, async_results::CIM_PAUSED);
- // now tell the meta dispatcher we are stopped
+ // set the paused bit and update
+ _capabilities |= module_capabilities::paused;
+ update_service(_capabilities, _mask);
+ _make_response(req, async_results::CIM_PAUSED);
+ // now tell the meta dispatcher we are stopped
}
-void MessageQueueService::handle_CimServiceResume(CimServiceResume *req)
+void MessageQueueService::handle_CimServiceResume(CimServiceResume* req)
{
- // clear the paused bit and update
- _capabilities &= (~(module_capabilities::paused));
- update_service(_capabilities, _mask);
- _make_response(req, async_results::OK);
- // now tell the meta dispatcher we are stopped
+ // clear the paused bit and update
+ _capabilities &= (~(module_capabilities::paused));
+ update_service(_capabilities, _mask);
+ _make_response(req, async_results::OK);
+ // now tell the meta dispatcher we are stopped
}
-void MessageQueueService::handle_AsyncOperationStart(AsyncOperationStart *req)
+void MessageQueueService::handle_AsyncOperationStart(AsyncOperationStart* req)
{
- _make_response(req, async_results::CIM_NAK);
+ _make_response(req, async_results::CIM_NAK);
}
-void MessageQueueService::handle_AsyncOperationResult(AsyncOperationResult *req)
+void MessageQueueService::handle_AsyncOperationResult(AsyncOperationResult* req)
{
- ;
}
-void MessageQueueService::handle_AsyncLegacyOperationStart(AsyncLegacyOperationStart *req)
+void MessageQueueService::handle_AsyncLegacyOperationStart(
+ AsyncLegacyOperationStart* req)
{
- // remove the legacy message from the request and enqueue it to its destination
- Uint32 result = async_results::CIM_NAK;
-
- Message *legacy = req->_act;
- if (legacy != 0)
- {
- MessageQueue* queue = MessageQueue::lookup(req->_legacy_destination);
- if (queue != 0)
- {
- if (queue->isAsync() == true)
- {
- (static_cast<MessageQueueService *>(queue))->handleEnqueue(legacy);
- }
- else
- {
- // Enqueue the response:
- queue->enqueue(req->get_action());
- }
-
- result = async_results::OK;
- }
- }
- _make_response(req, result);
+ // remove the legacy message from the request and enqueue it to its
+ // destination
+ Uint32 result = async_results::CIM_NAK;
+
+ Message* legacy = req->_act;
+ if (legacy != 0)
+ {
+ MessageQueue* queue = MessageQueue::lookup(req->_legacy_destination);
+ if (queue != 0)
+ {
+ if (queue->isAsync() == true)
+ {
+ (static_cast<MessageQueueService *>(queue))->handleEnqueue(
+ legacy);
+ }
+ else
+ {
+ // Enqueue the response:
+ queue->enqueue(req->get_action());
+ }
+
+ result = async_results::OK;
+ }
+ }
+ _make_response(req, result);
}
-void MessageQueueService::handle_AsyncLegacyOperationResult(AsyncLegacyOperationResult *rep)
+void MessageQueueService::handle_AsyncLegacyOperationResult(
+ AsyncLegacyOperationResult* rep)
{
- ;
}
-AsyncOpNode *MessageQueueService::get_op()
+AsyncOpNode* MessageQueueService::get_op()
{
- AsyncOpNode *op = new AsyncOpNode();
+ AsyncOpNode* op = new AsyncOpNode();
op->_state = ASYNC_OPSTATE_UNKNOWN;
op->_flags = ASYNC_OPFLAGS_SINGLE | ASYNC_OPFLAGS_NORMAL;
return op;
}
-void MessageQueueService::return_op(AsyncOpNode *op)
+void MessageQueueService::return_op(AsyncOpNode* op)
{
- PEGASUS_ASSERT(op->_state & ASYNC_OPSTATE_RELEASED);
- delete op;
+ PEGASUS_ASSERT(op->_state & ASYNC_OPSTATE_RELEASED);
+ delete op;
}
Boolean MessageQueueService::SendAsync(
- AsyncOpNode *op,
+ AsyncOpNode* op,
Uint32 destination,
- void (*callback)(AsyncOpNode *, MessageQueue *, void *),
- MessageQueue *callback_response_q,
- void *callback_ptr)
+ void (*callback)(AsyncOpNode*, MessageQueue*, void*),
+ MessageQueue* callback_response_q,
+ void* callback_ptr)
{
- PEGASUS_ASSERT(op != 0 && callback != 0);
-
- // get the queue handle for the destination
-
- op->lock();
- op->_op_dest = MessageQueue::lookup(destination); // destination of this message
- op->_flags |= ASYNC_OPFLAGS_CALLBACK;
- op->_flags &= ~(ASYNC_OPFLAGS_FIRE_AND_FORGET);
- // initialize the callback data
- op->_async_callback = callback; // callback function to be executed by recpt. of response
- op->_callback_node = op; // the op node
- op->_callback_response_q = callback_response_q; // the queue that will receive the response
- op->_callback_ptr = callback_ptr; // user data for callback
- op->_callback_request_q = this; // I am the originator of this request
-
- op->unlock();
- if (op->_op_dest == 0)
- return false;
-
- return _meta_dispatcher->route_async(op);
+ PEGASUS_ASSERT(op != 0 && callback != 0);
+
+ // get the queue handle for the destination
+
+ op->lock();
+ // destination of this message
+ op->_op_dest = MessageQueue::lookup(destination);
+ op->_flags |= ASYNC_OPFLAGS_CALLBACK;
+ op->_flags &= ~(ASYNC_OPFLAGS_FIRE_AND_FORGET);
+ // initialize the callback data
+ // callback function to be executed by recpt. of response
+ op->_async_callback = callback;
+ // the op node
+ op->_callback_node = op;
+ // the queue that will receive the response
+ op->_callback_response_q = callback_response_q;
+ // user data for callback
+ op->_callback_ptr = callback_ptr;
+ // I am the originator of this request
+ op->_callback_request_q = this;
+
+ op->unlock();
+ if (op->_op_dest == 0)
+ return false;
+
+ return _meta_dispatcher->route_async(op);
}
Boolean MessageQueueService::SendAsync(
- Message *msg,
+ Message* msg,
Uint32 destination,
- void (*callback)(Message *response, void *handle, void *parameter),
- void *handle,
- void *parameter)
+ void (*callback)(Message* response, void* handle, void* parameter),
+ void* handle,
+ void* parameter)
{
- if (msg == NULL)
- return false;
- if (callback == NULL)
- return SendForget(msg);
- AsyncOpNode *op = get_op();
- msg->dest = destination;
- if (NULL == (op->_op_dest = MessageQueue::lookup(msg->dest)))
- {
- op->release();
- return_op(op);
- return false;
- }
- op->_flags |= ASYNC_OPFLAGS_SAFE_CALLBACK;
- op->_flags &= ~(ASYNC_OPFLAGS_FIRE_AND_FORGET);
- op->_state &= ~ASYNC_OPSTATE_COMPLETE;
- op->__async_callback = callback;
- op->_callback_node = op;
- op->_callback_handle = handle;
- op->_callback_parameter = parameter;
- op->_callback_response_q = this;
-
- if (!(msg->getMask() & MessageMask::ha_async))
- {
- AsyncLegacyOperationStart *wrapper = new AsyncLegacyOperationStart(
- op,
- destination,
- msg,
- destination);
- }
- else
- {
- op->_request.reset(msg);
- (static_cast<AsyncMessage *>(msg))->op = op;
- }
- return _meta_dispatcher->route_async(op);
+ if (msg == NULL)
+ return false;
+ if (callback == NULL)
+ return SendForget(msg);
+ AsyncOpNode *op = get_op();
+ msg->dest = destination;
+ if (NULL == (op->_op_dest = MessageQueue::lookup(msg->dest)))
+ {
+ op->release();
+ return_op(op);
+ return false;
+ }
+ op->_flags |= ASYNC_OPFLAGS_SAFE_CALLBACK;
+ op->_flags &= ~(ASYNC_OPFLAGS_FIRE_AND_FORGET);
+ op->_state &= ~ASYNC_OPSTATE_COMPLETE;
+ op->__async_callback = callback;
+ op->_callback_node = op;
+ op->_callback_handle = handle;
+ op->_callback_parameter = parameter;
+ op->_callback_response_q = this;
+
+ if (!(msg->getMask() & MessageMask::ha_async))
+ {
+ AsyncLegacyOperationStart *wrapper = new AsyncLegacyOperationStart(
+ op,
+ destination,
+ msg,
+ destination);
+ }
+ else
+ {
+ op->_request.reset(msg);
+
(static_cast<AsyncMessage *>(msg))->op = op;
+ }
+ return _meta_dispatcher->route_async(op);
}
-Boolean MessageQueueService::SendForget(Message *msg)
+Boolean MessageQueueService::SendForget(Message* msg)
{
- AsyncOpNode *op = 0;
- Uint32 mask = msg->getMask();
-
- if (mask & MessageMask::ha_async)
- {
- op = (static_cast<AsyncMessage *>(msg))->op ;
- }
-
- if (op == 0)
- {
- op = get_op();
- op->_request.reset(msg);
- if (mask & MessageMask::ha_async)
- {
- (static_cast<AsyncMessage *>(msg))->op = op;
- }
- }
- op->_op_dest = MessageQueue::lookup(msg->dest);
- op->_flags |= ASYNC_OPFLAGS_FIRE_AND_FORGET;
- op->_flags &= ~(ASYNC_OPFLAGS_CALLBACK | ASYNC_OPFLAGS_SAFE_CALLBACK
- | ASYNC_OPFLAGS_SIMPLE_STATUS);
- op->_state &= ~ASYNC_OPSTATE_COMPLETE;
- if (op->_op_dest == 0)
- {
- op->release();
- return_op(op);
- return false;
- }
-
- // now see if the meta dispatcher will take it
- return _meta_dispatcher->route_async(op);
+ AsyncOpNode* op = 0;
+ Uint32 mask = msg->getMask();
+
+ if (mask & MessageMask::ha_async)
+ {
+ op = (static_cast<AsyncMessage *>(msg))->op;
+ }
+
+ if (op == 0)
+ {
+ op = get_op();
+ op->_request.reset(msg);
+ if (mask & MessageMask::ha_async)
+ {
+
(static_cast<AsyncMessage *>(msg))->op = op;
+ }
+ }
+ op->_op_dest = MessageQueue::lookup(msg->dest);
+ op->_flags |= ASYNC_OPFLAGS_FIRE_AND_FORGET;
+ op->_flags &= ~(ASYNC_OPFLAGS_CALLBACK | ASYNC_OPFLAGS_SAFE_CALLBACK
+ | ASYNC_OPFLAGS_SIMPLE_STATUS);
+ op->_state &= ~ASYNC_OPSTATE_COMPLETE;
+ if (op->_op_dest == 0)
+ {
+ op->release();
+ return_op(op);
+ return false;
+ }
+
+ // now see if the meta dispatcher will take it
+ return _meta_dispatcher->route_async(op);
}
-AsyncReply *MessageQueueService::SendWait(AsyncRequest *request)
+AsyncReply *MessageQueueService::SendWait(AsyncRequest* request)
{
- if (request == 0)
- return 0 ;
-
- Boolean destroy_op = false;
-
- if (request->op == 0)
- {
- request->op = get_op();
- request->op->_request.reset(request);
- destroy_op = true;
- }
-
- request->block = false;
- request->op->_flags |= ASYNC_OPFLAGS_PSEUDO_CALLBACK;
- SendAsync(
- request->op,
- request->dest,
- _sendwait_callback,
- this,
- (void *)0);
-
- request->op->_client_sem.wait();
-
- AsyncReply* rpl = static_cast<AsyncReply *>(request->op->removeResponse());
- rpl->op = 0;
-
- if (destroy_op == true)
- {
- request->op->lock();
- request->op->_request.release();
- request->op->_state |= ASYNC_OPSTATE_RELEASED;
- request->op->unlock();
- return_op(request->op);
- request->op = 0;
- }
- return rpl;
+ if (request == 0)
+ return 0;
+
+ Boolean destroy_op = false;
+
+ if (request->op == 0)
+ {
+ request->op = get_op();
+ request->op->_request.reset(request);
+ destroy_op = true;
+ }
+
+ request->block = false;
+ request->op->_flags |= ASYNC_OPFLAGS_PSEUDO_CALLBACK;
+ SendAsync(
+ request->op,
+ request->dest,
+ _sendwait_callback,
+ this,
+ (void *)0);
+
+ request->op->_client_sem.wait();
+
+
AsyncReply* rpl = static_cast<AsyncReply *>(request->op->removeResponse());
+ rpl->op = 0;
+
+ if (destroy_op == true)
+ {
+ request->op->lock();
+ request->op->_request.release();
+ request->op->_state |= ASYNC_OPSTATE_RELEASED;
+ request->op->unlock();
+ return_op(request->op);
+ request->op = 0;
+ }
+ return rpl;
}
Uint32 capabilities,
Uint32 mask)
{
- RegisterCimService *msg = new RegisterCimService(
- 0,
- true,
- name,
- capabilities,
- mask,
- _queueId);
- msg->dest = CIMOM_Q_ID;
-
- Boolean registered = false;
- AsyncReply *reply = static_cast<AsyncReply *>(SendWait(msg));
-
- if (reply != 0)
- {
- if (reply->getMask() & MessageMask::ha_async)
- {
- if (reply->getMask() & MessageMask::ha_reply)
- {
- if (reply->result == async_results::OK ||
- reply->result == async_results::MODULE_ALREADY_REGISTERED)
+ RegisterCimService *msg = new RegisterCimService(
+ 0,
+ true,
+ name,
+ capabilities,
+ mask,
+ _queueId);
+ msg->dest = CIMOM_Q_ID;
+
+ Boolean registered = false;
+ AsyncReply *reply = static_cast<AsyncReply *>(SendWait(msg));
+
+ if (reply != 0)
+ {
+ if (reply->getMask() & MessageMask::ha_async)
+ {
+ if (reply->getMask() & MessageMask::ha_reply)
{
- registered = true;
+ if (reply->result == async_results::OK ||
+ reply->result == async_results::MODULE_ALREADY_REGISTERED)
+ {
+ registered = true;
+ }
}
- }
- }
+ }
- delete reply;
- }
- delete msg;
- return registered;
+ delete reply;
+ }
+ delete msg;
+ return registered;
}
Boolean MessageQueueService::update_service(Uint32 capabilities, Uint32 mask)
{
- UpdateCimService *msg = new UpdateCimService(
- 0,
- true,
- _queueId,
- _capabilities,
- _mask);
- Boolean registered = false;
-
- AsyncMessage *reply = SendWait(msg);
- if (reply)
- {
- if (reply->getMask() & MessageMask::ha_async)
- {
- if (reply->getMask() & MessageMask::ha_reply)
- {
- if (static_cast<AsyncReply *>(reply)->result == async_results::OK)
+ UpdateCimService *msg = new UpdateCimService(
+ 0,
+ true,
+ _queueId,
+ _capabilities,
+ _mask);
+ Boolean registered = false;
+
+ AsyncMessage* reply = SendWait(msg);
+ if (reply)
+ {
+ if (reply->getMask() & MessageMask::ha_async)
+ {
+ if (reply->getMask() & MessageMask::ha_reply)
{
- registered = true;
+ if (static_cast<AsyncReply *>(reply)->result ==
+ async_results::OK)
+ {
+ registered = true;
+ }
}
- }
- }
- delete reply;
- }
- delete msg;
- return registered;
+ }
+ delete reply;
+ }
+ delete msg;
+ return registered;
}
Boolean MessageQueueService::deregister_service()
{
-
- _meta_dispatcher->deregister_module(_queueId);
- return true;
+ _meta_dispatcher->deregister_module(_queueId);
+ return true;
}
String name,
Uint32 capabilities,
Uint32 mask,
- Array<Uint32> *results)
+ Array<Uint32>* results)
{
- if (results == 0)
- {
- throw NullPointer();
- }
-
- results->clear();
-
- FindServiceQueue *req = new FindServiceQueue(
- 0,
- _queueId,
- true,
- name,
- capabilities,
- mask);
-
- req->dest = CIMOM_Q_ID;
-
- AsyncMessage *reply = SendWait(req);
- if (reply)
- {
- if (reply->getMask() & MessageMask::ha_async)
- {
- if (reply->getMask() & MessageMask::ha_reply)
- {
- if (reply->getType() == async_messages::FIND_SERVICE_Q_RESULT)
+ if (results == 0)
+ {
+ throw NullPointer();
+ }
+
+ results->clear();
+
+ FindServiceQueue *req = new FindServiceQueue(
+ 0,
+ _queueId,
+ true,
+ name,
+ capabilities,
+ mask);
+
+ req->dest = CIMOM_Q_ID;
+
+ AsyncMessage *reply = SendWait(req);
+ if (reply)
+ {
+ if (reply->getMask() & MessageMask::ha_async)
+ {
+ if (reply->getMask() & MessageMask::ha_reply)
{
- if ((static_cast<FindServiceQueueResult *>(reply))->result == async_results::OK)
- *results = (static_cast<FindServiceQueueResult *>(reply))->qids;
+ if (reply->getType() == async_messages::FIND_SERVICE_Q_RESULT)
+ {
+ if ((static_cast<FindServiceQueueResult*>(reply))->result ==
+ async_results::OK)
+ *results =
+ (static_cast<FindServiceQueueResult*>(reply))->qids;
+ }
}
- }
- }
- delete reply;
- }
- delete req;
- return ;
+ }
+ delete reply;
+ }
+ delete req;
}
-void MessageQueueService::enumerate_service(Uint32 queue, message_module *result)
+void MessageQueueService::enumerate_service(
+ Uint32 queue,
+ message_module* result)
{
- if (result == 0)
- {
- throw NullPointer();
- }
-
- EnumerateService *req = new EnumerateService(
- 0,
- _queueId,
- true,
- queue);
-
- AsyncMessage *reply = SendWait(req);
-
- if (reply)
- {
- Boolean found = false;
-
- if (reply->getMask() & MessageMask::ha_async)
- {
- if (reply->getMask() & MessageMask::ha_reply)
- {
- if (reply->getType() == async_messages::ENUMERATE_SERVICE_RESULT)
+ if (result == 0)
+ {
+ throw NullPointer();
+ }
+
+ EnumerateService *req = new EnumerateService(
+ 0,
+ _queueId,
+ true,
+ queue);
+
+ AsyncMessage* reply = SendWait(req);
+
+ if (reply)
+ {
+ Boolean found = false;
+
+ if (reply->getMask() & MessageMask::ha_async)
+ {
+ if (reply->getMask() & MessageMask::ha_reply)
{
- if ((static_cast<EnumerateServiceResponse *>(reply))->result == async_results::OK)
- {
- if (found == false)
- {
- found = true;
-
- result->put_name((static_cast<EnumerateServiceResponse *>(reply))->name);
- result->put_capabilities((static_cast<EnumerateServiceResponse *>(reply))->capabilities);
- result->put_mask((static_cast<EnumerateServiceResponse *>(reply))->mask);
- result->put_queue((static_cast<EnumerateServiceResponse *>(reply))->qid);
- }
- }
+ if (reply->getType() ==
+ async_messages::ENUMERATE_SERVICE_RESULT)
+ {
+ if ((static_cast<EnumerateServiceResponse*>(reply))->
+ result == async_results::OK)
+ {
+ if (found == false)
+ {
+ found = true;
+
+ result->put_name((static_cast<
+ EnumerateServiceResponse*>(reply))->name);
+ result->put_capabilities((static_cast<
+ EnumerateServiceResponse*>(reply))->
+ capabilities);
+ result->put_mask((static_cast<
+ EnumerateServiceResponse*>(reply))->mask);
+ result->put_queue((static_cast<
+ EnumerateServiceResponse*>(reply))->qid);
+ }
+ }
+ }
}
- }
- }
- delete reply;
- }
- delete req;
-
- return;
+ }
+ delete reply;
+ }
+ delete req;
}
MessageQueueService::PollingList* MessageQueueService::_get_polling_list()
_polling_list_mutex.lock();
if (!_polling_list)
- _polling_list = new PollingList;
+ _polling_list = new PollingList;
_polling_list_mutex.unlock();
class cimom;
-class PEGASUS_COMMON_LINKAGE MessageQueueService :
+class PEGASUS_COMMON_LINKAGE MessageQueueService :
public Linkable, public MessageQueue
{
public:
typedef MessageQueue Base;
MessageQueueService(
- const char *name,
+ const char* name,
Uint32 queueID = MessageQueue::getNextQueueId(),
Uint32 capabilities = 0,
Uint32 mask = MessageMask::type_cimom |
// enqueue may throw an IPCException
virtual void enqueue(Message *);
- AsyncReply *SendWait(AsyncRequest *request);
- Boolean SendAsync(AsyncOpNode *op,
- Uint32 destination,
- void (*callback)(AsyncOpNode *, MessageQueue *, void *),
- MessageQueue *callback_q,
- void *callback_ptr);
+ AsyncReply* SendWait(AsyncRequest* request);
+ Boolean SendAsync(AsyncOpNode* op,
+ Uint32 destination,
+ void (*callback)(AsyncOpNode*, MessageQueue*, void*),
+ MessageQueue* callback_q,
+ void* callback_ptr);
Boolean SendAsync(Message *msg,
- Uint32 destination,
- void (*callback)(Message *response, void *handle, void *parameter),
- void *handle,
- void *parameter);
+ Uint32 destination,
+ void (*callback)(Message* response, void* handle, void* parameter),
+ void* handle,
+ void* parameter);
- Boolean SendForget(Message *msg);
+ Boolean SendForget(Message* msg);
Boolean register_service(String name, Uint32 capabilities, Uint32 mask);
Boolean deregister_service();
virtual void _shutdown_incoming_queue();
- void find_services(String name,
- Uint32 capabilities,
- Uint32 mask,
- Array<Uint32> *results);
- void enumerate_service(Uint32 queue, message_module *result);
- static AsyncOpNode *get_op();
- void return_op(AsyncOpNode *op);
+ void find_services(
+ String name,
+ Uint32 capabilities,
+ Uint32 mask,
+ Array<Uint32>* results);
+ void enumerate_service(Uint32 queue, message_module* result);
+ static AsyncOpNode* get_op();
+ void return_op(AsyncOpNode* op);
- static ThreadPool *get_thread_pool();
+ static ThreadPool* get_thread_pool();
Uint32 _mask;
AtomicInt _die;
- AtomicInt _threads;
- Uint32 getIncomingCount() {return _incoming.count(); }
+ AtomicInt _threads;
+ Uint32 getIncomingCount() {return _incoming.count(); }
protected:
- virtual Boolean accept_async(AsyncOpNode *op);
- virtual Boolean messageOK(const Message *msg);
+ virtual Boolean accept_async(AsyncOpNode* op);
+ virtual Boolean messageOK(const Message* msg);
virtual void handleEnqueue() = 0;
virtual void handleEnqueue(Message *) = 0;
Boolean _enqueueResponse(Message *, Message *);
-// virtual void _handle_incoming_operation(AsyncOpNode *operation, Thread *thread, MessageQueue *queue);
+// virtual void _handle_incoming_operation(
+// AsyncOpNode* operation,
+// Thread* thread,
+// MessageQueue* queue);
virtual void _handle_incoming_operation(AsyncOpNode *);
- virtual void _handle_async_request(AsyncRequest *req);
- virtual void _handle_async_callback(AsyncOpNode *operation);
- virtual void _make_response(Message *req, Uint32 code);
-
- virtual void handle_heartbeat_request(AsyncRequest *req);
- virtual void handle_heartbeat_reply(AsyncReply *rep);
-
- virtual void handle_AsyncIoctl(AsyncIoctl *req);
- virtual void handle_CimServiceStart(CimServiceStart *req);
- virtual void handle_CimServiceStop(CimServiceStop *req);
- virtual void handle_CimServicePause(CimServicePause *req);
- virtual void handle_CimServiceResume(CimServiceResume *req);
-
- virtual void handle_AsyncOperationStart(AsyncOperationStart *req);
- virtual void handle_AsyncOperationResult(AsyncOperationResult *rep);
- virtual void handle_AsyncLegacyOperationStart(AsyncLegacyOperationStart *req);
- virtual void handle_AsyncLegacyOperationResult(AsyncLegacyOperationResult *rep);
-
- void _completeAsyncResponse(AsyncRequest *request,
- AsyncReply *reply,
- Uint32 state,
- Uint32 flag);
+ virtual void _handle_async_request(AsyncRequest* req);
+ virtual void _handle_async_callback(AsyncOpNode* operation);
+ virtual void _make_response(Message* req, Uint32 code);
+
+ virtual void handle_heartbeat_request(AsyncRequest* req);
+ virtual void handle_heartbeat_reply(AsyncReply* rep);
+
+ virtual void handle_AsyncIoctl(AsyncIoctl* req);
+ virtual void handle_CimServiceStart(CimServiceStart* req);
+ virtual void handle_CimServiceStop(CimServiceStop* req);
+ virtual void handle_CimServicePause(CimServicePause* req);
+ virtual void handle_CimServiceResume(CimServiceResume* req);
+
+ virtual void handle_AsyncOperationStart(AsyncOperationStart* req);
+ virtual void handle_AsyncOperationResult(AsyncOperationResult* rep);
+ virtual void handle_AsyncLegacyOperationStart(
+ AsyncLegacyOperationStart* req);
+ virtual void handle_AsyncLegacyOperationResult(
+ AsyncLegacyOperationResult* rep);
+
+ void _completeAsyncResponse(
+ AsyncRequest* request,
+ AsyncReply* reply,
+ Uint32 state,
+ Uint32 flag);
void _complete_op_node(AsyncOpNode *, Uint32, Uint32, Uint32);
- static cimom *_meta_dispatcher;
+ static cimom* _meta_dispatcher;
static AtomicInt _service_count;
static Mutex _meta_dispatcher_mutex;
- static ThreadPool *_thread_pool;
+ static ThreadPool* _thread_pool;
private:
static ThreadReturnType PEGASUS_THREAD_CDECL polling_routine(void *);
return _name;
}
-Message* RegisteredModuleHandle::_receive_message(Message *msg)
+Message* RegisteredModuleHandle::_receive_message(Message* msg)
{
return _module_receive_message(msg, _module_address);
}
}
-ModuleController::ModuleController(const char *name )
- :Base(name, MessageQueue::getNextQueueId(),
- module_capabilities::module_controller |
- module_capabilities::async),
- _modules()
+ModuleController::ModuleController(const char* name)
+ : Base(name, MessageQueue::getNextQueueId(),
+ module_capabilities::module_controller |
+ module_capabilities::async),
+ _modules()
{
}
ModuleController::~ModuleController()
{
+ RegisteredModuleHandle* module;
- RegisteredModuleHandle *module;
-
- try
- {
- module = _modules.remove_front();
- while(module)
- {
- delete module;
- module = _modules.remove_front();
- }
-
- }
- catch(...)
- {
- }
+ try
+ {
+ module = _modules.remove_front();
+ while (module)
+ {
+ delete module;
+ module = _modules.remove_front();
+ }
+ }
+ catch (...)
+ {
+ }
}
// called by a module to register itself, returns a handle to the controller
-ModuleController & ModuleController::register_module(
- const String & controller_name,
- const String & module_name,
- void *module_address,
- Message * (*receive_message)(Message *, void *),
+ModuleController& ModuleController::register_module(
+ const String& controller_name,
+ const String& module_name,
+ void* module_address,
+ Message* (*receive_message)(Message *, void *),
void (*async_callback)(Uint32, Message *, void *),
RegisteredModuleHandle** instance)
{
- RegisteredModuleHandle *module;
- ModuleController *controller;
-
- Array<Uint32> services;
-
- MessageQueue *message_queue = MessageQueue::lookup(controller_name.getCString());
+ RegisteredModuleHandle *module;
+ ModuleController *controller;
- if ((message_queue == NULL) || ( false == message_queue->isAsync() ))
- {
- throw IncompatibleTypesException();
- }
+ Array<Uint32> services;
- MessageQueueService *service = static_cast<MessageQueueService *>(message_queue);
- if( (service == NULL) || ! ( service->get_capabilities() & module_capabilities::module_controller ))
- {
- throw IncompatibleTypesException();
- }
+ MessageQueue *message_queue =
+ MessageQueue::lookup(controller_name.getCString());
- controller = static_cast<ModuleController *>(service);
+ if ((message_queue == NULL) || (!message_queue->isAsync()))
+ {
+ throw IncompatibleTypesException();
+ }
- {
+ MessageQueueService *service =
+ static_cast<MessageQueueService *>(message_queue);
+ if ((service == NULL) ||
+ !(service->get_capabilities() & module_capabilities::module_controller))
+ {
+ throw IncompatibleTypesException();
+ }
- // see if the module already exists in this controller.
- _module_lock lock(&(controller->_modules));
+ controller = static_cast<ModuleController *>(service);
- module = controller->_modules.front();
- while(module != NULL )
- {
- if(module->get_name() == module_name )
- {
- MessageLoaderParms parms("Common.ModuleController.MODULE",
- "module \"$0\"",
- module_name);
- throw AlreadyExistsException(parms);
- }
- module = controller->_modules.next_of(module);
- }
+ {
- }
+ // see if the module already exists in this controller.
+ _module_lock lock(&(controller->_modules));
+
+ module = controller->_modules.front();
+ while (module != NULL)
+ {
+ if (module->get_name() == module_name)
+ {
+ MessageLoaderParms parms(
+ "Common.ModuleController.MODULE",
+ "module \"$0\"",
+ module_name);
+ throw AlreadyExistsException(parms);
+ }
+ module = controller->_modules.next_of(module);
+ }
+ }
- // now reserve this module name with the meta dispatcher
+ // now reserve this module name with the meta dispatcher
- Uint32 result = 0 ;
- AutoPtr<RegisteredModule> request(new RegisteredModule(
- 0,
- true,
- controller->getQueueId(),
- module_name));
+ Uint32 result = 0;
+ AutoPtr<RegisteredModule> request(new RegisteredModule(
+ 0,
+ true,
+ controller->getQueueId(),
+ module_name));
- request->dest = CIMOM_Q_ID;
+ request->dest = CIMOM_Q_ID;
- AutoPtr<AsyncReply> response(controller->SendWait(request.get()));
- if( response.get() != NULL)
- result = response->result;
+
AutoPtr<AsyncReply> response(controller->SendWait(request.get()));
+ if (response.get() != NULL)
+ result = response->result;
- request.reset();
- response.reset();
- if ( result == async_results::MODULE_ALREADY_REGISTERED)
- {
- MessageLoaderParms parms("Common.ModuleController.MODULE",
- "module \"$0\"", module_name);
- throw AlreadyExistsException(parms);
- }
+ request.reset();
+ response.reset();
+ if (result == async_results::MODULE_ALREADY_REGISTERED)
+ {
+ MessageLoaderParms parms(
+ "Common.ModuleController.MODULE",
+ "module \"$0\"", module_name);
+ throw AlreadyExistsException(parms);
+ }
- // the module does not exist, go ahead and create it.
- module = new RegisteredModuleHandle(
- module_name,
- module_address,
- receive_message,
- async_callback);
+ // the module does not exist, go ahead and create it.
+ module = new RegisteredModuleHandle(
+ module_name,
+ module_address,
+ receive_message,
+ async_callback);
- controller->_modules.insert_back(module);
+ controller->_modules.insert_back(module);
- if(instance != NULL)
- *instance = module;
+ if (instance != NULL)
+ *instance = module;
- return *controller;
+ return *controller;
}
-Boolean ModuleController::deregister_module(const String & module_name)
+Boolean ModuleController::deregister_module(const String& module_name)
{
- AutoPtr<DeRegisteredModule> request(new DeRegisteredModule(
- 0,
- true,
- getQueueId(),
- module_name));
- request->dest = _meta_dispatcher->getQueueId();
+ AutoPtr<DeRegisteredModule> request(new DeRegisteredModule(
+ 0,
+ true,
+ getQueueId(),
+ module_name));
+ request->dest = _meta_dispatcher->getQueueId();
- AutoPtr<AsyncReply> response(SendWait(request.get()));
+
AutoPtr<AsyncReply> response(SendWait(request.get()));
- request.reset();
- response.reset();
+ request.reset();
+ response.reset();
- RegisteredModuleHandle *module;
+ RegisteredModuleHandle* module;
- _module_lock lock(&_modules);
- module = _modules.front();
- while(module != NULL )
- {
- if( module->get_name() == module_name)
- {
- _modules.remove(module);
- return true;
- }
- module = _modules.next_of(module);
- }
- return false;
+ _module_lock lock(&_modules);
+ module = _modules.front();
+ while (module != NULL)
+ {
+ if (module->get_name() == module_name)
+ {
+ _modules.remove(module);
+ return true;
+ }
+ module = _modules.next_of(module);
+ }
+ return false;
}
-Boolean ModuleController::verify_handle(RegisteredModuleHandle *handle)
+Boolean ModuleController::verify_handle(RegisteredModuleHandle* handle)
{
- RegisteredModuleHandle *module;
+ RegisteredModuleHandle *module;
- if (handle->_module_address == (void *)this)
- return true;
+ if (handle->_module_address == (void *)this)
+ return true;
- _module_lock lock(&_modules);
+ _module_lock lock(&_modules);
- module = _modules.front();
- while(module != NULL)
- {
- if ( module == handle)
- {
- return true;
- }
- module = _modules.next_of(module);
- }
- return false;
+ module = _modules.front();
+ while (module != NULL)
+ {
+ if ( module == handle)
+ {
+ return true;
+ }
+ module = _modules.next_of(module);
+ }
+ return false;
}
// given a name, find a service's queue id
Uint32 ModuleController::find_service(
- const RegisteredModuleHandle & handle,
- const String & name)
+ const RegisteredModuleHandle& handle,
+ const String& name)
{
-
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw Permission(Threads::self());
- Array<Uint32> services;
- Base::find_services(name, 0, 0, &services);
- return( services[0]);
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw Permission(Threads::self());
+ Array<Uint32> services;
+ Base::find_services(name, 0, 0, &services);
+ return services[0];
}
// zero otherwise
Uint32 ModuleController::find_module_in_service(
- const RegisteredModuleHandle & handle,
- const String & name)
+ const RegisteredModuleHandle& handle,
+ const String& name)
{
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
- Uint32 result = 0 ;
+ Uint32 result = 0;
- AutoPtr<FindModuleInService> request(new FindModuleInService(
- 0,
- true,
- _meta_dispatcher->getQueueId(),
- name));
- request->dest = _meta_dispatcher->getQueueId();
- AutoPtr<FindModuleInServiceResponse>
- response(static_cast<FindModuleInServiceResponse *>(SendWait(request.get())));
- if( response.get() != NULL)
- result = response->_module_service_queue;
+ AutoPtr<FindModuleInService> request(new FindModuleInService(
+ 0,
+ true,
+ _meta_dispatcher->getQueueId(),
+ name));
+ request->dest = _meta_dispatcher->getQueueId();
+ AutoPtr<FindModuleInServiceResponse> response(
+ static_cast<FindModuleInServiceResponse *>(SendWait(request.get())));
+ if (response.get() != NULL)
+ result = response->_module_service_queue;
- return result;
+ return result;
}
-AsyncReply *ModuleController::_send_wait(Uint32 destination_q,
- AsyncRequest *request)
+AsyncReply* ModuleController::_send_wait(
+ Uint32 destination_q,
+ AsyncRequest* request)
{
- request->dest = destination_q;
- AsyncReply *reply = Base::SendWait(request);
- return reply;
+ request->dest = destination_q;
+ AsyncReply* reply = Base::SendWait(request);
+ return reply;
}
// sendwait to another service
-AsyncReply * ModuleController::ModuleSendWait(
- const RegisteredModuleHandle & handle,
+AsyncReply* ModuleController::ModuleSendWait(
+ const RegisteredModuleHandle& handle,
Uint32 destination_q,
- AsyncRequest *request)
+ AsyncRequest* request)
{
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
- return _send_wait(destination_q, request);
+ return _send_wait(destination_q, request);
}
-AsyncReply *ModuleController::_send_wait(Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message)
+AsyncReply* ModuleController::_send_wait(
+ Uint32 destination_q,
+ const String& destination_module,
+ AsyncRequest* message)
{
- AutoPtr<AsyncModuleOperationStart> request(new AsyncModuleOperationStart(
- 0,
- destination_q,
- getQueueId(),
- true,
- destination_module,
- message));
+
AutoPtr<AsyncModuleOperationStart> request(new AsyncModuleOperationStart(
+ 0,
+ destination_q,
+ getQueueId(),
+ true,
+ destination_module,
+ message));
- request->dest = destination_q;
- AutoPtr<AsyncModuleOperationResult>
-
response(static_cast<AsyncModuleOperationResult *>(SendWait(request.get())));
+ request->dest = destination_q;
+ AutoPtr<AsyncModuleOperationResult> response(
+
static_cast<AsyncModuleOperationResult *>(SendWait(request.get())));
- AsyncReply *ret = 0;
+ AsyncReply *ret = 0;
- if (response.get() != NULL && response->getType() == async_messages::ASYNC_MODULE_OP_RESULT )
- {
- ret = static_cast<AsyncReply *>(response->get_result());
- //clear the request out of the envelope so it can be deleted by the module
- }
- request->get_action();
- return ret;
+ if (response.get() != NULL &&
+ response->getType() == async_messages::ASYNC_MODULE_OP_RESULT)
+ {
+ // clear the request out of the envelope so it can be deleted by the
+ // module
+ ret = static_cast<AsyncReply *>(response->get_result());
+ }
+ request->get_action();
+ return ret;
}
// sendwait to another module controlled by another service.
// throws Deadlock() if destination_q is this->queue_id
-AsyncReply * ModuleController::ModuleSendWait(
- const RegisteredModuleHandle & handle,
+AsyncReply* ModuleController::ModuleSendWait(
+ const RegisteredModuleHandle& handle,
Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message)
+ const String& destination_module,
+ AsyncRequest* message)
{
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
- return _send_wait(destination_q, destination_module, message);
+ return _send_wait(destination_q, destination_module, message);
}
-void ModuleController::_async_handleEnqueue(AsyncOpNode *op,
- MessageQueue *q,
- void *parm)
+void ModuleController::_async_handleEnqueue(
+ AsyncOpNode* op,
+ MessageQueue* q,
+ void* parm)
{
+ ModuleController* myself = static_cast<ModuleController *>(q);
+ Message* request = op->removeRequest();
+ Message* response = op->removeResponse();
- ModuleController *myself = static_cast<ModuleController *>(q);
- Message *request = op->removeRequest();
- Message *response = op->removeResponse();
-
- if( request && (! (request->getMask() & MessageMask::ha_async)))
- throw TypeMismatchException();
-
- if( response && (! (response->getMask() & MessageMask::ha_async) ))
- throw TypeMismatchException();
+ if (request && (!(request->getMask() & MessageMask::ha_async)))
+ throw TypeMismatchException();
- op->release();
- myself->return_op(op);
+ if (response && (!(response->getMask() & MessageMask::ha_async)))
+ throw TypeMismatchException();
- // get rid of the module wrapper
- if( request && request->getType() == async_messages::ASYNC_MODULE_OP_START )
- {
- (static_cast<AsyncMessage *>(request))->op = NULL;
- AsyncModuleOperationStart *rq = static_cast<AsyncModuleOperationStart *>(request);
- request = rq->get_action();
- delete rq;
- }
+ op->release();
+ myself->return_op(op);
- // get rid of the module wrapper
- if(response && response->getType() == async_messages::ASYNC_MODULE_OP_RESULT )
- {
- (static_cast<AsyncMessage *>(response))->op = NULL;
- AsyncModuleOperationResult *rp = static_cast<AsyncModuleOperationResult *>(response);
- response = rp->get_result();
- delete rp;
- }
+ // get rid of the module wrapper
+ if (request && request->getType() == async_messages::ASYNC_MODULE_OP_START)
+ {
+ (static_cast<AsyncMessage *>(request))->op = NULL;
+ AsyncModuleOperationStart *rq =
+ static_cast<AsyncModuleOperationStart *>(request);
+ request = rq->get_action();
+ delete rq;
+ }
- callback_handle *cb = reinterpret_cast<callback_handle *>(parm);
+ // get rid of the module wrapper
+ if (response &&
+ response->getType() == async_messages::ASYNC_MODULE_OP_RESULT)
+ {
+ (static_cast<AsyncMessage *>(response))->op = NULL;
+ AsyncModuleOperationResult *rp =
+ static_cast<AsyncModuleOperationResult *>(response);
+ response = rp->get_result();
+ delete rp;
+ }
- cb->_module->_send_async_callback(0, response, cb->_parm);
- delete cb;
+ callback_handle *cb = reinterpret_cast<callback_handle *>(parm);
- return;
+ cb->_module->_send_async_callback(0, response, cb->_parm);
+ delete cb;
}
// send an async message to a service asynchronously
Boolean ModuleController::ModuleSendAsync(
- const RegisteredModuleHandle & handle,
+ const RegisteredModuleHandle& handle,
Uint32 msg_handle,
Uint32 destination_q,
- AsyncRequest *message,
- void *callback_parm)
+ AsyncRequest* message,
+ void* callback_parm)
{
- //printf("verifying handle %p, controller at %p \n", &handle, this);
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
-
- if (message->op == NULL)
- {
- message->op = get_op();
- message->op->setRequest(message);
- }
+ if (message->op == NULL)
+ {
+ message->op = get_op();
+ message->op->setRequest(message);
+ }
- callback_handle *cb = new callback_handle(
- const_cast<RegisteredModuleHandle *>(&handle),
- callback_parm);
+ callback_handle *cb = new callback_handle(
+ const_cast<RegisteredModuleHandle *>(&handle),
+ callback_parm);
- message->resp = getQueueId();
- message->block = false;
- message->dest = destination_q;
- return SendAsync(message->op,
- destination_q,
- _async_handleEnqueue,
- this,
- cb);
+ message->resp = getQueueId();
+ message->block = false;
+ message->dest = destination_q;
+ return SendAsync(
+ message->op,
+ destination_q,
+ _async_handleEnqueue,
+ this,
+ cb);
}
// send a message to a module within another service asynchronously
-Boolean ModuleController::ModuleSendAsync(const RegisteredModuleHandle& handle,
- Uint32 msg_handle,
- Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message,
- void *callback_parm)
-{
-
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
-
- AsyncOpNode *op = get_op();
- AsyncModuleOperationStart *request =
- new AsyncModuleOperationStart(
- op,
- destination_q,
- getQueueId(),
- true,
- destination_module,
- message);
- request->dest = destination_q;
- callback_handle *cb = new callback_handle(
- const_cast<RegisteredModuleHandle *>(&handle),
- callback_parm);
- return SendAsync(op,
- destination_q,
- _async_handleEnqueue,
- this,
- cb);
-}
-
-
-Boolean ModuleController::_send_forget(Uint32 destination_q, AsyncRequest *message)
+Boolean ModuleController::ModuleSendAsync(
+ const RegisteredModuleHandle& handle,
+ Uint32 msg_handle,
+ Uint32 destination_q,
+ const String& destination_module,
+ AsyncRequest* message,
+ void* callback_parm)
+{
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
+
+ AsyncOpNode *op = get_op();
+ AsyncModuleOperationStart *request = new AsyncModuleOperationStart(
+ op,
+ destination_q,
+ getQueueId(),
+ true,
+ destination_module,
+ message);
+ request->dest = destination_q;
+ callback_handle* cb = new callback_handle(
+ const_cast<RegisteredModuleHandle *>(&handle),
+ callback_parm);
+ return SendAsync(
+ op,
+ destination_q,
+ _async_handleEnqueue,
+ this,
+ cb);
+}
+
+
+Boolean ModuleController::_send_forget(
+ Uint32 destination_q,
+ AsyncRequest *message)
{
- message->dest = destination_q;
- return SendForget(message);
+ message->dest = destination_q;
+ return SendForget(message);
}
-Boolean ModuleController::_send_forget(Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message)
+Boolean ModuleController::_send_forget(
+ Uint32 destination_q,
+ const String& destination_module,
+ AsyncRequest* message)
{
- AsyncOpNode *op = get_op();
- message->dest = destination_q;
- AsyncModuleOperationStart *request =
- new AsyncModuleOperationStart(
- op,
- destination_q,
- getQueueId(),
- true,
- destination_module,
- message);
- return SendForget(request);
+ AsyncOpNode* op = get_op();
+ message->dest = destination_q;
+ AsyncModuleOperationStart* request = new AsyncModuleOperationStart(
+ op,
+ destination_q,
+ getQueueId(),
+ true,
+ destination_module,
+ message);
+ return SendForget(request);
}
-
Boolean ModuleController::ModuleSendForget(
- const RegisteredModuleHandle & handle,
+ const RegisteredModuleHandle& handle,
Uint32 destination_q,
- AsyncRequest *message)
+ AsyncRequest* message)
{
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
- return _send_forget(destination_q, message);
+ return _send_forget(destination_q, message);
}
Boolean ModuleController::ModuleSendForget(
- const RegisteredModuleHandle & handle,
+ const RegisteredModuleHandle& handle,
Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message)
+ const String& destination_module,
+ AsyncRequest* message)
+{
+ if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
+ throw(Permission(Threads::self()));
+ return _send_forget(destination_q, destination_module, message);
+}
+
+
+void ModuleController::_handle_async_request(AsyncRequest* rq)
{
- if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
- throw(Permission(Threads::self()));
- return _send_forget(destination_q,
- destination_module,
- message);
-}
-
-
-void ModuleController::_handle_async_request(AsyncRequest *rq)
-{
-
- if( rq->getType() == async_messages::ASYNC_MODULE_OP_START)
- {
- // find the target module
- RegisteredModuleHandle *target;
- Message *module_result = NULL;
-
- {
- _module_lock lock(&_modules);
- target = _modules.front();
- while(target != NULL)
- {
- if(target->get_name() == static_cast<AsyncModuleOperationStart *>(rq)->_target_module)
- {
- break;
- }
-
- target = _modules.next_of(target);
- }
- }
-
- if (target)
- {
- // ATTN: This statement was taken out of the _module_lock block
- // above because that caused all requests to control providers to
- // be serialized. There is now a risk that the control provider
- // module may be deleted after the lookup and before this call.
- // See Bugzilla 3120.
- module_result = target->_receive_message(
- static_cast<AsyncModuleOperationStart *>(rq)->_act);
- }
-
- if(module_result == NULL)
- {
- module_result = new AsyncReply(async_messages::REPLY,
- MessageMask::ha_async | MessageMask::ha_reply,
- rq->op,
- async_results::CIM_NAK,
- rq->resp,
- false);
- }
-
- AsyncModuleOperationResult *result =
- new AsyncModuleOperationResult(
- rq->op,
- async_results::OK,
- static_cast<AsyncModuleOperationStart *>(rq)->resp,
- false,
- static_cast<AsyncModuleOperationStart *>(rq)->_target_module,
- module_result);
- _complete_op_node(rq->op, 0, 0, 0);
- }
- else
- Base::_handle_async_request(rq);
-}
-
-void ModuleController::_handle_async_callback(AsyncOpNode *op)
-{
- Base::_handle_async_callback(op);
+ if (rq->getType() == async_messages::ASYNC_MODULE_OP_START)
+ {
+ // find the target module
+ RegisteredModuleHandle* target;
+ Message* module_result = NULL;
+
+ {
+ _module_lock lock(&_modules);
+ target = _modules.front();
+ while (target != NULL)
+ {
+ if (target->get_name() ==
+ static_cast<AsyncModuleOperationStart *>(rq)->
+ _target_module)
+ {
+ break;
+ }
+
+ target = _modules.next_of(target);
+ }
+ }
+
+ if (target)
+ {
+ // ATTN: This statement was taken out of the _module_lock block
+ // above because that caused all requests to control providers to
+ // be serialized. There is now a risk that the control provider
+ // module may be deleted after the lookup and before this call.
+ // See Bugzilla 3120.
+ module_result = target->_receive_message(
+ static_cast<AsyncModuleOperationStart *>(rq)->_act);
+ }
+
+ if (module_result == NULL)
+ {
+ module_result = new AsyncReply(
+ async_messages::REPLY,
+ MessageMask::ha_async | MessageMask::ha_reply,
+ rq->op,
+ async_results::CIM_NAK,
+ rq->resp,
+ false);
+ }
+
+ AsyncModuleOperationResult *result = new AsyncModuleOperationResult(
+ rq->op,
+ async_results::OK,
+ static_cast<AsyncModuleOperationStart *>(rq)->resp,
+ false,
+ static_cast<AsyncModuleOperationStart *>(rq)->_target_module,
+ module_result);
+ _complete_op_node(rq->op, 0, 0, 0);
+ }
+ else
+ Base::_handle_async_request(rq);
+}
+void ModuleController::_handle_async_callback(AsyncOpNode* op)
+{
+ Base::_handle_async_callback(op);
}
ModuleController* ModuleController::getModuleController()
{
- MessageQueue *messageQueue =
- MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE);
- PEGASUS_ASSERT(messageQueue != 0);
- PEGASUS_ASSERT(messageQueue->isAsync());
+ MessageQueue* messageQueue =
+ MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE);
+ PEGASUS_ASSERT(messageQueue != 0);
+ PEGASUS_ASSERT(messageQueue->isAsync());
- MessageQueueService* service =
- dynamic_cast<MessageQueueService*>(messageQueue);
- PEGASUS_ASSERT(service != 0);
- PEGASUS_ASSERT(
- service->get_capabilities() & module_capabilities::module_controller);
+ MessageQueueService* service =
+ dynamic_cast<MessageQueueService*>(messageQueue);
+ PEGASUS_ASSERT(service != 0);
+ PEGASUS_ASSERT(
+ service->get_capabilities() & module_capabilities::module_controller);
- return static_cast<ModuleController*>(service);
+ return static_cast<ModuleController*>(service);
}
// send a message to another service
-AsyncReply *ModuleController::ClientSendWait(
- Uint32 destination_q,
- AsyncRequest *request)
+AsyncReply* ModuleController::ClientSendWait(
+ Uint32 destination_q,
+ AsyncRequest* request)
{
- return _send_wait(destination_q, request);
+ return _send_wait(destination_q, request);
}
// send a message to another module via another service
AsyncReply *ModuleController::ClientSendWait(
- Uint32 destination_q,
- String & destination_module,
- AsyncRequest *request)
+ Uint32 destination_q,
+ String& destination_module,
+ AsyncRequest* request)
{
- return _send_wait(destination_q, destination_module, request);
+ return _send_wait(destination_q, destination_module, request);
}
// send an async message to another service
Boolean ModuleController::ClientSendAsync(
- Uint32 msg_handle,
- Uint32 destination_q,
- AsyncRequest *message,
- void (*async_callback)(Uint32, Message *, void *) ,
- void *callback_parm)
+ Uint32 msg_handle,
+ Uint32 destination_q,
+ AsyncRequest* message,
+ void (*async_callback)(Uint32, Message *, void *),
+ void* callback_parm)
{
- RegisteredModuleHandle *temp = new RegisteredModuleHandle(
- String(PEGASUS_MODULENAME_TEMP),
- this,
- 0,
- async_callback);
- return ModuleSendAsync( *temp,
- msg_handle,
- destination_q,
- message,
- callback_parm);
+ RegisteredModuleHandle* temp = new RegisteredModuleHandle(
+ String(PEGASUS_MODULENAME_TEMP),
+ this,
+ 0,
+ async_callback);
+ return ModuleSendAsync(
+ *temp,
+ msg_handle,
+ destination_q,
+ message,
+ callback_parm);
}
// send an async message to another module via another service
Boolean ModuleController::ClientSendAsync(
- Uint32 msg_handle,
- Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message,
- void (*async_callback)(Uint32, Message *, void *),
- void *callback_parm)
+ Uint32 msg_handle,
+ Uint32 destination_q,
+ const String& destination_module,
+ AsyncRequest* message,
+ void (*async_callback)(Uint32, Message *, void *),
+ void* callback_parm)
{
- RegisteredModuleHandle *temp = new RegisteredModuleHandle(
- String(PEGASUS_MODULENAME_TEMP),
- this,
- 0,
- async_callback);
- return ModuleSendAsync(*temp,
- msg_handle,
- destination_q,
- destination_module,
- message,
- callback_parm);
+ RegisteredModuleHandle* temp = new RegisteredModuleHandle(
+ String(PEGASUS_MODULENAME_TEMP),
+ this,
+ 0,
+ async_callback);
+ return ModuleSendAsync(
+ *temp,
+ msg_handle,
+ destination_q,
+ destination_module,
+ message,
+ callback_parm);
}
-
Boolean ModuleController::ClientSendForget(
- Uint32 destination_q,
- AsyncRequest *message)
+ Uint32 destination_q,
+ AsyncRequest* message)
{
- return _send_forget(destination_q, message);
+ return _send_forget(destination_q, message);
}
Boolean ModuleController::ClientSendForget(
- Uint32 destination_q,
- const String & destination_module,
- AsyncRequest *message)
+ Uint32 destination_q,
+ const String& destination_module,
+ AsyncRequest* message)
{
- return _send_forget(destination_q, destination_module, message);
+ return _send_forget(destination_q, destination_module, message);
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com) <<< Wed Mar 13 20:49:40 2002 mdd >>>
-//
-// Modified By: Amit K Arora, IBM (amita@in.ibm.com)
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ModuleController_h
virtual ~RegisteredModuleHandle();
- const String & get_name() const;
+ const String& get_name() const;
private:
~callback_handle()
{
- if( _module->get_name() == String(PEGASUS_MODULENAME_TEMP) )
+ if (_module->get_name() == String(PEGASUS_MODULENAME_TEMP))
_module.reset();
}
AutoPtr<RegisteredModuleHandle> _module;
- void *_parm;
+ void* _parm;
};
public:
};
+ static void _async_handleEnqueue(
+ AsyncOpNode* h,
+ MessageQueue* q,
+ void* parm);
- static void _async_handleEnqueue(AsyncOpNode *h, MessageQueue *q, void *parm);
List<RegisteredModuleHandle, Mutex> _modules;
AsyncReply *_send_wait(Uint32, AsyncRequest *);
AsyncReply *_send_wait(Uint32, const String &, AsyncRequest *);
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Dave Sudlik, IBM (dsudlik@us.ibm.com)
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Config.h>
// TRANSLATABLE = "translatable"
// </pre>
//
-// The keyword toinstance is not in the CIM specification. For the moment
+// The keyword toinstance is not in the CIM specification. For the moment
// we are assuming that it is the same as the toSubclass. We had a choice
// of using one entity for both or separating them and letting the
// compiler set both.
//
//==============================================================================
//
-// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_MofWriter_h
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Mike Day (monitor_2) mdday@us.ibm.com
-// Amit K Arora (Bug#1153) amita@in.ibm.com
-// Alagaraja Ramasubramanian (alags_raj@in.ibm.com) for Bug#1090
-// Sushma Fernandes (sushma@hp.com) for Bug#2057
-// Josephine Eskaline Joyce (jojustin@in.ibm.com) for PEP#101
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Network.h"
// Start the count at 1 because initilizeTickler()
// has added an entry in the first position of the
// _entries array
- for( int i = 1; i < numberOfMonitorEntriesToAllocate; i++ )
+ for (int i = 1; i < numberOfMonitorEntriesToAllocate; i++)
{
_MonitorEntry entry(0, 0, 0);
_entries.append(entry);
Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
"returning from monitor destructor");
}
-void Monitor::uninitializeTickler(){
-
+void Monitor::uninitializeTickler()
+{
Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "uninitializing interface");
- try{
- if(_tickle_peer_socket >= 0)
+ try
+ {
+ if (_tickle_peer_socket >= 0)
{
Socket::close(_tickle_peer_socket);
}
- if(_tickle_client_socket >= 0)
+ if (_tickle_client_socket >= 0)
{
Socket::close(_tickle_client_socket);
}
- if(_tickle_server_socket >= 0)
+ if (_tickle_server_socket >= 0)
{
Socket::close(_tickle_server_socket);
}
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
"Failed to close tickle sockets");
}
-void Monitor::initializeTickler(){
+void Monitor::initializeTickler()
+{
/*
NOTE: On any errors trying to
setup out tickle connection,
*/
/* setup the tickle server/listener */
- // try until the tcpip is restarted
+ // try until the tcpip is restarted
do
{
-
// get a socket for the server side
- if((_tickle_server_socket = Socket::createSocket(PF_INET, SOCK_STREAM, 0)) == PEGASUS_INVALID_SOCKET)
+ if ((_tickle_server_socket =
+ Socket::createSocket(PF_INET, SOCK_STREAM, 0)) ==
+ PEGASUS_INVALID_SOCKET)
{
- //handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_CREATE",
- "Received error number $0 while creating the internal socket.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_CREATE",
+ "Received error number $0 while creating the internal socket.",
+ getSocketError());
throw Exception(parms);
}
SocketLength _addr_size = sizeof(_tickle_server_addr);
// bind server side to socket
- if((::bind(_tickle_server_socket,
- reinterpret_cast<struct sockaddr*>(&_tickle_server_addr),
- sizeof(_tickle_server_addr))) < 0)
+ if ((::bind(_tickle_server_socket,
+ reinterpret_cast<struct sockaddr*>(&_tickle_server_addr),
+ sizeof(_tickle_server_addr))) < 0)
{
- // handle error
#ifdef PEGASUS_OS_ZOS
- MessageLoaderParms parms("Common.Monitor.TICKLE_BIND_LONG",
- "Received error:$0 while binding the internal socket."
- ,strerror(errno));
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_BIND_LONG",
+ "Received error:$0 while binding the internal socket.",
+ strerror(errno));
#else
- MessageLoaderParms parms("Common.Monitor.TICKLE_BIND",
- "Received error number $0 while binding the internal socket.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_BIND",
+ "Received error number $0 while binding the internal socket.",
+ getSocketError());
#endif
throw Exception(parms);
}
// tell the kernel we are a server
- if((::listen(_tickle_server_socket,3)) < 0)
+ if ((::listen(_tickle_server_socket, 3)) < 0)
{
- // handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_LISTEN",
- "Received error number $0 while listening to the internal socket.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_LISTEN",
+ "Received error number $0 while listening to the internal "
+ "socket.",
+ getSocketError());
throw Exception(parms);
}
// make sure we have the correct socket for our server
- int sock = ::getsockname(_tickle_server_socket,
- reinterpret_cast<struct sockaddr*>(&_tickle_server_addr),
- &_addr_size);
- if(sock < 0)
+ int sock = ::getsockname(
+ _tickle_server_socket,
+ reinterpret_cast<struct sockaddr*>(&_tickle_server_addr),
+ &_addr_size);
+ if (sock < 0)
{
- // handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_SOCKNAME",
- "Received error number $0 while getting the internal socket name.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_SOCKNAME",
+ "Received error number $0 while getting the internal socket "
+ "name.",
+ getSocketError());
throw Exception(parms);
}
/* set up the tickle client/connector */
// get a socket for our tickle client
- if((_tickle_client_socket = Socket::createSocket(PF_INET, SOCK_STREAM, 0))
- == PEGASUS_INVALID_SOCKET)
+ if ((_tickle_client_socket =
+ Socket::createSocket(PF_INET, SOCK_STREAM, 0)) ==
+ PEGASUS_INVALID_SOCKET)
{
- // handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_CLIENT_CREATE",
- "Received error number $0 while creating the internal client socket.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_CLIENT_CREATE",
+ "Received error number $0 while creating the internal client "
+ "socket.",
+ getSocketError());
throw Exception(parms);
}
// setup the address of the client
memset(&_tickle_client_addr, 0, sizeof(_tickle_client_addr));
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
-#pragma convert(37)
+# pragma convert(37)
#endif
_tickle_client_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
-#pragma convert(0)
+# pragma convert(0)
#endif
_tickle_client_addr.sin_family = PF_INET;
_tickle_client_addr.sin_port = 0;
// bind socket to client side
- if((::bind(_tickle_client_socket,
- reinterpret_cast<struct sockaddr*>(&_tickle_client_addr),
- sizeof(_tickle_client_addr))) < 0)
+ if ((::bind(_tickle_client_socket,
+ reinterpret_cast<struct sockaddr*>(&_tickle_client_addr),
+ sizeof(_tickle_client_addr))) < 0)
{
- // handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_CLIENT_BIND",
- "Received error number $0 while binding the internal client socket.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_CLIENT_BIND",
+ "Received error number $0 while binding the internal client "
+ "socket.",
+ getSocketError());
throw Exception(parms);
}
// connect to server side
- if((::connect(_tickle_client_socket,
- reinterpret_cast<struct sockaddr*>(&_tickle_server_addr),
- sizeof(_tickle_server_addr))) < 0)
+ if ((::connect(_tickle_client_socket,
+ reinterpret_cast<struct sockaddr*>(&_tickle_server_addr),
+ sizeof(_tickle_server_addr))) < 0)
{
- // handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_CLIENT_CONNECT",
- "Received error number $0 while connecting the internal client socket.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_CLIENT_CONNECT",
+ "Received error number $0 while connecting the internal "
+ "client socket.",
+ getSocketError());
throw Exception(parms);
}
SocketLength peer_size = sizeof(_tickle_peer_addr);
Threads::sleep(1);
- // this call may fail, we will try a max of 20 times to establish this peer connection
- if((_tickle_peer_socket = ::accept(_tickle_server_socket,
- reinterpret_cast<struct sockaddr*>(&_tickle_peer_addr),
- &peer_size)) < 0)
+ // this call may fail, we will try a max of 20 times to establish
+ // this peer connection
+ if ((_tickle_peer_socket = ::accept(_tickle_server_socket,
+ reinterpret_cast<struct sockaddr*>(&_tickle_peer_addr),
+ &peer_size)) < 0)
{
- if(_tickle_peer_socket == PEGASUS_SOCKET_ERROR
- && getSocketError() == PEGASUS_NETWORK_TRYAGAIN)
+ if (_tickle_peer_socket == PEGASUS_SOCKET_ERROR &&
+ getSocketError() == PEGASUS_NETWORK_TRYAGAIN)
{
int retries = 0;
do
{
Threads::sleep(1);
- _tickle_peer_socket = ::accept(_tickle_server_socket,
- reinterpret_cast<struct sockaddr*>(&_tickle_peer_addr),
- &peer_size);
+ _tickle_peer_socket = ::accept(
+ _tickle_server_socket,
+ reinterpret_cast<struct sockaddr*>(&_tickle_peer_addr),
+ &peer_size);
retries++;
- } while(_tickle_peer_socket == PEGASUS_SOCKET_ERROR
- && getSocketError() == PEGASUS_NETWORK_TRYAGAIN
- && retries < 20);
+ } while (_tickle_peer_socket == PEGASUS_SOCKET_ERROR &&
+ getSocketError() == PEGASUS_NETWORK_TRYAGAIN &&
+ retries < 20);
}
// TCP/IP is down, destroy sockets and retry again.
- if(_tickle_peer_socket == PEGASUS_SOCKET_ERROR &&
- getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED )
+ if (_tickle_peer_socket == PEGASUS_SOCKET_ERROR &&
+ getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED)
{
// destroy everything
uninitializeTickler();
continue;
}
}
- if(_tickle_peer_socket == PEGASUS_SOCKET_ERROR)
+ if (_tickle_peer_socket == PEGASUS_SOCKET_ERROR)
{
- // handle error
- MessageLoaderParms parms("Common.Monitor.TICKLE_ACCEPT",
- "Received error number $0 while accepting the internal socket connection.",
- getSocketError());
+ MessageLoaderParms parms(
+ "Common.Monitor.TICKLE_ACCEPT",
+ "Received error number $0 while accepting the internal "
+ "socket connection.",
+ getSocketError());
throw Exception(parms);
- } else
+ }
+ else
{
// socket is ok
break;
}
- } while(1); // try until TCP/IP is restarted
+ } while (1); // try until TCP/IP is restarted
Socket::disableBlocking(_tickle_peer_socket);
Socket::disableBlocking(_tickle_client_socket);
- // add the tickler to the list of entries to be monitored and set to IDLE because Monitor only
+ // add the tickler to the list of entries to be monitored and set to
+ // IDLE because Monitor only
// checks entries with IDLE state for events
_MonitorEntry entry(_tickle_peer_socket, 1, INTERNAL);
entry._status = _MonitorEntry::IDLE;
// if not, overwrite the tickler entry with new socket
_entries[0]=entry;
}
-
}
-void Monitor::tickle(void)
+void Monitor::tickle()
{
static char _buffer[] =
{
ArrayIterator<_MonitorEntry> entries(_entries);
- // Check the stopConnections flag. If set, clear the Acceptor monitor entries
+ // Check the stopConnections flag. If set, clear the Acceptor monitor
+ // entries
if (_stopConnections.get() == 1)
{
for ( int indx = 0; indx < (int)entries.size(); indx++)
entries[indx]._status.get() == _MonitorEntry::DYING )
{
// remove the entry
- entries[indx]._status = _MonitorEntry::EMPTY;
+ entries[indx]._status = _MonitorEntry::EMPTY;
}
else
{
}
}
_stopConnections = 0;
- _stopConnectionsSem.signal();
+ _stopConnectionsSem.signal();
}
- for( int indx = 0; indx < (int)entries.size(); indx++)
+ for (int indx = 0; indx < (int)entries.size(); indx++)
{
- const _MonitorEntry &entry = entries[indx];
- if ((entry._status.get() == _MonitorEntry::DYING) &&
- (entry._type == Monitor::CONNECTION))
- {
- MessageQueue *q = MessageQueue::lookup(entry.queueId);
- PEGASUS_ASSERT(q != 0);
- HTTPConnection &h = *static_cast<HTTPConnection *>(q);
-
- if (h._connectionClosePending == false)
- continue;
-
- // NOTE: do not attempt to delete while there are pending responses
- // coming thru. The last response to come thru after a
- // _connectionClosePending will reset _responsePending to false
- // and then cause the monitor to rerun this code and clean up.
- // (see HTTPConnection.cpp)
-
- if (h._responsePending == true)
- {
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "Monitor::run - "
- "Ignoring connection delete request because "
- "responses are still pending. "
- "connection=0x%p, socket=%d\n",
- (void *)&h, h.getSocket());
- continue;
- }
- h._connectionClosePending = false;
- MessageQueue &o = h.get_owner();
- Message* message= new CloseConnectionMessage(entry.socket);
- message->dest = o.getQueueId();
-
- // HTTPAcceptor is responsible for closing the connection.
- // The lock is released to allow HTTPAcceptor to call
- // unsolicitSocketMessages to free the entry.
- // Once HTTPAcceptor completes processing of the close
- // connection, the lock is re-requested and processing of
- // the for loop continues. This is safe with the current
- // implementation of the entries object. Note that the
- // loop condition accesses the entries.size() on each
- // iteration, so that a change in size while the mutex is
- // unlocked will not result in an ArrayIndexOutOfBounds
- // exception.
-
- _entry_mut.unlock();
- o.enqueue(message);
- _entry_mut.lock();
- // After enqueue a message and the autoEntryMutex has been released and locked again,
- // the array of _entries can be changed. The ArrayIterator has be reset with the original _entries.
- entries.reset(_entries);
- }
+ const _MonitorEntry &entry = entries[indx];
+ if ((entry._status.get() == _MonitorEntry::DYING) &&
+ (entry._type == Monitor::CONNECTION))
+ {
+ MessageQueue *q = MessageQueue::lookup(entry.queueId);
+ PEGASUS_ASSERT(q != 0);
+ HTTPConnection &h = *static_cast<HTTPConnection *>(q);
+
+ if (h._connectionClosePending == false)
+ continue;
+
+ // NOTE: do not attempt to delete while there are pending responses
+ // coming thru. The last response to come thru after a
+ // _connectionClosePending will reset _responsePending to false
+ // and then cause the monitor to rerun this code and clean up.
+ // (see HTTPConnection.cpp)
+
+ if (h._responsePending == true)
+ {
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::run - Ignoring connection delete request "
+ "because responses are still pending. "
+ "connection=0x%p, socket=%d\n",
+ (void *)&h, h.getSocket());
+ continue;
+ }
+ h._connectionClosePending = false;
+ MessageQueue &o = h.get_owner();
+ Message* message= new CloseConnectionMessage(entry.socket);
+ message->dest = o.getQueueId();
+
+ // HTTPAcceptor is responsible for closing the connection.
+ // The lock is released to allow HTTPAcceptor to call
+ // unsolicitSocketMessages to free the entry.
+ // Once HTTPAcceptor completes processing of the close
+ // connection, the lock is re-requested and processing of
+ // the for loop continues. This is safe with the current
+ // implementation of the entries object. Note that the
+ // loop condition accesses the entries.size() on each
+ // iteration, so that a change in size while the mutex is
+ // unlocked will not result in an ArrayIndexOutOfBounds
+ // exception.
+
+ _entry_mut.unlock();
+ o.enqueue(message);
+ _entry_mut.lock();
+
+ // After enqueue a message and the autoEntryMutex has been
+ // released and locked again, the array of _entries can be
+ // changed. The ArrayIterator has be reset with the original
+ // _entries.
+ entries.reset(_entries);
+ }
}
Uint32 _idleEntries = 0;
because we have to traverse the entire array.
*/
SocketHandle maxSocketCurrentPass = 0;
- for( int indx = 0; indx < (int)entries.size(); indx++)
+ for (int indx = 0; indx < (int)entries.size(); indx++)
{
- if(maxSocketCurrentPass < entries[indx].socket)
- maxSocketCurrentPass = entries[indx].socket;
+ if (maxSocketCurrentPass < entries[indx].socket)
+ maxSocketCurrentPass = entries[indx].socket;
- if(entries[indx]._status.get() == _MonitorEntry::IDLE)
+ if (entries[indx]._status.get() == _MonitorEntry::IDLE)
{
_idleEntries++;
FD_SET(entries[indx].socket, &fdread);
int events = select(maxSocketCurrentPass, &fdread, NULL, NULL, &tv);
#endif
_entry_mut.lock();
- // After enqueue a message and the autoEntryMutex has been released and locked again,
- // the array of _entries can be changed. The ArrayIterator has be reset with the original _entries
+
+ // After enqueue a message and the autoEntryMutex has been released and
+ // locked again, the array of _entries can be changed. The ArrayIterator
+ // has be reset with the original _entries
entries.reset(_entries);
if (events == PEGASUS_SOCKET_ERROR)
{
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::run - errorno = %d has occurred on select.", errno);
- // The EBADF error indicates that one or more or the file
- // descriptions was not valid. This could indicate that
- // the entries structure has been corrupted or that
- // we have a synchronization error.
-
- PEGASUS_ASSERT(errno != EBADF);
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::run - errorno = %d has occurred on select.", errno);
+ // The EBADF error indicates that one or more or the file
+ // descriptions was not valid. This could indicate that
+ // the entries structure has been corrupted or that
+ // we have a synchronization error.
+
+ PEGASUS_ASSERT(errno != EBADF);
}
else if (events)
{
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::run select event received events = %d, monitoring %d idle entries",
- events, _idleEntries);
- for( int indx = 0; indx < (int)entries.size(); indx++)
- {
- // The Monitor should only look at entries in the table that are IDLE (i.e.,
- // owned by the Monitor).
- if((entries[indx]._status.get() == _MonitorEntry::IDLE) &&
- (FD_ISSET(entries[indx].socket, &fdread)))
- {
- MessageQueue *q = MessageQueue::lookup(entries[indx].queueId);
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::run indx = %d, queueId = %d, q = %p",
- indx, entries[indx].queueId, q);
- PEGASUS_ASSERT(q !=0);
-
- try
- {
- if(entries[indx]._type == Monitor::CONNECTION)
- {
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "entries[indx].type for indx = %d is Monitor::CONNECTION", indx);
- static_cast<HTTPConnection *>(q)->_entry_index = indx;
-
- // Do not update the entry just yet. The entry gets updated once
- // the request has been read.
- //entries[indx]._status = _MonitorEntry::BUSY;
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::run select event received events = %d, monitoring %d "
+ "idle entries",
+ events, _idleEntries);
+ for (int indx = 0; indx < (int)entries.size(); indx++)
+ {
+ // The Monitor should only look at entries in the table that are
+ // IDLE (i.e., owned by the Monitor).
+ if ((entries[indx]._status.get() == _MonitorEntry::IDLE) &&
+ (FD_ISSET(entries[indx].socket, &fdread)))
+ {
+ MessageQueue *q = MessageQueue::lookup(entries[indx].queueId);
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::run indx = %d, queueId = %d, q = %p",
+ indx, entries[indx].queueId, q);
+ PEGASUS_ASSERT(q !=0);
- // If allocate_and_awaken failure, retry on next iteration
+ try
+ {
+ if (entries[indx]._type == Monitor::CONNECTION)
+ {
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "entries[indx].type for indx = %d is "
+ "Monitor::CONNECTION",
+ indx);
+ static_cast<HTTPConnection *>(q)->_entry_index = indx;
+
+ // Do not update the entry just yet. The entry gets
+ // updated once the request has been read.
+ //entries[indx]._status = _MonitorEntry::BUSY;
+
+ // If allocate_and_awaken failure, retry on next
+ // iteration
/* Removed for PEP 183.
- if (!MessageQueueService::get_thread_pool()->allocate_and_awaken(
- (void *)q, _dispatch))
- {
- Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "Monitor::run: Insufficient resources to process request.");
- entries[indx]._status = _MonitorEntry::IDLE;
- return true;
- }
+ if (!MessageQueueService::get_thread_pool()->
+ allocate_and_awaken((void *)q, _dispatch))
+ {
+ Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
+ "Monitor::run: Insufficient resources to "
+ "process request.");
+ entries[indx]._status = _MonitorEntry::IDLE;
+ return true;
+ }
*/
// Added for PEP 183
- HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(q);
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::_dispatch: entering run() for indx = %d, queueId = %d, q = %p",
- dst->_entry_index, dst->_monitor->_entries[dst->_entry_index].queueId, dst);
- try
- {
- dst->run(1);
- }
- catch (...)
- {
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::_dispatch: exception received");
- }
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::_dispatch: exited run() for index %d", dst->_entry_index);
-
- // It is possible the entry status may not be set to busy.
- // The following will fail in that case.
- // PEGASUS_ASSERT(dst->_monitor->_entries[dst->_entry_index]._status.get() == _MonitorEntry::BUSY);
- // Once the HTTPConnection thread has set the status value to either
- // Monitor::DYING or Monitor::IDLE, it has returned control of the connection
- // to the Monitor. It is no longer permissible to access the connection
- // or the entry in the _entries table.
-
- // The following is not relevant as the worker thread or the
- // reader thread will update the status of the entry.
- //if (dst->_connectionClosePending)
- //{
- // dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::DYING;
- //}
- //else
- //{
- // dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::IDLE;
- //}
+ HTTPConnection *dst =
+ reinterpret_cast<HTTPConnection *>(q);
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::_dispatch: entering run() for "
+ "indx = %d, queueId = %d, q = %p",
+ dst->_entry_index,
+ dst->_monitor->_entries[dst->_entry_index].queueId,
+ dst);
+
+ try
+ {
+ dst->run(1);
+ }
+ catch (...)
+ {
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::_dispatch: exception received");
+ }
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::_dispatch: exited run() for index %d",
+ dst->_entry_index);
+
+ // It is possible the entry status may not be set to
+ // busy. The following will fail in that case.
+ // PEGASUS_ASSERT(dst->_monitor->_entries[
+ // dst->_entry_index]._status.get() ==
+ // _MonitorEntry::BUSY);
+ // Once the HTTPConnection thread has set the status
+ // value to either Monitor::DYING or Monitor::IDLE,
+ // it has returned control of the connection to the
+ // Monitor. It is no longer permissible to access
+ // the connection or the entry in the _entries table.
+
+ // The following is not relevant as the worker thread
+ // or the reader thread will update the status of the
+ // entry.
+ //if (dst->_connectionClosePending)
+ //{
+ // dst->_monitor->_entries[dst->_entry_index]._status =
+ // _MonitorEntry::DYING;
+ //}
+ //else
+ //{
+ // dst->_monitor->_entries[dst->_entry_index]._status =
+ // _MonitorEntry::IDLE;
+ //}
// end Added for PEP 183
- }
- else if( entries[indx]._type == Monitor::INTERNAL){
- // set ourself to BUSY,
+ }
+ else if (entries[indx]._type == Monitor::INTERNAL)
+ {
+ // set ourself to BUSY,
// read the data
// and set ourself back to IDLE
- entries[indx]._status = _MonitorEntry::BUSY;
- static char buffer[2];
- Sint32 amt = Socket::read(entries[indx].socket,&buffer, 2);
-
- if(amt == PEGASUS_SOCKET_ERROR &&
- getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED )
- {
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::run: Tickler socket got an IO error. "
- "Going to re-create Socket and wait for TCP/IP restart.");
- uninitializeTickler();
- initializeTickler();
-
- } else
- {
- entries[indx]._status = _MonitorEntry::IDLE;
+ entries[indx]._status = _MonitorEntry::BUSY;
+ static char buffer[2];
+ Sint32 amt =
+ Socket::read(entries[indx].socket,&buffer, 2);
+
+ if (amt == PEGASUS_SOCKET_ERROR &&
+ getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED)
+ {
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::run: Tickler socket got an IO error. "
+ "Going to re-create Socket and wait for "
+ "TCP/IP restart.");
+ uninitializeTickler();
+ initializeTickler();
+ }
+ else
+ {
+ entries[indx]._status = _MonitorEntry::IDLE;
+ }
+ }
+ else
+ {
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Non-connection entry, indx = %d, has been "
+ "received.",
+ indx);
+ int events = 0;
+ events |= SocketMessage::READ;
+ Message* msg = new SocketMessage(
+ entries[indx].socket, events);
+ entries[indx]._status = _MonitorEntry::BUSY;
+ _entry_mut.unlock();
+ q->enqueue(msg);
+ _entry_mut.lock();
+
+ // After enqueue a message and the autoEntryMutex has
+ // been released and locked again, the array of
+ // entries can be changed. The ArrayIterator has be
+ // reset with the original _entries
+ entries.reset(_entries);
+ entries[indx]._status = _MonitorEntry::IDLE;
+ }
+ }
+ catch (...)
+ {
+ }
}
-
- }
- else
- {
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Non-connection entry, indx = %d, has been received.", indx);
- int events = 0;
- events |= SocketMessage::READ;
- Message *msg = new SocketMessage(entries[indx].socket, events);
- entries[indx]._status = _MonitorEntry::BUSY;
- _entry_mut.unlock();
- q->enqueue(msg);
- _entry_mut.lock();
- // After enqueue a message and the autoEntryMutex has been released and locked again,
- // the array of entries can be changed. The ArrayIterator has be reset with the original _entries
- entries.reset(_entries);
- entries[indx]._status = _MonitorEntry::IDLE;
- }
- }
- catch(...)
- {
- }
- }
- }
+ }
}
}
}
-int Monitor::solicitSocketMessages(
+int Monitor::solicitSocketMessages(
SocketHandle socket,
Uint32 events,
Uint32 queueId,
int type)
{
- PEG_METHOD_ENTER(TRC_HTTP, "Monitor::solicitSocketMessages");
- AutoMutex autoMut(_entry_mut);
- // Check to see if we need to dynamically grow the _entries array
- // We always want the _entries array to 2 bigger than the
- // current connections requested
- _solicitSocketCount++; // bump the count
- int size = (int)_entries.size();
- if((int)_solicitSocketCount >= (size-1)){
- for(int i = 0; i < ((int)_solicitSocketCount - (size-1)); i++){
- _MonitorEntry entry(0, 0, 0);
- _entries.append(entry);
+ PEG_METHOD_ENTER(TRC_HTTP, "Monitor::solicitSocketMessages");
+ AutoMutex autoMut(_entry_mut);
+ // Check to see if we need to dynamically grow the _entries array
+ // We always want the _entries array to 2 bigger than the
+ // current connections requested
+ _solicitSocketCount++; // bump the count
+ int size = (int)_entries.size();
+ if ((int)_solicitSocketCount >= (size-1))
+ {
+ for (int i = 0; i < ((int)_solicitSocketCount - (size-1)); i++)
+ {
+ _MonitorEntry entry(0, 0, 0);
+ _entries.append(entry);
}
- }
-
- int index;
- for(index = 1; index < (int)_entries.size(); index++)
- {
- try
- {
- if(_entries[index]._status.get() == _MonitorEntry::EMPTY)
- {
- _entries[index].socket = socket;
- _entries[index].queueId = queueId;
- _entries[index]._type = type;
- _entries[index]._status = _MonitorEntry::IDLE;
-
- return index;
- }
- }
- catch(...)
- {
- }
- }
- _solicitSocketCount--; // decrease the count, if we are here we didnt do anything meaningful
- PEG_METHOD_EXIT();
- return -1;
+ }
+ int index;
+ for (index = 1; index < (int)_entries.size(); index++)
+ {
+ try
+ {
+ if (_entries[index]._status.get() == _MonitorEntry::EMPTY)
+ {
+ _entries[index].socket = socket;
+ _entries[index].queueId = queueId;
+ _entries[index]._type = type;
+ _entries[index]._status = _MonitorEntry::IDLE;
+
+ return index;
+ }
+ }
+ catch (...)
+ {
+ }
+ }
+ // decrease the count, if we are here we didn't do anything meaningful
+ _solicitSocketCount--;
+ PEG_METHOD_EXIT();
+ return -1;
}
void Monitor::unsolicitSocketMessages(SocketHandle socket)
{
-
PEG_METHOD_ENTER(TRC_HTTP, "Monitor::unsolicitSocketMessages");
AutoMutex autoMut(_entry_mut);
/*
- Start at index = 1 because _entries[0] is the tickle entry which never needs
- to be EMPTY;
+ Start at index = 1 because _entries[0] is the tickle entry which
+ never needs to be EMPTY;
*/
unsigned int index;
- for(index = 1; index < _entries.size(); index++)
+ for (index = 1; index < _entries.size(); index++)
{
- if(_entries[index].socket == socket)
- {
- _entries[index]._status = _MonitorEntry::EMPTY;
- _entries[index].socket = PEGASUS_INVALID_SOCKET;
- _solicitSocketCount--;
- break;
- }
+ if (_entries[index].socket == socket)
+ {
+ _entries[index]._status = _MonitorEntry::EMPTY;
+ _entries[index].socket = PEGASUS_INVALID_SOCKET;
+ _solicitSocketCount--;
+ break;
+ }
}
/*
- Dynamic Contraction:
- To remove excess entries we will start from the end of the _entries array
- and remove all entries with EMPTY status until we find the first NON EMPTY.
- This prevents the positions, of the NON EMPTY entries, from being changed.
+ Dynamic Contraction:
+ To remove excess entries we will start from the end of the _entries
+ array and remove all entries with EMPTY status until we find the
+ first NON EMPTY. This prevents the positions, of the NON EMPTY
+ entries, from being changed.
*/
index = _entries.size() - 1;
- while(_entries[index]._status.get() == _MonitorEntry::EMPTY){
- if(_entries.size() > MAX_NUMBER_OF_MONITOR_ENTRIES)
+ while (_entries[index]._status.get() == _MonitorEntry::EMPTY)
+ {
+ if (_entries.size() > MAX_NUMBER_OF_MONITOR_ENTRIES)
_entries.remove(index);
- index--;
+ index--;
}
PEG_METHOD_EXIT();
}
// Note: this is no longer called with PEP 183.
-ThreadReturnType PEGASUS_THREAD_CDECL Monitor::_dispatch(void *parm)
+ThreadReturnType PEGASUS_THREAD_CDECL Monitor::_dispatch(void* parm)
{
- HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(parm);
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::_dispatch: entering run() for indx = %d, queueId = %d, q = %p",
- dst->_entry_index, dst->_monitor->_entries[dst->_entry_index].queueId, dst);
- try
- {
- dst->run(1);
- }
- catch (...)
- {
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::_dispatch: exception received");
- }
- Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
- "Monitor::_dispatch: exited run() for index %d", dst->_entry_index);
-
- PEGASUS_ASSERT(dst->_monitor->_entries[dst->_entry_index]._status.get() == _MonitorEntry::BUSY);
-
- // Once the HTTPConnection thread has set the status value to either
- // Monitor::DYING or Monitor::IDLE, it has returned control of the connection
- // to the Monitor. It is no longer permissible to access the connection
- // or the entry in the _entries table.
- if (dst->_connectionClosePending)
- {
- dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::DYING;
- }
- else
- {
- dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::IDLE;
- }
- return 0;
+ HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(parm);
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::_dispatch: entering run() for indx = %d, queueId = %d, "
+ "q = %p",
+ dst->_entry_index,
+ dst->_monitor->_entries[dst->_entry_index].queueId,
+ dst);
+
+ try
+ {
+ dst->run(1);
+ }
+ catch (...)
+ {
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::_dispatch: exception received");
+ }
+ Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
+ "Monitor::_dispatch: exited run() for index %d", dst->_entry_index);
+
+ PEGASUS_ASSERT(dst->_monitor->_entries[dst->_entry_index]._status.get() ==
+ _MonitorEntry::BUSY);
+
+ // Once the HTTPConnection thread has set the status value to either
+ // Monitor::DYING or Monitor::IDLE, it has returned control of the
+ // connection to the Monitor. It is no longer permissible to access the
+ // connection or the entry in the _entries table.
+ if (dst->_connectionClosePending)
+ {
+ dst->_monitor->_entries[dst->_entry_index]._status =
+ _MonitorEntry::DYING;
+ }
+ else
+ {
+ dst->_monitor->_entries[dst->_entry_index]._status =
+ _MonitorEntry::IDLE;
+ }
+ return 0;
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Amit Arora (amita@in.ibm.com) for Bug#1170
-// Sushma Fernandes (sushma@hp.com) for Bug#2057
-// Josephine Eskaline Joyce (jojustin@in.ibm.com) for PEP#101
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Monitor_h
class PEGASUS_COMMON_LINKAGE _MonitorEntry
{
public:
- SocketHandle socket;
- Uint32 queueId;
- AtomicInt _status;
-
- // This copy constructor is inecessary since AtomicInt does not support
- // copy construction.
- _MonitorEntry(const _MonitorEntry& x) :
- socket(x.socket),
- queueId(x.queueId),
- _status(x._status.get()),
- _type(x._type)
- {
- }
- int _type;
-
- _MonitorEntry(SocketHandle sock, Uint32 q, int Type)
- : socket(sock), queueId(q), _status(EMPTY), _type(Type)
- {
- }
-
- _MonitorEntry() : socket(0), queueId(0), _status(EMPTY), _type(0)
- {
- }
-
- _MonitorEntry & operator =(const _MonitorEntry & entry)
- {
- if( this != &entry )
- {
- this->socket = entry.socket;
- this->queueId = entry.queueId;
- this->_status = entry._status.get();
- this->_type = entry._type;
- }
-
- return *this;
- }
-
- enum entry_status
+ SocketHandle socket;
+ Uint32 queueId;
+ AtomicInt _status;
+
+ // This copy constructor is inecessary since AtomicInt does not support
+ // copy construction.
+ _MonitorEntry(const _MonitorEntry& x) :
+ socket(x.socket),
+ queueId(x.queueId),
+ _status(x._status.get()),
+ _type(x._type)
+ {
+ }
+ int _type;
+
+ _MonitorEntry(SocketHandle sock, Uint32 q, int Type)
+ : socket(sock), queueId(q), _status(EMPTY), _type(Type)
+ {
+ }
+
+ _MonitorEntry() : socket(0), queueId(0), _status(EMPTY), _type(0)
{
- IDLE,
- BUSY,
- DYING,
- EMPTY
+ }
+
+ _MonitorEntry& operator=(const _MonitorEntry& entry)
+ {
+ if (this != &entry)
+ {
+ this->socket = entry.socket;
+ this->queueId = entry.queueId;
+ this->_status = entry._status.get();
+ this->_type = entry._type;
+ }
+
+ return *this;
+ }
+
+ enum entry_status
+ {
+ IDLE,
+ BUSY,
+ DYING,
+ EMPTY
};
};
{
public:
- enum Events { READ = 1, WRITE = 2, EXCEPTION = 4 };
+ enum Events { READ = 1, WRITE = 2, EXCEPTION = 4 };
+ SocketMessage(SocketHandle socket_, Uint32 events_)
+ : Message(SOCKET_MESSAGE), socket(socket_), events(events_)
+ {
+ }
- SocketMessage(SocketHandle socket_, Uint32 events_) :
- Message(SOCKET_MESSAGE), socket(socket_), events(events_)
- {
- }
-
- SocketHandle socket;
- Uint32 events;
+ SocketHandle socket;
+ Uint32 events;
};
/** This class monitors system-level events and notifies its clients of these
class PEGASUS_COMMON_LINKAGE Monitor
{
public:
- enum Type
+ enum Type
{
- UNTYPED, ACCEPTOR, CONNECTOR, CONNECTION, INTERNAL
+ UNTYPED, ACCEPTOR, CONNECTOR, CONNECTION, INTERNAL
};
-
- /** Default constructor. */
- Monitor();
-
- /** This destruct deletes all handlers which were installed. */
- ~Monitor();
-
- /** Sets the state of the monitor entry to the specified state.
- This is used to synchronize the monitor and the worker
- thread. Bug# 2057 */
- void setState( Uint32 index, _MonitorEntry::entry_status status );
-
- void initializeTickler();
- void uninitializeTickler();
-
- void tickle();
- /** Monitor system-level for the given number of milliseconds. Post a
- message to the corresponding queue when such an event occurs.
- Return after the time has elapsed or a single event has occurred,
- whichever occurs first.
-
- @param timeoutMsec the number of milliseconds to wait for an event.
- @return true if an event occured.
- */
- void run(Uint32 timeoutMsec);
-
- /** Solicit interest in SocketMessages. Note that there may only
- be one solicitor per socket.
-
- @param socket the socket to monitor for activity.
- @param events socket events to monitor (see the SocketMessage::Events
- enumeration for details).
- @param queueId of queue on which to post socket messages.
- @return false if messages have already been solicited on this socket.
- */
- int solicitSocketMessages(
- SocketHandle socket,
- Uint32 events,
- Uint32 queueId,
- int type);
-
- /** Unsolicit messages on the given socket.
-
- @param socket on which to unsolicit messages.
- @return false if no such solicitation has been made on the given socket.
- */
- void unsolicitSocketMessages(SocketHandle);
-
- /** dispatch a message to the cimom on an independent thread
- Note: The Monitor class uses the MessageQueueService ThreadPool.
- This ThreadPool is only available if it has been initialized by
- the MessageQueueService. Therefore, the Monitor class should
- only be used when the MessageQueueService is active in the
- system.
- */
- static ThreadReturnType PEGASUS_THREAD_CDECL _dispatch(void *);
-
- /** stop listening for client connections
- */
- void stopListeningForConnections(Boolean wait);
+ /** Default constructor. */
+ Monitor();
+
+ /** This destruct deletes all handlers which were installed. */
+ ~Monitor();
+
+ /** Sets the state of the monitor entry to the specified state.
+ This is used to synchronize the monitor and the worker
+ thread. Bug# 2057 */
+ void setState( Uint32 index, _MonitorEntry::entry_status status );
+
+ void initializeTickler();
+ void uninitializeTickler();
+
+ void tickle();
+ /** Monitor system-level for the given number of milliseconds. Post a
+ message to the corresponding queue when such an event occurs.
+ Return after the time has elapsed or a single event has occurred,
+ whichever occurs first.
+
+ @param timeoutMsec the number of milliseconds to wait for an event.
+ @return true if an event occured.
+ */
+ void run(Uint32 timeoutMsec);
+
+ /** Solicit interest in SocketMessages. Note that there may only
+ be one solicitor per socket.
+
+ @param socket the socket to monitor for activity.
+ @param events socket events to monitor (see the SocketMessage::Events
+ enumeration for details).
+ @param queueId of queue on which to post socket messages.
+ @return false if messages have already been solicited on this socket.
+ */
+ int solicitSocketMessages(
+ SocketHandle socket,
+ Uint32 events,
+ Uint32 queueId,
+ int type);
+
+ /** Unsolicit messages on the given socket.
+
+ @param socket on which to unsolicit messages.
+ @return false if no such solicitation has been made on the given socket.
+ */
+ void unsolicitSocketMessages(SocketHandle);
+
+ /** dispatch a message to the cimom on an independent thread
+ Note: The Monitor class uses the MessageQueueService ThreadPool.
+ This ThreadPool is only available if it has been initialized by
+ the MessageQueueService. Therefore, the Monitor class should
+ only be used when the MessageQueueService is active in the
+ system.
+ */
+ static ThreadReturnType PEGASUS_THREAD_CDECL _dispatch(void *);
+
+ /** stop listening for client connections
+ */
+ void stopListeningForConnections(Boolean wait);
private:
- Array<_MonitorEntry> _entries;
- Mutex _entry_mut;
- AtomicInt _stopConnections;
- Semaphore _stopConnectionsSem;
- Uint32 _solicitSocketCount; // tracks how many times solicitSocketCount() has been called
- friend class HTTPConnection;
- struct sockaddr_in _tickle_server_addr;
- struct sockaddr_in _tickle_client_addr;
- struct sockaddr_in _tickle_peer_addr;
- SocketHandle _tickle_client_socket;
- SocketHandle _tickle_server_socket;
- SocketHandle _tickle_peer_socket;
- Mutex _tickle_mutex;
+ Array<_MonitorEntry> _entries;
+ Mutex _entry_mut;
+ AtomicInt _stopConnections;
+ Semaphore _stopConnectionsSem;
+ /** tracks how many times solicitSocketCount() has been called */
+ Uint32 _solicitSocketCount;
+ friend class HTTPConnection;
+ struct sockaddr_in _tickle_server_addr;
+ struct sockaddr_in _tickle_client_addr;
+ struct sockaddr_in _tickle_peer_addr;
+ SocketHandle _tickle_client_socket;
+ SocketHandle _tickle_server_socket;
+ SocketHandle _tickle_peer_socket;
+ Mutex _tickle_mutex;
};
PEGASUS_NAMESPACE_END
// This file includes network-related system-header files. Please include
// this file directly rather than including system headers directly. If
// special inclusions are necessary for any platform, please add them to
-// this file rather than other files. The reason for this file is to limit
-// platform-specific conditional compilation expressions to only a few
+// this file rather than other files. The reason for this file is to limit
+// platform-specific conditional compilation expressions to only a few
// well-known header files.
-//
+//
//==============================================================================
//------------------------------------------------------------------------------
#ifdef PEGASUS_OS_TYPE_WINDOWS
# ifdef FD_SETSIZE
-# error
- "<Pegasus/Common/Network.h>: FD_SETSIZE is already defined. This "
- "file must be included prior to any header file that defines "
- "FD_SETSIZE, such as <windows.h>, <winsock.h>, or winsock2.h>."
+# error "<Pegasus/Common/Network.h>: FD_SETSIZE is already defined. \
+ This file must be included prior to any header file that defines \
+ FD_SETSIZE, such as <windows.h>, <winsock.h>, or <winsock2.h>."
# endif
# define FD_SETSIZE 1024
# include <windows.h>
//------------------------------------------------------------------------------
//
// PEGASUS_NETWORK_TCPIP_STOPPED
-//
-// This return code indicates that the transpor layer is
+//
+// This return code indicates that the transpor layer is
// stopped and the socket is invalid. The socket must created again.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// PEGASUS_NETWORK_TCPIP_TRYAGAIN
-//
+//
// This return code indicates that the transport layer is
// temporary unavailable and the program can try again.
//
//------------------------------------------------------------------------------
//
// PEGASUS_NETWORK_TRYAGAIN
-//
-// This return code indicates that the network function
+//
+// This return code indicates that the network function
// should be tried again by the program.
//
//------------------------------------------------------------------------------
//
//==============================================================================
//
-// Author: Chip Vincent (cvincent@us.ibm.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/ObjectNormalizer.h>
PEGASUS_NAMESPACE_BEGIN
CIMQualifier _processQualifier(
- CIMConstQualifier & referenceQualifier,
- CIMConstQualifier & cimQualifier)
+ CIMConstQualifier& referenceQualifier,
+ CIMConstQualifier& cimQualifier)
{
// check name
- if(!referenceQualifier.getName().equal(cimQualifier.getName()))
+ if (!referenceQualifier.getName().equal(cimQualifier.getName()))
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_QUALIFIER_NAME",
}
// check type
- if(referenceQualifier.getType() != cimQualifier.getType())
+ if (referenceQualifier.getType() != cimQualifier.getType())
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_QUALIFIER_TYPE",
// TODO: check override
// update value
- if(!cimQualifier.getValue().isNull())
+ if (!cimQualifier.getValue().isNull())
{
normalizedQualifier.setValue(cimQualifier.getValue());
}
- return(normalizedQualifier);
+ return normalizedQualifier;
}
CIMProperty ObjectNormalizer::_processProperty(
- CIMConstProperty & referenceProperty,
- CIMConstProperty & instProperty,
+ CIMConstProperty& referenceProperty,
+ CIMConstProperty& instProperty,
Boolean includeQualifiers,
Boolean includeClassOrigin,
- NormalizerContext * context,
- const CIMNamespaceName & nameSpace)
+ NormalizerContext* context,
+ const CIMNamespaceName& nameSpace)
{
// check name
- if(!referenceProperty.getName().equal(instProperty.getName()))
+ if (!referenceProperty.getName().equal(instProperty.getName()))
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_PROPERTY_NAME",
// check type
CIMType referencePropType = referenceProperty.getType();
CIMType instPropType = instProperty.getType();
- if(referencePropType != instPropType)
+ if (referencePropType != instPropType)
{
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
// CMPI Providers cannot return a CIMTYPE_INSTANCE, so if the
// referenceProperty type is CIMTYPE_INSTANCE and the instProperty
// type is CIMTYPE_OBJECT, ignore the mismatch. The Normalizer
// will correct it.
- if(referencePropType != CIMTYPE_INSTANCE ||
+ if (referencePropType != CIMTYPE_INSTANCE ||
instPropType != CIMTYPE_OBJECT)
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
{
// TODO: check override (especially for references)?
// update value
- if(!instProperty.getValue().isNull())
+ if (!instProperty.getValue().isNull())
{
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
// This happens ONLY when the referencePropType is CIMTYPE_INSTANCE
// and the cimPropType is CIMTYPE_OBJECT, otherwise an exception
// would have been thrown. Correct the mismatch here.
- if(referencePropType != instPropType)
+ if (referencePropType != instPropType)
{
CIMObject tmpObject;
instProperty.getValue().get(tmpObject);
}
// update class origin
- if(includeClassOrigin)
+ if (includeClassOrigin)
{
normalizedProperty.setClassOrigin(referenceProperty.getClassOrigin());
}
// add qualifiers
- if(includeQualifiers)
+ if (includeQualifiers)
{
// propagate class property qualifiers
- for(Uint32 i = 0, n = referenceProperty.getQualifierCount(); i < n; i++)
+ for (Uint32 i=0, n = referenceProperty.getQualifierCount(); i < n; i++)
{
- CIMConstQualifier referenceQualifier = referenceProperty.getQualifier(i);
+ CIMConstQualifier referenceQualifier =
+ referenceProperty.getQualifier(i);
- Uint32 pos = instProperty.findQualifier(referenceQualifier.getName());
+ Uint32 pos =
+ instProperty.findQualifier(referenceQualifier.getName());
// update value if qualifier is present in the specified property
- if(pos != PEG_NOT_FOUND)
+ if (pos != PEG_NOT_FOUND)
{
CIMConstQualifier cimQualifier = instProperty.getQualifier(pos);
}
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
#ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY
- else if(referenceProperty.getType() == CIMTYPE_INSTANCE)
+ else if (referenceProperty.getType() == CIMTYPE_INSTANCE)
{
Uin32 refPos = referenceProperty.findQualifier("EmbeddedInstance");
Uin32 cimPos = instProperty.findQualifier("EmbeddedInstance");
- if(refPos != PEG_NOT_FOUND && cimPos == PEG_NOT_FOUND)
+ if (refPos != PEG_NOT_FOUND && cimPos == PEG_NOT_FOUND)
{
instProperty.addQualifier(refProperty.getQualifier(pos));
}
// Check the type of the embedded instance against the class specified by
// the EmbeddedInstance qualifier. We can only do this if the context
// is non-zero.
- if(context != 0)
+ if (context != 0)
{
- if(referenceProperty.getType() == CIMTYPE_INSTANCE)
+ if (referenceProperty.getType() == CIMTYPE_INSTANCE)
{
Uint32 pos = referenceProperty.findQualifier("EmbeddedInstance");
embeddedInstSubclasses.append(embedInstClassName);
Array<CIMInstance> embeddedInstances;
- if(referenceProperty.isArray())
+ if (referenceProperty.isArray())
{
instProperty.getValue().get(embeddedInstances);
}
}
Array<CIMClass> embeddedClassDefs;
- for(Uint32 i = 0, n = embeddedInstances.size(); i < n; ++i)
+ for (Uint32 i = 0, n = embeddedInstances.size(); i < n; ++i)
{
- CIMInstance & currentInstance = embeddedInstances[i];
+ CIMInstance& currentInstance = embeddedInstances[i];
CIMName currentClassName = currentInstance.getClassName();
- if(Contains(embeddedInstSubclasses, currentClassName))
+ if (Contains(embeddedInstSubclasses, currentClassName))
{
CIMClass embeddedClassDef;
bool found = false;
- for(Uint32 j = 0, m = embeddedClassDefs.size(); j < m;
+ for (Uint32 j = 0, m = embeddedClassDefs.size(); j < m;
++j)
{
- CIMClass & tmpClassDef = embeddedClassDefs[j];
- if(tmpClassDef.getClassName() == currentClassName)
+ CIMClass& tmpClassDef = embeddedClassDefs[j];
+ if (tmpClassDef.getClassName() == currentClassName)
{
embeddedClassDef = tmpClassDef;
found = true;
}
}
- if(!found)
+ if (!found)
{
embeddedClassDef = context->getClass(nameSpace,
currentClassName);
embeddedClassDefs.append(embeddedClassDef);
}
- AutoPtr<NormalizerContext> tmpContext(context->clone().release());
+ AutoPtr<NormalizerContext> tmpContext(
+ context->clone().release());
ObjectNormalizer tmpNormalizer(embeddedClassDef,
includeQualifiers, includeClassOrigin, nameSpace,
tmpContext);
- if(currentInstance.getPath().getKeyBindings().size()==0)
+ if (currentInstance.getPath().getKeyBindings().size()==0)
{
currentInstance.setPath(
currentInstance.buildPath(embeddedClassDef));
}
- embeddedInstances[i] = tmpNormalizer.processInstance(currentInstance);
+ embeddedInstances[i] =
+ tmpNormalizer.processInstance(currentInstance);
}
else
{
MessageLoaderParms message(
- "Common.ObjectNormalizer.INVALID_EMBEDDED_INSTANCE_TYPE",
- "Found embedded instance of type $0: was expecting $1 for property $2",
+ "Common.ObjectNormalizer."
+ "INVALID_EMBEDDED_INSTANCE_TYPE",
+ "Found embedded instance of type $0: was expecting "
+ "$1 for property $2",
currentClassName.getString(),
qualClassStr,
instProperty.getName().getString());
}
}
- if(referenceProperty.isArray())
+ if (referenceProperty.isArray())
{
normalizedProperty.setValue(CIMValue(embeddedInstances));
}
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- return(normalizedProperty);
+ return normalizedProperty;
}
-ObjectNormalizer::ObjectNormalizer(void)
+ObjectNormalizer::ObjectNormalizer()
: _includeQualifiers(false),
_includeClassOrigin(false),
_context(0)
}
ObjectNormalizer::ObjectNormalizer(
- const CIMClass & cimClass,
+ const CIMClass& cimClass,
Boolean includeQualifiers,
Boolean includeClassOrigin,
- const CIMNamespaceName & nameSpace,
- AutoPtr<NormalizerContext> & context)
+ const CIMNamespaceName& nameSpace,
+ AutoPtr<NormalizerContext>& context)
: _cimClass(cimClass),
_includeQualifiers(includeQualifiers),
_includeClassOrigin(includeClassOrigin),
_context(context),
_nameSpace(nameSpace)
{
- if(!_cimClass.isUninitialized())
+ if (!_cimClass.isUninitialized())
{
- // ATTN: the following code is intended to expedite normalizing instances and instance object
- // paths by establishing the keys once now rather than multiple times later. it is biased
+ // ATTN: the following code is intended to expedite normalizing
+ // instances and instance object paths by establishing the keys
+ // once now rather than multiple times later. it is biased
// toward providers that return many instances with many properties.
// build a reference object path within the class
Array<CIMKeyBinding> keys;
- for(Uint32 i = 0, n = _cimClass.getPropertyCount(); i < n; i++)
+ for (Uint32 i = 0, n = _cimClass.getPropertyCount(); i < n; i++)
{
CIMConstProperty referenceProperty = _cimClass.getProperty(i);
Uint32 pos = referenceProperty.findQualifier("key");
- if((pos != PEG_NOT_FOUND) && (referenceProperty.getQualifier(pos).getValue().equal(CIMValue(true))))
+ if ((pos != PEG_NOT_FOUND) &&
+ (referenceProperty.getQualifier(pos).getValue().equal(
+ CIMValue(true))))
{
- if(referenceProperty.getType() == CIMTYPE_REFERENCE)
+ if (referenceProperty.getType() == CIMTYPE_REFERENCE)
{
- // ATTN: a fake reference is inserted in the key so that the _BubbleSort() method
- // in CIMObjectPath does not throw and exception. It implicitly validates keys of
- // type REFERENCE so just place a dummy value for now. The value will be replaced
- // by the normalized object later.
- keys.append(CIMKeyBinding(referenceProperty.getName(), "class.key=\"value\"", CIMKeyBinding::REFERENCE));
+ // ATTN: a fake reference is inserted in the key so that
+ // the _BubbleSort() method in CIMObjectPath does not
+ // throw and exception. It implicitly validates keys of
+ // type REFERENCE so just place a dummy value for now.
+ // The value will be replaced by the normalized object
+ // later.
+ keys.append(CIMKeyBinding(referenceProperty.getName(),
+ "class.key=\"value\"", CIMKeyBinding::REFERENCE));
}
else
{
- keys.append(CIMKeyBinding(referenceProperty.getName(), referenceProperty.getValue()));
+ keys.append(CIMKeyBinding(referenceProperty.getName(),
+ referenceProperty.getValue()));
}
}
}
}
}
-CIMObjectPath ObjectNormalizer::processClassObjectPath(const CIMObjectPath & cimObjectPath) const
+CIMObjectPath ObjectNormalizer::processClassObjectPath(
+ const CIMObjectPath& cimObjectPath) const
{
// pre-check
- if(_cimClass.isUninitialized())
+ if (_cimClass.isUninitialized())
{
// do nothing
- return(cimObjectPath);
+ return cimObjectPath;
}
/*
- // ATTN: moving similar logic to the response handlers because this type of error should
- // be checked regardless with or without normalization enabled.
- if(cimObjectPath.getClassName().isNull())
+ // ATTN: moving similar logic to the response handlers because this
+ // type of error should be checked regardless with or without
+ // normalization enabled.
+ if (cimObjectPath.getClassName().isNull())
{
throw CIMException(CIM_ERR_FAILED, "uninitialized object path");
}
*/
/*
- // ATTN: The following code is currently redundant because the CIMName object validates
- // legal names when it is constructed. It is included here for completeness.
+ // ATTN: The following code is currently redundant because the CIMName
+ // object validates legal names when it is constructed. It is included
+ // here for completeness.
// check class name
- if(!CIMName(cimObjectPath.getClassName()).legal())
+ if (!CIMName(cimObjectPath.getClassName()).legal())
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_CLASS_NAME",
*/
// check class type
- if(!_cimClass.getClassName().equal(cimObjectPath.getClassName()))
+ if (!_cimClass.getClassName().equal(cimObjectPath.getClassName()))
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_CLASS_TYPE",
// ignore any keys, they are not part of a class object path
- return(normalizedObjectPath);
+ return normalizedObjectPath;
}
-CIMObjectPath ObjectNormalizer::processInstanceObjectPath(const CIMObjectPath & cimObjectPath) const
+CIMObjectPath ObjectNormalizer::processInstanceObjectPath(
+ const CIMObjectPath& cimObjectPath) const
{
// pre-check
- if(_cimClass.isUninitialized())
+ if (_cimClass.isUninitialized())
{
// do nothing
- return(cimObjectPath);
+ return cimObjectPath;
}
/*
- // ATTN: moving similar logic to the response handlers because this type of error should
- // be checked regardless with or without normalization enabled.
- if(cimObjectPath.getClassName().isNull())
+ // ATTN: moving similar logic to the response handlers because this
+ // type of error should be checked regardless with or without
+ // normalization enabled.
+ if (cimObjectPath.getClassName().isNull())
{
throw CIMException(CIM_ERR_FAILED, "uninitialized object path");
}
*/
/*
- // ATTN: The following code is currently redundant because the CIMName object validates
- // legal names when it is constructed. It is included here for completeness.
+ // ATTN: The following code is currently redundant because the CIMName
+ // object validates legal names when it is constructed. It is included
+ // here for completeness.
// check class name
- if(!CIMName(cimObjectPath.getClassName()).legal())
+ if (!CIMName(cimObjectPath.getClassName()).legal())
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_CLASS_NAME",
*/
// check class type
- if(!_cimClass.getClassName().equal(cimObjectPath.getClassName()))
+ if (!_cimClass.getClassName().equal(cimObjectPath.getClassName()))
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_CLASS_TYPE",
Array<CIMKeyBinding> referenceKeys = _cimClass.getPath().getKeyBindings();
Array<CIMKeyBinding> cimKeys = cimObjectPath.getKeyBindings();
- for(Uint32 i = 0, n = referenceKeys.size(); i < n; i++)
+ for (Uint32 i = 0, n = referenceKeys.size(); i < n; i++)
{
CIMKeyBinding key;
// override the value from the specified object
- for(Uint32 j = 0, m = cimKeys.size(); j < m; j++)
+ for (Uint32 j = 0, m = cimKeys.size(); j < m; j++)
{
- if(referenceKeys[i].getName().equal(cimKeys[j].getName()))
+ if (referenceKeys[i].getName().equal(cimKeys[j].getName()))
{
// check type
- if(referenceKeys[i].getType() != cimKeys[j].getType())
+ if (referenceKeys[i].getType() != cimKeys[j].getType())
{
MessageLoaderParms message(
"Common.ObjectNormalizer.INVALID_KEY_TYPE",
throw CIMException(CIM_ERR_FAILED, message);
}
- key = CIMKeyBinding(referenceKeys[i].getName(), cimKeys[j].getValue(), referenceKeys[i].getType());
+ key = CIMKeyBinding(referenceKeys[i].getName(),
+ cimKeys[j].getValue(), referenceKeys[i].getType());
break;
}
}
// key not found
- if(key.getName().isNull())
+ if (key.getName().isNull())
{
MessageLoaderParms message(
"Common.ObjectNormalizer.MISSING_KEY",
normalizedObjectPath.setKeyBindings(normalizedKeys);
- return(normalizedObjectPath);
+ return normalizedObjectPath;
}
-CIMInstance ObjectNormalizer::processInstance(const CIMInstance & cimInstance) const
+CIMInstance ObjectNormalizer::processInstance(
+ const CIMInstance& cimInstance) const
{
// pre-checks
- if(_cimClass.isUninitialized())
+ if (_cimClass.isUninitialized())
{
// do nothing
- return(cimInstance);
+ return cimInstance;
}
/*
- // ATTN: moving similar logic to the response handlers because this type of error should
- // be checked regardless with or without normalization enabled.
- if(cimInstance.isUninitialized())
+ // ATTN: moving similar logic to the response handlers because this
+ // type of error should be checked regardless with or without
+ // normalization enabled.
+ if (cimInstance.isUninitialized())
{
throw CIMException(CIM_ERR_FAILED, "unintialized instance object.");
}
CIMInstance normalizedInstance(_cimClass.getClassName());
// proces object path
- normalizedInstance.setPath(processInstanceObjectPath(cimInstance.getPath()));
+ normalizedInstance.setPath(
+ processInstanceObjectPath(cimInstance.getPath()));
// process instance qualifiers
- if(_includeQualifiers)
+ if (_includeQualifiers)
{
// propagate class qualifiers
- for(Uint32 i = 0, n = _cimClass.getQualifierCount(); i < n; i++)
+ for (Uint32 i = 0, n = _cimClass.getQualifierCount(); i < n; i++)
{
CIMConstQualifier referenceQualifier = _cimClass.getQualifier(i);
- Uint32 pos = cimInstance.findQualifier(referenceQualifier.getName());
+ Uint32 pos =
+ cimInstance.findQualifier(referenceQualifier.getName());
// update value if qualifier is present in the specified property
- if(pos != PEG_NOT_FOUND)
+ if (pos != PEG_NOT_FOUND)
{
CIMConstQualifier cimQualifier = cimInstance.getQualifier(pos);
}
}
- // check property names and types. any properties in the class but not in the instance
- // are implicitly dropped.
- for(Uint32 i = 0, n = _cimClass.getPropertyCount(); i < n; i++)
+ // check property names and types. any properties in the class but not
+ // in the instance are implicitly dropped.
+ for (Uint32 i = 0, n = _cimClass.getPropertyCount(); i < n; i++)
{
CIMConstProperty referenceProperty = _cimClass.getProperty(i);
Uint32 pos = cimInstance.findProperty(referenceProperty.getName());
- if(pos != PEG_NOT_FOUND)
+ if (pos != PEG_NOT_FOUND)
{
CIMConstProperty cimProperty = cimInstance.getProperty(pos);
}
}
- return(normalizedInstance);
+ return normalizedInstance;
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Chip Vincent (cvincent@us.ibm.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ObjectNormalizer_h
class PEGASUS_COMMON_LINKAGE ObjectNormalizer
{
public:
- ObjectNormalizer(void);
+ ObjectNormalizer();
ObjectNormalizer(
- const CIMClass & cimClass,
+ const CIMClass& cimClass,
Boolean includeQualifiers,
Boolean includeClassOrigin,
const CIMNamespaceName& nameSpace,
- AutoPtr<NormalizerContext> & context);
+ AutoPtr<NormalizerContext>& context);
- CIMObjectPath processClassObjectPath(const CIMObjectPath & cimObjectPath) const;
- CIMObjectPath processInstanceObjectPath(const CIMObjectPath & cimObjectPath) const;
+ CIMObjectPath processClassObjectPath(
+ const CIMObjectPath& cimObjectPath) const;
+ CIMObjectPath processInstanceObjectPath(
+ const CIMObjectPath& cimObjectPath) const;
- //CIMClass processClass(const CIMClass & cimClass) const;
- CIMInstance processInstance(const CIMInstance & cimInstance) const;
- //CIMIndication processIndication(const CIMIndication & cimIndication);
+ //CIMClass processClass(const CIMClass& cimClass) const;
+ CIMInstance processInstance(const CIMInstance& cimInstance) const;
+ //CIMIndication processIndication(const CIMIndication& cimIndication);
static CIMProperty _processProperty(
- CIMConstProperty & referenceProperty,
- CIMConstProperty & cimProperty,
+ CIMConstProperty& referenceProperty,
+ CIMConstProperty& cimProperty,
Boolean includeQualifiers,
Boolean includeClassOrigin,
NormalizerContext * context,
- const CIMNamespaceName & nameSpace);
+ const CIMNamespaceName& nameSpace);
private:
CIMClass _cimClass;
//
//==============================================================================
//
-// Author: Adrian Schuur (schuur@de.ibm.com) - PEP 164
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef ObjectStreamer_h
PEGASUS_NAMESPACE_BEGIN
-class PEGASUS_COMMON_LINKAGE ObjectStreamer {
-
+class PEGASUS_COMMON_LINKAGE ObjectStreamer
+{
public:
- ObjectStreamer() {}
+ ObjectStreamer() {}
- virtual ~ObjectStreamer() {}
+ virtual ~ObjectStreamer() {}
- virtual void encode(Buffer& out, const CIMClass& cls) = 0;
- virtual void encode(Buffer& out, const CIMInstance& inst) = 0;
- virtual void encode(Buffer& out, const CIMQualifierDecl& qual) = 0;
+ virtual void encode(Buffer& out, const CIMClass& cls) = 0;
+ virtual void encode(Buffer& out, const CIMInstance& inst) = 0;
+ virtual void encode(Buffer& out, const CIMQualifierDecl& qual) = 0;
- virtual void decode(const Buffer& in, unsigned int pos, CIMClass& cls) = 0;
- virtual void decode(const Buffer& in, unsigned int pos, CIMInstance& inst) = 0;
- virtual void decode(const Buffer& in, unsigned int pos, CIMQualifierDecl& qual) = 0;
+ virtual void decode(const Buffer& in, unsigned int pos, CIMClass& cls) = 0;
+ virtual void decode(
+ const Buffer& in,
+ unsigned int pos,
+ CIMInstance& inst) = 0;
+ virtual void decode(
+ const Buffer& in,
+ unsigned int pos,
+ CIMQualifierDecl& qual) = 0;
- virtual void write(PEGASUS_STD(ostream)& os, Buffer& in)
- {
- os.write(in.getData(), static_cast<PEGASUS_STD(streamsize)>(in.size()));
- }
+ virtual void write(PEGASUS_STD(ostream)& os, Buffer& in)
+ {
+
os.write(in.getData(), static_cast<PEGASUS_STD(streamsize)>(in.size()));
+ }
};
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Once.h"
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Once_h
//
//==============================================================================
//
-// Author: Chip Vincent (cvincent@us.ibm.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
-// Terry Martin, Hewlett-Packard Company (terry.martin@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "OperationContext.h"
#include "ArrayInternal.h"
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
PEGASUS_NAMESPACE_BEGIN
class OperationContextRep
{
public:
- Array<OperationContext::Container *> containers;
+ Array<OperationContext::Container*> containers;
};
-OperationContext::OperationContext(void)
+OperationContext::OperationContext()
{
_rep = new OperationContextRep;
}
-OperationContext::OperationContext(const OperationContext & context)
+OperationContext::OperationContext(const OperationContext& context)
{
_rep = new OperationContextRep;
*this = context;
}
-OperationContext::~OperationContext(void)
+OperationContext::~OperationContext()
{
clear();
delete _rep;
}
-OperationContext & OperationContext::operator=(const OperationContext & context)
+OperationContext& OperationContext::operator=(const OperationContext& context)
{
- if(this == &context)
+ if (this == &context)
{
- return(*this);
+ return *this;
}
clear();
- for(Uint32 i = 0, n = context._rep->containers.size(); i < n; i++)
+ for (Uint32 i = 0, n = context._rep->containers.size(); i < n; i++)
{
_rep->containers.append(context._rep->containers[i]->clone());
}
- return(*this);
+ return *this;
}
-void OperationContext::clear(void)
+void OperationContext::clear()
{
- for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
+ for (Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
{
_rep->containers[i]->destroy();
}
_rep->containers.clear();
}
-const OperationContext::Container & OperationContext::get(
+const OperationContext::Container& OperationContext::get(
const String& containerName) const
{
Uint32 size = _rep->containers.size();
Container** data = (Container**)_rep->containers.getData();
for (; size--; data++)
- if (data[0]->getName() == containerName)
- return *(data[0]);
+ if (data[0]->getName() == containerName)
+ return *(data[0]);
static Exception _exception(MessageLoaderParms(
- "Common.OperationContext.OBJECT_NOT_FOUND", "object not found"));
+ "Common.OperationContext.OBJECT_NOT_FOUND", "object not found"));
throw Exception(_exception);
}
return false;
}
-void OperationContext::set(const OperationContext::Container & container)
+void OperationContext::set(const OperationContext::Container& container)
{
- for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
+ for (Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
{
- if(container.getName() == _rep->containers[i]->getName())
+ if (container.getName() == _rep->containers[i]->getName())
{
// delete previous container
_rep->containers[i]->destroy();
}
}
- //l10n
- MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
- "object not found");
+ MessageLoaderParms parms(
+ "Common.OperationContext.OBJECT_NOT_FOUND",
+ "object not found");
throw Exception(parms);
- //throw Exception("object not found");
}
-void OperationContext::insert(const OperationContext::Container & container)
+void OperationContext::insert(const OperationContext::Container& container)
{
- for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
+ for (Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
{
- if(container.getName() == _rep->containers[i]->getName())
+ if (container.getName() == _rep->containers[i]->getName())
{
- //l10n
- MessageLoaderParms parms("Common.OperationContext.OBJECT_ALREADY_EXISTS",
- "object already exists.");
- throw Exception(parms);
- //throw Exception("object already exists.");
+ MessageLoaderParms parms(
+ "Common.OperationContext.OBJECT_ALREADY_EXISTS",
+ "object already exists.");
+ throw Exception(parms);
}
}
void OperationContext::remove(const String& containerName)
{
- for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
+ for (Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
{
- if(containerName == _rep->containers[i]->getName())
+ if (containerName == _rep->containers[i]->getName())
{
_rep->containers[i]->destroy();
_rep->containers.remove(i);
}
}
- //l10n
- MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
- "object not found");
+ MessageLoaderParms parms(
+ "Common.OperationContext.OBJECT_NOT_FOUND",
+ "object not found");
throw Exception(parms);
- //throw Exception("object not found");
}
-
+
//
// OperationContext::Container
//
-OperationContext::Container::~Container(void)
+OperationContext::Container::~Container()
{
}
const String IdentityContainer::NAME = "IdentityContainer";
-IdentityContainer::IdentityContainer(const OperationContext::Container & container)
+IdentityContainer::IdentityContainer(
+ const OperationContext::Container& container)
{
- const IdentityContainer * p = dynamic_cast<const IdentityContainer *>(&container);
+ const IdentityContainer* p =
+ dynamic_cast<const IdentityContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->userName = p->_rep->userName;
}
-IdentityContainer::IdentityContainer(const IdentityContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined (PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+IdentityContainer::IdentityContainer(const IdentityContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined (PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new IdentityContainerRep();
_rep->userName = container._rep->userName;
}
-IdentityContainer::IdentityContainer(const String & userName)
+IdentityContainer::IdentityContainer(const String& userName)
{
_rep = new IdentityContainerRep();
_rep->userName = userName;
}
-IdentityContainer::~IdentityContainer(void)
+IdentityContainer::~IdentityContainer()
{
delete _rep;
}
-IdentityContainer & IdentityContainer::operator=(
- const IdentityContainer & container)
+IdentityContainer& IdentityContainer::operator=(
+ const IdentityContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->userName = container._rep->userName;
- return (*this);
+ return *this;
}
-String IdentityContainer::getName(void) const
+String IdentityContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * IdentityContainer::clone(void) const
+OperationContext::Container* IdentityContainer::clone() const
{
- return(new IdentityContainer(_rep->userName));
+ return new IdentityContainer(_rep->userName);
}
-void IdentityContainer::destroy(void)
+void IdentityContainer::destroy()
{
delete this;
}
-String IdentityContainer::getUserName(void) const
+String IdentityContainer::getUserName() const
{
- return(_rep->userName);
+ return _rep->userName;
}
const String SubscriptionInstanceContainer::NAME =
"SubscriptionInstanceContainer";
-SubscriptionInstanceContainer::SubscriptionInstanceContainer
- (const OperationContext::Container & container)
+SubscriptionInstanceContainer::SubscriptionInstanceContainer(
+ const OperationContext::Container& container)
{
- const SubscriptionInstanceContainer * p =
- dynamic_cast<const SubscriptionInstanceContainer *>(&container);
+ const SubscriptionInstanceContainer* p =
+ dynamic_cast<const SubscriptionInstanceContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->subscriptionInstance = p->_rep->subscriptionInstance;
}
-SubscriptionInstanceContainer::SubscriptionInstanceContainer
- (const SubscriptionInstanceContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+SubscriptionInstanceContainer::SubscriptionInstanceContainer(
+ const SubscriptionInstanceContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new SubscriptionInstanceContainerRep();
_rep->subscriptionInstance = container._rep->subscriptionInstance;
}
-SubscriptionInstanceContainer::SubscriptionInstanceContainer
- (const CIMInstance & subscriptionInstance)
+SubscriptionInstanceContainer::SubscriptionInstanceContainer(
+ const CIMInstance& subscriptionInstance)
{
_rep = new SubscriptionInstanceContainerRep();
_rep->subscriptionInstance = subscriptionInstance;
}
-SubscriptionInstanceContainer::~SubscriptionInstanceContainer(void)
+SubscriptionInstanceContainer::~SubscriptionInstanceContainer()
{
delete _rep;
}
-SubscriptionInstanceContainer & SubscriptionInstanceContainer::operator=(
- const SubscriptionInstanceContainer & container)
+SubscriptionInstanceContainer& SubscriptionInstanceContainer::operator=(
+ const SubscriptionInstanceContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->subscriptionInstance = container._rep->subscriptionInstance;
- return (*this);
+ return *this;
}
-String SubscriptionInstanceContainer::getName(void) const
+String SubscriptionInstanceContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * SubscriptionInstanceContainer::clone(void) const
+OperationContext::Container* SubscriptionInstanceContainer::clone() const
{
- return(new SubscriptionInstanceContainer(_rep->subscriptionInstance));
+ return new SubscriptionInstanceContainer(_rep->subscriptionInstance);
}
-void SubscriptionInstanceContainer::destroy(void)
+void SubscriptionInstanceContainer::destroy()
{
delete this;
}
-CIMInstance SubscriptionInstanceContainer::getInstance(void) const
+CIMInstance SubscriptionInstanceContainer::getInstance() const
{
- return(_rep->subscriptionInstance);
+ return _rep->subscriptionInstance;
}
Array<CIMObjectPath> subscriptionInstanceNames;
};
-const String SubscriptionInstanceNamesContainer::NAME =
+const String SubscriptionInstanceNamesContainer::NAME =
"SubscriptionInstanceNamesContainer";
-SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
- (const OperationContext::Container & container)
+SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer(
+ const OperationContext::Container& container)
{
- const SubscriptionInstanceNamesContainer * p =
- dynamic_cast<const SubscriptionInstanceNamesContainer *>(&container);
+ const SubscriptionInstanceNamesContainer* p =
+ dynamic_cast<const SubscriptionInstanceNamesContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;
}
-SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
- (const SubscriptionInstanceNamesContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer(
+ const SubscriptionInstanceNamesContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new SubscriptionInstanceNamesContainerRep();
_rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
}
-SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
- (const Array<CIMObjectPath> & subscriptionInstanceNames)
+SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer(
+ const Array<CIMObjectPath>& subscriptionInstanceNames)
{
_rep = new SubscriptionInstanceNamesContainerRep();
_rep->subscriptionInstanceNames = subscriptionInstanceNames;
}
-SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer(void)
+SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer()
{
delete _rep;
}
-SubscriptionInstanceNamesContainer &
+SubscriptionInstanceNamesContainer&
SubscriptionInstanceNamesContainer::operator=(
- const SubscriptionInstanceNamesContainer & container)
+ const SubscriptionInstanceNamesContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
- return (*this);
+ return *this;
}
-String SubscriptionInstanceNamesContainer::getName(void) const
+String SubscriptionInstanceNamesContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container *
- SubscriptionInstanceNamesContainer::clone(void) const
+OperationContext::Container*
+ SubscriptionInstanceNamesContainer::clone() const
{
- return(new SubscriptionInstanceNamesContainer
- (_rep->subscriptionInstanceNames));
+ return new SubscriptionInstanceNamesContainer(
+ _rep->subscriptionInstanceNames);
}
-void SubscriptionInstanceNamesContainer::destroy(void)
+void SubscriptionInstanceNamesContainer::destroy()
{
delete this;
}
-Array<CIMObjectPath>
- SubscriptionInstanceNamesContainer::getInstanceNames(void) const
+Array<CIMObjectPath>
+ SubscriptionInstanceNamesContainer::getInstanceNames() const
{
- return(_rep->subscriptionInstanceNames);
+ return _rep->subscriptionInstanceNames;
}
String queryLanguage;
};
-const String SubscriptionFilterConditionContainer::NAME =
+const String SubscriptionFilterConditionContainer::NAME =
"SubscriptionFilterConditionContainer";
-SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
- (const OperationContext::Container & container)
+SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
+ const OperationContext::Container& container)
{
- const SubscriptionFilterConditionContainer * p =
- dynamic_cast<const SubscriptionFilterConditionContainer *>(&container);
+ const SubscriptionFilterConditionContainer* p =
+ dynamic_cast<const SubscriptionFilterConditionContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->queryLanguage = p->_rep->queryLanguage;
}
-SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
- (const SubscriptionFilterConditionContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
+ const SubscriptionFilterConditionContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new SubscriptionFilterConditionContainerRep();
}
SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
- const String & filterCondition,
- const String & queryLanguage)
+ const String& filterCondition,
+ const String& queryLanguage)
{
_rep = new SubscriptionFilterConditionContainerRep();
_rep->filterCondition = filterCondition;
_rep->queryLanguage = queryLanguage;
}
-SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer
- (void)
+SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer()
{
delete _rep;
}
-SubscriptionFilterConditionContainer &
+SubscriptionFilterConditionContainer&
SubscriptionFilterConditionContainer::operator=(
- const SubscriptionFilterConditionContainer & container)
+ const SubscriptionFilterConditionContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->filterCondition = container._rep->filterCondition;
_rep->queryLanguage = container._rep->queryLanguage;
- return (*this);
+ return *this;
}
-String SubscriptionFilterConditionContainer::getName(void) const
+String SubscriptionFilterConditionContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * SubscriptionFilterConditionContainer::clone(void) const
+OperationContext::Container* SubscriptionFilterConditionContainer::clone() const
{
- return(new SubscriptionFilterConditionContainer(_rep->filterCondition,
- _rep->queryLanguage));
+ return new SubscriptionFilterConditionContainer(
+ _rep->filterCondition, _rep->queryLanguage);
}
-void SubscriptionFilterConditionContainer::destroy(void)
+void SubscriptionFilterConditionContainer::destroy()
{
delete this;
}
-String SubscriptionFilterConditionContainer::getFilterCondition(void) const
+String SubscriptionFilterConditionContainer::getFilterCondition() const
{
- return(_rep->filterCondition);
+ return _rep->filterCondition;
}
-String SubscriptionFilterConditionContainer::getQueryLanguage(void) const
+String SubscriptionFilterConditionContainer::getQueryLanguage() const
{
- return(_rep->queryLanguage);
+ return _rep->queryLanguage;
}
const String SubscriptionFilterQueryContainer::NAME =
"SubscriptionFilterQueryContainer";
-
-SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer
- (const OperationContext::Container & container)
-{
- const SubscriptionFilterQueryContainer * p =
- dynamic_cast<const SubscriptionFilterQueryContainer *>(&container);
-
- if(p == 0)
+
+SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
+ const OperationContext::Container& container)
+{
+ const SubscriptionFilterQueryContainer* p =
+ dynamic_cast<const SubscriptionFilterQueryContainer*>(&container);
+
+ if (p == 0)
{
throw DynamicCastFailedException();
}
-
+
_rep = new SubscriptionFilterQueryContainerRep();
_rep->filterQuery = p->_rep->filterQuery;
_rep->queryLanguage = p->_rep->queryLanguage;
_rep->sourceNameSpace = p->_rep->sourceNameSpace;
-}
+}
-SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer
- (const SubscriptionFilterQueryContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
+ const SubscriptionFilterQueryContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new SubscriptionFilterQueryContainerRep();
}
SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
- const String & filterQuery,
- const String & queryLanguage,
- const CIMNamespaceName & sourceNameSpace)
-{
+ const String& filterQuery,
+ const String& queryLanguage,
+ const CIMNamespaceName& sourceNameSpace)
+{
_rep = new SubscriptionFilterQueryContainerRep();
_rep->filterQuery = filterQuery;
_rep->queryLanguage = queryLanguage;
_rep->sourceNameSpace = sourceNameSpace;
}
-SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer
- (void)
+SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer()
{
delete _rep;
}
-SubscriptionFilterQueryContainer &
+
+SubscriptionFilterQueryContainer&
SubscriptionFilterQueryContainer::operator=(
- const SubscriptionFilterQueryContainer & container)
+ const SubscriptionFilterQueryContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->filterQuery = container._rep->filterQuery;
_rep->queryLanguage = container._rep->queryLanguage;
_rep->sourceNameSpace = container._rep->sourceNameSpace;
- return (*this);
+ return *this;
}
-String SubscriptionFilterQueryContainer::getName(void) const
-{
- return(NAME);
+String SubscriptionFilterQueryContainer::getName() const
+{
+ return NAME;
}
-OperationContext::Container * SubscriptionFilterQueryContainer::clone(void) const
-{
- return(new SubscriptionFilterQueryContainer(_rep->filterQuery,
- _rep->queryLanguage,
- _rep->sourceNameSpace));
+OperationContext::Container* SubscriptionFilterQueryContainer::clone() const
+{
+ return new SubscriptionFilterQueryContainer(
+ _rep->filterQuery,
+ _rep->queryLanguage,
+ _rep->sourceNameSpace);
}
-void SubscriptionFilterQueryContainer::destroy(void)
-{
+void SubscriptionFilterQueryContainer::destroy()
+{
delete this;
}
-String SubscriptionFilterQueryContainer::getFilterQuery(void) const
+String SubscriptionFilterQueryContainer::getFilterQuery() const
{
- return(_rep->filterQuery);
+ return _rep->filterQuery;
}
-String SubscriptionFilterQueryContainer::getQueryLanguage(void) const
+String SubscriptionFilterQueryContainer::getQueryLanguage() const
{
- return(_rep->queryLanguage);
+ return _rep->queryLanguage;
}
-CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace(void) const
+CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace() const
{
- return(_rep->sourceNameSpace);
+ return _rep->sourceNameSpace;
}
const String TimeoutContainer::NAME = "TimeoutContainer";
-TimeoutContainer::TimeoutContainer(const OperationContext::Container & container)
+TimeoutContainer::TimeoutContainer(const OperationContext::Container& container)
{
- const TimeoutContainer * p = dynamic_cast<const TimeoutContainer *>(&container);
- if(p == 0)
- {
- throw DynamicCastFailedException();
- }
- _value = p->_value;
+ const TimeoutContainer* p =
+ dynamic_cast<const TimeoutContainer*>(&container);
+ if (p == 0)
+ {
+ throw DynamicCastFailedException();
+ }
+ _value = p->_value;
}
TimeoutContainer::TimeoutContainer(Uint32 timeout)
{
- _value = timeout;
+ _value = timeout;
}
-String TimeoutContainer::getName(void) const
+String TimeoutContainer::getName() const
{
- return (NAME);
+ return NAME;
}
-OperationContext::Container * TimeoutContainer::clone(void) const
+OperationContext::Container* TimeoutContainer::clone() const
{
- return (new TimeoutContainer(_value));
+ return new TimeoutContainer(_value);
}
-void TimeoutContainer::destroy(void)
+void TimeoutContainer::destroy()
{
- delete this;
+ delete this;
}
-Uint32 TimeoutContainer::getTimeOut(void) const
+Uint32 TimeoutContainer::getTimeOut() const
{
- return _value;
+ return _value;
}
const String AcceptLanguageListContainer::NAME =
"AcceptLanguageListContainer";
-AcceptLanguageListContainer::AcceptLanguageListContainer
- (const OperationContext::Container & container)
+AcceptLanguageListContainer::AcceptLanguageListContainer(
+ const OperationContext::Container& container)
{
- const AcceptLanguageListContainer * p =
- dynamic_cast<const AcceptLanguageListContainer *>(&container);
+ const AcceptLanguageListContainer* p =
+ dynamic_cast<const AcceptLanguageListContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->languages = p->_rep->languages;
}
-AcceptLanguageListContainer::AcceptLanguageListContainer
- (const AcceptLanguageListContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+AcceptLanguageListContainer::AcceptLanguageListContainer(
+ const AcceptLanguageListContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new AcceptLanguageListContainerRep();
_rep->languages = container._rep->languages;
}
-AcceptLanguageListContainer::AcceptLanguageListContainer
- (const AcceptLanguageList & languages)
+AcceptLanguageListContainer::AcceptLanguageListContainer(
+ const AcceptLanguageList& languages)
{
_rep = new AcceptLanguageListContainerRep();
_rep->languages = languages;
}
-AcceptLanguageListContainer::~AcceptLanguageListContainer(void)
+AcceptLanguageListContainer::~AcceptLanguageListContainer()
{
delete _rep;
}
-AcceptLanguageListContainer & AcceptLanguageListContainer::operator=(
- const AcceptLanguageListContainer & container)
+AcceptLanguageListContainer& AcceptLanguageListContainer::operator=(
+ const AcceptLanguageListContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->languages = container._rep->languages;
- return (*this);
+ return *this;
}
-String AcceptLanguageListContainer::getName(void) const
+String AcceptLanguageListContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * AcceptLanguageListContainer::clone(void) const
+OperationContext::Container* AcceptLanguageListContainer::clone() const
{
- return(new AcceptLanguageListContainer(_rep->languages));
+ return new AcceptLanguageListContainer(_rep->languages);
}
-void AcceptLanguageListContainer::destroy(void)
+void AcceptLanguageListContainer::destroy()
{
delete this;
}
-AcceptLanguageList AcceptLanguageListContainer::getLanguages(void) const
+AcceptLanguageList AcceptLanguageListContainer::getLanguages() const
{
- return(_rep->languages);
+ return _rep->languages;
}
const String ContentLanguageListContainer::NAME =
"ContentLanguageListContainer";
-ContentLanguageListContainer::ContentLanguageListContainer
- (const OperationContext::Container & container)
+ContentLanguageListContainer::ContentLanguageListContainer(
+ const OperationContext::Container& container)
{
- const ContentLanguageListContainer * p =
- dynamic_cast<const ContentLanguageListContainer *>(&container);
+ const ContentLanguageListContainer* p =
+ dynamic_cast<const ContentLanguageListContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->languages = p->_rep->languages;
}
-ContentLanguageListContainer::ContentLanguageListContainer
- (const ContentLanguageListContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+ContentLanguageListContainer::ContentLanguageListContainer(
+ const ContentLanguageListContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new ContentLanguageListContainerRep();
_rep->languages = container._rep->languages;
}
-ContentLanguageListContainer::ContentLanguageListContainer
- (const ContentLanguageList & languages)
+ContentLanguageListContainer::ContentLanguageListContainer(
+ const ContentLanguageList& languages)
{
_rep = new ContentLanguageListContainerRep();
_rep->languages = languages;
}
-ContentLanguageListContainer::~ContentLanguageListContainer(void)
+ContentLanguageListContainer::~ContentLanguageListContainer()
{
delete _rep;
}
-ContentLanguageListContainer & ContentLanguageListContainer::operator=(
- const ContentLanguageListContainer & container)
+ContentLanguageListContainer& ContentLanguageListContainer::operator=(
+ const ContentLanguageListContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->languages = container._rep->languages;
- return (*this);
+ return *this;
}
-String ContentLanguageListContainer::getName(void) const
+String ContentLanguageListContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * ContentLanguageListContainer::clone(void) const
+OperationContext::Container* ContentLanguageListContainer::clone() const
{
- return(new ContentLanguageListContainer(_rep->languages));
+ return new ContentLanguageListContainer(_rep->languages);
}
-void ContentLanguageListContainer::destroy(void)
+void ContentLanguageListContainer::destroy()
{
delete this;
}
-ContentLanguageList ContentLanguageListContainer::getLanguages(void) const
+ContentLanguageList ContentLanguageListContainer::getLanguages() const
{
- return(_rep->languages);
+ return _rep->languages;
}
-
//
// SnmpTrapOidContainer
//
const String SnmpTrapOidContainer::NAME =
"SnmpTrapOidContainer";
-SnmpTrapOidContainer::SnmpTrapOidContainer
- (const OperationContext::Container & container)
+SnmpTrapOidContainer::SnmpTrapOidContainer(
+ const OperationContext::Container& container)
{
- const SnmpTrapOidContainer * p =
- dynamic_cast<const SnmpTrapOidContainer *>(&container);
+ const SnmpTrapOidContainer* p =
+ dynamic_cast<const SnmpTrapOidContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
_rep->snmpTrapOid = p->_rep->snmpTrapOid;
}
-SnmpTrapOidContainer::SnmpTrapOidContainer
- (const SnmpTrapOidContainer & container)
-#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
- : OperationContext::Container()
+SnmpTrapOidContainer::SnmpTrapOidContainer(
+ const SnmpTrapOidContainer& container)
+#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
+ defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+ : OperationContext::Container()
#endif
{
_rep = new SnmpTrapOidContainerRep();
_rep->snmpTrapOid = container._rep->snmpTrapOid;
}
-SnmpTrapOidContainer::SnmpTrapOidContainer
- (const String & snmpTrapOid)
+SnmpTrapOidContainer::SnmpTrapOidContainer(const String& snmpTrapOid)
{
_rep = new SnmpTrapOidContainerRep();
_rep->snmpTrapOid = snmpTrapOid;
}
-SnmpTrapOidContainer::~SnmpTrapOidContainer(void)
+SnmpTrapOidContainer::~SnmpTrapOidContainer()
{
delete _rep;
}
-SnmpTrapOidContainer & SnmpTrapOidContainer::operator=(
- const SnmpTrapOidContainer & container)
+SnmpTrapOidContainer& SnmpTrapOidContainer::operator=(
+ const SnmpTrapOidContainer& container)
{
if (this == &container)
{
- return (*this);
+ return *this;
}
_rep->snmpTrapOid = container._rep->snmpTrapOid;
- return (*this);
+ return *this;
}
-String SnmpTrapOidContainer::getName(void) const
+String SnmpTrapOidContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * SnmpTrapOidContainer::clone(void) const
+OperationContext::Container* SnmpTrapOidContainer::clone() const
{
- return(new SnmpTrapOidContainer(_rep->snmpTrapOid));
+ return new SnmpTrapOidContainer(_rep->snmpTrapOid);
}
-void SnmpTrapOidContainer::destroy(void)
+void SnmpTrapOidContainer::destroy()
{
delete this;
}
-String SnmpTrapOidContainer::getSnmpTrapOid(void) const
+String SnmpTrapOidContainer::getSnmpTrapOid() const
{
- return(_rep->snmpTrapOid);
+ return _rep->snmpTrapOid;
}
PEGASUS_NAMESPACE_END
virtual String getName() const = 0;
/**
- Makes a copy of the Container object. The caller is responsible
+ Makes a copy of the Container object. The caller is responsible
for cleaning up the copy by calling destroy() method.
@return A pointer to the new Container object.
*/
indication subscription filter.
*/
SubscriptionFilterConditionContainer(
- const String& filterCondition,
+ const String& filterCondition,
const String& queryLanguage);
/**
The unique name for this container type.
*/
static const String NAME;
-
+
/**
Constructs a TimeoutContainer object from the specified Container.
@param container The Container object to copy.
method.
*/
virtual void destroy();
-
+
/**
Gets the timeout value from the TimeoutContainer.
@return An integer timeout value (in milliseconds).
that are acceptable in this context.
*/
AcceptLanguageListContainer(const AcceptLanguageList& languages);
-
+
/**
Destructs the AcceptLanguageListContainer.
*/
object is not an SnmpTrapOidContainer object.
*/
SnmpTrapOidContainer(const OperationContext::Container& container);
-
+
/**
Constructs a copy of the specified SnmpTrapOidContainer.
@param container The SnmpTrapOidContainer object to copy.
//
//==============================================================================
//
-// Author: Chip Vincent (cvincent@us.ibm.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "OperationContextInternal.h"
const String LocaleContainer::NAME = "LocaleContainer";
-LocaleContainer::LocaleContainer(const OperationContext::Container & container)
+LocaleContainer::LocaleContainer(const OperationContext::Container& container)
{
- const LocaleContainer * p = dynamic_cast<const LocaleContainer *>(&container);
+ const LocaleContainer* p = dynamic_cast<const LocaleContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
*this = *p;
}
-LocaleContainer::LocaleContainer(const String & languageId)
+LocaleContainer::LocaleContainer(const String& languageId)
{
_languageId = languageId;
}
-LocaleContainer::~LocaleContainer(void)
+LocaleContainer::~LocaleContainer()
{
}
-LocaleContainer & LocaleContainer::operator=(const LocaleContainer &container)
+LocaleContainer& LocaleContainer::operator=(const LocaleContainer&container)
{
- if(this == &container)
+ if (this == &container)
{
- return(*this);
+ return *this;
}
_languageId = container._languageId;
- return(*this);
+ return *this;
}
-String LocaleContainer::getName(void) const
+String LocaleContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * LocaleContainer::clone(void) const
+OperationContext::Container* LocaleContainer::clone() const
{
- return(new LocaleContainer(*this));
+ return new LocaleContainer(*this);
}
-void LocaleContainer::destroy(void)
+void LocaleContainer::destroy()
{
delete this;
}
-String LocaleContainer::getLanguageId(void) const
+String LocaleContainer::getLanguageId() const
{
- return(_languageId);
+ return _languageId;
}
//
const String ProviderIdContainer::NAME = "ProviderIdContainer";
-ProviderIdContainer::ProviderIdContainer(const OperationContext::Container & container)
+ProviderIdContainer::ProviderIdContainer(
+ const OperationContext::Container& container)
{
- const ProviderIdContainer * p = dynamic_cast<const ProviderIdContainer *>(&container);
+ const ProviderIdContainer* p =
+ dynamic_cast<const ProviderIdContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
}
ProviderIdContainer::ProviderIdContainer(
- const CIMInstance & module,
- const CIMInstance & provider,
+ const CIMInstance& module,
+ const CIMInstance& provider,
Boolean isRemoteNameSpace,
- const String & remoteInfo)
+ const String& remoteInfo)
: _module(module),
_provider(provider),
_isRemoteNameSpace(isRemoteNameSpace),
{
}
-ProviderIdContainer::~ProviderIdContainer(void)
+ProviderIdContainer::~ProviderIdContainer()
{
}
-ProviderIdContainer & ProviderIdContainer::operator=(const ProviderIdContainer & container)
+ProviderIdContainer& ProviderIdContainer::operator=(
+ const ProviderIdContainer& container)
{
- if(this == &container)
+ if (this == &container)
{
- return(*this);
+ return *this;
}
_module = container._module;
_isRemoteNameSpace = container._isRemoteNameSpace;
_remoteInfo = container._remoteInfo;
- return(*this);
+ return *this;
}
-String ProviderIdContainer::getName(void) const
+String ProviderIdContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * ProviderIdContainer::clone(void) const
+OperationContext::Container* ProviderIdContainer::clone() const
{
- return(new ProviderIdContainer(*this));
+ return new ProviderIdContainer(*this);
}
-void ProviderIdContainer::destroy(void)
+void ProviderIdContainer::destroy()
{
delete this;
}
-CIMInstance ProviderIdContainer::getModule(void) const
+CIMInstance ProviderIdContainer::getModule() const
{
- return(_module);
+ return _module;
}
-CIMInstance ProviderIdContainer::getProvider(void) const
+CIMInstance ProviderIdContainer::getProvider() const
{
- return(_provider);
+ return _provider;
}
-Boolean ProviderIdContainer::isRemoteNameSpace(void) const
+Boolean ProviderIdContainer::isRemoteNameSpace() const
{
- return(_isRemoteNameSpace);
+ return _isRemoteNameSpace;
}
-String ProviderIdContainer::getRemoteInfo(void) const
+String ProviderIdContainer::getRemoteInfo() const
{
- return(_remoteInfo);
+ return _remoteInfo;
}
//
// CachedClassDefinitionContainer
//
-const String CachedClassDefinitionContainer::NAME = "CachedClassDefinitionContainer";
+const String CachedClassDefinitionContainer::NAME =
+ "CachedClassDefinitionContainer";
-CachedClassDefinitionContainer::CachedClassDefinitionContainer(const OperationContext::Container & container)
+CachedClassDefinitionContainer::CachedClassDefinitionContainer(
+ const OperationContext::Container& container)
{
- const CachedClassDefinitionContainer * p = dynamic_cast<const CachedClassDefinitionContainer *>(&container);
+ const CachedClassDefinitionContainer* p =
+ dynamic_cast<const CachedClassDefinitionContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
}
-CachedClassDefinitionContainer::CachedClassDefinitionContainer(const CIMClass & cimClass)
+CachedClassDefinitionContainer::CachedClassDefinitionContainer(
+ const CIMClass& cimClass)
: _cimClass(cimClass)
{
}
-CachedClassDefinitionContainer::~CachedClassDefinitionContainer(void)
+CachedClassDefinitionContainer::~CachedClassDefinitionContainer()
{
}
-CachedClassDefinitionContainer & CachedClassDefinitionContainer::operator=(const CachedClassDefinitionContainer & container)
+CachedClassDefinitionContainer& CachedClassDefinitionContainer::operator=(
+ const CachedClassDefinitionContainer& container)
{
- if(this == &container)
+ if (this == &container)
{
- return(*this);
+ return *this;
}
_cimClass = container._cimClass;
- return(*this);
+ return *this;
}
-String CachedClassDefinitionContainer::getName(void) const
+String CachedClassDefinitionContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * CachedClassDefinitionContainer::clone(void) const
+OperationContext::Container* CachedClassDefinitionContainer::clone() const
{
- return(new CachedClassDefinitionContainer(*this));
+ return new CachedClassDefinitionContainer(*this);
}
-void CachedClassDefinitionContainer::destroy(void)
+void CachedClassDefinitionContainer::destroy()
{
delete this;
}
-CIMClass CachedClassDefinitionContainer::getClass(void) const
+CIMClass CachedClassDefinitionContainer::getClass() const
{
- return(_cimClass);
+ return _cimClass;
}
//
const String NormalizerContextContainer::NAME = "NormalizerContextContainer";
NormalizerContextContainer::NormalizerContextContainer(
- const OperationContext::Container & container)
+ const OperationContext::Container& container)
{
- const NormalizerContextContainer * p =
- dynamic_cast<const NormalizerContextContainer *>(&container);
+ const NormalizerContextContainer* p =
+ dynamic_cast<const NormalizerContextContainer*>(&container);
- if(p == 0)
+ if (p == 0)
{
throw DynamicCastFailedException();
}
NormalizerContextContainer::NormalizerContextContainer(
- AutoPtr<NormalizerContext> & context) : normalizerContext(context.get())
+ AutoPtr<NormalizerContext>& context) : normalizerContext(context.get())
{
context.release();
}
NormalizerContextContainer::NormalizerContextContainer(
- const NormalizerContextContainer & container)
+ const NormalizerContextContainer& container)
#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || \
defined (PEGASUS_PLATFORM_DARWIN_PPC_GNU)
: OperationContext::Container()
#endif
{
- if(this != &container)
+ if (this != &container)
{
normalizerContext.reset(container.normalizerContext->clone().release());
}
{
}
-NormalizerContextContainer & NormalizerContextContainer::operator=(
- const NormalizerContextContainer & container)
+NormalizerContextContainer& NormalizerContextContainer::operator=(
+ const NormalizerContextContainer& container)
{
- if(this == &container)
+ if (this == &container)
{
- return(*this);
+ return *this;
}
normalizerContext.reset(container.normalizerContext->clone().release());
- return(*this);
+ return *this;
}
String NormalizerContextContainer::getName() const
{
- return(NAME);
+ return NAME;
}
-OperationContext::Container * NormalizerContextContainer::clone() const
+OperationContext::Container* NormalizerContextContainer::clone() const
{
- return(new NormalizerContextContainer(*this));
+ return new NormalizerContextContainer(*this);
}
void NormalizerContextContainer::destroy()
delete this;
}
-NormalizerContext * NormalizerContextContainer::getContext() const
+NormalizerContext* NormalizerContextContainer::getContext() const
{
return normalizerContext.get();
}
//
//==============================================================================
//
-// Author: Chip Vincent (cvincent@us.ibm.com)
-//
-// Modified By: Mike Day (mdday@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_OperationContextInternal_h
public:
static const String NAME;
- LocaleContainer(const OperationContext::Container & container);
- LocaleContainer(const String & languageId);
- virtual ~LocaleContainer(void);
+ LocaleContainer(const OperationContext::Container& container);
+ LocaleContainer(const String& languageId);
+ virtual ~LocaleContainer();
// NOTE: The compiler default implementation of the copy constructor
// is used for this class.
- LocaleContainer & operator=(const LocaleContainer & container);
+ LocaleContainer& operator=(const LocaleContainer& container);
- virtual String getName(void) const;
- virtual OperationContext::Container * clone(void) const;
- virtual void destroy(void);
+ virtual String getName() const;
+ virtual OperationContext::Container* clone() const;
+ virtual void destroy();
- String getLanguageId(void) const;
+ String getLanguageId() const;
protected:
String _languageId;
public:
static const String NAME;
- ProviderIdContainer(const OperationContext::Container & container);
- ProviderIdContainer(const CIMInstance & module, const CIMInstance & provider,
- Boolean isRemoteNameSpace = false, const String & remoteInfo = String::EMPTY);
- virtual ~ProviderIdContainer(void);
+ ProviderIdContainer(const OperationContext::Container& container);
+ ProviderIdContainer(
+ const CIMInstance& module,
+ const CIMInstance& provider,
+ Boolean isRemoteNameSpace = false,
+ const String& remoteInfo = String::EMPTY);
+ virtual ~ProviderIdContainer();
// NOTE: The compiler default implementation of the copy constructor
// is used for this class.
- ProviderIdContainer & operator=(const ProviderIdContainer & container);
+ ProviderIdContainer& operator=(const ProviderIdContainer& container);
- virtual String getName(void) const;
- virtual OperationContext::Container * clone(void) const;
- virtual void destroy(void);
+ virtual String getName() const;
+ virtual OperationContext::Container* clone() const;
+ virtual void destroy();
- CIMInstance getModule(void) const;
- CIMInstance getProvider(void) const;
- Boolean isRemoteNameSpace(void) const;
- String getRemoteInfo(void) const;
+ CIMInstance getModule() const;
+ CIMInstance getProvider() const;
+ Boolean isRemoteNameSpace() const;
+ String getRemoteInfo() const;
protected:
CIMInstance _module;
public:
static const String NAME;
- CachedClassDefinitionContainer(const OperationContext::Container & container);
- CachedClassDefinitionContainer(const CIMClass & cimClass);
- virtual ~CachedClassDefinitionContainer(void);
+ CachedClassDefinitionContainer(
+ const OperationContext::Container& container);
+ CachedClassDefinitionContainer(const CIMClass& cimClass);
+ virtual ~CachedClassDefinitionContainer();
// NOTE: The compiler default implementation of the copy constructor
// is used for this class.
- CachedClassDefinitionContainer & operator=(const CachedClassDefinitionContainer & container);
+ CachedClassDefinitionContainer& operator=(
+ const CachedClassDefinitionContainer& container);
- virtual String getName(void) const;
- virtual OperationContext::Container * clone(void) const;
- virtual void destroy(void);
+ virtual String getName() const;
+ virtual OperationContext::Container* clone() const;
+ virtual void destroy();
- CIMClass getClass(void) const;
+ CIMClass getClass() const;
protected:
CIMClass _cimClass;
public:
static const String NAME;
- NormalizerContextContainer(const OperationContext::Container & container);
- NormalizerContextContainer(AutoPtr<NormalizerContext> & context);
- NormalizerContextContainer(const NormalizerContextContainer & container);
- virtual ~NormalizerContextContainer(void);
+ NormalizerContextContainer(const OperationContext::Container& container);
+ NormalizerContextContainer(AutoPtr<NormalizerContext>& context);
+ NormalizerContextContainer(const NormalizerContextContainer& container);
+ virtual ~NormalizerContextContainer();
- NormalizerContextContainer & operator=(const NormalizerContextContainer & container);
+ NormalizerContextContainer& operator=(
+ const NormalizerContextContainer& container);
- virtual String getName(void) const;
- virtual OperationContext::Container * clone(void) const;
- virtual void destroy(void);
+ virtual String getName() const;
+ virtual OperationContext::Container* clone() const;
+ virtual void destroy();
- NormalizerContext * getContext(void) const;
+ NormalizerContext* getContext() const;
protected:
AutoPtr<NormalizerContext> normalizerContext;
-
+
private:
NormalizerContextContainer();
};
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Karl Schopmeyer(k.schopmeyer@opengroup.org)
-// June 2001 - Extend help and print to include help description
-// Feb 2002 - ad IsTrue
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
// Delete all options in the list:
for (Uint32 i = 0; i < _options.size(); i++)
- delete _options[i];
+ delete _options[i];
}
void OptionManager::registerOption(Option* option)
{
if (!option)
- throw NullPointer();
+ throw NullPointer();
if (lookupOption(option->getOptionName()))
- throw OMDuplicateOption(option->getOptionName());
+ throw OMDuplicateOption(option->getOptionName());
_options.append(option);
}
{
for (Uint32 i = 0; i < numOptions; i++)
{
- // Get option name:
+ // Get option name:
- if (!optionRow[i].optionName)
- throw NullPointer();
+ if (!optionRow[i].optionName)
+ throw NullPointer();
- String optionName = optionRow[i].optionName;
+ String optionName = optionRow[i].optionName;
- // Get default value:
+ // Get default value:
- String defaultValue;
+ String defaultValue;
- if (optionRow[i].defaultValue)
- defaultValue = optionRow[i].defaultValue;
+ if (optionRow[i].defaultValue)
+ defaultValue = optionRow[i].defaultValue;
- // Get the required flag:
+ // Get the required flag:
- Boolean required = optionRow[i].required != 0;
+ Boolean required = optionRow[i].required != 0;
- // Get the type:
+ // Get the type:
- Option::Type type = optionRow[i].type;
+ Option::Type type = optionRow[i].type;
- // Get the domain:
+ // Get the domain:
- Array<String> domain;
+ Array<String> domain;
- if (optionRow[i].domain)
- {
- Uint32 domainSize = optionRow[i].domainSize;
+ if (optionRow[i].domain)
+ {
+ Uint32 domainSize = optionRow[i].domainSize;
- for (Uint32 j = 0; j < domainSize; j++)
- domain.append(optionRow[i].domain[j]);
- }
+ for (Uint32 j = 0; j < domainSize; j++)
+ domain.append(optionRow[i].domain[j]);
+ }
- // Get commandLineOptionName:
+ // Get commandLineOptionName:
- String commandLineOptionName;
+ String commandLineOptionName;
- if (optionRow[i].commandLineOptionName)
- commandLineOptionName = optionRow[i].commandLineOptionName;
+ if (optionRow[i].commandLineOptionName)
+ commandLineOptionName = optionRow[i].commandLineOptionName;
- // get optionHelp Message String
+ // get optionHelp Message String
- String optionHelpMessage;
+ String optionHelpMessage;
- if (optionRow[i].optionHelpMessage)
- optionHelpMessage = optionRow[i].optionHelpMessage;
+ if (optionRow[i].optionHelpMessage)
+ optionHelpMessage = optionRow[i].optionHelpMessage;
- // Add the option:
+ // Add the option:
- Option* option = new Option(
- optionName,
- defaultValue,
- required,
- type,
- domain,
- commandLineOptionName,
- optionHelpMessage);
+ Option* option = new Option(
+ optionName,
+ defaultValue,
+ required,
+ type,
+ domain,
+ commandLineOptionName,
+ optionHelpMessage);
- registerOption(option);
+ registerOption(option);
}
}
-void OptionManager::mergeCommandLine(int& argc, char**& argv, Boolean abortOnErr)
+void OptionManager::mergeCommandLine(
+ int& argc,
+ char**& argv,
+ Boolean abortOnErr)
{
for (int i = 0; i < argc; )
{
- // Check for -option:
+ // Check for -option:
- const char* arg = argv[i];
+ const char* arg = argv[i];
- if (*arg == '-')
- {
- // Look for the option:
+ if (*arg == '-')
+ {
+ // Look for the option:
- Option* option = _lookupOptionByCommandLineOptionName(arg + 1);
+ Option* option = _lookupOptionByCommandLineOptionName(arg + 1);
- if (!option)
- {
- if (abortOnErr)
+ if (!option)
+ {
+ if (abortOnErr)
{
throw OMMBadCmdLineOption(arg);
}
else
{
i++;
- continue;
+ continue;
}
- }
+ }
- // Get the option argument if any:
+ // Get the option argument if any:
- const char* optionArgument = "true";
+ const char* optionArgument = "true";
- if (option->getType() != Option::BOOLEAN)
- {
- if (i + 1 == argc)
- throw OMMissingCommandLineOptionArgument(arg);
+ if (option->getType() != Option::BOOLEAN)
+ {
+ if (i + 1 == argc)
+ throw OMMissingCommandLineOptionArgument(arg);
- optionArgument = argv[i + 1];
- }
+ optionArgument = argv[i + 1];
+ }
- // Validate the value:
+ // Validate the value:
- if (!option->isValid(optionArgument))
- throw OMInvalidOptionValue(arg, optionArgument);
+ if (!option->isValid(optionArgument))
+ throw OMInvalidOptionValue(arg, optionArgument);
- // Set the value:
+ // Set the value:
- option->setValue(optionArgument);
+ option->setValue(optionArgument);
- // Remove the option and its argument from the command line:
+ // Remove the option and its argument from the command line:
- if (option->getType() == Option::BOOLEAN)
- {
- memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
- argc--;
- }
- else
- {
- memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
- argc -= 2;
- }
- }
- else
- i++;
+ if (option->getType() == Option::BOOLEAN)
+ {
+ memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
+ argc--;
+ }
+ else
+ {
+ memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
+ argc -= 2;
+ }
+ }
+ else
+ i++;
}
}
#endif
if (!is)
- throw NoSuchFile(fileName);
+ throw NoSuchFile(fileName);
// For each line of the file:
for (Uint32 lineNumber = 1; GetLine(is, line); lineNumber++)
{
- // -- Get the identifier and value:
+ // -- Get the identifier and value:
- if (line[0] == '#')
- continue;
+ if (line[0] == '#')
+ continue;
- // Skip leading whitespace:
+ // Skip leading whitespace:
- const Char16* p = line.getChar16Data();
+ const Char16* p = line.getChar16Data();
- while (*p && isspace(*p))
- p++;
+ while (*p && isspace(*p))
+ p++;
- if (!*p)
- continue;
+ if (!*p)
+ continue;
- if (*p == '#')
- continue;
+ if (*p == '#')
+ continue;
- // Get the identifier:
+ // Get the identifier:
- String ident;
+ String ident;
- if (!(isalpha(*p) || *p == '_'))
- throw OMConfigFileSyntaxError(fileName, lineNumber);
+ if (!(isalpha(*p) || *p == '_'))
+ throw OMConfigFileSyntaxError(fileName, lineNumber);
- ident.append(*p++);
+ ident.append(*p++);
- while (isalnum(*p) || *p == '_')
- ident.append(*p++);
+ while (isalnum(*p) || *p == '_')
+ ident.append(*p++);
- // Skip whitespace after identifier:
+ // Skip whitespace after identifier:
- while (*p && isspace(*p))
- p++;
+ while (*p && isspace(*p))
+ p++;
- // Expect an equal sign:
+ // Expect an equal sign:
- if (*p != '=')
- throw OMConfigFileSyntaxError(fileName, lineNumber);
- p++;
+ if (*p != '=')
+ throw OMConfigFileSyntaxError(fileName, lineNumber);
+ p++;
- // Skip whitespace after equal sign:
+ // Skip whitespace after equal sign:
- while (*p && isspace(*p))
- p++;
+ while (*p && isspace(*p))
+ p++;
- // Expect open quote:
+ // Expect open quote:
- if (*p != '"')
- throw OMConfigFileSyntaxError(fileName, lineNumber);
- p++;
+ if (*p != '"')
+ throw OMConfigFileSyntaxError(fileName, lineNumber);
+ p++;
- // Get the value:
+ // Get the value:
- String value;
+ String value;
- while (*p && *p != '"')
- {
- if (*p == '\\')
- {
- p++;
+ while (*p && *p != '"')
+ {
+ if (*p == '\\')
+ {
+ p++;
- switch (*p)
- {
- case 'n':
- value.append('\n');
- break;
+ switch (*p)
+ {
+ case 'n':
+ value.append('\n');
+ break;
- case 'r':
- value.append('\r');
- break;
+ case 'r':
+ value.append('\r');
+ break;
- case 't':
- value.append('\t');
- break;
+ case 't':
+ value.append('\t');
+ break;
- case 'f':
- value.append('\f');
- break;
+ case 'f':
+ value.append('\f');
+ break;
- case '"':
- value.append('"');
- break;
+ case '"':
+ value.append('"');
+ break;
- case '\0':
- throw OMConfigFileSyntaxError(fileName, lineNumber);
+ case '\0':
+ throw OMConfigFileSyntaxError(fileName, lineNumber);
- default:
- value.append(*p);
- }
- p++;
- }
- else
- value.append(*p++);
- }
+ default:
+ value.append(*p);
+ }
+ p++;
+ }
+ else
+ value.append(*p++);
+ }
- // Expect close quote:
+ // Expect close quote:
- if (*p != '"')
- throw OMConfigFileSyntaxError(fileName, lineNumber);
- p++;
+ if (*p != '"')
+ throw OMConfigFileSyntaxError(fileName, lineNumber);
+ p++;
- // Skip whitespace through end of line:
+ // Skip whitespace through end of line:
- while (*p && isspace(*p))
- p++;
+ while (*p && isspace(*p))
+ p++;
- if (*p)
- throw OMConfigFileSyntaxError(fileName, lineNumber);
+ if (*p)
+ throw OMConfigFileSyntaxError(fileName, lineNumber);
- // Now that we have the identifier and value, merge it:
+ // Now that we have the identifier and value, merge it:
- Option* option = (Option*)lookupOption(ident);
+ Option* option = (Option*)lookupOption(ident);
- if (!option)
- throw OMUnrecognizedConfigFileOption(ident);
+ if (!option)
+ throw OMUnrecognizedConfigFileOption(ident);
- if (!option->isValid(value))
- throw OMInvalidOptionValue(ident, value);
+ if (!option->isValid(value))
+ throw OMInvalidOptionValue(ident, value);
- option->setValue(value);
+ option->setValue(value);
}
}
{
for (Uint32 i = 0; i < _options.size(); i++)
{
- const Option* option = _options[i];
+ const Option* option = _options[i];
- if (option->getRequired() && !option->isResolved())
- throw OMMissingRequiredOptionValue(option->getOptionName());
+ if (option->getRequired() && !option->isResolved())
+ throw OMMissingRequiredOptionValue(option->getOptionName());
}
}
{
for (Uint32 i = 0; i < _options.size(); i++)
{
- if (_options[i]->getOptionName() == name)
- return _options[i];
+ if (_options[i]->getOptionName() == name)
+ return _options[i];
}
return 0;
const Option* option = lookupOption(name);
if (!option)
- return false;
+ return false;
value = option->getValue();
return true;
}
-Boolean OptionManager::lookupIntegerValue(const String& name, Uint32& value) const
+Boolean OptionManager::lookupIntegerValue(
+ const String& name,
+ Uint32& value) const
{
//ATTN: KS P1 7 May 2002 - Add test for Integer type in om table.
String valueString;
if (lookupValue(name, valueString))
{
- value = atol(valueString.getCString());
- return true;
+ value = atol(valueString.getCString());
+ return true;
}
else
{
- return false;
+ return false;
}
}
-Boolean OptionManager::valueEquals(const String& name, const String& value)
- const
+Boolean OptionManager::valueEquals(
+ const String& name,
+ const String& value) const
{
String optionString;
- return (lookupValue(name, optionString) && optionString == value) ? true : false;
+ return (lookupValue(name, optionString) && optionString == value);
}
Boolean OptionManager::isTrue(const String& name) const
//ATTN: KS 7 May 2002 P3 Add test to confirm boolean type
return valueEquals(name, "true") ? true: false;
}
+
/* ATTN: P3 MB 2001 Buried this one for the moment to think about it.
-Uint32 OptionManager::isStringInOptionMask(const String& option,
- const String& entry)
+Uint32 OptionManager::isStringInOptionMask(
+ const String& option,
+ const String& entry)
{
String optionString;
if (lookupValue(name, optionString) && optionString == value)
- if (optionString.find(entry)
- return 1;
+ if (optionString.find(entry)
+ return 1;
else
- return PEG_NOT_FOUND;
+ return PEG_NOT_FOUND;
}
*/
{
for (Uint32 i = 0; i < _options.size(); i++)
{
- if (_options[i]->getCommandLineOptionName() == name)
- return _options[i];
+ if (_options[i]->getCommandLineOptionName() == name)
+ return _options[i];
}
return 0;
{
for (Uint32 i = 0; i < _options.size(); i++)
{
- Option* option = _options[i];
- cout << option->getOptionName() << "=\"";
- cout << option->getValue() << "\" ";
- cout << option->getOptionHelpMessage() << "\n";
+ Option* option = _options[i];
+ cout << option->getOptionName() << "=\"";
+ cout << option->getValue() << "\" ";
+ cout << option->getOptionHelpMessage() << "\n";
}
cout << endl;
}
{
for (Uint32 i = 0; i < _options.size(); i++)
{
- Option* option = _options[i];
- cout << " -";
- cout << option->getCommandLineOptionName() << " ";
- cout << option->getOptionName() << ". ";
- cout << option->getOptionHelpMessage();
+ Option* option = _options[i];
+ cout << " -";
+ cout << option->getCommandLineOptionName() << " ";
+ cout << option->getOptionName() << ". ";
+ cout << option->getOptionHelpMessage();
cout << ". Default(" << option->getDefaultValue() << ")\n";
}
cout << endl;
}
-void OptionManager::printOptionsHelpTxt(const String& header, const String& trailer) const
+void OptionManager::printOptionsHelpTxt(
+ const String& header,
+ const String& trailer) const
{
cout << "\n" << header << "\n";
printOptionsHelp();
_resolved(false)
{
if (!isValid(_value))
- throw OMInvalidOptionValue(_optionName, _value);
+ throw OMInvalidOptionValue(_optionName, _value);
}
Option::Option(const Option& x)
{
if (this != &x)
{
- _optionName = x._optionName;
- _defaultValue = x._defaultValue;
- _value = x._value;
- _required = x._required;
- _type = x._type;
- _domain = x._domain;
- _commandLineOptionName = x._commandLineOptionName;
- _optionHelpMessage = x._optionHelpMessage;
+ _optionName = x._optionName;
+ _defaultValue = x._defaultValue;
+ _value = x._value;
+ _required = x._required;
+ _type = x._type;
+ _domain = x._domain;
+ _commandLineOptionName = x._commandLineOptionName;
+ _optionHelpMessage = x._optionHelpMessage;
}
return *this;
}
if (domainSize)
{
- Boolean found = false;
+ Boolean found = false;
- for (Uint32 i = 0; i < domainSize; i++)
- {
- if (value == _domain[i])
- found = true;
- }
+ for (Uint32 i = 0; i < domainSize; i++)
+ {
+ if (value == _domain[i])
+ found = true;
+ }
- if (!found)
- return false;
+ if (!found)
+ return false;
}
// Check the type:
switch (_type)
{
- case BOOLEAN:
- {
- if (value == "true" || value == "false")
- return true;
+ case BOOLEAN:
+ {
+ if (value == "true" || value == "false")
+ return true;
else
return false;
- }
+ }
- case STRING:
- return true;
+ case STRING:
+ return true;
- case INTEGER:
- case NATURAL_NUMBER:
- case WHOLE_NUMBER:
- {
- CString tmp = value.getCString();
- char* end = 0;
- long x = strtol(tmp, &end, 10);
+ case INTEGER:
+ case NATURAL_NUMBER:
+ case WHOLE_NUMBER:
+ {
+ CString tmp = value.getCString();
+ char* end = 0;
+ long x = strtol(tmp, &end, 10);
- if (!end || *end != '\0')
- return false;
+ if (!end || *end != '\0')
+ return false;
- switch (_type)
- {
- case INTEGER:
- return true;
+ switch (_type)
+ {
+ case INTEGER:
+ return true;
- case NATURAL_NUMBER:
- return x >= 1;
+ case NATURAL_NUMBER:
+ return x >= 1;
- case WHOLE_NUMBER:
- return x >= 0;
+ case WHOLE_NUMBER:
+ return x >= 0;
- default:
- break;
- }
- }
+ default:
+ break;
+ }
+ }
}
// Unreachable!
{
char buffer[32];
sprintf(buffer, "%d", line);
- //l10n
- MessageLoaderParms parms("Common.OptionManager.SYNTAX_ERR_CONFIG_FILE",
- "Syntax error in configuration file: ");
- String result = MessageLoader::getMessage(parms);
- //String result = "Syntax error in configuration file: ";
+ MessageLoaderParms parms(
+ "Common.OptionManager.SYNTAX_ERR_CONFIG_FILE",
+ "Syntax error in configuration file: ");
+ String result = MessageLoader::getMessage(parms);
result.append(file);
result.append("(");
result.append(buffer);
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Karl Schopmyer(k.schopmeyer@opengroup.org)
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// The OptionManager Class
// The Option Class - Used to define information about an option
// The Option Row structure - Used to define option declarations in a
-// program
+// program
// The optionexcptions Class
//
//////////////////////////////////////////////////////////////////////////////
A program option may be specified in two ways:
<ul>
- <li>In a configuration file</li>
- <li>On the command line</li>
+ <li>In a configuration file</li>
+ <li>On the command line</li>
</ul>
This class provides methods for merging options from both of these
merge options from a command line into the option manager.
<pre>
- int main(int argc, char** argv)
- {
- OptionManager om;
+ int main(int argc, char** argv)
+ {
+ OptionManager om;
- ...
+ ...
- // Merge options from the command line into the option manager's
- // option list. Remove arguments from command line.
+ // Merge options from the command line into the option manager's
+ // option list. Remove arguments from command line.
- om.mergeCommandLine(argc, argv);
+ om.mergeCommandLine(argc, argv);
- ...
- }
+ ...
+ }
</pre>
Similarly, the OptionManager::mergeFile() method allows options to be
can be resolved:
<ul>
- <li>The option's name</li>
- <li>The default value (to be used if not specified elsewhere)</li>
- <li>Whether the option is required</li>
- <li>The option's type (e.g., boolean, integer or string)</li>
- <li>The domain of the option if any (set of legal values)</li>
- <li>The name the option as it appears on the command line</li>
+ <li>The option's name</li>
+ <li>The default value (to be used if not specified elsewhere)</li>
+ <li>Whether the option is required</li>
+ <li>The option's type (e.g., boolean, integer or string)</li>
+ <li>The domain of the option if any (set of legal values)</li>
+ <li>The name the option as it appears on the command line</li>
</ul>
Here is how to regsiter an option:
<pre>
- OptionManager om;
+ OptionManager om;
- Option* option = new Option("port", "80", false,
- Option::NATURAL_NUMBER, Array<String>(), "p");
+ Option* option = new Option("port", "80", false,
+ Option::NATURAL_NUMBER, Array<String>(), "p");
- om.registerOption(option);
+ om.registerOption(option);
</pre>
The arguments of the Option constructor are the same (and in the same
lookupOption() method like this:
<pre>
- Option* option = om.lookupOption("port");
- String port = option->getValue();
+ Option* option = om.lookupOption("port");
+ String port = option->getValue();
</pre>
Or the lookupValue() convenience function may be used to lookup values:
<pre>
- String value;
- om.lookupValue("port", value);
+ String value;
+ om.lookupValue("port", value);
</pre>
Boolean Options can easily be tested as follows:
mergeCommandLine() like this:
<pre>
- om.mergeCommandLine(argc, argv);
+ om.mergeCommandLine(argc, argv);
</pre>
This method searches the command line for options that match the registered
method like this:
<pre>
- om.mergeFile(fileName);
+ om.mergeFile(fileName);
</pre>
This searches the file for options matching registered ones. Exceptions
information optatined during option registration).
<ul>
- <li>The type of the option - whether integer, positive integer,
- or string or whatever.</li>
- <li>The domain of the option - whether the supplied option is a legal
- value for that otpion</li>
- <li>User extended validation - whether the user overriden
- Option::isValid() returns true when the value is passed to it</li>
+ <li>The type of the option - whether integer, positive integer,
+ or string or whatever.</li>
+ <li>The domain of the option - whether the supplied option is a legal
+ value for that otpion</li>
+ <li>User extended validation - whether the user overriden
+ Option::isValid() returns true when the value is passed to it</li>
</ul>
<h4>Typcial Usage</h4>
The option manager allows for several types of options including:
<UL>
- <LI> (BOOLEAN)Simple keyword parameters (ex. -t or -h on the command
- line). These are Boolean parameters and there are no additional parameters
- after the keyword.
+ <LI> (BOOLEAN)Simple keyword parameters (ex. -t or -h on the command
+ line). These are Boolean parameters and there are no additional
+ parameters after the keyword.
- <LI> (INTEGER) Numeric parameters - (ex -port 5988). These are
- parameters where a numeric variable follows the parameter defintion.
+ <LI> (INTEGER) Numeric parameters - (ex -port 5988). These are
+ parameters where a numeric variable follows the parameter defintion.
- <LI>(WHOLE_NUMBER) Numeric parameters ATTN: Finish.
+ <LI>(WHOLE_NUMBER) Numeric parameters ATTN: Finish.
- <LI> (NATURAL_NUMBER Numieric parameters - (ex ). ATTN: finish
+ <LI> (NATURAL_NUMBER Numieric parameters - (ex ). ATTN: finish
- <LI>(STRING) String Parameters - (ex. -file abd.log) These are
- parameters that are represented by strings following the option
- keyword. No limitations are placed on the string except that it must
- be resolvable to a single string.
+ <LI>(STRING) String Parameters - (ex. -file abd.log) These are
+ parameters that are represented by strings following the option
+ keyword. No limitations are placed on the string except that it must
+ be resolvable to a single string.
- <LI> (STRING) Domain Parameters - These are parameters where there is
- a choice of keywords from a domain of keywords. The input parameter may be any
- one of these keywords. Thus, the domain (red blue green) for the
- parameter "color" (-c) could be entered as -c red. The difference
- between String interpretation and domain interpretation is the use of the
- domain fields in the option definition.
+ <LI> (STRING) Domain Parameters - These are parameters where there is
+ a choice of keywords from a domain of keywords. The input parameter
+ may be any one of these keywords. Thus, the domain (red blue green)
+ for the parameter "color" (-c) could be entered as -c red. The
+ difference between String interpretation and domain interpretation
+ is the use of the domain fields in the option definition.
- <LI> Mask parameters - These are parameters that define an internal
- bit mask from a set of keywords input.
- ATTN: Finish this definition.
+ <LI> Mask parameters - These are parameters that define an internal
+ bit mask from a set of keywords input.
+ ATTN: Finish this definition.
</UL>
*/
~OptionManager();
/** Registers an option. The OptionManager is responsible for disposing
- of the option; the caller must not delete this object.
+ of the option; the caller must not delete this object.
- @param option option to be registerd.
- @exception NullPointer exception if option argument is null.
- @exception OMDuplicateOption if option already defined.
+ @param option option to be registerd.
+ @exception NullPointer exception if option argument is null.
+ @exception OMDuplicateOption if option already defined.
*/
void registerOption(Option* option);
/** Provides a simple way to register several options at once using
- a declartive style table. This may also be done programmitically
- by repeatedly calling registerOption above. See documentation for
- OptionRow for details on how to use them.
+ a declartive style table. This may also be done programmitically
+ by repeatedly calling registerOption above. See documentation for
+ OptionRow for details on how to use them.
*/
void registerOptions(OptionRow* options, Uint32 numOptions);
/** Merge option values from the command line. Searches the command
- line for registered options whose names are given by the
- Option::getCommandLineOptionName() method. Validation is performed
- on each option value obtained by calling Option::isValid(). Valid
- option values are set by calling Option::setValue(). The argc and
- argv arguments are modified: the option and its argument are
- stripped from the command line. The option and its argument have the
- following form: -option-name argument. A space must be supplied
- between the two. Boolean option arguments are an exception. They
- must have the form -option. If they are present, then they are
- taken to be true.
-
- ¶m argc number of argument on the command line.
- ¶m argv list of command line arguments.
- ¶m abortOnErr - Optional Boolean that if true causes exception if there is
- a parameter found that is not in the table. Defaults to true
- &exception InvalidOptionValue if validation fails.
- &exception OMMissingCommandLineOptionArgument
+ line for registered options whose names are given by the
+ Option::getCommandLineOptionName() method. Validation is performed
+ on each option value obtained by calling Option::isValid(). Valid
+ option values are set by calling Option::setValue(). The argc and
+ argv arguments are modified: the option and its argument are
+ stripped from the command line. The option and its argument have the
+ following form: -option-name argument. A space must be supplied
+ between the two. Boolean option arguments are an exception. They
+ must have the form -option. If they are present, then they are
+ taken to be true.
+
+ @param argc number of argument on the command line.
+ @param argv list of command line arguments.
+ @param abortOnErr - Optional Boolean that if true causes exception
+ if there is a parameter found that is not in the table. Defaults to
+ true
+ @exception InvalidOptionValue if validation fails.
+ @exception OMMissingCommandLineOptionArgument
*/
void mergeCommandLine(int& argc, char**& argv, Boolean abortOnErr=true);
/** Merge option values from a file. Searches file for registered options
- whose names are given by the options which have been registered.
- Validation is performed on each option value by calling
- Option::isValid(). Valid option values are set by calling
- Option::setValue().
-
- ¶m fileName name of file to be merged.
- &exception NoSuchFile if file cannot be opened.
- &exception BadConfigFileOption
+ whose names are given by the options which have been registered.
+ Validation is performed on each option value by calling
+ Option::isValid(). Valid option values are set by calling
+ Option::setValue().
+
+ @param fileName name of file to be merged.
+ @exception NoSuchFile if file cannot be opened.
+ @exception BadConfigFileOption
*/
void mergeFile(const String& fileName);
/** After merging, this method is called to check for required options
- that were not merged (specified).
+ that were not merged (specified).
- &exception OMMissingRequiredRequiredOption
+ @exception OMMissingRequiredRequiredOption
*/
void checkRequiredOptions() const;
/** Lookup the option with the given name.
- @param Name provides the name of the option.
- @return 0 if no such option.
+ @param Name provides the name of the option.
+ @return 0 if no such option.
*/
const Option* lookupOption(const String& name) const;
/** Lookup value of an option.
- @param Name provides the name of the option (ex. "port")
- @param String parameter contains the String that contains the
- value for this parameter (in String format).
- @return Boolean return. True if the option found.
+ @param Name provides the name of the option (ex. "port")
+ @param String parameter contains the String that contains the
+ value for this parameter (in String format).
+ @return Boolean return. True if the option found.
*/
Boolean lookupValue(const String& name, String& value ) const;
/** LookupIntegerValue value of an option determines if the value exists
- and converts it to integer (Uint32).
- @param Name provides the name of the option (ex. "port")
- @param String parameter contains the String that contains the
- value for this parameter (in String format).
- @return Boolean return. True if the option found.
+ and converts it to integer (Uint32).
+ @param Name provides the name of the option (ex. "port")
+ @param String parameter contains the String that contains the
+ value for this parameter (in String format).
+ @return Boolean return. True if the option found.
*/
Boolean lookupIntegerValue(const String& name, Uint32& value) const;
- /** isStringInOptionMask - Looks for a String value in an option.
- This function is used to detect particular options listed in strings of
- entries forming a STRING option. Thus, for example if the option string
- were "abc,def,ijk" in option toy isStringInOption ("toy", "def") returns
- true.
- @param option name of the option in the option table
- @param entry Entry to compare
- @return True if the entry String is found in the option.
+ /** isStringInOptionMask - Looks for a String value in an option.
+ This function is used to detect particular options listed in strings of
+ entries forming a STRING option. Thus, for example if the option string
+ were "abc,def,ijk" in option toy isStringInOption ("toy", "def") returns
+ true.
+ @param option name of the option in the option table
+ @param entry Entry to compare
+ @return True if the entry String is found in the option.
*/
//Uint32 isStringInOptionMask (const String& option, String& entry) const;
/** optionValueEquals - Test the string value of an option.
- @param name provides the name of the option (ex. "port")
- @param value String value for comparison.
- @return true if the option exists and the value of the option
- equals the input parameter value.
+ @param name provides the name of the option (ex. "port")
+ @param value String value for comparison.
+ @return true if the option exists and the value of the option
+ equals the input parameter value.
*/
Boolean valueEquals(const String& name, const String& value) const;
*/
void printOptionsHelp() const;
- /** Print Complete Help Text message including header before the options help
- and trailer after the options help
+ /** Print Complete Help Text message including header before the options
+ help and trailer after the options help
*/
void printOptionsHelpTxt(const String& header, const String& trailer) const;
private:
/** Lookup the option by its commandLineOptionName.
- @return 0 if no such option.
+ @return 0 if no such option.
*/
Option* _lookupOptionByCommandLineOptionName(const String& name);
/** Valid value types. */
enum Type
{
- // (..., -3, -2, -1, 0, 1, 2, 3, ...)
- INTEGER,
+ // (..., -3, -2, -1, 0, 1, 2, 3, ...)
+ INTEGER,
- // (1, 2, 3, ...)
- NATURAL_NUMBER,
+ // (1, 2, 3, ...)
+ NATURAL_NUMBER,
- // (0, 1, 2, 3, ...)
- WHOLE_NUMBER,
+ // (0, 1, 2, 3, ...)
+ WHOLE_NUMBER,
- // "true" or "false"
- BOOLEAN,
+ // "true" or "false"
+ BOOLEAN,
- // Anything
- STRING
+ // Anything
+ STRING
};
/** Constructor.
- @param optionName the name of this option.
+ @param optionName the name of this option.
- @param defaultValue the default value of this option.
+ @param defaultValue the default value of this option.
- @param required whether the value of this option is required.
+ @param required whether the value of this option is required.
- @param type type of the value. This is used to validate the value.
+ @param type type of the value. This is used to validate the value.
- @param domain list of legal value for this option. If this list
- is empty, then no domain is enforced.
+ @param domain list of legal value for this option. If this list
+ is empty, then no domain is enforced.
- @param commandLineOptionName name of the corresponding command line
- option (which may be different from the option name).
+ @param commandLineOptionName name of the corresponding command line
+ option (which may be different from the option name).
- @param optionHelpMessage Text message that defines option. To be used
- in Usage messages.
+ @param optionHelpMessage Text message that defines option. To be used
+ in Usage messages.
*/
Option(
const String& optionName,
}
/** Accessor
- @return - Returns string representation of value
+ @return - Returns string representation of value
*/
const String& getValue() const
{
void setValue(const String& value)
{
_value = value;
- _resolved = true;
+ _resolved = true;
}
/** Accessor */
/** Accessor */
const String& getOptionHelpMessage() const
{
- return _optionHelpMessage;
+ return _optionHelpMessage;
}
/** Modifier */
}
/** Accesor. Returns true if an option value was ever obtained for
- this option.
+ this option.
*/
Boolean isResolved() const
{
- return _resolved;
+ return _resolved;
}
/** Checks to see if the given value is valid or not. This method may be
- overriden by derived classes to do special purpose validation of the
- value. This implementation just checks the domain and type.
+ overriden by derived classes to do special purpose validation of the
+ value. This implementation just checks the domain and type.
*/
virtual Boolean isValid(const String& value) const;
register one of these option lists with an OptionManager.
<pre>
- static OptionRow options[] =
- {
- { "port", "80", false, Option::NATURAL_NUMBER },
- { "hostname", "", true, Option::STRING }
- };
+ static OptionRow options[] =
+ {
+ { "port", "80", false, Option::NATURAL_NUMBER },
+ { "hostname", "", true, Option::STRING }
+ };
- ...
+ ...
- OptionManager om;
- om.registerOptions(options, sizeof(options) / sizeof(options[0]));
+ OptionManager om;
+ om.registerOptions(options, sizeof(options) / sizeof(options[0]));
</pre>
Recall that static memory areas are initialized with zeros so that the
{"red", "green", "blue"}. Here is how to express that:
<pre>
- static const char* colors[] = { "red", "green", "blue" };
- static const Uint32 NUM_COLORS = sizeof(colors) / sizeof(colors[0]);
+ static const char* colors[] = { "red", "green", "blue" };
+ static const Uint32 NUM_COLORS = sizeof(colors) / sizeof(colors[0]);
- static OptionRow options[] =
- {
- { "color", "red", false, Option::STRING, colors, NUM_COLORS }
- };
+ static OptionRow options[] =
+ {
+ { "color", "red", false, Option::STRING, colors, NUM_COLORS }
+ };
</pre>
When a domain is defined, any of the keywords in that domain are legal
option keywords. For example. With the domain defined above, a command
*/
/** Exception class */
-class PEGASUS_COMMON_LINKAGE OMMissingCommandLineOptionArgument : public Exception
+class PEGASUS_COMMON_LINKAGE OMMissingCommandLineOptionArgument
+ : public Exception
{
public:
- //l10n
- //OMMissingCommandLineOptionArgument(const String& optionName)
- //: Exception("Missing command line option argument: " + optionName) { }
- OMMissingCommandLineOptionArgument(const String& optionName)
- : Exception(MessageLoaderParms("Common.OptionManager.MISSING_CMD_LINE_OPTION",
- "Missing command line option argument: $0",
- optionName)) { }
+ OMMissingCommandLineOptionArgument(const String& optionName)
+ : Exception(MessageLoaderParms(
+ "Common.OptionManager.MISSING_CMD_LINE_OPTION",
+ "Missing command line option argument: $0",
+ optionName))
+ {
+ }
};
/** Exception class */
{
public:
- //l10n
- //OMInvalidOptionValue(const String& name, const String& value)
- //: Exception("Invalid option value: " + name + "=\"" + value + "\"") { }
- OMInvalidOptionValue(const String& name, const String& value)
- : Exception(MessageLoaderParms("Common.OptionManager.INVALID_OPTION_VALUE",
- "Invalid option value: $0=\"$1\"",
- name,
- value)) { }
+ OMInvalidOptionValue(const String& name, const String& value)
+ : Exception(MessageLoaderParms(
+ "Common.OptionManager.INVALID_OPTION_VALUE",
+ "Invalid option value: $0=\"$1\"",
+ name,
+ value))
+ {
+ }
};
/** Exception class */
class PEGASUS_COMMON_LINKAGE OMDuplicateOption : public Exception
{
public:
-//l10n
- //OMDuplicateOption(const String& name)
- //: Exception("Duplicate option: " + name) { }
- OMDuplicateOption(const String& name)
- : Exception(MessageLoaderParms("Common.OptionManager.DUPLICATE_OPTION",
- "Duplicate option: $0",
- name)) { }
+ OMDuplicateOption(const String& name)
+ : Exception(MessageLoaderParms(
+ "Common.OptionManager.DUPLICATE_OPTION",
+ "Duplicate option: $0",
+ name))
+ {
+ }
};
/** Exception class */
public:
OMConfigFileSyntaxError(const String& file, Uint32 line)
- : Exception(_formatMessage(file, line)) { }
+ : Exception(_formatMessage(file, line)) { }
static String _formatMessage(const String& file, Uint32 line);
};
class PEGASUS_COMMON_LINKAGE OMUnrecognizedConfigFileOption : public Exception
{
public:
-//l10n
- //OMUnrecognizedConfigFileOption(const String& name)
- //: Exception("Unrecognized config file option: " + name) { }
- OMUnrecognizedConfigFileOption(const String& name)
- : Exception(MessageLoaderParms("Common.OptionManager.UNRECOGNIZED_CONFIG_FILE_OPTION",
- "Unrecognized config file option: $0",
- name)) { }
+ OMUnrecognizedConfigFileOption(const String& name)
+ : Exception(MessageLoaderParms(
+ "Common.OptionManager.UNRECOGNIZED_CONFIG_FILE_OPTION",
+ "Unrecognized config file option: $0",
+ name))
+ {
+ }
};
/** Exception class */
class PEGASUS_COMMON_LINKAGE OMMissingRequiredOptionValue : public Exception
{
public:
-//l10n
- //OMMissingRequiredOptionValue(const String& name)
- //: Exception("Missing required option value: " + name) { }
- OMMissingRequiredOptionValue(const String& name)
- : Exception(MessageLoaderParms("Common.OptionManager.MISSING_REQUIRED_OPTION",
- "Missing required option value: $0",
- name)) { }
+ OMMissingRequiredOptionValue(const String& name)
+ : Exception(MessageLoaderParms(
+ "Common.OptionManager.MISSING_REQUIRED_OPTION",
+ "Missing required option value: $0",
+ name))
+ {
+ }
};
/** Exception class */
class PEGASUS_COMMON_LINKAGE OMMBadCmdLineOption : public Exception
{
public:
-//l10n
- // OMMBadCmdLineOption(const String& name)
- //: Exception("Parameter not Valid: " + name) { }
- OMMBadCmdLineOption(const String& name)
- : Exception(MessageLoaderParms("Common.OptionManager.PARAMETER_NOT_VALID",
- "Parameter not Valid: $0",
- name)) { }
+ OMMBadCmdLineOption(const String& name)
+ : Exception(MessageLoaderParms(
+ "Common.OptionManager.PARAMETER_NOT_VALID",
+ "Parameter not Valid: $0",
+ name))
+ {
+ }
};
-
PEGASUS_NAMESPACE_END
#endif /* Pegasus_OM_h */
//
//==============================================================================
//
-// Author: Michael E. Brasher
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <string.h>
while (n--)
{
- if (Uint16(*p++) > 0xFF)
- return true;
+ if (Uint16(*p++) > 0xFF)
+ return true;
}
return false;
if (_constains16BitChars(x))
{
- packUint8(out, 16);
- packSize(out, n);
- packChar16(out, x.getChar16Data(), n);
+ packUint8(out, 16);
+ packSize(out, n);
+ packChar16(out, x.getChar16Data(), n);
}
else
{
- packUint8(out, 8);
- packSize(out, n);
- const Char16* data = x.getChar16Data();
+ packUint8(out, 8);
+ packSize(out, n);
+ const Char16* data = x.getChar16Data();
- for (Uint32 i = 0; i < n; i++)
- Packer::packUint8(out, (Uint8)data[i]);
+ for (Uint32 i = 0; i < n; i++)
+ Packer::packUint8(out, (Uint8)data[i]);
}
}
if (x > 16383)
{
- // Use four bytes for size (tag == '1')
- packUint32(out, 0x80000000 | x);
+ // Use four bytes for size (tag == '1')
+ packUint32(out, 0x80000000 | x);
}
else if (x > 63)
{
- // Use two bytes for size.
- packUint16(out, 0x4000 | Uint16(x));
+ // Use two bytes for size.
+ packUint16(out, 0x4000 | Uint16(x));
}
else /* x > 1073741823 */
{
- // Use one byte for size.
- packUint8(out, 0x00 | Uint8(x));
+ // Use one byte for size.
+ packUint8(out, 0x00 | Uint8(x));
}
}
if (!tag)
{
- // One-byte size:
- x = byte;
+ // One-byte size:
+ x = byte;
}
else if (tag == 0x80)
{
- // Four-byte size:
- Uint8 b0 = tag ^ byte;
- Uint8 b1;
- Uint8 b2;
- Uint8 b3;
-
- Packer::unpackUint8(in, pos, b1);
- Packer::unpackUint8(in, pos, b2);
- Packer::unpackUint8(in, pos, b3);
- Uint32 tmp = (Uint32(b0) << 24) |
- (Uint32(b1) << 16) |
- (Uint32(b2) << 8) |
- (Uint32(b3));
-
- x = tmp;
+ // Four-byte size:
+ Uint8 b0 = tag ^ byte;
+ Uint8 b1;
+ Uint8 b2;
+ Uint8 b3;
+
+ Packer::unpackUint8(in, pos, b1);
+ Packer::unpackUint8(in, pos, b2);
+ Packer::unpackUint8(in, pos, b3);
+ Uint32 tmp = (Uint32(b0) << 24) |
+ (Uint32(b1) << 16) |
+ (Uint32(b2) << 8) |
+ (Uint32(b3));
+
+ x = tmp;
}
else if (tag == 0x40)
{
- // Two-byte size:
- x = (tag ^ byte) << 8;
- Packer::unpackUint8(in, pos, byte);
- x |= byte;
+ // Two-byte size:
+ x = (tag ^ byte) << 8;
+ Packer::unpackUint8(in, pos, byte);
+ x |= byte;
}
else
{
- PEGASUS_DEBUG_ASSERT(0);
+ PEGASUS_DEBUG_ASSERT(0);
}
PEGASUS_DEBUG_ASSERT(pos <= in.size());
if (Packer::isLittleEndian())
{
- for (size_t i = 0; i < n; i++)
- {
- T tmp = Packer::swap(x[i]);
- out.append((char*)&tmp, sizeof(tmp));
- }
+ for (size_t i = 0; i < n; i++)
+ {
+ T tmp = Packer::swap(x[i]);
+ out.append((char*)&tmp, sizeof(tmp));
+ }
}
else
- out.append((char*)x, bytes);
+ out.append((char*)x, bytes);
}
void Packer::packBoolean(Buffer& out, const Boolean* x, Uint32 n)
for (size_t i = 0; i < n; i++)
{
- Uint8 tmp = Uint8(x[i]);
- out.append((char*)&tmp, sizeof(tmp));
+ Uint8 tmp = Uint8(x[i]);
+ out.append((char*)&tmp, sizeof(tmp));
}
}
void Packer::packString(Buffer& out, const String* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- packString(out, x[i]);
+ packString(out, x[i]);
}
void Packer::unpackUint16(
pos += sizeof(x);
if (isLittleEndian())
- x = Packer::swapUint16(x);
+ x = Packer::swapUint16(x);
}
void Packer::unpackUint32(
pos += sizeof(x);
if (isLittleEndian())
- x = Packer::swapUint32(x);
+ x = Packer::swapUint32(x);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
pos += sizeof(x);
if (isLittleEndian())
- x = Packer::swapUint64(x);
+ x = Packer::swapUint64(x);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
if (bits & 8)
{
- x.assign(&in[pos], n);
- pos += n;
+ x.assign(&in[pos], n);
+ pos += n;
}
else
{
- x.clear();
- x.reserveCapacity(n);
-
- for (size_t i = 0; i < n; i++)
- {
- Char16 tmp;
- unpackChar16(in , pos, tmp);
- x.append(tmp);
- }
+ x.clear();
+ x.reserveCapacity(n);
+
+ for (size_t i = 0; i < n; i++)
+ {
+ Char16 tmp;
+ unpackChar16(in , pos, tmp);
+ x.append(tmp);
+ }
}
PEGASUS_DEBUG_ASSERT(pos <= in.size());
Buffer& in, Uint32& pos, Boolean* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- unpackBoolean(in, pos, x[i]);
+ unpackBoolean(in, pos, x[i]);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
Buffer& in, Uint32& pos, Uint8* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- unpackUint8(in, pos, x[i]);
+ unpackUint8(in, pos, x[i]);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
Buffer& in, Uint32& pos, Uint16* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- unpackUint16(in, pos, x[i]);
+ unpackUint16(in, pos, x[i]);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
Buffer& in, Uint32& pos, Uint32* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- unpackUint32(in, pos, x[i]);
+ unpackUint32(in, pos, x[i]);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
Buffer& in, Uint32& pos, Uint64* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- unpackUint64(in, pos, x[i]);
+ unpackUint64(in, pos, x[i]);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
Buffer& in, Uint32& pos, String* x, Uint32 n)
{
for (size_t i = 0; i < n; i++)
- unpackString(in, pos, x[i]);
+ unpackString(in, pos, x[i]);
PEGASUS_DEBUG_ASSERT(pos <= in.size());
}
//
//==============================================================================
//
-// Author: Michael E. Brasher
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef _Pegasus_Common_Packer_h
static void unpackSize(const Buffer& out, Uint32& pos, Uint32& x);
static void unpackBoolean(
- Buffer& in, Uint32& pos, Boolean* x, Uint32 n);
+ Buffer& in, Uint32& pos, Boolean* x, Uint32 n);
static void unpackUint8(
- Buffer& in, Uint32& pos, Uint8* x, Uint32 n);
+ Buffer& in, Uint32& pos, Uint8* x, Uint32 n);
static void unpackUint16(
- Buffer& in, Uint32& pos, Uint16* x, Uint32 n);
+ Buffer& in, Uint32& pos, Uint16* x, Uint32 n);
static void unpackUint32(
- Buffer& in, Uint32& pos, Uint32* x, Uint32 n);
+ Buffer& in, Uint32& pos, Uint32* x, Uint32 n);
static void unpackUint64(
- Buffer& in, Uint32& pos, Uint64* x, Uint32 n);
+ Buffer& in, Uint32& pos, Uint64* x, Uint32 n);
static void unpackReal32(
- Buffer& in, Uint32& pos, Real32* x, Uint32 n);
+ Buffer& in, Uint32& pos, Real32* x, Uint32 n);
static void unpackReal64(
- Buffer& in, Uint32& pos, Real64* x, Uint32 n);
+ Buffer& in, Uint32& pos, Real64* x, Uint32 n);
static void unpackChar16(
- Buffer& in, Uint32& pos, Char16* x, Uint32 n);
+ Buffer& in, Uint32& pos, Char16* x, Uint32 n);
static void unpackString(
- Buffer& in, Uint32& pos, String* x, Uint32 n);
+ Buffer& in, Uint32& pos, String* x, Uint32 n);
static bool isLittleEndian();
inline void Packer::packUint16(Buffer& out, Uint16 x)
{
if (isLittleEndian())
- x = Packer::swapUint16(x);
+ x = Packer::swapUint16(x);
out.append((char*)&x, sizeof(x));
}
inline void Packer::packUint32(Buffer& out, Uint32 x)
{
if (isLittleEndian())
- x = Packer::swapUint32(x);
+ x = Packer::swapUint32(x);
out.append((char*)&x, sizeof(x));
}
inline void Packer::packUint64(Buffer& out, Uint64 x)
{
if (isLittleEndian())
- x = Packer::swapUint64(x);
+ x = Packer::swapUint64(x);
out.append((char*)&x, sizeof(x));
}
inline Uint16 Packer::swapUint16(Uint16 x)
{
return (Uint16)(
- (((Uint16)(x) & 0x00ffU) << 8) |
- (((Uint16)(x) & 0xff00U) >> 8));
+ (((Uint16)(x) & 0x00ffU) << 8) |
+ (((Uint16)(x) & 0xff00U) >> 8));
}
inline Uint32 Packer::swapUint32(Uint32 x)
{
return (Uint32)(
- (((Uint32)(x) & 0x000000ffUL) << 24) |
- (((Uint32)(x) & 0x0000ff00UL) << 8) |
- (((Uint32)(x) & 0x00ff0000UL) >> 8) |
- (((Uint32)(x) & 0xff000000UL) >> 24));
+ (((Uint32)(x) & 0x000000ffUL) << 24) |
+ (((Uint32)(x) & 0x0000ff00UL) << 8) |
+ (((Uint32)(x) & 0x00ff0000UL) >> 8) |
+ (((Uint32)(x) & 0xff000000UL) >> 24));
}
inline void Packer::swap(Uint8& x, Uint8& y)
{
union
{
- Uint64 x;
- Uint8 bytes[8];
+ Uint64 x;
+ Uint8 bytes[8];
}
u;
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Pair.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Pair_h
U second;
Pair() : first(), second()
- {
-
+ {
}
Pair(const Pair<T,U>& x) : first(x.first), second(x.second)
- {
-
+ {
}
Pair(const T& first_, const U& second_) : first(first_), second(second_)
{
-
}
Pair<T,U>& operator=(const Pair<T,U>& x)
{
- first = x.first;
- second = x.second;
- return *this;
+ first = x.first;
+ second = x.second;
+ return *this;
}
};
//
//==============================================================================
//
-// Author: Jim Wunderlich, (Jim_Wunderlich@prodigy.net)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Assert_h
#define Pegasus_Assert_h
-
-// NOTE:
+
+// NOTE:
//
-// All built and tested OK with <assert.h>
+// All built and tested OK with <assert.h>
// but <cassert> is more appropriate for c++ files
-// however if this should be a problem for any c fileswithin the tree
-// it is possible to revert back to assert.h
+// however if this should be a problem for any c fileswithin the tree
+// it is possible to revert back to assert.h
// J Wunderlich 11/21/2005
//
/** define PEGASUS_ASSERT assertion statement. This statement tests the
condition defined by the parameters and if not True executes an
- It only generates code if NDEBUG is not defined.
+ It only generates code if NDEBUG is not defined.
See also the man page for assert().
- NOTE: if NDEBUG is set then the assert() macro will generate no code,
- and hence do nothing at all.
+ NOTE: if NDEBUG is set then the assert() macro will generate no code,
+ and hence do nothing at all.
<pre>
assert()
/* define PEGASUS_DEBUG_ASSERT() assertion statement. This statement tests the
- condition defined by the parameters and if not True executes an assert.
+ condition defined by the parameters and if not True executes an assert.
It only generates code if PEGASUS_DEBUG is defined and NDEBUG is not
- defined.
+ defined.
See also the man page for assert().
- NOTE: if NDEBUG is set then the assert() macro will generate no code,
- and hence do nothing at all.
+ NOTE: if NDEBUG is set then the assert() macro will generate no code,
+ and hence do nothing at all.
*/
#ifdef PEGASUS_DEBUG
-#define PEGASUS_DEBUG_ASSERT(COND) assert(COND)
+# define PEGASUS_DEBUG_ASSERT(COND) assert(COND)
#else
-#define PEGASUS_DEBUG_ASSERT(COND)
+# define PEGASUS_DEBUG_ASSERT(COND)
#endif
-#define PEGASUS_TEST_ASSERT(COND) \
-do \
-{ \
- if (!(COND)) \
- { \
- printf("PEGASUS_TEST_ASSERT failed in file %s at line %d\n",__FILE__, __LINE__); \
- abort(); \
- } \
-} while (0)
+#define PEGASUS_TEST_ASSERT(COND) \
+ do \
+ { \
+ if (!(COND)) \
+ { \
+ printf("PEGASUS_TEST_ASSERT failed in file %s at line %d\n", \
+ __FILE__, __LINE__); \
+ abort(); \
+ } \
+ } while (0)
#endif /* Pegasus_Assert_h */
//
//==============================================================================
//
-// Author: Karl Schopmeyer (k.schopmeyer@opengroup.org)
-//
-// Modified By: Jenny Yu (jenny_yu@hp.com)
-// Warren Otsuka (warren.otsuka@hp.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Version_h
//
// The sequence would look like:
// # define PEGASUS_PRODUCT_VERSION "2.5"
-// # define PEGASUS_PRODUCT_STATUS "" // Blank implies Released
+// # define PEGASUS_PRODUCT_STATUS "" // Blank implies Released
//
// # define PEGASUS_PRODUCT_VERSION "2.5.1"
// # define PEGASUS_PRODUCT_STATUS "Development"
// # define PEGASUS_PRODUCT_STATUS "Pre-Release"
//
// # define PEGASUS_PRODUCT_VERSION "2.5.1"
-// # define PEGASUS_PRODUCT_STATUS "" // Blank implies Released
+// # define PEGASUS_PRODUCT_STATUS "" // Blank implies Released
//
// # define PEGASUS_PRODUCT_VERSION "2.5.2"
// # define PEGASUS_PRODUCT_STATUS "Development"
// # define PEGASUS_PRODUCT_STATUS "Pre-Release"
//
// # define PEGASUS_PRODUCT_VERSION "2.5.2"
-// # define PEGASUS_PRODUCT_STATUS "" // Blank implies Released
-//
+// # define PEGASUS_PRODUCT_STATUS "" // Blank implies Released
+//
# define PEGASUS_PRODUCT_NAME "CIM Server"
# define PLATFORM_COMPONENT_NAME "Pegasus Component"
# endif
-# ifndef PLATFORM_COMPONENT_VERSION
-# define PLATFORM_COMPONENT_VERSION PEGASUS_PRODUCT_VERSION
+# ifndef PLATFORM_COMPONENT_VERSION
+# define PLATFORM_COMPONENT_VERSION PEGASUS_PRODUCT_VERSION
# endif
# ifndef PLATFORM_COMPONENT_STATUS
#endif /* PEGASUS_OS_HPUX */
-// This macro can be examined by preprocessor directives (i.e., #if) to
-// make compile time branch decisions based on the Pegasus version number.
+// This macro can be examined by preprocessor directives (i.e., #if) to
+// make compile time branch decisions based on the Pegasus version number.
// When read from left to right, the bytes have the following meaning:
//
// Byte 0: major version number
// ..
// #endif
//
-// CAUTION: always check whether PEGASUS_VERSION_NUMBER is defined when
+// CAUTION: always check whether PEGASUS_VERSION_NUMBER is defined when
// integrating with versions prior to 2.5.1.
//
#define PEGASUS_VERSION_NUMBER 0x02060000
#define _MSE_PROTOS
#define _OPEN_SOURCE 3
-#define _MULTI_THREADED
+#define _MULTI_THREADED
#include <cstddef>
#define PEGASUS_OS_TYPE_UNIX
#include <ifs.cleinc>
-
+
#define PEGASUS_OS_OS400
#define PEGASUS_ARCHITECTURE_ISERIES
#define PEGASUS_UINT64 unsigned long long
-#define PEGASUS_SINT64 signed long long
+#define PEGASUS_SINT64 signed long long
#define PEGASUS_HAVE_NAMESPACES
//
//==============================================================================
//
-// Author: Sean Keenan (sean.keenan@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Platform_VMS_h
//
//==============================================================================
//
-// Author: Sean Keenan (sean.keenan@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Platform_VMS_ALPHA_DECCXX_h
#define PEGASUS_HAVE_BROKEN_GLOBAL_CONSTRUCTION
// PEGASUS_DISABLE_INTERNAL_INLINES
-// Debug builds fail with undefined symbols. Perhaps this is
-// because debug (nooptimize) builds have the compiler inline
-// feature turned off.
+// Debug builds fail with undefined symbols. Perhaps this is
+// because debug (nooptimize) builds have the compiler inline
+// feature turned off.
#define PEGASUS_DISABLE_INTERNAL_INLINES
#define PEGASUS_HAVE_PTHREADS
//
//==============================================================================
//
-// Author: Sean Keenan (sean.keenan@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Platform_VMS_IA64_DECCXX_h
#define PEGASUS_UINT64 unsigned __int64
#define PEGASUS_SINT64 __int64
-
+
#define PEGASUS_SINT64_LITERAL(X) Sint64(X)
#define PEGASUS_UINT64_LITERAL(X) Uint64(X)
#define PEGASUS_DISABLE_INTERNAL_INLINES
// Exclude rarely-used stuff from Windows headers
-// Note: this is also an easy way to avoid the often introduced
+// Note: this is also an easy way to avoid the often introduced
// winsock.h/winsock2.h mixing compiler error problems.
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
// Suppress this warning : "'this' : used in base member initializer list"
#pragma warning ( disable : 4355 )
-// Suppress this warning: 'type' : forcing value to bool 'true' or 'false' (performance warning)
+// Suppress this warning: 'type' : forcing value to bool 'true' or 'false'
+// (performance warning)
#ifdef PEGASUS_INTERNALONLY
-#pragma warning( disable : 4800 )
+#pragma warning( disable : 4800 )
#endif
// VC 8 specific pragmas
// This warning is supported beginning with VC 8.
#pragma warning ( disable : 4996 )
-// Suppress this warning: behavior change: an object of POD type constructed with an
-// initializer of the form () will be default-initialized
+// Suppress this warning: behavior change: an object of POD type constructed
+// with an initializer of the form () will be default-initialized
#pragma warning ( disable : 4345 )
#endif
//
// Prior to Microsoft Visual Studio 7.0, there were no stream inserters for
// __int64 and unsigned __int64. We declare them if the _MSC_VER is less than
-// 1300 (subtract 600 to get the version of Visual Studio). Look in
+// 1300 (subtract 600 to get the version of Visual Studio). Look in
// SystemWindows.cpp for the definitions.
//
#if (_MSC_VER < 1300) && defined(PEGASUS_INTERNALONLY) && defined(__cplusplus)
//
//==============================================================================
//
-// Author: Markus Mueller (mmueller@de.ibm.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Platform_ZOS_ZSERIES_IBM_h
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com),
-//
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "PropertyAccessor.h"
*/
template<class T>
bool _Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
T& x)
{
bool isNull;
const CIMValue& value = inst.getProperty(pos).getValue();
if ((isNull = value.isNull()))
- x = T();
+ x = T();
else
- value.get(x);
+ value.get(x);
return !isNull;
}
*/
template<class T>
void _Set(
- CIMInstance& inst,
- const String& name,
+ CIMInstance& inst,
+ const String& name,
const T& x,
bool null)
{
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Boolean& value)
{
return _Get(inst, name, value);
}
void Set(
- CIMInstance& inst,
- const String& name,
- const Boolean& value,
+ CIMInstance& inst,
+ const String& name,
+ const Boolean& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Boolean>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Boolean>& value,
+ const String& name,
+ const Array<Boolean>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint8& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Uint8& value,
+ const String& name,
+ const Uint8& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint8>& value)
{
return _Get(inst, name, value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint8>& value,
+ const String& name,
+ const Array<Uint8>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint8& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Sint8& value,
+ const String& name,
+ const Sint8& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint8>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint8>& value,
+ const String& name,
+ const Array<Sint8>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint16& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Uint16& value,
+ const String& name,
+ const Uint16& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint16>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint16>& value,
+ const String& name,
+ const Array<Uint16>& value,
bool null)
{
_Set(inst, name, value, null);
}
+
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint16& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Sint16& value,
+ const String& name,
+ const Sint16& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint16>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint16>& value,
+ const String& name,
+ const Array<Sint16>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint32& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Uint32& value,
+ const String& name,
+ const Uint32& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint32>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint32>& value,
+ const String& name,
+ const Array<Uint32>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint32& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Sint32& value,
+ const String& name,
+ const Sint32& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint32>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint32>& value,
+ const String& name,
+ const Array<Sint32>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint64& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Uint64& value,
+ const String& name,
+ const Uint64& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint64>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint64>& value,
+ const String& name,
+ const Array<Uint64>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint64& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Sint64& value,
+ const String& name,
+ const Sint64& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint64>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint64>& value,
+ const String& name,
+ const Array<Sint64>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Real32& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Real32& value,
+ const String& name,
+ const Real32& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Real32>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Real32>& value,
+ const String& name,
+ const Array<Real32>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Real64& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Real64& value,
+ const String& name,
+ const Real64& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Real64>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Real64>& value,
+ const String& name,
+ const Array<Real64>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Char16& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Char16& value,
+ const String& name,
+ const Char16& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Char16>& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Char16>& value,
+ const String& name,
+ const Array<Char16>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
String& value)
{
return _Get(inst, name, value);;
void Set(
CIMInstance& inst,
- const String& name,
- const String& value,
+ const String& name,
+ const String& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<String>& value)
{
return _Get(inst, name, value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<String>& value,
+ const String& name,
+ const Array<String>& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
CIMDateTime& value)
{
return _Get(inst, name, value);
void Set(
CIMInstance& inst,
- const String& name,
- const CIMDateTime& value,
+ const String& name,
+ const CIMDateTime& value,
bool null)
{
_Set(inst, name, value, null);
}
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<CIMDateTime>& value)
{
return _Get(inst, name, value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<CIMDateTime>& value,
+ const String& name,
+ const Array<CIMDateTime>& value,
bool null)
{
_Set(inst, name, value, null);
#include <Pegasus/Common/CIMInstance.h>
PEGASUS_NAMESPACE_BEGIN
-/* PropertyAccessor is a set of support functions for property value access within instances.
- These functions provide the capability to get and set the value of all of the
- native property types within Pegasus using only the reference to the instance and
- the property name as identifiers. The provide, in effect, an associative link to
- property values as an alternate to the index based reference defined in the CIMInstance
- object. Further, they allow directly getting and setting the value in place of the
- multistep approach in the objects where the the CIMValue must first be retrieved before
- the value can be accessed. This reduces the access to a single line of code.
-
- These functions assume that the property exists in the instance and execute a
- Examples:
- Set(_inst, "ErrorSourceFormat", Uint16(value), null);
- bool nullStat = Get(_inst, "ErrorSourceFormat", t);
- These functions are to be used only internally within Open Pegasus
+/*
+ PropertyAccessor is a set of support functions for property value access
+ within instances. These functions provide the capability to get and set
+ the value of all of the native property types within Pegasus using only
+ the reference to the instance and the property name as identifiers. They
+ provide, in effect, an associative link to property values as an
+ alternate to the index based reference defined in the CIMInstance
+ object. Further, they allow directly getting and setting the value in
+ place of the multistep approach in the objects where the the CIMValue
+ must first be retrieved before the value can be accessed. This reduces
+ the access to a single line of code.
+
+ These functions assume that the property exists in the instance.
+
+ Examples:
+ Set(_inst, "ErrorSourceFormat", Uint16(value), null);
+ bool nullStat = Get(_inst, "ErrorSourceFormat", t);
+ These functions are to be used only internally within OpenPegasus
*/
/** Get the named property value from the target instance.
variable if the NULL attribute is NOT set for the CIMValue for this
property.
@return bool returns true if the CIMValue for the property is NOT Null.
- @exception Returns CIM_ERR_NO_SUCH_PROPERTY if the named property is not in the
- instance.
-*/
+ @exception Returns CIM_ERR_NO_SUCH_PROPERTY if the named property is not
+ in the instance.
+*/
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Boolean& value);
/** Get the named property value from the target instance.
@param null bool If this is set true, the value parameter is ignored and the
property is set to NULL.
@return bool returns true if the CIMValue for the property is NOT Null.
- @exception Returns CIM_ERR_NO_SUCH_PROPERTY if the named property is not in the
- instance.
-*/
+ @exception Returns CIM_ERR_NO_SUCH_PROPERTY if the named property is not
+ in the instance.
+*/
void Set(
CIMInstance& inst,
- const String& name,
- const Boolean& value,
+ const String& name,
+ const Boolean& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Boolean>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Boolean>& value,
+ const String& name,
+ const Array<Boolean>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint8& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Uint8& value,
+ const String& name,
+ const Uint8& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint8>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint8>& value,
+ const String& name,
+ const Array<Uint8>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint8& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Sint8& value,
+ const String& name,
+ const Sint8& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint8>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint8>& value,
+ const String& name,
+ const Array<Sint8>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint16& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Uint16& value,
+ const String& name,
+ const Uint16& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint16>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint16>& value,
+ const String& name,
+ const Array<Uint16>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint16& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Sint16& value,
+ const String& name,
+ const Sint16& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint16>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint16>& value,
+ const String& name,
+ const Array<Sint16>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint32& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Uint32& value,
+ const String& name,
+ const Uint32& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint32>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint32>& value,
+ const String& name,
+ const Array<Uint32>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint32& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Sint32& value,
+ const String& name,
+ const Sint32& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint32>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint32>& value,
+ const String& name,
+ const Array<Sint32>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Uint64& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Uint64& value,
+ const String& name,
+ const Uint64& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Uint64>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Uint64>& value,
+ const String& name,
+ const Array<Uint64>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Sint64& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Sint64& value,
+ const String& name,
+ const Sint64& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Sint64>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Sint64>& value,
+ const String& name,
+ const Array<Sint64>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Real32& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Real32& value,
+ const String& name,
+ const Real32& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Real32>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Real32>& value,
+ const String& name,
+ const Array<Real32>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Real64& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Real64& value,
+ const String& name,
+ const Real64& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Real64>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Real64>& value,
+ const String& name,
+ const Array<Real64>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Char16& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Char16& value,
+ const String& name,
+ const Char16& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<Char16>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<Char16>& value,
+ const String& name,
+ const Array<Char16>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
String& value);
void Set(
CIMInstance& inst,
- const String& name,
- const String& value,
+ const String& name,
+ const String& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<String>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<String>& value,
+ const String& name,
+ const Array<String>& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
CIMDateTime& value);
void Set(
CIMInstance& inst,
- const String& name,
- const CIMDateTime& value,
+ const String& name,
+ const CIMDateTime& value,
bool null);
bool Get(
- const CIMInstance& inst,
- const String& name,
+ const CIMInstance& inst,
+ const String& name,
Array<CIMDateTime>& value);
void Set(
CIMInstance& inst,
- const String& name,
- const Array<CIMDateTime>& value,
+ const String& name,
+ const Array<CIMDateTime>& value,
bool null);
inline CIMType GetType(Boolean*) { return CIMTYPE_BOOLEAN; }
//
//==============================================================================
//
-// Author: Adrian Schuur (schuur@de.ibm.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
-#include "QueryExpressionRep.h"
+#include "QueryExpressionRep.h"
PEGASUS_NAMESPACE_BEGIN
-QueryExpressionRep::QueryExpressionRep(const String & language)
- : _queryLanguage(language), _query(String::EMPTY)
+QueryExpressionRep::QueryExpressionRep(const String& language)
+ : _queryLanguage(language), _query(String::EMPTY)
{
}
-QueryExpressionRep::QueryExpressionRep(const String & language, const String & query)
- : _queryLanguage(language), _query(query)
+QueryExpressionRep::QueryExpressionRep(
+ const String& language,
+ const String& query)
+ : _queryLanguage(language), _query(query)
{
}
-const String & QueryExpressionRep::getQueryLanguage() const
+const String& QueryExpressionRep::getQueryLanguage() const
{
- return _queryLanguage;
+ return _queryLanguage;
}
-const String & QueryExpressionRep::getQuery() const
+const String& QueryExpressionRep::getQuery() const
{
- return _query;
+ return _query;
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Adrian Schuur (schuur@de.ibm.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_QueryExpressionRep_h
ReadWriteSem::~ReadWriteSem()
{
- int r=0;
- while (r=pthread_rwlock_destroy(&_rwlock.rwlock) == EBUSY || (r == -1 && errno == EBUSY))
+ int r = 0;
+ while (r=pthread_rwlock_destroy(&_rwlock.rwlock) == EBUSY ||
+ (r == -1 && errno == EBUSY))
{
Threads::yield();
}
int ReadWriteSem::read_count() const
{
- return (_readers.get());
+ return _readers.get();
}
int ReadWriteSem::write_count() const
{
- return (_writers.get());
+ return _writers.get();
}
#endif /* PEGASUS_USE_POSIX_RWLOCK */
{
_rwlock._internal_lock.lock();
}
- catch(Deadlock &)
+ catch (Deadlock &)
{
// no problem - we own the lock, which is what we want
}
- catch(IPCException &)
+ catch (IPCException &)
{
PEGASUS_ASSERT(0);
}
else
_rwlock._internal_lock.timed_lock(milliseconds);
}
- catch(const IPCException & e)
+ catch (const IPCException & e)
{
caught = e;
goto throw_from_here;
{
_rwlock._wlock.try_lock();
}
- catch(IPCException & e)
+ catch (IPCException & e)
{
_rwlock._internal_lock.unlock();
caught = e;
{
_rwlock._wlock.lock();
}
- catch(const IPCException & e)
+ catch (const IPCException & e)
{
_rwlock._internal_lock.unlock();
caught = e;
{
_rwlock._wlock.timed_lock(milliseconds);
}
- catch(const IPCException & e)
+ catch (const IPCException & e)
{
_rwlock._internal_lock.unlock();
caught = e;
{
_rwlock._rlock.try_wait();
}
- catch(const IPCException &)
+ catch (const IPCException &)
{
// the wait failed, there must be too many readers
// already.
{
_rwlock._rlock.wait();
}
- catch(const IPCException & e)
+ catch (const IPCException & e)
{
_rwlock._internal_lock.unlock();
caught = e;
{
_rwlock._rlock.time_wait(milliseconds);
}
- catch(const IPCException & e)
+ catch (const IPCException & e)
{
_rwlock._internal_lock.unlock();
caught = e;
_rwlock._internal_lock.unlock();
}
throw_from_here:
- // ATTN:
+ // ATTN:
Threads::cleanup_pop(0);
}
int ReadWriteSem::read_count() const
{
- return (_readers.get());
+ return _readers.get();
}
int ReadWriteSem::write_count() const
{
- return (_writers.get());
+ return _writers.get();
}
#endif /* !PEGASUS_USE_SEMAPHORE_RWLOCK */
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
-// Reworked By: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ReadWriteSem_h
Mutex _wlock;
Mutex _internal_lock;
ThreadType _owner;
- ReadWriteSemRep() :
+ ReadWriteSemRep() :
_rlock(10), _wlock(), _internal_lock(), _owner(Threads::self())
{
}
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Resolver.h>
PEGASUS_NAMESPACE_BEGIN
-void Resolver::resolveClass (
- CIMClass & theClass,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace)
+void Resolver::resolveClass(
+ CIMClass& theClass,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace)
{
- theClass._checkRep ();
- theClass._rep->resolve (declContext, nameSpace);
+ theClass._checkRep();
+ theClass._rep->resolve(declContext, nameSpace);
}
-void Resolver::resolveInstance (
- CIMInstance & theInstance,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
+void Resolver::resolveInstance(
+ CIMInstance& theInstance,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
Boolean propagateQualifiers)
{
- theInstance._checkRep ();
+ theInstance._checkRep();
CIMConstClass cimClass;
- theInstance._rep->resolve (declContext, nameSpace, cimClass,
- propagateQualifiers);
+ theInstance._rep->resolve(
+ declContext, nameSpace, cimClass, propagateQualifiers);
}
-void Resolver::resolveInstance (
- CIMInstance & theInstance,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
- CIMConstClass & cimClassOut,
+void Resolver::resolveInstance(
+ CIMInstance& theInstance,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
+ CIMConstClass& cimClassOut,
Boolean propagateQualifiers)
{
- theInstance._checkRep ();
- theInstance._rep->resolve (declContext, nameSpace, cimClassOut,
+ theInstance._checkRep();
+ theInstance._rep->resolve(declContext, nameSpace, cimClassOut,
propagateQualifiers);
}
-void Resolver::resolveProperty (
- CIMProperty & theProperty,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
+void Resolver::resolveProperty(
+ CIMProperty& theProperty,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
Boolean isInstancePart,
- const CIMConstProperty & inheritedProperty,
+ const CIMConstProperty& inheritedProperty,
Boolean propagateQualifiers)
{
- theProperty._checkRep ();
- theProperty._rep->resolve (declContext, nameSpace, isInstancePart,
+ theProperty._checkRep();
+ theProperty._rep->resolve(declContext, nameSpace, isInstancePart,
inheritedProperty, propagateQualifiers);
}
-void Resolver::resolveProperty (
- CIMProperty & theProperty,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
+void Resolver::resolveProperty(
+ CIMProperty& theProperty,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
Boolean isInstancePart,
Boolean propagateQualifiers)
{
- theProperty._checkRep ();
- theProperty._rep->resolve (declContext, nameSpace, isInstancePart,
+ theProperty._checkRep();
+ theProperty._rep->resolve(declContext, nameSpace, isInstancePart,
propagateQualifiers);
}
-void Resolver::resolveMethod (
- CIMMethod & theMethod,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
- const CIMConstMethod & inheritedMethod)
+void Resolver::resolveMethod(
+ CIMMethod& theMethod,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
+ const CIMConstMethod& inheritedMethod)
{
- theMethod._checkRep ();
- theMethod._rep->resolve (declContext, nameSpace, inheritedMethod);
+ theMethod._checkRep();
+ theMethod._rep->resolve(declContext, nameSpace, inheritedMethod);
}
-void Resolver::resolveMethod (
- CIMMethod & theMethod,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace)
+void Resolver::resolveMethod(
+ CIMMethod& theMethod,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace)
{
- theMethod._checkRep ();
- theMethod._rep->resolve (declContext, nameSpace);
+ theMethod._checkRep();
+ theMethod._rep->resolve(declContext, nameSpace);
}
-void Resolver::resolveParameter (
- CIMParameter & theParameter,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace)
+void Resolver::resolveParameter(
+ CIMParameter& theParameter,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace)
{
- theParameter._checkRep ();
- theParameter._rep->resolve (declContext, nameSpace);
+ theParameter._checkRep();
+ theParameter._rep->resolve(declContext, nameSpace);
}
-void Resolver::resolveQualifierFlavor (
- CIMQualifier & theQualifier,
- const CIMFlavor & inheritedFlavor,
+void Resolver::resolveQualifierFlavor(
+ CIMQualifier& theQualifier,
+ const CIMFlavor& inheritedFlavor,
Boolean inherited)
{
- theQualifier._checkRep ();
- theQualifier._rep->resolveFlavor (inheritedFlavor, inherited);
+ theQualifier._checkRep();
+ theQualifier._rep->resolveFlavor(inheritedFlavor, inherited);
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Resolver_h
PEGASUS_NAMESPACE_BEGIN
/**
- The Resolver class provides methods to resolve CIM objects, including
- CIMClass, CIMInstance, CIMProperty, CIMMethod, CIMParameter, and
- CIMQualifier flavor. These methods were moved here from the
- CIM[objectType] classes. These methods in turn call the resolve () methods
+ The Resolver class provides methods to resolve CIM objects, including
+ CIMClass, CIMInstance, CIMProperty, CIMMethod, CIMParameter, and
+ CIMQualifier flavor. These methods were moved here from the
+ CIM[objectType] classes. These methods in turn call the resolve() methods
of the CIM[objectType]Rep classes, which actually do the work.
- Note that this class contains only internal functions and should not be
+ Note that this class contains only internal functions and should not be
made available to external users.
-
- @author Hewlett-Packard Company
*/
class PEGASUS_COMMON_LINKAGE Resolver
{
public:
- /**
- Resolves the class. Inherits any properties, methods and qualifiers.
- Makes sure the superClass exists and is consistent with this class.
+ /**
+ Resolves the class. Inherits any properties, methods and qualifiers.
+ Makes sure the superClass exists and is consistent with this class.
Sets the propagated and class origin flags for each class feature.
@param theClass CIMClass object to be resolved
@param declContext Defines the context in which the class is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the class.
@param nameSpace Namespace in which the class is to be placed
*/
- static void resolveClass (
- CIMClass & theClass,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace);
+ static void resolveClass(
+ CIMClass& theClass,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace);
- /**
+ /**
Resolves the instance. Makes sure the class exists and is not
- abstract. Validates and propagates qualifiers, if requested.
- Validates and resolves properties. Sets the propagated and class
+ abstract. Validates and propagates qualifiers, if requested.
+ Validates and resolves properties. Sets the propagated and class
origin flags.
@param theInstance CIMInstance object to be resolved
@param declContext Defines the context in which the instance is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the instance.
- @param nameSpace Namespace in which the instance is to be
+ @param nameSpace Namespace in which the instance is to be
placed
@param propagateQualifiers Boolean indicating whether qualifiers are to
- be propagated
+ be propagated
*/
- static void resolveInstance (
- CIMInstance & theInstance,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
+ static void resolveInstance(
+ CIMInstance& theInstance,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
Boolean propagateQualifiers);
- /**
+ /**
Resolves the instance. Makes sure the class exists and is not
- abstract. Validates and propagates qualifiers, if requested.
- Validates and resolves properties. Sets the propagated and class
+ abstract. Validates and propagates qualifiers, if requested.
+ Validates and resolves properties. Sets the propagated and class
origin flags.
@param theInstance CIMInstance object to be resolved
@param declContext Defines the context in which the instance is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the instance.
- @param nameSpace Namespace in which the instance is to be
+ @param nameSpace Namespace in which the instance is to be
placed
- @param cimClassOut CIMClass output parameter containing the
+ @param cimClassOut CIMClass output parameter containing the
class to which the instance belongs
@param propagateQualifiers Boolean indicating whether qualifiers are to
- be propagated
+ be propagated
*/
- static void resolveInstance (
- CIMInstance & theInstance,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
- CIMConstClass & cimClassOut,
+ static void resolveInstance(
+ CIMInstance& theInstance,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
+ CIMConstClass& cimClassOut,
Boolean propagateQualifiers);
- /**
- Resolves the property. Resolution is the process of integrating the
- property into the the context of a repository or other store.
+ /**
+ Resolves the property. Resolution is the process of integrating the
+ property into the the context of a repository or other store.
Validates the qualifiers of the property.
@param theProperty CIMProperty object to be resolved
@param declContext Defines the context in which the property is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the property.
- @param nameSpace Namespace in which the property is to be
+ @param nameSpace Namespace in which the property is to be
placed
@param isInstancePart Indicates instance or class resolution
@param inheritedProperty CIMConstProperty containing the property from
the class or superclass
@param propagateQualifiers Boolean indicating whether qualifiers are to
*/
- static void resolveProperty (
- CIMProperty & theProperty,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
- Boolean isInstancePart,
- const CIMConstProperty & inheritedProperty,
- Boolean propagateQualifiers);
+ static void resolveProperty(
+ CIMProperty& theProperty,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
+ Boolean isInstancePart,
+ const CIMConstProperty& inheritedProperty,
+ Boolean propagateQualifiers);
// ATTN: P3 03/02/02 KS Needs more documentation.
- /**
- Resolves the property. Resolution is the process of integrating the
- property into the the context of a repository or other store.
+ /**
+ Resolves the property. Resolution is the process of integrating the
+ property into the the context of a repository or other store.
Validates the qualifiers of the property.
@param theProperty CIMProperty object to be resolved
@param declContext Defines the context in which the property is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the property.
- @param nameSpace Namespace in which the property is to be
+ @param nameSpace Namespace in which the property is to be
placed
@param isInstancePart Indicates instance or class resolution
@param propagateQualifiers Boolean indicating whether qualifiers are to
- be propagated
+ be propagated
*/
- static void resolveProperty (
- CIMProperty & theProperty,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
- Boolean isInstancePart,
- Boolean propagateQualifiers);
+ static void resolveProperty(
+ CIMProperty& theProperty,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
+ Boolean isInstancePart,
+ Boolean propagateQualifiers);
- /**
+ /**
Resolves the CIMMethod. Validates the qualifiers and parameters of the
method.
@param theMethod CIMMethod object to be resolved
@param declContext Defines the context in which the method is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the method.
- @param nameSpace Namespace in which the method is to be
+ @param nameSpace Namespace in which the method is to be
placed
@param inheritedMethod CIMConstMethod containing the method from
the class or superclass
*/
- static void resolveMethod (
- CIMMethod & theMethod,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace,
- const CIMConstMethod & inheritedMethod);
+ static void resolveMethod(
+ CIMMethod& theMethod,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace,
+ const CIMConstMethod& inheritedMethod);
- /**
+ /**
Resolves the CIMMethod. Validates the qualifiers and parameters of the
method.
@param theMethod CIMMethod object to be resolved
@param declContext Defines the context in which the method is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the method.
- @param nameSpace Namespace in which the method is to be
+ @param nameSpace Namespace in which the method is to be
placed
*/
- static void resolveMethod (
- CIMMethod & theMethod,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace);
+ static void resolveMethod(
+ CIMMethod& theMethod,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace);
- /**
+ /**
Resolves the parameter. Validates the qualifiers of the parameter.
@param theParameter CIMParameter object to be resolved
@param declContext Defines the context in which the parameter is
to be resolved. This provides the basis for
- other functions to get information from the
+ other functions to get information from the
context to use to resolve the parameter.
- @param nameSpace Namespace in which the parameter is to be
+ @param nameSpace Namespace in which the parameter is to be
placed
*/
- static void resolveParameter (
- CIMParameter & theParameter,
- DeclContext * declContext,
- const CIMNamespaceName & nameSpace);
+ static void resolveParameter(
+ CIMParameter& theParameter,
+ DeclContext* declContext,
+ const CIMNamespaceName& nameSpace);
- /**
- Resolves the qualifier flavor. This function is used only in object
+ /**
+ Resolves the qualifier flavor. This function is used only in object
creation to resolve the combination of a qualifer flavor input and
- the corresponding inherited flavor from declaration or superclass and
- set the current qualifier to that definition. The function changes
+ the corresponding inherited flavor from declaration or superclass and
+ set the current qualifier to that definition. The function changes
the current flavor based on the characteristics of the inheritance.
@param inheritedFlavor The flavor inherited from higher level
- @param inherited True if inherited from definition
+ @param inherited True if inherited from definition
False if this is definition that inherits from
the declaration
*/
- static void resolveQualifierFlavor (
- CIMQualifier & theQualifier,
- const CIMFlavor & inheritedFlavor,
+ static void resolveQualifierFlavor(
+ CIMQualifier& theQualifier,
+ const CIMFlavor& inheritedFlavor,
Boolean inherited);
};
//
//==============================================================================
//
-// Author: Chip Vincent (cvincent@us.ibm.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "ResponseHandler.h"
_deleteRep(this);
}
-OperationContext ResponseHandler::getContext(void) const
+OperationContext ResponseHandler::getContext() const
{
- return(_getRep(this)->getContext());
+ return _getRep(this)->getContext();
}
void ResponseHandler::setContext(const OperationContext & context)
//
//==============================================================================
//
-// Author: Chuck Carmack (carmack@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "ResponseHandlerRep.h"
ResponseHandlerRep::~ResponseHandlerRep()
{
-
}
-ResponseHandlerRep::ResponseHandlerRep(const ResponseHandlerRep& x) :
- _context(x._context)
+ResponseHandlerRep::ResponseHandlerRep(const ResponseHandlerRep& x)
+ : _context(x._context)
{
-
}
OperationContext ResponseHandlerRep::getContext() const
//
//==============================================================================
//
-// Author: Chuck Carmack (carmack@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ResponseHandlerRep_h
/** This class defines the internal representation of the ResponseHandler class.
*/
-class ResponseHandlerRep
+class ResponseHandlerRep
{
public:
//
//==============================================================================
//
-// Author: Markus Mueller (sedgewick_de@yahoo.de)
-//
-// Modified By: Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-// Heather Sterling, IBM (hsterl@us.ibm.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-// Aruran, IBM (ashanmug@in.ibm.com) for Bug#4422
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifdef PEGASUS_HAS_SSL
#include <Pegasus/Common/Tracer.h>
#include <Pegasus/Common/FileSystem.h>
#include <time.h>
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include <Pegasus/Common/Formatter.h>
#include "SSLContext.h"
strcpy(tempString, (char *)&timeStamp);
dateTime.set(tempString);
- return (dateTime);
+ return dateTime;
}
//
{
public:
- static int verificationCallback(int preVerifyOk, X509_STORE_CTX *ctx);
- static int verificationCRLCallback(int ok, X509_STORE_CTX *ctx, X509_STORE* sslCRLStore);
+ static int verificationCallback(
+ int preVerifyOk,
+ X509_STORE_CTX* ctx);
+ static int verificationCRLCallback(
+ int ok,
+ X509_STORE_CTX* ctx,
+ X509_STORE* sslCRLStore);
};
//
//
// return 1 if revoked, 0 otherwise
//
-int SSLCallback::verificationCRLCallback(int ok, X509_STORE_CTX *ctx, X509_STORE* sslCRLStore)
+int SSLCallback::verificationCRLCallback(
+ int ok,
+ X509_STORE_CTX* ctx,
+ X509_STORE* sslCRLStore)
{
PEG_METHOD_ENTER(TRC_SSL, "SSLCallback::verificationCRLCallback");
//check whether a CRL store was specified
if (sslCRLStore == NULL)
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: CRL store is NULL");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: CRL store is NULL");
PEG_METHOD_EXIT();
return 0;
}
//log certificate information
//this is information in the "public" key, so it does no harm to log it
X509_NAME_oneline(issuerName, buf, sizeof(buf));
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: Certificate Data: Issuer/Subject");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: Certificate Data: Issuer/Subject");
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, buf);
X509_NAME_oneline(subjectName, buf, sizeof(buf));
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, buf);
X509_STORE_CTX crlStoreCtx;
X509_STORE_CTX_init(&crlStoreCtx, sslCRLStore, NULL, NULL);
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: Initialized CRL store");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: Initialized CRL store");
//attempt to get a CRL issued by the certificate's issuer
X509_OBJECT obj;
- if (X509_STORE_get_by_subject(&crlStoreCtx, X509_LU_CRL, issuerName, &obj) <= 0)
+ if (X509_STORE_get_by_subject(
+ &crlStoreCtx, X509_LU_CRL, issuerName, &obj) <= 0)
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: No CRL by that issuer");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: No CRL by that issuer");
PEG_METHOD_EXIT();
return 0;
}
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: CRL is null");
PEG_METHOD_EXIT();
return 0;
- } else
+ }
+ else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: Found CRL by that issuer");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: Found CRL by that issuer");
}
//get revoked certificates
STACK_OF(X509_REVOKED)* revokedCerts = NULL;
revokedCerts = X509_CRL_get_REVOKED(crl);
int numRevoked = sk_X509_REVOKED_num(revokedCerts);
- Tracer::trace(TRC_SSL, Tracer::LEVEL4,"---> SSL: Number of certificates revoked by the issuer %d\n", numRevoked);
+ Tracer::trace(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: Number of certificates revoked by the issuer %d\n",
+ numRevoked);
//check whether the subject's certificate is revoked
X509_REVOKED* revokedCert = NULL;
//a matching serial number indicates revocation
if (ASN1_INTEGER_cmp(revokedCert->serialNumber, serialNumber) == 0)
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2, "---> SSL: Certificate is revoked");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
+ "---> SSL: Certificate is revoked");
X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_REVOKED);
PEG_METHOD_EXIT();
return 1;
}
}
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: Certificate is not revoked at this level");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: Certificate is not revoked at this level");
PEG_METHOD_EXIT();
return 0;
// Callback function that is called by the OpenSSL library. This function
// extracts X509 certficate information and pass that on to client application
// callback function.
-// We HAVE to build the certificate in all cases since it's needed to get the associated username out of the repository
-// later in the transaction
+// We HAVE to build the certificate in all cases since it's needed to get
+// the associated username out of the repository later in the transaction.
//
-int SSLCallback::verificationCallback(int preVerifyOk, X509_STORE_CTX *ctx)
+int SSLCallback::verificationCallback(int preVerifyOk, X509_STORE_CTX* ctx)
{
PEG_METHOD_ENTER(TRC_SSL, "SSLCallback::callback()");
int revoked = -1;
Tracer::trace(TRC_SSL, Tracer::LEVEL4,
- "--->SSL: Preverify Error %d", verifyError);
+ "--->SSL: Preverify Error %d", verifyError);
//
// get the verification callback info specific to each SSL connection
//
- ssl = (SSL*) X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
- SSLCallbackInfo* exData = (SSLCallbackInfo*) SSL_get_ex_data(ssl, SSLCallbackInfo::SSL_CALLBACK_INDEX);
+ ssl = (SSL*) X509_STORE_CTX_get_ex_data(
+ ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
+ SSLCallbackInfo* exData = (SSLCallbackInfo*) SSL_get_ex_data(
+ ssl, SSLCallbackInfo::SSL_CALLBACK_INDEX);
-
#ifdef PEGASUS_ENABLE_SSL_CRL_VERIFICATION
//
// Check to see if a CRL path is defined
//
if (exData->_rep->crlStore != NULL)
{
- revoked = verificationCRLCallback(preVerifyOk,ctx,exData->_rep->crlStore);
- Tracer::trace(TRC_SSL, Tracer::LEVEL4, "---> SSL: CRL callback returned %d", revoked);
+ revoked = verificationCRLCallback(
+ preVerifyOk,ctx,exData->_rep->crlStore);
+ Tracer::trace(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: CRL callback returned %d", revoked);
if (revoked) //with the SSL callbacks '0' indicates failure
{
}
}
- Tracer::trace(TRC_SSL, Tracer::LEVEL4, "---> SSL: CRL callback returned %d", revoked);
+ Tracer::trace(TRC_SSL, Tracer::LEVEL4,
+ "---> SSL: CRL callback returned %d", revoked);
#endif
//
if (!preVerifyOk)
{
Tracer::trace(TRC_SSL, Tracer::LEVEL4,
- "---> SSL: certificate default verification error: %s", (const char*)errorStr.getCString());
+ "---> SSL: certificate default verification error: %s",
+ (const char*)errorStr.getCString());
}
//
//
// Create the certificate object
//
-
- //insert at the beginning of the array so that the peer certificate is first and the root CA is last
- exData->_rep->peerCertificate.insert(0, new SSLCertificateInfo(subjectName, issuerName, version, serialNumber,
+
+ // insert at the beginning of the array so that the peer certificate is
+ // first and the root CA is last
+ exData->_rep->peerCertificate.insert(0, new SSLCertificateInfo(
+ subjectName, issuerName, version, serialNumber,
notBefore, notAfter, depth, errorCode, errorStr, preVerifyOk));
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "Created SSLCertificateInfo");
- // NOT_YET_VALID checks do not work correctly on subsequent tries -- Bugzilla#4283
- // call this prior to calling the user-specified callback in case they want to override it
- if (errorCode == X509_V_OK && (CIMDateTime::getDifference(CIMDateTime::getCurrentDateTime(), notBefore) > 0))
+ // NOT_YET_VALID checks do not work correctly on subsequent tries --
+ // Bugzilla#4283
+ // call this prior to calling the user-specified callback in case they
+ // want to override it
+ if (errorCode == X509_V_OK &&
+ (CIMDateTime::getDifference(
+ CIMDateTime::getCurrentDateTime(), notBefore) > 0))
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "Certificate was not yet valid.");
- X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_NOT_YET_VALID);
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "Certificate was not yet valid.");
+ X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_NOT_YET_VALID);
}
//
- // Call the user-specified application callback if it is specified. If it is null, return OpenSSL's verification code.
- // Note that the verification result does not automatically get set to X509_V_OK if the callback is successful.
- // This is because OpenSSL retains the original default error in case we want to use it later.
- // To set the error, we could use X509_STORE_CTX_set_error(ctx, verifyError); but there is no real benefit to doing that here.
+ // Call the user-specified application callback if it is specified.
+ // If it is null, return OpenSSL's verification code.
+ // Note that the verification result does not automatically get set
+ // to X509_V_OK if the callback is successful.
+ // This is because OpenSSL retains the original default error in case
+ // we want to use it later.
+ // To set the error, we could use X509_STORE_CTX_set_error(ctx,
+ // verifyError); but there is no real benefit to doing that here.
//
if (exData->_rep->verifyCertificateCallback == NULL)
{
return preVerifyOk;
- } else
+ }
+ else
{
- if (exData->_rep->verifyCertificateCallback(*exData->_rep->peerCertificate[0]))
+ if (exData->_rep->verifyCertificateCallback(
+ *exData->_rep->peerCertificate[0]))
{
- Tracer::trace(TRC_SSL, Tracer::LEVEL4,
- "--> SSL: _rep->verifyCertificateCallback() returned X509_V_OK");
+ Tracer::trace(TRC_SSL, Tracer::LEVEL4,
+ "--> SSL: _rep->verifyCertificateCallback() returned "
+ "X509_V_OK");
PEG_METHOD_EXIT();
return 1;
else // verification failed, handshake will be immediately terminated
{
Tracer::trace(TRC_SSL, Tracer::LEVEL4,
- "--> SSL: _rep->verifyCertificateCallback() returned error %d", exData->_rep->peerCertificate[0]->getErrorCode());
+ "--> SSL: _rep->verifyCertificateCallback() returned error %d",
+ exData->_rep->peerCertificate[0]->getErrorCode());
PEG_METHOD_EXIT();
return 0;
}
//
-// Callback function called by OpenSSL. This request is merely forwarded to the static
-// function SSLCallback::callback(). The SSLCallback class is a friend class of the
-// Pegasus SSL related classes needed to complete the callback.
+// Callback function called by OpenSSL. This request is merely forwarded
+// to the static function SSLCallback::callback(). The SSLCallback class
+// is a friend class of the Pegasus SSL related classes needed to complete
+// the callback.
//
extern "C" int prepareForCallback(int preVerifyOk, X509_STORE_CTX *ctx)
{
//
// Implement OpenSSL locking callback.
//
-void pegasus_locking_callback( int mode,
- int type,
- const char* file,
- int line)
+void pegasus_locking_callback(
+ int mode,
+ int type,
+ const char* file,
+ int line)
{
// Check whether the mode is lock or unlock.
// Set the locking callback to pegasus_locking_callback.
- CRYPTO_set_locking_callback((CRYPTO_SET_LOCKING_CALLBACK) pegasus_locking_callback);
+ CRYPTO_set_locking_callback(
+ (CRYPTO_SET_LOCKING_CALLBACK) pegasus_locking_callback);
}
// must enable PEGASUS_SSL_RANDOMFILE flag.
//
SSLContextRep::SSLContextRep(
- const String& trustStore,
- const String& certPath,
- const String& keyPath,
- const String& crlPath,
- SSLCertificateVerifyFunction* verifyCert,
- const String& randomFile)
+ const String& trustStore,
+ const String& certPath,
+ const String& keyPath,
+ const String& crlPath,
+ SSLCertificateVerifyFunction* verifyCert,
+ const String& randomFile)
{
PEG_METHOD_ENTER(TRC_SSL, "SSLContextRep::SSLContextRep()");
_certificateVerifyFunction = verifyCert;
//
- // If a truststore and/or peer verification function is specified, enable peer verification
+ // If a truststore and/or peer verification function is specified,
+ // enable peer verification
//
if (trustStore != String::EMPTY || verifyCert != NULL)
{
}
//
- // Initialiaze SSL callbacks and increment the SSLContextRep object _counter.
+ // Initialize SSL callbacks and increment the SSLContextRep object _counter.
//
{
AutoMutex autoMut(_countRepMutex);
"After calling SSL_library_init %d", Threads::id());
}
- _countRep++;
+ _countRep++;
} // mutex unlocks here
_randomInit(randomFile);
_certificateVerifyFunction = sslContextRep._certificateVerifyFunction;
_randomFile = sslContextRep._randomFile;
- // Initialiaze SSL callbacks and increment the SSLContextRep object _counter.
+ // Initialize SSL callbacks and increment the SSLContextRep object _counter.
{
AutoMutex autoMut(_countRepMutex);
Tracer::trace(TRC_SSL, Tracer::LEVEL4,
- "Value of Countrep in copy constructor %d", _countRep);
+ "Value of Countrep in copy constructor %d", _countRep);
if ( _countRep == 0 )
{
init_ssl();
}
- _countRep++;
+ _countRep++;
} // mutex unlocks here
_sslContext = _makeSSLContext();
// Free SSL locks if no instances of SSLContextRep exist.
Tracer::trace(TRC_SSL, Tracer::LEVEL4,
- "Value of Countrep in destructor %d", _countRep);
+ "Value of Countrep in destructor %d", _countRep);
if ( _countRep == 0 )
{
free_ssl();
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
"Random seed file is required.");
PEG_METHOD_EXIT();
- //l10n
- //throw( SSLException("Random seed file required"));
- MessageLoaderParms parms("Common.SSLContext.RANDOM_SEED_FILE_REQUIRED",
- "Random seed file required");
+ MessageLoaderParms parms(
+ "Common.SSLContext.RANDOM_SEED_FILE_REQUIRED",
+ "Random seed file required");
throw SSLException(parms);
}
// Try the given random seed file
//
ret = FileSystem::exists(randomFile);
- if( ret )
+ if (ret)
{
retVal = RAND_load_file(randomFile.getCString(), -1);
if ( retVal < 0 )
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
"Not enough seed data in seed file: " + randomFile);
PEG_METHOD_EXIT();
- //l10n
- // do not put in $0 in default message, but pass in filename for bundle message
- //throw( SSLException("Not enough seed data in random seed file."));
- MessageLoaderParms parms("Common.SSLContext.NOT_ENOUGH_SEED_DATA_IN_FILE",
- "Not enough seed data in random seed file.",
- randomFile);
+ // do not put in $0 in default message, but pass in filename
+ // for bundle message
+ MessageLoaderParms parms(
+ "Common.SSLContext.NOT_ENOUGH_SEED_DATA_IN_FILE",
+ "Not enough seed data in random seed file.",
+ randomFile);
throw SSLException(parms);
}
}
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
"seed file - " + randomFile + " does not exist.");
PEG_METHOD_EXIT();
- //l10n
- //throw( SSLException("Seed file '" + randomFile + "' does not exist."));
- MessageLoaderParms parms("Common.SSLContext.SEED_FILE_DOES_NOT_EXIST",
- "Seed file '$0' does not exist.",
- randomFile);
+ MessageLoaderParms parms(
+ "Common.SSLContext.SEED_FILE_DOES_NOT_EXIST",
+ "Seed file '$0' does not exist.",
+ randomFile);
throw SSLException(parms);
}
"Not enough seed data in random seed file, RAND_status = " +
seedRet);
PEG_METHOD_EXIT();
- //l10n 485
- // do not put in $0 in default message, but pass in filename for bundle message
- //throw( SSLException("Not enough seed data in random seed file."));
- MessageLoaderParms parms("Common.SSLContext.NOT_ENOUGH_SEED_DATA_IN_FILE",
- "Not enough seed data in random seed file.",
- randomFile);
+ // do not put in $0 in default message, but pass in filename
+ // for bundle message
+ MessageLoaderParms parms(
+ "Common.SSLContext.NOT_ENOUGH_SEED_DATA_IN_FILE",
+ "Not enough seed data in random seed file.",
+ randomFile);
throw SSLException(parms);
}
}
}
#endif /* PEGASUS_SSL_RANDOMFILE */
- int seedRet = RAND_status();
- if ( seedRet == 0 )
+ int seedRet = RAND_status();
+ if (seedRet == 0)
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
"Not enough seed data , RAND_status = " + seedRet );
PEG_METHOD_EXIT();
- //l10n
- //throw( SSLException("Not enough seed data."));
- MessageLoaderParms parms("Common.SSLContext.NOT_ENOUGH_SEED_DATA",
- "Not enough seed data.");
+ MessageLoaderParms parms(
+ "Common.SSLContext.NOT_ENOUGH_SEED_DATA",
+ "Not enough seed data.");
throw SSLException(parms);
}
PEG_METHOD_EXIT();
}
-SSL_CTX * SSLContextRep::_makeSSLContext()
+SSL_CTX* SSLContextRep::_makeSSLContext()
{
PEG_METHOD_ENTER(TRC_SSL, "SSLContextRep::_makeSSLContext()");
// create SSL Context Area
//
- if (!( sslContext = SSL_CTX_new(SSLv23_method()) ))
+ if (!(sslContext = SSL_CTX_new(SSLv23_method())))
{
PEG_METHOD_EXIT();
- //l10n
- //throw( SSLException("Could not get SSL CTX"));
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_GET",
- "Could not get SSL CTX");
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_GET",
+ "Could not get SSL CTX");
throw SSLException(parms);
}
#ifdef PEGASUS_SSL_WEAKENCRYPTION
- if (!(SSL_CTX_set_cipher_list(sslContext, SSL_TXT_EXP40))){
- //l10n
- //throw( SSLException("Could not set the cipher list"));
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_SET_CIPHER_LIST",
- "Could not set the cipher list");
+ if (!(SSL_CTX_set_cipher_list(sslContext, SSL_TXT_EXP40)))
+ {
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_SET_CIPHER_LIST",
+ "Could not set the cipher list");
throw SSLException(parms);
}
#endif
if (_verifyPeer)
{
- //ATTN: We might still need a flag to specify SSL_VERIFY_FAIL_IF_NO_PEER_CERT
- // If SSL_VERIFY_FAIL_IF_NO_PEER_CERT is ON, SSL will immediately be terminated
- // if the client sends no certificate or sends an untrusted certificate. The
- // callback function is not called in this case; the handshake is simply terminated.
+ // ATTN: We might still need a flag to specify
+ // SSL_VERIFY_FAIL_IF_NO_PEER_CERT
+ // If SSL_VERIFY_FAIL_IF_NO_PEER_CERT is ON, SSL will immediately be
+ // terminated if the client sends no certificate or sends an
+ // untrusted certificate. The callback function is not called in
+ // this case; the handshake is simply terminated.
// This value has NO effect in from a client perspective
if (_certificateVerifyFunction != NULL)
}
else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: Trust Store specified");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: Trust Store specified");
SSL_CTX_set_verify(sslContext,
- SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
+ SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE |
+ SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
prepareForCallback);
}
}
else
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
- "---> SSL: Trust Store and certificate verification callback are NOT specified");
+ "---> SSL: Trust Store and certificate verification callback "
+ "are NOT specified");
SSL_CTX_set_verify(sslContext, SSL_VERIFY_NONE, NULL);
}
//
- // Check if there is CA certificate file or directory specified. If specified,
- // and is not empty, load the certificates from the Trust store.
+ // Check if there is CA certificate file or directory specified. If
+ // specified, and is not empty, load the certificates from the Trust store.
//
if (_trustStore != String::EMPTY)
{
// load certificates from the trust store
//
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
- "---> SSL: Loading certificates from the trust store: " + _trustStore);
+ "---> SSL: Loading certificates from the trust store: " +
+ _trustStore);
- if ((!SSL_CTX_load_verify_locations(sslContext, NULL, _trustStore.getCString())) ||
+ if ((!SSL_CTX_load_verify_locations(
+ sslContext, NULL, _trustStore.getCString())) ||
(!SSL_CTX_set_default_verify_paths(sslContext)))
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
- "---> SSL: Could not load certificates from the trust store: " + _trustStore);
- //l10n
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_LOAD_CERTIFICATES",
+ "---> SSL: Could not load certificates from the trust "
+ "store: " + _trustStore);
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_LOAD_CERTIFICATES",
"Could not load certificates in to trust store.");
PEG_METHOD_EXIT();
throw SSLException(parms);
else if (FileSystem::exists(_trustStore))
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
- "---> SSL: Truststore is a file");
+ "---> SSL: Truststore is a file");
//
// Get size of the trust store file:
//
// load certificates from the trust store
//
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
- "---> SSL: Loading certificates from the trust store: " + _trustStore);
+ "---> SSL: Loading certificates from the trust store: " +
+ _trustStore);
- if ((!SSL_CTX_load_verify_locations(sslContext, _trustStore.getCString(), NULL)) ||
+ if ((!SSL_CTX_load_verify_locations(
+ sslContext, _trustStore.getCString(), NULL)) ||
(!SSL_CTX_set_default_verify_paths(sslContext)))
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
- "---> SSL: Could not load certificates from the trust store: " + _trustStore);
- //l10n
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_LOAD_CERTIFICATES",
+ "---> SSL: Could not load certificates from the "
+ "trust store: " + _trustStore);
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_LOAD_CERTIFICATES",
"Could not load certificates in to trust store.");
PEG_METHOD_EXIT();
throw SSLException(parms);
// no certificates found in the trust store
//
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
- "---> SSL: No certificates to load from the trust store: " + _trustStore);
+ "---> SSL: No certificates to load from the trust "
+ "store: " + _trustStore);
}
}
}
if (_crlPath != String::EMPTY)
{
- //need to save this -- can we make it static since there's only one CRL for cimserver?
+ // need to save this -- can we make it static since there's only
+ // one CRL for cimserver?
X509_LOOKUP* pLookup;
_crlStore = X509_STORE_new();
- //the validity of the crlstore was checked in ConfigManager during server startup
+ // the validity of the crlstore was checked in ConfigManager
+ // during server startup
if (FileSystem::isDirectory(_crlPath))
{
Tracer::trace(TRC_SSL, Tracer::LEVEL3,
- "---> SSL: CRL store is a directory in %s", (const char*)_crlPath.getCString());
+ "---> SSL: CRL store is a directory in %s",
+ (const char*)_crlPath.getCString());
- if ((pLookup = X509_STORE_add_lookup(_crlStore, X509_LOOKUP_hash_dir())) == NULL)
+ if ((pLookup = X509_STORE_add_lookup(
+ _crlStore, X509_LOOKUP_hash_dir())) == NULL)
{
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_LOAD_CRLS",
- "Could not load certificate revocation list.");
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_LOAD_CRLS",
+ "Could not load certificate revocation list.");
X509_STORE_free(_crlStore);
PEG_METHOD_EXIT();
throw SSLException(parms);
}
- X509_LOOKUP_add_dir(pLookup, (const char*)_crlPath.getCString(), X509_FILETYPE_PEM);
+ X509_LOOKUP_add_dir(
+ pLookup, (const char*)_crlPath.getCString(), X509_FILETYPE_PEM);
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
- "---> SSL: Successfully configured CRL directory");
-
- } else
+ "---> SSL: Successfully configured CRL directory");
+ }
+ else
{
Tracer::trace(TRC_SSL, Tracer::LEVEL3,
- "---> SSL: CRL store is the file %s", (const char*)_crlPath.getCString());
+ "---> SSL: CRL store is the file %s",
+ (const char*)_crlPath.getCString());
- if ((pLookup = X509_STORE_add_lookup(_crlStore, X509_LOOKUP_file())) == NULL)
+ if ((pLookup = X509_STORE_add_lookup(
+ _crlStore, X509_LOOKUP_file())) == NULL)
{
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_LOAD_CRLS",
- "Could not load certificate revocation list.");
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_LOAD_CRLS",
+ "Could not load certificate revocation list.");
X509_STORE_free(_crlStore);
PEG_METHOD_EXIT();
throw SSLException(parms);
}
- X509_LOOKUP_load_file(pLookup, (const char*)_crlPath.getCString(), X509_FILETYPE_PEM);
+ X509_LOOKUP_load_file(
+ pLookup, (const char*)_crlPath.getCString(), X509_FILETYPE_PEM);
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
- "---> SSL: Successfully configured CRL file");
+ "---> SSL: Successfully configured CRL file");
}
}
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
"---> SSL: No server certificate found in " + _certPath);
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_GET_SERVER_CERTIFICATE",
- "Could not get server certificate.");
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_GET_SERVER_CERTIFICATE",
+ "Could not get server certificate.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
//
// If there is no key file (file containing server
- // private key) specified, then try loading the key from the certificate file.
- // As of 2.4, if a keyfile is specified, its location is verified during server
- // startup and will throw an error if the path is invalid.
+ // private key) specified, then try loading the key from the
+ // certificate file.
+ // As of 2.4, if a keyfile is specified, its location is verified
+ // during server startup and will throw an error if the path is invalid.
//
if (_keyPath == String::EMPTY)
{
//
if (!_verifyPrivateKey(sslContext, _certPath))
{
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_GET_PRIVATE_KEY",
- "Could not get private key.");
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_GET_PRIVATE_KEY",
+ "Could not get private key.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
//
if (!_verifyPrivateKey(sslContext, _keyPath))
{
- MessageLoaderParms parms("Common.SSLContext.COULD_NOT_GET_PRIVATE_KEY",
- "Could not get private key.");
+ MessageLoaderParms parms(
+ "Common.SSLContext.COULD_NOT_GET_PRIVATE_KEY",
+ "Could not get private key.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
{
PEG_METHOD_ENTER(TRC_SSL, "_verifyPrivateKey()");
- if (SSL_CTX_use_PrivateKey_file(ctx, keyPath.getCString(), SSL_FILETYPE_PEM) <= 0)
+ if (SSL_CTX_use_PrivateKey_file(
+ ctx, keyPath.getCString(), SSL_FILETYPE_PEM) <= 0)
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL2,
"---> SSL: no private key found in " + String(keyPath));
return true;
}
-SSL_CTX * SSLContextRep::getContext() const
+SSL_CTX* SSLContextRep::getContext() const
{
return _sslContext;
}
return _verifyPeer;
}
-SSLCertificateVerifyFunction* SSLContextRep::getSSLCertificateVerifyFunction() const
+SSLCertificateVerifyFunction*
+ SSLContextRep::getSSLCertificateVerifyFunction() const
{
return _certificateVerifyFunction;
}
// these definitions are used if ssl is not available
//
-SSLContextRep::SSLContextRep(const String& trustStore,
- const String& certPath,
- const String& keyPath,
- const String& crlPath,
- SSLCertificateVerifyFunction* verifyCert,
- const String& randomFile)
-{}
+SSLContextRep::SSLContextRep(
+ const String& trustStore,
+ const String& certPath,
+ const String& keyPath,
+ const String& crlPath,
+ SSLCertificateVerifyFunction* verifyCert,
+ const String& randomFile)
+{
+}
SSLContextRep::SSLContextRep(const SSLContextRep& sslContextRep) {}
SSLContextRep::~SSLContextRep() {}
-SSL_CTX * SSLContextRep::_makeSSLContext() { return 0; }
+SSL_CTX* SSLContextRep::_makeSSLContext() { return 0; }
-Boolean SSLContextRep::_verifyPrivateKey(SSL_CTX *ctx,
- const String& keyPath) { return false; }
+Boolean SSLContextRep::_verifyPrivateKey(
+ SSL_CTX *ctx,
+ const String& keyPath)
+{
+ return false;
+}
-SSL_CTX * SSLContextRep::getContext() const { return 0; }
+SSL_CTX* SSLContextRep::getContext() const { return 0; }
String SSLContextRep::getTrustStore() const { return String::EMPTY; }
Boolean SSLContextRep::isPeerVerificationEnabled() const { return false; }
-SSLCertificateVerifyFunction* SSLContextRep::getSSLCertificateVerifyFunction() const { return NULL; }
+SSLCertificateVerifyFunction*
+ SSLContextRep::getSSLCertificateVerifyFunction() const
+{
+ return NULL;
+}
void SSLContextRep::init_ssl() {}
SSLCertificateVerifyFunction* verifyCert,
const String& randomFile)
{
- _rep = new SSLContextRep(trustStore, String::EMPTY, String::EMPTY, String::EMPTY, verifyCert, randomFile);
+ _rep = new SSLContextRep(
+ trustStore,
+ String::EMPTY,
+ String::EMPTY,
+ String::EMPTY,
+ verifyCert,
+ randomFile);
}
SSLContext::SSLContext(
SSLCertificateVerifyFunction* verifyCert,
const String& randomFile)
{
- _rep = new SSLContextRep(trustStore, certPath, keyPath, String::EMPTY, verifyCert, randomFile);
+ _rep = new SSLContextRep(
+ trustStore, certPath, keyPath, String::EMPTY, verifyCert, randomFile);
}
//PEP187
const String& randomFile)
{
#ifndef PEGASUS_ENABLE_SSL_CRL_VERIFICATION
- if ( crlPath.size() > 0 )
+ if (crlPath.size() > 0)
{
- MessageLoaderParms parms("Common.Exception.SSL_CRL_NOT_ENABLED_EXCEPTION",
- "SSL CRL verification is not enabled.");
+ MessageLoaderParms parms(
+ "Common.Exception.SSL_CRL_NOT_ENABLED_EXCEPTION",
+ "SSL CRL verification is not enabled.");
throw Exception(parms);
}
#endif
- _rep = new SSLContextRep(trustStore, certPath, keyPath, crlPath, verifyCert, randomFile);
+ _rep = new SSLContextRep(
+ trustStore, certPath, keyPath, crlPath, verifyCert, randomFile);
}
#ifdef PEGASUS_USE_DEPRECATED_INTERFACES
String trustStoreUserName,
const String& randomFile)
{
- _rep = new SSLContextRep(trustStore, certPath, keyPath, String::EMPTY, verifyCert, randomFile);
+ _rep = new SSLContextRep(
+ trustStore, certPath, keyPath, String::EMPTY, verifyCert, randomFile);
}
#endif
String SSLContext::getTrustStore() const
{
- return (_rep->getTrustStore());
+ return _rep->getTrustStore();
}
String SSLContext::getCertPath() const
{
- return (_rep->getCertPath());
+ return _rep->getCertPath();
}
String SSLContext::getKeyPath() const
{
- return (_rep->getKeyPath());
+ return _rep->getKeyPath();
}
String SSLContext::getCRLPath() const
{
#ifdef PEGASUS_ENABLE_SSL_CRL_VERIFICATION
- return (_rep->getCRLPath());
+ return _rep->getCRLPath();
#else
- MessageLoaderParms parms("Common.Exception.SSL_CRL_NOT_ENABLED_EXCEPTION",
- "SSL CRL verification is not enabled.");
+ MessageLoaderParms parms(
+ "Common.Exception.SSL_CRL_NOT_ENABLED_EXCEPTION",
+ "SSL CRL verification is not enabled.");
throw Exception(parms);
#endif
}
X509_STORE* SSLContext::getCRLStore() const
{
#ifdef PEGASUS_ENABLE_SSL_CRL_VERIFICATION
- return (_rep->getCRLStore());
+ return _rep->getCRLStore();
#else
- MessageLoaderParms parms("Common.Exception.SSL_CRL_NOT_ENABLED_EXCEPTION",
- "SSL CRL verification is not enabled.");
+ MessageLoaderParms parms(
+ "Common.Exception.SSL_CRL_NOT_ENABLED_EXCEPTION",
+ "SSL CRL verification is not enabled.");
throw Exception(parms);
#endif
}
Boolean SSLContext::isPeerVerificationEnabled() const
{
- return (_rep->isPeerVerificationEnabled());
+ return _rep->isPeerVerificationEnabled();
}
#ifdef PEGASUS_USE_DEPRECATED_INTERFACES
String SSLContext::getTrustStoreUserName() const
{
- return (_rep->getTrustStoreUserName());
+ return _rep->getTrustStoreUserName();
}
#endif
-SSLCertificateVerifyFunction* SSLContext::getSSLCertificateVerifyFunction() const
+SSLCertificateVerifyFunction*
+ SSLContext::getSSLCertificateVerifyFunction() const
{
- return (_rep->getSSLCertificateVerifyFunction());
+ return _rep->getSSLCertificateVerifyFunction();
}
///////////////////////////////////////////////////////////////////////////////
//
// Certificate validation result codes.
//
-const int SSLCertificateInfo::V_OK = 0;
-
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_GET_ISSUER_CERT = 2;
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_GET_CRL = 3;
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE = 4;
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE = 5;
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY = 6;
-const int SSLCertificateInfo::V_ERR_CERT_SIGNATURE_FAILURE = 7;
-const int SSLCertificateInfo::V_ERR_CRL_SIGNATURE_FAILURE = 8;
-const int SSLCertificateInfo::V_ERR_CERT_NOT_YET_VALID = 9;
-const int SSLCertificateInfo::V_ERR_CERT_HAS_EXPIRED = 10;
-const int SSLCertificateInfo::V_ERR_CRL_NOT_YET_VALID = 11;
-const int SSLCertificateInfo::V_ERR_CRL_HAS_EXPIRED = 12;
-const int SSLCertificateInfo::V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD = 13;
-const int SSLCertificateInfo::V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD = 14;
-const int SSLCertificateInfo::V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD = 15;
-const int SSLCertificateInfo::V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD = 16;
-const int SSLCertificateInfo::V_ERR_OUT_OF_MEM = 17;
-const int SSLCertificateInfo::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT = 18;
-const int SSLCertificateInfo::V_ERR_SELF_SIGNED_CERT_IN_CHAIN = 19;
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 20;
-const int SSLCertificateInfo::V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE = 21;
-const int SSLCertificateInfo::V_ERR_CERT_CHAIN_TOO_LONG = 22;
-const int SSLCertificateInfo::V_ERR_CERT_REVOKED = 23;
-const int SSLCertificateInfo::V_ERR_INVALID_CA = 24;
-const int SSLCertificateInfo::V_ERR_PATH_LENGTH_EXCEEDED = 25;
-const int SSLCertificateInfo::V_ERR_INVALID_PURPOSE = 26;
-const int SSLCertificateInfo::V_ERR_CERT_UNTRUSTED = 27;
-const int SSLCertificateInfo::V_ERR_CERT_REJECTED = 28;
-const int SSLCertificateInfo::V_ERR_SUBJECT_ISSUER_MISMATCH = 29;
-const int SSLCertificateInfo::V_ERR_AKID_SKID_MISMATCH = 30;
-const int SSLCertificateInfo::V_ERR_AKID_ISSUER_SERIAL_MISMATCH = 31;
-const int SSLCertificateInfo::V_ERR_KEYUSAGE_NO_CERTSIGN = 32;
-
-const int SSLCertificateInfo::V_ERR_APPLICATION_VERIFICATION = 50;
+const int SSLCertificateInfo::V_OK = 0;
+
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_GET_ISSUER_CERT = 2;
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_GET_CRL = 3;
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE = 4;
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE = 5;
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY = 6;
+const int SSLCertificateInfo::V_ERR_CERT_SIGNATURE_FAILURE = 7;
+const int SSLCertificateInfo::V_ERR_CRL_SIGNATURE_FAILURE = 8;
+const int SSLCertificateInfo::V_ERR_CERT_NOT_YET_VALID = 9;
+const int SSLCertificateInfo::V_ERR_CERT_HAS_EXPIRED = 10;
+const int SSLCertificateInfo::V_ERR_CRL_NOT_YET_VALID = 11;
+const int SSLCertificateInfo::V_ERR_CRL_HAS_EXPIRED = 12;
+const int SSLCertificateInfo::V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD = 13;
+const int SSLCertificateInfo::V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD = 14;
+const int SSLCertificateInfo::V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD = 15;
+const int SSLCertificateInfo::V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD = 16;
+const int SSLCertificateInfo::V_ERR_OUT_OF_MEM = 17;
+const int SSLCertificateInfo::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT = 18;
+const int SSLCertificateInfo::V_ERR_SELF_SIGNED_CERT_IN_CHAIN = 19;
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 20;
+const int SSLCertificateInfo::V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE = 21;
+const int SSLCertificateInfo::V_ERR_CERT_CHAIN_TOO_LONG = 22;
+const int SSLCertificateInfo::V_ERR_CERT_REVOKED = 23;
+const int SSLCertificateInfo::V_ERR_INVALID_CA = 24;
+const int SSLCertificateInfo::V_ERR_PATH_LENGTH_EXCEEDED = 25;
+const int SSLCertificateInfo::V_ERR_INVALID_PURPOSE = 26;
+const int SSLCertificateInfo::V_ERR_CERT_UNTRUSTED = 27;
+const int SSLCertificateInfo::V_ERR_CERT_REJECTED = 28;
+const int SSLCertificateInfo::V_ERR_SUBJECT_ISSUER_MISMATCH = 29;
+const int SSLCertificateInfo::V_ERR_AKID_SKID_MISMATCH = 30;
+const int SSLCertificateInfo::V_ERR_AKID_ISSUER_SERIAL_MISMATCH = 31;
+const int SSLCertificateInfo::V_ERR_KEYUSAGE_NO_CERTSIGN = 32;
+
+const int SSLCertificateInfo::V_ERR_APPLICATION_VERIFICATION = 50;
class SSLCertificateInfoRep
{
String SSLCertificateInfo::getSubjectName() const
{
- return (_rep->subjectName);
+ return _rep->subjectName;
}
String SSLCertificateInfo::getIssuerName() const
{
- return (_rep->issuerName);
+ return _rep->issuerName;
}
Uint32 SSLCertificateInfo::getVersionNumber() const
{
- return (_rep->versionNumber);
+ return _rep->versionNumber;
}
long SSLCertificateInfo::getSerialNumber() const
{
- return (_rep->serialNumber);
+ return _rep->serialNumber;
}
CIMDateTime SSLCertificateInfo::getNotBefore() const
{
- return (_rep->notBefore);
+ return _rep->notBefore;
}
CIMDateTime SSLCertificateInfo::getNotAfter() const
{
- return (_rep->notAfter);
+ return _rep->notAfter;
}
Uint32 SSLCertificateInfo::getErrorDepth() const
{
- return (_rep->depth);
+ return _rep->depth;
}
Uint32 SSLCertificateInfo::getErrorCode() const
{
- return (_rep->errorCode);
+ return _rep->errorCode;
}
void SSLCertificateInfo::setErrorCode(const int errorCode)
String SSLCertificateInfo::getErrorString() const
{
- return (_rep->errorString);
+ return _rep->errorString;
}
Uint32 SSLCertificateInfo::getResponseCode() const
{
- return (_rep->respCode);
+ return _rep->respCode;
}
void SSLCertificateInfo::setResponseCode(const int respCode)
_rep->crlStore = NULL;
}
-SSLCallbackInfo::SSLCallbackInfo(SSLCertificateVerifyFunction* verifyCert, X509_STORE* crlStore)
+SSLCallbackInfo::SSLCallbackInfo(
+ SSLCertificateVerifyFunction* verifyCert,
+ X509_STORE* crlStore)
{
_rep = new SSLCallbackInfoRep();
_rep->verifyCertificateCallback = verifyCert;
// Pegasus-defined SSL certificate verification callback
typedef Boolean (SSLCertificateVerifyFunction) (SSLCertificateInfo &certInfo);
-/** This class provides information that is used during the SSL verification callback.
- We pass a pointer to this object to the SSL_set_ex_data function. We can then use SSL_get_ex_data
- from within the callback and cast the void* back to this object. In this case, we store a pointer
- to the Pegasus-defined callback function set in the SSLContext. We also store a pointer to a
- certificate object which we construct during the callback. Some of the certificate information is
- inaccessible outside the callback, so we need to retrieve the data within the function.
- Each SSL connection object will have the same callback function, but each connection will have its
- own certificate. Therefore, this class is constructed on a per-connection basis in SSLSocket.
+/** This class provides information that is used during the SSL verification
+ callback. We pass a pointer to this object to the SSL_set_ex_data
+ function. We can then use SSL_get_ex_data from within the callback and
+ cast the void* back to this object. In this case, we store a pointer to
+ the Pegasus-defined callback function set in the SSLContext. We also
+ store a pointer to a certificate object which we construct during the
+ callback. Some of the certificate information is inaccessible outside
+ the callback, so we need to retrieve the data within the function. Each
+ SSL connection object will have the same callback function, but each
+ connection will have its own certificate. Therefore, this class is
+ constructed on a per-connection basis in SSLSocket.
*/
class PEGASUS_COMMON_LINKAGE SSLCallbackInfo
{
//
// Certificate validation result codes.
//
- static const int V_OK;
-
- static const int V_ERR_UNABLE_TO_GET_ISSUER_CERT;
- static const int V_ERR_UNABLE_TO_GET_CRL;
- static const int V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE;
- static const int V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE;
- static const int V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
- static const int V_ERR_CERT_SIGNATURE_FAILURE;
- static const int V_ERR_CRL_SIGNATURE_FAILURE;
- static const int V_ERR_CERT_NOT_YET_VALID;
- static const int V_ERR_CERT_HAS_EXPIRED;
- static const int V_ERR_CRL_NOT_YET_VALID;
- static const int V_ERR_CRL_HAS_EXPIRED;
- static const int V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD;
- static const int V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD;
- static const int V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD;
- static const int V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD;
- static const int V_ERR_OUT_OF_MEM;
- static const int V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;
- static const int V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
- static const int V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;
- static const int V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE;
- static const int V_ERR_CERT_CHAIN_TOO_LONG;
- static const int V_ERR_CERT_REVOKED;
- static const int V_ERR_INVALID_CA;
- static const int V_ERR_PATH_LENGTH_EXCEEDED;
- static const int V_ERR_INVALID_PURPOSE;
- static const int V_ERR_CERT_UNTRUSTED;
- static const int V_ERR_CERT_REJECTED;
- static const int V_ERR_SUBJECT_ISSUER_MISMATCH;
- static const int V_ERR_AKID_SKID_MISMATCH;
- static const int V_ERR_AKID_ISSUER_SERIAL_MISMATCH;
- static const int V_ERR_KEYUSAGE_NO_CERTSIGN;
-
- static const int V_ERR_APPLICATION_VERIFICATION;
+ static const int V_OK;
+
+ static const int V_ERR_UNABLE_TO_GET_ISSUER_CERT;
+ static const int V_ERR_UNABLE_TO_GET_CRL;
+ static const int V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE;
+ static const int V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE;
+ static const int V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
+ static const int V_ERR_CERT_SIGNATURE_FAILURE;
+ static const int V_ERR_CRL_SIGNATURE_FAILURE;
+ static const int V_ERR_CERT_NOT_YET_VALID;
+ static const int V_ERR_CERT_HAS_EXPIRED;
+ static const int V_ERR_CRL_NOT_YET_VALID;
+ static const int V_ERR_CRL_HAS_EXPIRED;
+ static const int V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD;
+ static const int V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD;
+ static const int V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD;
+ static const int V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD;
+ static const int V_ERR_OUT_OF_MEM;
+ static const int V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;
+ static const int V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
+ static const int V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;
+ static const int V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE;
+ static const int V_ERR_CERT_CHAIN_TOO_LONG;
+ static const int V_ERR_CERT_REVOKED;
+ static const int V_ERR_INVALID_CA;
+ static const int V_ERR_PATH_LENGTH_EXCEEDED;
+ static const int V_ERR_INVALID_PURPOSE;
+ static const int V_ERR_CERT_UNTRUSTED;
+ static const int V_ERR_CERT_REJECTED;
+ static const int V_ERR_SUBJECT_ISSUER_MISMATCH;
+ static const int V_ERR_AKID_SKID_MISMATCH;
+ static const int V_ERR_AKID_ISSUER_SERIAL_MISMATCH;
+ static const int V_ERR_KEYUSAGE_NO_CERTSIGN;
+
+ static const int V_ERR_APPLICATION_VERIFICATION;
/** Constructor for a SSLCertificateInfo object.
@param issuerName issuer name of the certificate.
@param version version number value from the certificate.
@param serailNumber serial number value from the certificate.
- @param notAfter notAfter date from the validity period of the certificate.
- @param notBefore notBefore date from the validity period of the certificate.
+ @param notAfter notAfter date from the validity period of the
+ certificate.
+ @param notBefore notBefore date from the validity period of the
+ certificate.
@param depth depth of the certificate chain.
@param errorCode error code from the default verification of the
certificate by the OpenSSL library.
~SSLContext();
- /** Gets the truststore path of the SSLContext object. This may be a CA file or a directory.
+ /** Gets the truststore path of the SSLContext object. This may be a
+ CA file or a directory.
@return a string containing the truststore path.
*/
String getTrustStore() const;
String getTrustStoreUserName() const;
#endif
- /** Returns the verification callback associated with this context. This may be NULL.
+ /** Returns the verification callback associated with this context.
+ This may be NULL.
@return the verification callback function
*/
SSLCertificateVerifyFunction* getSSLCertificateVerifyFunction() const;
@param keyPath server key file path
@param verifyCert function pointer to a certificate verification
call back function.
- @param trustStoreUserName In OpenPegasus 2.5 this parameter specified the user to
- associate the truststore with; this was basically a workaround to
- providers that required a username. With the support provided in PEP 187,
+ @param trustStoreUserName In OpenPegasus 2.5 this parameter
+ specified the user to associate the truststore with; this was
+ basically a workaround to providers that required a username. With
+ the support provided in PEP 187,
this parameter is ignored beginning in release 2.5.
@param randomFile file path of a random file that is used as a seed
for random number generation by OpenSSL.
- @exception SSLException exception indicating failure to create a context.
+ @exception SSLException exception indicating failure to create a
+ context.
*/
SSLContext(
const String& trustStore,
"Could not reload the trust store, SSL Context is not initialized.");
MessageLoaderParms parms(
- "Pegasus.Common.SSLContextManager.COULD_NOT_RELOAD_TRUSTSTORE_SSL_CONTEXT_NOT_INITIALIZED",
- "Could not reload the trust store, SSL Context is not initialized.");
+ "Pegasus.Common.SSLContextManager."
+ "COULD_NOT_RELOAD_TRUSTSTORE_SSL_CONTEXT_NOT_INITIALIZED",
+ "Could not reload the trust store, SSL Context is not "
+ "initialized.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
if (trustStore == String::EMPTY)
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
- "Could not reload the trust store, the trust store is not configured.");
+ "Could not reload the trust store, the trust store is not "
+ "configured.");
MessageLoaderParms parms(
"Pegasus.Common.SSLContextManager.TRUST_STORE_NOT_CONFIGURED",
- "Could not reload the trust store, the trust store is not configured.");
+ "Could not reload the trust store, the trust store is not "
+ "configured.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
"Could not reload the crl store, SSL Context is not initialized.");
MessageLoaderParms parms(
- "Pegasus.Common.SSLContextManager.COULD_NOT_RELOAD_CRL_STORE_SSL_CONTEXT_NOT_INITIALIZED",
- "Could not reload the crl store, SSL Context is not initialized.");
+ "Pegasus.Common.SSLContextManager."
+ "COULD_NOT_RELOAD_CRL_STORE_SSL_CONTEXT_NOT_INITIALIZED",
+ "Could not reload the crl store, SSL Context is not initialized.");
PEG_METHOD_EXIT();
throw SSLException(parms);
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "CRL store path is " + crlPath);
- //update the CRL store for both the server and the export server since they share the same CRL store
+ // update the CRL store for both the server and the export server since
+ // they share the same CRL store
X509_STORE* crlStore;
{
"Could not reload the trust or crl store.");
MessageLoaderParms parms(
- "Pegasus.Common.SSLContextManager.COULD_NOT_RELOAD_TRUST_OR_CRL_STORE",
- "Could not reload the trust or crl store.");
+ "Pegasus.Common.SSLContextManager."
+ "COULD_NOT_RELOAD_TRUST_OR_CRL_STORE",
+ "Could not reload the trust or crl store.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
}
else if (FileSystem::exists(storePath))
{
- X509_LOOKUP* storeLookup = X509_STORE_add_lookup(newStore,
- X509_LOOKUP_file());
+ X509_LOOKUP* storeLookup = X509_STORE_add_lookup(
+ newStore, X509_LOOKUP_file());
if (storeLookup == NULL)
{
X509_STORE_free(newStore);
"Could not reload the trust or crl store.");
MessageLoaderParms parms(
- "Pegasus.Common.SSLContextManager.COULD_NOT_RELOAD_TRUST_OR_CRL_STORE",
- "Could not reload the trust or crl store.");
+ "Pegasus.Common.SSLContextManager."
+ "COULD_NOT_RELOAD_TRUST_OR_CRL_STORE",
+ "Could not reload the trust or crl store.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
else
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
- "Could not reload the trust or crl store, configured store not found.");
+ "Could not reload the trust or crl store, configured store "
+ "not found.");
MessageLoaderParms parms(
- "Pegasus.Common.SSLContextManager.CONFIGURED_TRUST_OR_CRL_STORE_NOT_FOUND",
- "Could not reload the trust or crl store, configured store not found.");
+ "Pegasus.Common.SSLContextManager."
+ "CONFIGURED_TRUST_OR_CRL_STORE_NOT_FOUND",
+ "Could not reload the trust or crl store, configured store "
+ "not found.");
PEG_METHOD_EXIT();
throw SSLException(parms);
}
void SSLContextManager::reloadCRLStore() { }
-X509_STORE* SSLContextManager::_getNewX509Store(const String& storePath) { return NULL; }
+X509_STORE* SSLContextManager::_getNewX509Store(
+ const String& storePath)
+{
+ return NULL;
+}
#endif //#ifdef PEGASUS_HAS_SSL
PEGASUS_NAMESPACE_BEGIN
-/**
- This class provides the functionality necessary to manage SSLContext objects.
+/**
+ This class provides the functionality necessary to manage SSLContext
+ objects.
*/
class PEGASUS_COMMON_LINKAGE SSLContextManager
{
~SSLContextManager();
void createSSLContext(
- const String& trustStore,
+ const String& trustStore,
const String& certPath,
- const String& keyPath,
- const String& crlStore,
- Boolean callback,
+ const String& keyPath,
+ const String& crlStore,
+ Boolean callback,
const String& randFile);
/**
- Reload the trust store used by either the CIM Server or
+ Reload the trust store used by either the CIM Server or
Indication Server based on the context type.
*/
void reloadTrustStore();
/**
A lock to control access to the _sslContext object.
- Before read accessing the _sslContext object, one must first
- lock this for read access. Before write accessing the _sslContext
+ Before read accessing the _sslContext object, one must first
+ lock this for read access. Before write accessing the _sslContext
object, one must first lock this for write access.
*/
ReadWriteSem _sslContextObjectLock;
- SSLContext* _sslContext;
+ SSLContext* _sslContext;
};
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Nag Boranna, Hewlett-Packard Company ( nagaraja_boranna@hp.com )
-//
-// Modified By: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-// Heather Sterling, IBM (hsterl@us.ibm.com)
-// Aruran, IBM (ashanmug@in.ibm.com) for Bug#4422
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifdef PEGASUS_HAS_SSL
-#define OPENSSL_NO_KRB5 1
+#define OPENSSL_NO_KRB5 1
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/rand.h>
class SSLContextRep
{
/*
- SSL locking callback function. It is needed to perform locking on
+ SSL locking callback function. It is needed to perform locking on
shared data structures.
This function needs access to variable ssl_locks.
String getKeyPath() const;
#ifdef PEGASUS_USE_DEPRECATED_INTERFACES
- String getTrustStoreUserName() const;
+ String getTrustStoreUserName() const;
#endif
String getCRLPath() const;
Boolean _verifyPrivateKey(SSL_CTX *ctx, const String& keyPath);
/*
- Initialize the SSL locking environment.
-
+ Initialize the SSL locking environment.
+
This function sets the locking callback functions.
*/
static void init_ssl();
#include <Pegasus/Common/IPCExceptions.h>
#include "Semaphore.h"
-PEGASUS_NAMESPACE_BEGIN
+PEGASUS_NAMESPACE_BEGIN
static const Uint32 PEGASUS_SEM_VALUE_MAX = 0x0000ffff;
// return the count of the semaphore
int Semaphore::count() const
{
- return (_count);
+ return _count;
}
#endif /* PEGASUS_USE_WINDOWS_SEMAPHORE */
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Semaphore_h
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Sharable.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// David Eger (dteger@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Sharable_h
PEGASUS_NAMESPACE_BEGIN
-/**
- The Sharable class implements a simple reference counting scheme.
- The static Inc() method increments the reference count member.
+/**
+ The Sharable class implements a simple reference counting scheme.
+ The static Inc() method increments the reference count member.
The static Dec() method decrements the reference count and deletes
the object when the reference count becomes zero.
virtual ~Sharable();
- friend void Inc(Sharable* sharable);
+ friend void Inc(Sharable* sharable);
friend void Dec(Sharable* sharable);
{
if (x)
{
- // A sharable object should never be incremented from zero.
- PEGASUS_DEBUG_ASSERT(x->_ref.get());
- x->_ref++;
+ // A sharable object should never be incremented from zero.
+ PEGASUS_DEBUG_ASSERT(x->_ref.get());
+ x->_ref++;
}
}
//
//==============================================================================
//
-// Author: Markus Mueller (markus_mueller@de.ibm.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090
-// David Dillard, VERITAS Software Corp (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <cstdio>
SignalHandler::SignalHandler()
{
- for(unsigned i=0;i <= PEGASUS_NSIG;i++)
+ for (unsigned i = 0; i <= PEGASUS_NSIG; i++)
{
register_handler &rh = reg_handler[i];
rh.signum = i;
}
}
-SignalHandler::register_handler&
+SignalHandler::register_handler&
SignalHandler::getHandler(unsigned signum)
{
verifySignum(signum);
- return(reg_handler[signum]);
+ return reg_handler[signum];
}
void SignalHandler::registerHandler(unsigned signum, signal_handler _sighandler)
verifySignum(signum);
-#if !defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM) && !defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
+#if !defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM) && \
+ !defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
sigignore(signum);
#else
struct sigaction sig_acts;
//
//==============================================================================
//
-// Author: Markus Mueller (markus_mueller@de.ibm.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// : Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Signal_h
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2513
-// David Dillard, Symantec Corp., (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Socket.h"
#endif
}
-Sint32 Socket::timedWrite(SocketHandle socket,
- const void* ptr,
- Uint32 size,
- Uint32 socketWriteTimeout)
+Sint32 Socket::timedWrite(
+ SocketHandle socket,
+ const void* ptr,
+ Uint32 size,
+ Uint32 socketWriteTimeout)
{
Sint32 bytesWritten = 0;
Sint32 totalBytesWritten = 0;
PEGASUS_RETRY_SYSTEM_CALL(
::write(socket, (char*)ptr, size), bytesWritten);
#endif
- // Some data written this cycle ?
+ // Some data written this cycle ?
// Add it to the total amount of written data.
if (bytesWritten > 0)
{
if (bytesWritten == PEGASUS_SOCKET_ERROR)
{
// if we already waited for the socket to get ready, bail out
- if( socketTimedOut ) return bytesWritten;
+ if (socketTimedOut) return bytesWritten;
#ifdef PEGASUS_OS_TYPE_WINDOWS
if (WSAGetLastError() == WSAEWOULDBLOCK)
#else
FD_SET(socket, &fdwrite);
selreturn = select(FD_SETSIZE, NULL, &fdwrite, NULL, &tv);
if (selreturn == 0) socketTimedOut = true; // ran out of time
- continue;
+ continue;
}
return bytesWritten;
}
if (socket != -1)
{
#ifdef PEGASUS_OS_TYPE_WINDOWS
- if(!closesocket(socket))
- socket = -1;
+ if (!closesocket(socket))
+ socket = -1;
#else
- int status;
- PEGASUS_RETRY_SYSTEM_CALL(::close(socket), status);
+ int status;
+ PEGASUS_RETRY_SYSTEM_CALL(::close(socket), status);
- if (status == 0)
- socket = -1;
+ if (status == 0)
+ socket = -1;
#endif
}
}
{
WSADATA tmp;
- if (WSAStartup(0x202, &tmp) == SOCKET_ERROR)
- WSACleanup();
+ if (WSAStartup(0x202, &tmp) == SOCKET_ERROR)
+ WSACleanup();
}
_socketInterfaceRefCount++;
{
// This function disables "Nagle's Algorithm" also known as "the TCP delay
// algorithm", which causes read operations to obtain whatever data is
- // already in the input queue and then wait a little longer to see if
- // more data arrives. This algorithm optimizes the case in which data is
- // sent in only one direction but severely impairs performance of round
- // trip servers. Disabling TCP delay is a standard technique for round
+ // already in the input queue and then wait a little longer to see if
+ // more data arrives. This algorithm optimizes the case in which data is
+ // sent in only one direction but severely impairs performance of round
+ // trip servers. Disabling TCP delay is a standard technique for round
// trip servers.
int opt = 1;
{
#ifdef PEGASUS_OS_ZOS
// This function enables the notification of the CIM Server that a new
- // TCPIP transport layer is active. This is needed to be aware of a
+ // TCPIP transport layer is active. This is needed to be aware of a
// restart of the transport layer. When this option is in effect,
// the accetp(), select(), and read() request will receive an errno=EIO.
// Once this happens, the socket should be closed and create a new.
-
+
int NewTcpipOn = 1;
- setibmsockopt(socket,SOL_SOCKET,SO_EioIfNewTP,(char*)&NewTcpipOn,sizeof(NewTcpipOn));
+ setibmsockopt(
+ socket,
+ SOL_SOCKET,
+ SO_EioIfNewTP,
+ (char*)&NewTcpipOn,
+ sizeof(NewTcpipOn));
#endif
}
{
SocketHandle newSocket;
- if( domain == AF_UNIX)
+ if (domain == AF_UNIX)
{
- return(socket(domain,type,protocol));
+ return socket(domain,type,protocol);
}
bool sendTcpipMsg = true;
- while(1)
+ while (1)
{
-
newSocket = socket(domain,type,protocol);
// The program should wait for transport layer to become ready.
- if(newSocket == PEGASUS_INVALID_SOCKET &&
+ if (newSocket == PEGASUS_INVALID_SOCKET &&
getSocketError() == PEGASUS_NETWORK_TCPIP_TRYAGAIN )
{
- if(sendTcpipMsg)
+ if (sendTcpipMsg)
{
- Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
- "Common.Socket.WAIT_FOR_TCPIP",
- "TCP/IP temporary unavailable.");
+ Logger::put_l(
+ Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
+ "Common.Socket.WAIT_FOR_TCPIP",
+ "TCP/IP temporary unavailable.");
sendTcpipMsg=false;
}
System::sleep(30);
continue;
- } else
+ }
+ else
{
break;
}
if (newSocket == PEGASUS_INVALID_SOCKET)
{
// return immediate
- return(PEGASUS_INVALID_SOCKET);
- } else {
-
+ return PEGASUS_INVALID_SOCKET;
+ }
+ else
+ {
// set aditional socket options
_setTCPNoDelay(newSocket);
_setInformIfNewTCPIP(newSocket);
- return(newSocket);
+ return newSocket;
}
-
}
PEGASUS_NAMESPACE_END
-
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Socket_h
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+//==============================================================================
+//
//%/////////////////////////////////////////////////////////////////////////////
+
#ifndef SocketzOS_inline_h
#define SocketzOS_inline_h
-#include <Pegasus/Common/Logger.h>
+#include <Pegasus/Common/Logger.h>
#include <sys/ioctl.h>
#include <net/rtrouteh.h>
#include <net/if.h>
MP_Socket::MP_Socket(SocketHandle socket)
- : _socket(socket), _isSecure(false),
- _userAuthenticated(false)
+ : _socket(socket), _isSecure(false),
+ _userAuthenticated(false)
{
- _username[0]=0;
+ _username[0]=0;
}
MP_Socket::MP_Socket(
SocketHandle socket,
SSLContext * sslcontext,
ReadWriteSem * sslContextObjectLock)
- : _socket(socket),
+ : _socket(socket),
_userAuthenticated(false)
{
PEG_METHOD_ENTER(TRC_SSL, "MP_Socket::MP_Socket()");
- _username[0]=0;
+ _username[0]=0;
if (sslcontext != NULL)
{
_isSecure = true;
errnoIoctl = errno;
errno2Ioctl =__errno2();
- if(rcIoctl < 0)
+ if (rcIoctl < 0)
{
switch(errnoIoctl)
- {
+ {
case(EINPROGRESS):
case(EWOULDBLOCK):
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> Accept pending (EWB).");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> Accept pending (EWB).");
return 0; // accept pending
}
case(ECONNRESET):
{
- Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
- "Pegasus.Common.SocketzOS_inline.CONNECTION_RESET_ERROR",
- "ATTLS reset the connection due to handshake failure. \
- Connection closed.");
+ Logger::put_l(
+ Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
+ "Pegasus.Common.SocketzOS_inline.CONNECTION_RESET_ERROR",
+ "ATTLS reset the connection due to handshake failure. "
+ "Connection closed.");
PEG_METHOD_EXIT();
- return -1;
+ return -1;
}
default:
{
char str_errno2[10];
sprintf(str_errno2,"%08X",errno2Ioctl);
- Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
- "Pegasus.Common.SocketzOS_inline.UNEXPECTED_ERROR",
- "An unexpected error occurs: $0 ( errno $1, reason code 0x$2 ). \
- Connection closed."
- ,strerror(errnoIoctl),errnoIoctl,str_errno2);
+ Logger::put_l(
+ Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
+ "Pegasus.Common.SocketzOS_inline.UNEXPECTED_ERROR",
+ "An unexpected error occurs: $0 ( errno $1, reason code "
+ "0x$2 ). Connection closed.",
+ strerror(errnoIoctl),
+ errnoIoctl,
+ str_errno2);
PEG_METHOD_EXIT();
return -1;
-
}
} // end switch(errnoIoctl)
- } // -1 ioctl()
+ } // -1 ioctl()
- // this should be a secured connection so
+ // this should be a secured connection so
// check the configuration of ATTLS policy.
switch(ioc.TTLSi_Stat_Policy)
{
case(TTLS_POL_NO_POLICY):
case(TTLS_POL_NOT_ENABLED):
{
- Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
- "Pegasus.Common.SocketzOS_inline.POLICY_NOT_ENABLED",
- "ATTLS policy is not aktive for the CIM Server HTTPS port. \
- Communication not secured. Connection closed.");
+ Logger::put_l(
+ Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
+ "Pegasus.Common.SocketzOS_inline.POLICY_NOT_ENABLED",
+ "ATTLS policy is not aktive for the CIM Server HTTPS port. "
+ "Communication not secured. Connection closed.");
PEG_METHOD_EXIT();
return -1;
}
case(TTLS_POL_ENABLED):
{
- break; // a policy exists so it is ensured that a secured connectio will be established
+ // a policy exists so it is ensured that a secured connection will
+ // be established
+ break;
}
case(TTLS_POL_APPLCNTRL):
{
- Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
- "Pegasus.Common.SocketzOS_inline.APPLCNTRL",
- "ATTLS policy not valid for CIM Server. \
- Set ApplicationControlled to OFF. Connection closed.");
+ Logger::put_l(
+ Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
+ "Pegasus.Common.SocketzOS_inline.APPLCNTRL",
+ "ATTLS policy not valid for CIM Server. "
+ "Set ApplicationControlled to OFF. Connection closed.");
PEG_METHOD_EXIT();
return -1;
-
}
-
+
} // end switch(ioc.TTLSi_Stat_Policy)
// check status of connection, configuration is ok for the CIM Server
{
break; // the connection is secure
}
-
+
} // end switch(ioc.TTLSi_Stat_Conn)
- //
+ //
switch(ioc.TTLSi_Sec_Type)
{
case(TTLS_SEC_UNKNOWN):
case(TTLS_SEC_CLIENT):
{
- Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
- "Pegasus.Common.SocketzOS_inline.WRONG_ROLE",
- "ATTLS policy specifies the wrong HandshakeRole for the CIM Server HTTPS port. \
- Communication not secured. Connection closed.");
+ Logger::put_l(
+ Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
+ "Pegasus.Common.SocketzOS_inline.WRONG_ROLE",
+ "ATTLS policy specifies the wrong HandshakeRole for the "
+ "CIM Server HTTPS port. Communication not secured. "
+ "Connection closed.");
PEG_METHOD_EXIT();
return -1;
case(TTLS_SEC_SRV_CA_FULL):
case(TTLS_SEC_SRV_CA_REQD):
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
- "---> ATTLS Securtiy Type is valid but no SAFCHK.");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> ATTLS Securtiy Type is valid but no SAFCHK.");
PEG_METHOD_EXIT();
return 1;
}
{
_userAuthenticated=true;
memcpy(_username,ioc.TTLSi_UserID,ioc.TTLSi_UserID_Len);
- _username[ioc.TTLSi_UserID_Len]=0; // null terminated string
- __etoa(_username); // the user name is in EBCDIC !
- PEG_TRACE((TRC_SSL, Tracer::LEVEL2,
- "---> ATTLS Securtiy Type is SAFCHK. Resolved user ID \'%s\'",_username));
+ _username[ioc.TTLSi_UserID_Len]=0; // null terminated string
+ __etoa(_username); // the user name is in EBCDIC !
+ PEG_TRACE((TRC_SSL, Tracer::LEVEL2,
+ "---> ATTLS Securtiy Type is SAFCHK. Resolved user ID \'%s\'",
+ _username));
PEG_METHOD_EXIT();
return 1;
}
} // end switch(ioc.TTLSi_Sec_Type)
// This should never be reached
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
- "---> Never reach this! New/wrong return value of ioctl().");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> Never reach this! New/wrong return value of ioctl().");
PEG_METHOD_EXIT();
return -1;
} // end ATTLS_zOS_Query
//
//==============================================================================
//
-// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
-// Modified By: David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Network.h"
//
//==============================================================================
//
-// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_SpinLock_h
PEGASUS_NAMESPACE_BEGIN
-// This type implements a spinlock. It is deliberately not a class since we
+// This type implements a spinlock. It is deliberately not a class since we
// wish to avoid automatic construction/destruction.
struct SpinLock
{
PEGASUS_NAMESPACE_BEGIN
-// This type implements a spinlock. It is deliberately not a class since we
+// This type implements a spinlock. It is deliberately not a class since we
// wish to avoid automatic construction/destruction.
struct SpinLock
{
// Loop until lock becomes zero.
do
{
- // Load and store unsigned byte (LDSTUB). Load the lock argument
- // into value and set lock to 0xFF (atomically).
- asm("ldstub %1, %0"
- : "=r" (value),
- "=m" (x.lock)
- : "m" (x.lock));
+ // Load and store unsigned byte (LDSTUB). Load the lock argument
+ // into value and set lock to 0xFF (atomically).
+ asm("ldstub %1, %0"
+ : "=r" (value),
+ "=m" (x.lock)
+ : "m" (x.lock));
}
while (value);
}
PEGASUS_NAMESPACE_BEGIN
-// This type implements a spinlock. It is deliberately not a class since we
+// This type implements a spinlock. It is deliberately not a class since we
// wish to avoid automatic construction/destruction.
struct SpinLock
{
union
{
- char mutex[sizeof(Mutex)];
- Uint64 alignment8;
+ char mutex[sizeof(Mutex)];
+ Uint64 alignment8;
};
};
PEGASUS_NAMESPACE_BEGIN
-// This array defines spin locks shared across the system. These are
+// This array defines spin locks shared across the system. These are
// initialized by calling SpinLockCreatePool().
extern SpinLock spinLockPool[PEGASUS_NUM_SHARED_SPIN_LOCKS];
void SpinLockCreatePool();
// Maps an address into the spinLockPool[] array defined above. This is used
-// to assign objects (by their addresses) to a shared lock. Collisions are
+// to assign objects (by their addresses) to a shared lock. Collisions are
// okay.
inline size_t SpinLockIndex(const void* x)
{
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Stack.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Stack_h
Stack(const Stack<T>& x) : _rep(x._rep) { }
/** This constructor was added to provide a fast way of creating a stack
- with a single element on it. This constructor is necessary to realize
- the return-value compiler optimization which permits objects used in
- return/constructor expressions to be initialized only once.
+ with a single element on it. This constructor is necessary to realize
+ the return-value compiler optimization which permits objects used in
+ return/constructor expressions to be initialized only once.
- Notice that this constructor is explicit to avoid implicit
- initialization of a stack with the type of T.
- which
+ Notice that this constructor is explicit to avoid implicit
+ initialization of a stack with the type of T.
+ which
*/
PEGASUS_EXPLICIT Stack(const T& x) { _rep.append(x); }
void push(const T& x) { _rep.append(x); }
/** Returns reference to the top element on the stack.
- @return reference to top element on stack.
- @exception throws StackUnderflow if stack is empty.
+ @return reference to top element on stack.
+ @exception throws StackUnderflow if stack is empty.
*/
T& top();
/** Const version of indxing operator. */
const T& operator[](Uint32 i) const { return _rep[i]; }
-
+
void reserveCapacity(Uint32 capacity) { _rep.reserveCapacity(capacity); }
private:
T& Stack<T>::top()
{
if (isEmpty())
- throw StackUnderflow();
+ throw StackUnderflow();
return _rep[_rep.size() - 1];
}
void Stack<T>::pop()
{
if (isEmpty())
- throw StackUnderflow();
+ throw StackUnderflow();
_rep.remove(_rep.size() - 1);
}
//
//==============================================================================
//
-// Author: Arthur Pichlkostner
-// (checked in: Markus Mueller sedgewick_de@yahoo.de)
-// Modified By: Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "StatisticalData.h"
// The table on the right represents the mapping from the enumerated types
-// in the CIM_CIMOMStatisticalDate class ValueMap versus the internal
-// message type defined in Message.h. This conversion is performed by
+// in the CIM_CIMOMStatisticalDate class ValueMap versus the internal
+// message type defined in Message.h. This conversion is performed by
// getOpType() in CIMOMStatDataProvider.cpp.
//
-String StatisticalData::requestName[] =
+String StatisticalData::requestName[] =
{
- // Enumerated ValueMap Value
+ // Enumerated ValueMap Value
// value from from class
// internal CIM_StatisticalData
// message type
// -------------- -------------------
- "GetClass", // 1 3
- "GetInstance", // 2 4
- "IndicationDelivery", // 3 26
- "DeleteClass", // 4 5
- "DeleteInstance", // 5 6
- "CreateClass", // 6 7
+ "GetClass", // 1 3
+ "GetInstance", // 2 4
+ "IndicationDelivery", // 3 26
+ "DeleteClass", // 4 5
+ "DeleteInstance", // 5 6
+ "CreateClass", // 6 7
"CreateInstance", // 7 8
"ModifyClass", // 8 9
- "ModifyInstance", // 9 10
- "EnumerateClasses", // 10 11
- "EnumerateClassNames", // 11 12
- "EnumerateInstances", // 12 13
- "EnumerateInstanceNames", // 13 14
- "ExecQuery", // 14 15
- "Associators", // 15 16
- "AssociatorNames", // 16 17
- "References", // 17 18
- "ReferenceNames", // 18 19
- "GetProperty", // 19 20
- "SetProperty", // 20 21
- "GetQualifier", // 21 22
- "SetQualifier", // 22 23
- "DeleteQualifier", // 23 24
- "EnumerateQualifiers", // 24 25
+ "ModifyInstance", // 9 10
+ "EnumerateClasses", // 10 11
+ "EnumerateClassNames", // 11 12
+ "EnumerateInstances", // 12 13
+ "EnumerateInstanceNames", // 13 14
+ "ExecQuery", // 14 15
+ "Associators", // 15 16
+ "AssociatorNames", // 16 17
+ "References", // 17 18
+ "ReferenceNames", // 18 19
+ "GetProperty", // 19 20
+ "SetProperty", // 20 21
+ "GetQualifier", // 21 22
+ "SetQualifier", // 22 23
+ "DeleteQualifier", // 23 24
+ "EnumerateQualifiers", // 24 25
"InvokeMethod" // 25 Not Present
};
for (unsigned int i=0; i<StatisticalData::length; i++)
{
numCalls[i] = 0;
- cimomTime[i] = 0;
+ cimomTime[i] = 0;
providerTime[i] = 0;
responseSize[i] = 0;
requestSize[i] = 0;
void StatisticalData::setCopyGSD(Boolean flag)
{
-
- copyGSD = flag;
+ copyGSD = flag;
}
PEGASUS_NAMESPACE_END
response->endServer();\
#define STAT_BYTESSENT \
-Uint16 statType = (response->getType() >= CIM_GET_CLASS_RESPONSE_MESSAGE)? \
- response->getType() - CIM_GET_CLASS_RESPONSE_MESSAGE:response->getType() - 1;\
-StatisticalData::current()->addToValue(message.size(), statType, StatisticalData::PEGASUS_STATDATA_BYTES_SENT);
-
+Uint16 statType = (response->getType() >= CIM_GET_CLASS_RESPONSE_MESSAGE) ? \
+ response->getType() - CIM_GET_CLASS_RESPONSE_MESSAGE : \
+ response->getType() - 1; \
+StatisticalData::current()->addToValue( \
+ message.size(), statType, StatisticalData::PEGASUS_STATDATA_BYTES_SENT);
#define STAT_SERVEREND_ERROR \
response->endServer();
-/*the request size value must be stored (requSize) and passed to the StatisticalData object at the
- end of processing other wise it will be the ONLY vlaue that is passed to the client which reports
- the current state of the object, not the pevious (one command ago) state */
+/*
+ The request size value must be stored (requSize) and passed to the
+ StatisticalData object at the end of processing other wise it will be
+ the ONLY vlaue that is passed to the client which reports the current
+ state of the object, not the pevious (one command ago) state
+*/
#define STAT_BYTESREAD \
-Uint16 statType = (request->getType() >= CIM_GET_CLASS_RESPONSE_MESSAGE)? \
- request->getType() - CIM_GET_CLASS_RESPONSE_MESSAGE: request->getType()-1;\
-StatisticalData::current()->requSize = contentLength;
+Uint16 statType = (request->getType() >= CIM_GET_CLASS_RESPONSE_MESSAGE) ? \
+ request->getType() - CIM_GET_CLASS_RESPONSE_MESSAGE : \
+ request->getType() - 1; \
+StatisticalData::current()->requSize = contentLength;
#else
#define STAT_GETSTARTTIME
class PEGASUS_COMMON_LINKAGE StatisticalData
{
- public:
- enum StatRequestType{
- GET_CLASS,
- GET_INSTANCE,
- INDICATION_DELIVERY,
- DELETE_CLASS,
- DELETE_INSTANCE,
- CREATE_CLASS,
- CREATE_INSTANCE,
- MODIFY_CLASS,
- MODIFY_INSTANCE,
- ENUMERATE_CLASSES,
- ENUMERATE_CLASS_NAMES,
- ENUMERATE_INSTANCES,
- ENUMERATE_INSTANCE_NAMES,
- EXEC_QUERY,
- ASSOCIATORS,
- ASSOCIATOR_NAMES,
- REFERENCES,
- REFERENCE_NAMES,
- GET_PROPERTY,
- SET_PROPERTY,
- GET_QUALIFIER,
- SET_QUALIFIER,
- DELETE_QUALIFIER,
- ENUMERATE_QUALIFIERS,
- INVOKE_METHOD,
- NUMBER_OF_TYPES
- };
-
- enum StatDataType{
- PEGASUS_STATDATA_SERVER,
- PEGASUS_STATDATA_PROVIDER,
- PEGASUS_STATDATA_BYTES_SENT,
- PEGASUS_STATDATA_BYTES_READ
- };
-
- static const Uint32 length;
- static StatisticalData* current();
-
- StatisticalData();
-
- timeval timestamp;
-
- Sint64 numCalls[NUMBER_OF_TYPES];
- Sint64 cimomTime[NUMBER_OF_TYPES];
- Sint64 providerTime[NUMBER_OF_TYPES];
- Sint64 responseSize[NUMBER_OF_TYPES];
- Sint64 requestSize[NUMBER_OF_TYPES];
- Sint64 requSize; //tempory storage for requestSize vlaue
- Boolean copyGSD;
-// Uint64 totalServTime;
- static StatisticalData* cur;
- void addToValue(Sint64 value, Uint16 type, Uint32 t);
- static String requestName[];
- void setCopyGSD(Boolean flag);
-
- protected:
- Mutex _mutex;
+public:
+ enum StatRequestType
+ {
+ GET_CLASS,
+ GET_INSTANCE,
+ INDICATION_DELIVERY,
+ DELETE_CLASS,
+ DELETE_INSTANCE,
+ CREATE_CLASS,
+ CREATE_INSTANCE,
+ MODIFY_CLASS,
+ MODIFY_INSTANCE,
+ ENUMERATE_CLASSES,
+ ENUMERATE_CLASS_NAMES,
+ ENUMERATE_INSTANCES,
+ ENUMERATE_INSTANCE_NAMES,
+ EXEC_QUERY,
+ ASSOCIATORS,
+ ASSOCIATOR_NAMES,
+ REFERENCES,
+ REFERENCE_NAMES,
+ GET_PROPERTY,
+ SET_PROPERTY,
+ GET_QUALIFIER,
+ SET_QUALIFIER,
+ DELETE_QUALIFIER,
+ ENUMERATE_QUALIFIERS,
+ INVOKE_METHOD,
+ NUMBER_OF_TYPES
+ };
+
+ enum StatDataType
+ {
+ PEGASUS_STATDATA_SERVER,
+ PEGASUS_STATDATA_PROVIDER,
+ PEGASUS_STATDATA_BYTES_SENT,
+ PEGASUS_STATDATA_BYTES_READ
+ };
+
+ static const Uint32 length;
+ static StatisticalData* current();
+
+ StatisticalData();
+
+ timeval timestamp;
+
+ Sint64 numCalls[NUMBER_OF_TYPES];
+ Sint64 cimomTime[NUMBER_OF_TYPES];
+ Sint64 providerTime[NUMBER_OF_TYPES];
+ Sint64 responseSize[NUMBER_OF_TYPES];
+ Sint64 requestSize[NUMBER_OF_TYPES];
+ Sint64 requSize; //tempory storage for requestSize vlaue
+ Boolean copyGSD;
+ static StatisticalData* cur;
+ void addToValue(Sint64 value, Uint16 type, Uint32 t);
+ static String requestName[];
+ void setCopyGSD(Boolean flag);
+
+protected:
+ Mutex _mutex;
};
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-// Chip Vincent (cvincent@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Stopwatch.h"
PEGASUS_NAMESPACE_BEGIN
-Stopwatch::Stopwatch(void) : _start(0), _stop(0), _total(0)
+Stopwatch::Stopwatch() : _start(0), _stop(0), _total(0)
{
}
-void Stopwatch::start(void)
+void Stopwatch::start()
{
_start = TimeValue::getCurrentTime().toMicroseconds();
}
-void Stopwatch::stop(void)
+void Stopwatch::stop()
{
_stop = TimeValue::getCurrentTime().toMicroseconds();
_total += _stop - _start;
}
-void Stopwatch::reset(void)
+void Stopwatch::reset()
{
_start = 0;
_stop = 0;
_total = 0;
}
-double Stopwatch::getElapsed(void) const
+double Stopwatch::getElapsed() const
{
Sint64 tmp = (Sint64)_total;
- return((double)tmp / (double)1000000.0);
+ return (double)tmp / (double)1000000.0;
}
-Uint64 Stopwatch::getElapsedUsec(void) const
+Uint64 Stopwatch::getElapsedUsec() const
{
return _total;
}
-void Stopwatch::printElapsed(void)
+void Stopwatch::printElapsed()
{
PEGASUS_STD(cout) << getElapsed() << " seconds" << PEGASUS_STD(endl);
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-// Chip Vincent (cvincent@us.ibm.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Stopwatch_h
must be called to start the timer.
@example Stopwatch time;
*/
- Stopwatch(void);
+ Stopwatch();
/** start - Starts accumulating time and continues until stop is called.
The object can be started and stopped multiple times to measure the
sum of several intervals, but each start must have a corresponding start.
*/
- void start(void);
+ void start();
/** stop - Stops the accumlation of time for an interval. The object
should only stopped if it has been started.
*/
- void stop(void);
+ void stop();
/** reset - Effectively clears the time values stored by a Stopwatch.
*/
- void reset(void);
+ void reset();
/** getElapsed - Get the elapsed time for the defined stopwatch. This
method should only be called if it is currently stopped.
@return Returns the elapsed time value as a double (in milliseconds).
*/
- double getElapsed(void) const;
+ double getElapsed() const;
/** Get number of elapsed microseconds
*/
- Uint64 getElapsedUsec(void) const;
+ Uint64 getElapsedUsec() const;
/** printElapsed method gets the current value of the timer and
sends it to standard out as a string with the word seconds attached
*/
- void printElapsed(void);
+ void printElapsed();
private:
Uint64 _start;
//
//==============================================================================
//
-// Author: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_StrLit_h
/* The StrLit class and associated macros provide a mechanism for retaining the
length C string literals at compile time. This is preferrable to repeated
recalculation of the length, usually with strlen(). For example, this:
-
- String s("hello world");
+
+ String s("hello world");
Is less efficient than this:
- String s("hello world", 11);
+ String s("hello world", 11);
The first form, forces the String constructor to call strlen(), an O(N)
- operation. This is unfortunate for C string literals since the length can
+ operation. This is unfortunate for C string literals since the length can
be obtained at compile time with the sizeof operator. For example:
- String s("hello world", sizeof("hello world") - 1);
+ String s("hello world", sizeof("hello world") - 1);
But repeating the literal twice is error prone, so instead we use the
STRLIT_ARGS() macro.
- String s(STRLIT_ARGS("hello world"));
+ String s(STRLIT_ARGS("hello world"));
This macro can also be used to define StrLit objects at compile time.
For example:
- const StrLit DEFAULT_HOSTNAME(STRLIT_ARGS("localhost"));
+ const StrLit DEFAULT_HOSTNAME(STRLIT_ARGS("localhost"));
- You can implement functions that take StrLit objects. For example, we
+ You can implement functions that take StrLit objects. For example, we
define this function:
- operator<<(const Buffer&, const StrLit&);
+ operator<<(const Buffer&, const StrLit&);
This function can be used in two ways. You can pass predefined StrLit
object to it like this:
- Buffer out;
- out << DEFAULT_HOSTNAME;
+ Buffer out;
+ out << DEFAULT_HOSTNAME;
Or you can use the STRLIT() macro to construct on on the fly:
- Buffer out;
- out << STRLIT("localhost");
+ Buffer out;
+ out << STRLIT("localhost");
Note that the latter form would be faster than this, since somebody
is going to have to call strlen() eventually.
- Buffer out;
- out << "localhost";
+ Buffer out;
+ out << "localhost";
- At first glance, this may seem like a small optimization, but this
- technique alone was used to decrease the Pegasus CIM server latency
- by ten percent (with only moderate application to the XML marshalling
+ At first glance, this may seem like a small optimization, but this
+ technique alone was used to decrease the Pegasus CIM server latency
+ by ten percent (with only moderate application to the XML marshalling
routines).
*/
struct StrLit
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@austin.rr.com)
-//
-// Modified By:
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3297
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-// Mike Brasher (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/PegasusAssert.h>
(+) DOC++ String.h - will open new bug?
(+) Added PEGASUS_DISABLE_INTERNAL_INLINES macro (to permit suppression
- on certain platforms).
+ on certain platforms).
================================================================================
*/
callers stack as a temporary object. The deletion is therefore
also the responsibility of the Compiler. The Compiler may cause
it to be deleted at anytime after the return. Typically it is
- done at the closeof the next scope. When it is deleted the
- "const char *p" above will become a dangling pointer.
+ done at the closeof the next scope. When it is deleted the
+ "const char *p" above will become a dangling pointer.
- The correct usage to achieve the "const char * p" is
+ The correct usage to achieve the "const char * p" is
as follows:
String str = "hello";
PEGASUS_STRING_INLINE String::String()
{
- // Note: ref() and unref() never touch the reference count of _emptyRep.
+ // Note: ref() and unref() never touch the reference count of _emptyRep.
// This allows use to optimize the copy constructor by not incrementing
// _emptyRep.refs here. Performance is critical in this function. Please
// do not add any code to this function.
PEGASUS_STRING_INLINE String::String(const String& str)
{
#ifdef PEGASUS_HAVE_BROKEN_GLOBAL_CONSTRUCTION
- //
+ //
// Some compilers don't do a good job of initializing global
// constructors in the proper sequence. This is one such case.
// String::EMPTY is not initialized by the time this is first
// called during initialization of the executable.
- //
+ //
if (!str._rep)
{
_rep = &StringRep::_emptyRep;
}
#endif
StringRep::ref(_rep = str._rep);
-}
+}
PEGASUS_STRING_INLINE String::~String()
{
StringRep::unref(_rep);
}
-PEGASUS_STRING_INLINE Uint32 String::size() const
-{
- return _rep->size;
+PEGASUS_STRING_INLINE Uint32 String::size() const
+{
+ return _rep->size;
}
-PEGASUS_STRING_INLINE const Char16* String::getChar16Data() const
-{
- return (Char16*)&(_rep->data[0]);
+PEGASUS_STRING_INLINE const Char16* String::getChar16Data() const
+{
+ return (Char16*)&(_rep->data[0]);
}
-PEGASUS_STRING_INLINE Char16& String::operator[](Uint32 i)
+PEGASUS_STRING_INLINE Char16& String::operator[](Uint32 i)
{
_checkBounds(i, _rep->size);
if (_rep->refs.get() != 1)
_rep = StringRep::copyOnWrite(_rep);
- return (Char16&)_rep->data[i];
+ return (Char16&)_rep->data[i];
}
-PEGASUS_STRING_INLINE const Char16 String::operator[](Uint32 i) const
+PEGASUS_STRING_INLINE const Char16 String::operator[](Uint32 i) const
{
_checkBounds(i, _rep->size);
- return (Char16&)_rep->data[i];
+ return (Char16&)_rep->data[i];
}
PEGASUS_STRING_INLINE String& String::operator=(const String& str)
inline void StringRep::unref(const StringRep* rep)
{
- if (rep != &StringRep::_emptyRep &&
- ((StringRep*)rep)->refs.decAndTestIfZero())
+ if (rep != &StringRep::_emptyRep &&
+ ((StringRep*)rep)->refs.decAndTestIfZero())
StringRep::free((StringRep*)rep);
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Rudy Schuet (rudy.schuet@compaq.com) 11/12/01
-// added nsk platform support
-// Ramnath Ravindran (Ramnath.Ravindran@compaq.com) 03/21/2002
-// replaced instances of "| ios::binary" with
-// PEGASUS_OR_IOS_BINARY
-// Robert Kieninger, IBM (kieningr@de.ibm.com) for Bug#667
-// Dave Sudlik, IBM (dsudlik@us.ibm.com) for Bug#1462
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
#include <Pegasus/Common/Config.h>
#endif
-
#include <fstream>
#include <cctype> // for tolower()
#include <cstring>
while (is.get(c))
{
- if (!os.put(c))
- return false;
+ if (!os.put(c))
+ return false;
}
return is.eof();
}
-static const Uint8 _toLowerTable[256] =
+static const Uint8 _toLowerTable[256] =
{
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
for (;;)
{
- if ((r = _toLowerTable[p[0]] - _toLowerTable[q[0]]) || !p[0] ||
- (r = _toLowerTable[p[1]] - _toLowerTable[q[1]]) || !p[1] ||
- (r = _toLowerTable[p[2]] - _toLowerTable[q[2]]) || !p[2] ||
- (r = _toLowerTable[p[3]] - _toLowerTable[q[3]]) || !p[3])
- break;
-
- p += 4;
- q += 4;
+ if ((r = _toLowerTable[p[0]] - _toLowerTable[q[0]]) || !p[0] ||
+ (r = _toLowerTable[p[1]] - _toLowerTable[q[1]]) || !p[1] ||
+ (r = _toLowerTable[p[2]] - _toLowerTable[q[2]]) || !p[2] ||
+ (r = _toLowerTable[p[3]] - _toLowerTable[q[3]]) || !p[3])
+ break;
+
+ p += 4;
+ q += 4;
}
return r;
// Return the just the file name from the path into basename
char *System::extract_file_name(const char *fullpath, char *basename)
{
- if (fullpath == NULL)
- {
- basename[0] = '\0';
- return basename;
- }
-
- for (const char* p = fullpath + strlen(fullpath) - 1; p >= fullpath; p--)
- {
- if (*p == '\\' || *p == '/')
- {
- strcpy(basename, p+1);
- return basename;
- }
- }
-
- strcpy(basename, fullpath);
- return basename;
+ if (fullpath == NULL)
+ {
+ basename[0] = '\0';
+ return basename;
+ }
+
+ for (const char* p = fullpath + strlen(fullpath) - 1; p >= fullpath; p--)
+ {
+ if (*p == '\\' || *p == '/')
+ {
+ strcpy(basename, p+1);
+ return basename;
+ }
+ }
+
+ strcpy(basename, fullpath);
+ return basename;
}
// Return the just the path to the file name into dirname
char *System::extract_file_path(const char *fullpath, char *dirname)
{
- char *p;
- char buff[4096];
- if (fullpath == NULL)
+ char *p;
+ char buff[4096];
+ if (fullpath == NULL)
{
- dirname[0] = '\0';
- return dirname;
+ dirname[0] = '\0';
+ return dirname;
}
- strncpy(buff, fullpath, sizeof(buff)-1);
- buff[sizeof(buff)-1] = '\0';
- for(p = buff + strlen(buff); p >= buff; p--)
+ strncpy(buff, fullpath, sizeof(buff)-1);
+ buff[sizeof(buff)-1] = '\0';
+ for (p = buff + strlen(buff); p >= buff; p--)
{
- if (*p == '\\' || *p == '/')
+ if (*p == '\\' || *p == '/')
{
strncpy(dirname, buff, p+1 - buff);
dirname[p+1 - buff] = '\0';
return dirname;
}
}
- strcpy(dirname, fullpath);
- return dirname;
+ strcpy(dirname, fullpath);
+ return dirname;
}
String System::getHostIP(const String &hostName)
#if defined(PEGASUS_OS_OS400)
char * gottenIPAdress = NULL;
gottenIPAdress = ::inet_ntoa( inaddr );
-
+
if (gottenIPAdress != NULL)
{
- EtoA(gottenIPAdress);
+ EtoA(gottenIPAdress);
ipAddress.assign(gottenIPAdress);
}
#else
// ------------------------------------------------------------------------
Uint32 System::_acquireIP(const char* hostname)
{
- Uint32 ip = 0xFFFFFFFF;
- if (!hostname) return 0xFFFFFFFF;
+ Uint32 ip = 0xFFFFFFFF;
+ if (!hostname) return 0xFFFFFFFF;
#ifdef PEGASUS_OS_OS400
- char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];
- if (strlen(hostname) < PEGASUS_MAXHOSTNAMELEN)
- strcpy(ebcdicHost, hostname);
- else
- return 0xFFFFFFFF;
- AtoE(ebcdicHost);
+ char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];
+ if (strlen(hostname) < PEGASUS_MAXHOSTNAMELEN)
+ strcpy(ebcdicHost, hostname);
+ else
+ return 0xFFFFFFFF;
+ AtoE(ebcdicHost);
#endif
////////////////////////////////////////////////////////////////////////////////
// This code used to check if the first character of "hostname" was alphabetic
-// to indicate hostname instead of IP address. But RFC 1123, section 2.1, relaxed
-// this requirement to alphabetic character *or* digit. So bug 1462 changed the
-// flow here to call inet_addr first to check for a valid IP address in dotted
-// decimal notation. If it's not a valid IP address, then try to validate
-// it as a hostname.
-// RFC 1123 states: The host SHOULD check the string syntactically for a
-// dotted-decimal number before looking it up in the Domain Name System.
+// to indicate hostname instead of IP address. But RFC 1123, section 2.1,
+// relaxed this requirement to alphabetic character *or* digit. So bug 1462
+// changed the flow here to call inet_addr first to check for a valid IP
+// address in dotted decimal notation. If it's not a valid IP address, then
+// try to validate it as a hostname.
+// RFC 1123 states: The host SHOULD check the string syntactically for a
+// dotted-decimal number before looking it up in the Domain Name System.
// Hence the call to inet_addr() first.
////////////////////////////////////////////////////////////////////////////////
#ifdef PEGASUS_OS_OS400
- Uint32 tmp_addr = inet_addr(ebcdicHost);
+ Uint32 tmp_addr = inet_addr(ebcdicHost);
#else
- Uint32 tmp_addr = inet_addr((char *) hostname);
+ Uint32 tmp_addr = inet_addr((char *) hostname);
#endif
struct hostent* hostEntry;
gethostname( hostName, PEGASUS_MAXHOSTNAMELEN );
hostName[sizeof(hostName)-1] = 0;
hostEntry = gethostbyname(hostName);
- } else
+ }
+ else
{
hostEntry = gethostbyname((char *)hostname);
}
hostEntry = gethostbyname((char *)hostname);
#endif
if (!hostEntry)
- {
- return 0xFFFFFFFF;
- }
- unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
-
- ip_part1 = hostEntry->h_addr[0];
- ip_part2 = hostEntry->h_addr[1];
- ip_part3 = hostEntry->h_addr[2];
- ip_part4 = hostEntry->h_addr[3];
- ip = ip_part1;
- ip = (ip << 8) + ip_part2;
- ip = (ip << 8) + ip_part3;
- ip = (ip << 8) + ip_part4;
- }
+ {
+ return 0xFFFFFFFF;
+ }
+ unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
+
+ ip_part1 = hostEntry->h_addr[0];
+ ip_part2 = hostEntry->h_addr[1];
+ ip_part3 = hostEntry->h_addr[2];
+ ip_part4 = hostEntry->h_addr[3];
+ ip = ip_part1;
+ ip = (ip << 8) + ip_part2;
+ ip = (ip << 8) + ip_part3;
+ ip = (ip << 8) + ip_part4;
+ }
else // else hostname *is* a dotted-decimal IP address
- {
- // resolve hostaddr to a real host entry
- // casting to (const char *) as (char *) will work as (void *) too, those it fits all platforms
+ {
+ // resolve hostaddr to a real host entry
+ // casting to (const char *) as (char *) will work as (void *) too,
+ // those it fits all platforms
#ifndef PEGASUS_OS_OS400
- hostEntry = gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
+ hostEntry =
+ gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
#else
- hostEntry = gethostbyaddr((char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
+ hostEntry =
+ gethostbyaddr((char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
#endif
- if (hostEntry == 0)
- {
- // error, couldn't resolve the ip
- return 0xFFFFFFFF;
- } else
- {
-
- unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
-
- ip_part1 = hostEntry->h_addr[0];
- ip_part2 = hostEntry->h_addr[1];
- ip_part3 = hostEntry->h_addr[2];
- ip_part4 = hostEntry->h_addr[3];
- ip = ip_part1;
- ip = (ip << 8) + ip_part2;
- ip = (ip << 8) + ip_part3;
- ip = (ip << 8) + ip_part4;
- }
- }
-
- return ip;
+ if (hostEntry == 0)
+ {
+ // error, couldn't resolve the ip
+ return 0xFFFFFFFF;
+ }
+ else
+ {
+ unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
+
+ ip_part1 = hostEntry->h_addr[0];
+ ip_part2 = hostEntry->h_addr[1];
+ ip_part3 = hostEntry->h_addr[2];
+ ip_part4 = hostEntry->h_addr[3];
+ ip = ip_part1;
+ ip = (ip << 8) + ip_part2;
+ ip = (ip << 8) + ip_part3;
+ ip = (ip << 8) + ip_part4;
+ }
+ }
+
+ return ip;
}
Boolean System::sameHost (const String & hostName)
return true;
}
-Boolean System::resolveHostNameAtDNS(const char* hostname, Uint32 * resolvedNameIP)
+Boolean System::resolveHostNameAtDNS(
+ const char* hostname,
+ Uint32* resolvedNameIP)
{
// ask the DNS for hostname resolution to IP address
// this can mean a time delay for as long as the DNS
- // takes to answer
+ // takes to answer
struct hostent* hostEntry;
#if defined(PEGASUS_OS_LINUX)
- char hostEntryBuffer[8192];
- struct hostent hostEntryStruct;
- int hostEntryErrno;
+ char hostEntryBuffer[8192];
+ struct hostent hostEntryStruct;
+ int hostEntryErrno;
- gethostbyname_r(
- hostname,
- &hostEntryStruct,
- hostEntryBuffer,
- sizeof(hostEntryBuffer),
- &hostEntry,
- &hostEntryErrno);
+ gethostbyname_r(
+ hostname,
+ &hostEntryStruct,
+ hostEntryBuffer,
+ sizeof(hostEntryBuffer),
+ &hostEntry,
+ &hostEntryErrno);
#elif defined(PEGASUS_OS_SOLARIS)
- char hostEntryBuffer[8192];
- struct hostent hostEntryStruct;
- int hostEntryErrno;
+ char hostEntryBuffer[8192];
+ struct hostent hostEntryStruct;
+ int hostEntryErrno;
- hostEntry = gethostbyname_r(
- (char *)hostname,
- &hostEntryStruct,
- hostEntryBuffer,
- sizeof(hostEntryBuffer),
- &hostEntryErrno);
+ hostEntry = gethostbyname_r(
+ (char *)hostname,
+ &hostEntryStruct,
+ hostEntryBuffer,
+ sizeof(hostEntryBuffer),
+ &hostEntryErrno);
#else
- hostEntry = gethostbyname((char *)hostname);
+ hostEntry = gethostbyname((char *)hostname);
#endif
if (hostEntry == 0)
{
// error, couldn't resolve the hostname to an ip address
return false;
- } else
+ }
+ else
{
unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
ip_part1 = hostEntry->h_addr[0];
Boolean System::resolveIPAtDNS(Uint32 ip_addr, Uint32 * resolvedIP)
{
- struct hostent *entry;
+ struct hostent *entry;
#ifndef PEGASUS_OS_OS400
- entry = gethostbyaddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);
+ entry = gethostbyaddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);
#else
- entry = gethostbyaddr((char *) &ip_addr, sizeof(ip_addr), AF_INET);
+ entry = gethostbyaddr((char *) &ip_addr, sizeof(ip_addr), AF_INET);
#endif
- if (entry == 0)
- {
- // error, couldn't resolve the ip
- return false;
- } else
- {
- unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
- ip_part1 = entry->h_addr[0];
- ip_part2 = entry->h_addr[1];
- ip_part3 = entry->h_addr[2];
- ip_part4 = entry->h_addr[3];
- *resolvedIP = ip_part1;
- *resolvedIP = (*resolvedIP << 8) + ip_part2;
- *resolvedIP = (*resolvedIP << 8) + ip_part3;
- *resolvedIP = (*resolvedIP << 8) + ip_part4;
- }
- return true;
+ if (entry == 0)
+ {
+ // error, couldn't resolve the ip
+ return false;
+ }
+ else
+ {
+ unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
+ ip_part1 = entry->h_addr[0];
+ ip_part2 = entry->h_addr[1];
+ ip_part3 = entry->h_addr[2];
+ ip_part4 = entry->h_addr[3];
+ *resolvedIP = ip_part1;
+ *resolvedIP = (*resolvedIP << 8) + ip_part2;
+ *resolvedIP = (*resolvedIP << 8) + ip_part3;
+ *resolvedIP = (*resolvedIP << 8) + ip_part4;
+ }
+ return true;
}
// should define their platform here,
// as this is the superior way to work
#if defined(PEGASUS_OS_LINUX) || defined(PEGASUS_OS_AIX)
-
+
struct in_addr inaddr;
// if inet_aton failed(return=0),
// we do not have a valip IP address (x.x.x.x)
// A better solution would be to use inet_aton() or equivalent, as
// inet_addr() is now considered "obsolete".
// Note: inet_aton() not yet supported on all Pegasus platforms
- tmp_addr = inet_addr((char *) cc_hostname);
+ tmp_addr = inet_addr((char *) cc_hostname);
if (tmp_addr == 0xFFFFFFFF) hostNameIsIPNotation = false;
else hostNameIsIPNotation = true;
#endif
-
+
if (!hostNameIsIPNotation) // if hostname is not an IP address
- {
+ {
// localhost ?
if (String::equalNoCase(hostName,String("localhost"))) return true;
- char* localHostName = strdup( (const char *) System::getHostName ().getCString() );
+ char* localHostName =
+ strdup((const char*) System::getHostName().getCString());
// given hostname equals what system returns as local hostname ?
if (String::equalNoCase(hostName,localHostName)) return true;
Uint32 hostIP;
// need to check if the local hosts name is possibly
// registered at the DNS with the IP address equal resolvedNameIP
Uint32 localHostIP;
- if (!System::resolveHostNameAtDNS(localHostName, &localHostIP)) return false;
+ if (!System::resolveHostNameAtDNS(localHostName, &localHostIP))
+ return false;
if (localHostIP == hostIP) return true;
- } else
+ }
+ else
{ // hostname is an IP address
// 127.0.0.1 is always the loopback
// inet_addr returns network byte order
// out of luck so far, lets ask the DNS what our IP is
// and check against what we got
Uint32 localHostIP;
- if (!System::resolveHostNameAtDNS((const char *) System::getHostName().getCString(), &localHostIP)) return false;
+ if (!System::resolveHostNameAtDNS(
+ (const char*) System::getHostName().getCString(), &localHostIP))
+ return false;
if (localHostIP == tmp_addr) return true;
// not yet, sometimes resolving the IP address we got against the DNS
// can solve the problem
- // casting to (const char *) as (char *) will work as (void *) too, those it fits all platforms
+ // casting to (const char *) as (char *) will work as (void *) too,
+ // those it fits all platforms
Uint32 hostIP;
if (!System::resolveIPAtDNS(tmp_addr, &hostIP)) return false;
if (hostIP == localHostIP) return true;
static void getCurrentTime(Uint32& seconds, Uint32& milliseconds);
/** Similar to getCurrentTime() above but get microseconds (rather than
- milliseconds).
+ milliseconds).
*/
static void getCurrentTimeUsec(Uint32& seconds, Uint32& microseconds);
/** getCurrentASCIITime Gets time/date in a fixed format. The format is
YY MM DD-HH:MM:SS
- @return Returns String with the ASCII time date.
+ @return Returns String with the ASCII time date.
*/
static String getCurrentASCIITime();
/**
Attempts to validate that the input hostName represents the same host as
- the host represented by the value returned by the
+ the host represented by the value returned by the
getFullyQualifiedHostName() method.
@param hostName the host name to validate
static Boolean sameHost (const String & hostName);
/**
- * Attempts to find the given IP address(32bit) on any of the local defined
- * network interfaces
+ Attempts to find the given IP address(32bit) on any of the local defined
+ network interfaces
*/
static Boolean isIpOnNetworkInterface(Uint32 inIP);
-
+
/**
- * Attempts to resolve a given hostname
- * this function possibly can take some as it can request information
- * from the DNS
- *
- * Return: return value == true if successful, false if not successful
- * the IP address that was determined resides in resolvedNameIP
+ Attempts to resolve a given hostname
+ this function possibly can take some as it can request information
+ from the DNS
+
+ @param resolvedNameIP On successful hostname resolution, this output
+ parameter contains the IP address that was determined.
+ @return true if successful, false if not successful.
*/
- static Boolean resolveHostNameAtDNS(const char* hostname, Uint32 * resolvedNameIP);
+ static Boolean resolveHostNameAtDNS(
+ const char* hostname,
+ Uint32* resolvedNameIP);
/**
- * Attempts to resolve a given IP address
- * this function possibly can take some as it can request information
- * from the DNS
- * Return: return value == true if successful, false if not successful
- * the IP address that was determined resides in resolvedNameIP
+ Attempts to resolve a given IP address
+ this function possibly can take some as it can request information
+ from the DNS
+ @param resolvedIP On successful hostname resolution, this output
+ parameter contains the IP address that was determined.
+ @return true if successful, false if not successful.
*/
static Boolean resolveIPAtDNS(Uint32 ip_addr, Uint32 * resolvedIP);
- /**
- * Bundling function used to determine if a given hostname or IP address
- * belongs to the local host
- * this function has the potential to take some time as it will possibly
- * use the DNS
+ /**
+ Bundling function used to determine if a given hostname or IP address
+ belongs to the local host
+ this function has the potential to take some time as it will possibly
+ use the DNS
*/
- static Boolean isLocalHost(const String &hostName);
+ static Boolean isLocalHost(const String& hostName);
static String getEffectiveUserName();
/**
- This function is used to input a password with echo disabled.
- The function reads up to a newline and returns a password of at most
- 8 characters.
+ This function is used to input a password with echo disabled.
+ The function reads up to a newline and returns a password of at most
+ 8 characters.
- @param prompt String containing the message prompt to be displayed
- @return password obtained from the user
+ @param prompt String containing the message prompt to be displayed
+ @return password obtained from the user
*/
static String getPassword(const char* prompt);
/**
- This function is used to encrypt the user's password.
- The encryption is compatible with Apache's password file (generated using
- the htpasswd command )
+ This function is used to encrypt the user's password.
+ The encryption is compatible with Apache's password file (generated
+ using the htpasswd command)
- @param password Password to be encrypted.
- @param salt Two character string chosen from the set [a-zA-Z0-9./].
+ @param password Password to be encrypted.
+ @param salt Two character string chosen from the set [a-zA-Z0-9./].
- @return Encrypted password.
+ @return Encrypted password.
*/
static String encryptPassword(const char* password, const char* salt);
/**
- This function is used to verify whether specified user is a user
- on the local system.
+ This function is used to verify whether specified user is a user
+ on the local system.
- @param userName User name to be verified.
+ @param userName User name to be verified.
- @return true if the username is valid, else false
+ @return true if the username is valid, else false
*/
static Boolean isSystemUser(const char* userName);
/**
- Checks whether the given user is a privileged user.
+ Checks whether the given user is a privileged user.
- @param userName User name to be checked.
- @return true if the user is a privileged user, else false
+ @param userName User name to be checked.
+ @return true if the user is a privileged user, else false
*/
static Boolean isPrivilegedUser(const String& userName);
/**
- This function returns the privileged user name on the system.
-
- @return the privileged user name
+ This function returns the privileged user name on the system.
+ @return the privileged user name
*/
static String getPrivilegedUserName();
/**
- This function is used to verify whether the specified user is a member
- of the specified user group.
+ This function is used to verify whether the specified user is a member
+ of the specified user group.
- @param userName User name to be verified.
+ @param userName User name to be verified.
+ @param groupName User group name.
- @param groupName User group name.
-
- @return true if the user is a member of the user group,
- false otherwise.
-
- @throw InternalSystemError - If there is an error
- accessing the specified user or group information.
+ @return true if the user is a member of the user group, false otherwise.
+ @throw InternalSystemError - If there is an error accessing the
+ specified user or group information.
*/
static Boolean isGroupMember(const char* userName, const char* groupName);
#endif
/**
- This function is used to get the process ID of the calling process.
-
- @return Process ID
+ This function is used to get the process ID of the calling process.
+ @return Process ID
*/
static Uint32 getPID();
const char* message);
static void openlog(
- const char *ident,
- int logopt,
+ const char *ident,
+ int logopt,
int facility);
static void closelog();
hint.ai_family = AF_UNSPEC; // any family
hint.ai_socktype = 0; // any socket type
hint.ai_protocol = 0; // any protocol
- int success = getaddrinfo(hostName,
- NULL,
- &hint,
- &resolv);
+ int success = getaddrinfo(hostName, NULL, &hint, &resolv);
if (success==0)
{
// assign fully qualified hostname
fqName.assign(resolv->ai_canonname);
- } else
+ }
+ else
{
if ((he = gethostbyname(hostName)))
{
// assign hostName
// if gethostbyname was successful assign that result
// else assign unqualified hostname
- fqName.assign(hostName);
+ fqName.assign(hostName);
}
freeaddrinfo(resolv);
delete resolv;
*/
char *getpassword(const char *prompt)
{
- const size_t MAX_PASS_LEN = 1024;
- static char buf[MAX_PASS_LEN];
- struct termios old, new_val;
- char *ptr;
- int c;
+ const size_t MAX_PASS_LEN = 1024;
+ static char buf[MAX_PASS_LEN];
+ struct termios old, new_val;
+ char *ptr;
+ int c;
+
+ buf[0] = 0;
- buf[0] = 0;
+ /* Turn echoing off and fail if we can't. */
+ if (tcgetattr (fileno (stdin), &old) != 0)
+ return buf;
+ new_val = old;
+ new_val.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
+ if (tcsetattr (fileno (stdin), TCSAFLUSH, &new_val) != 0)
+ return buf;
- /* Turn echoing off and fail if we can't. */
- if (tcgetattr (fileno (stdin), &old) != 0)
- return buf;
- new_val = old;
- new_val.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
- if (tcsetattr (fileno (stdin), TCSAFLUSH, &new_val) != 0)
- return buf;
+ /* Read the password. */
+ fputs (prompt, stdin);
+ ptr = buf;
+ while ( (c = getc(stdin)) != EOF && c != '\n')
+ {
+ if (ptr < &buf[MAX_PASS_LEN])
+ *ptr++ = c;
+ }
+ *ptr = 0;
+ putc('\n', stdin);
- /* Read the password. */
- fputs (prompt, stdin);
- ptr = buf;
- while ( (c = getc(stdin)) != EOF && c != '\n') {
- if (ptr < &buf[MAX_PASS_LEN])
- *ptr++ = c;
- }
- *ptr = 0;
- putc('\n', stdin);
-
- /* Restore terminal. */
- (void) tcsetattr (fileno (stdin), TCSAFLUSH, &old);
- fclose(stdin);
- return buf;
+ /* Restore terminal. */
+ (void) tcsetattr (fileno (stdin), TCSAFLUSH, &old);
+ fclose(stdin);
+ return buf;
}
#endif /* PEGASUS_OS_LSB */
struct passwd local_pwd;
char buf[PWD_BUFF_SIZE];
- if(getpwuid_r(geteuid(), &local_pwd, buf, PWD_BUFF_SIZE, &pwd) != 0)
+ if (getpwuid_r(geteuid(), &local_pwd, buf, PWD_BUFF_SIZE, &pwd) != 0)
{
String errorMsg = String("getpwuid_r failure : ") +
String(strerror(errno));
userName.assign(pwd->pw_name);
}
- return(userName);
+ return userName;
}
String System::encryptPassword(const char* password, const char* salt)
#elif !defined(PEGASUS_OS_OS400)
- return ( String(crypt( password,salt)) );
+ return String(crypt( password,salt));
#else
// Not supported on OS400, and we don't need it.
- return ( String(password) );
+ return String(password);
#endif
}
return false;
// ATTN-VMS: should this be a bitwise and?
- return ((PRV$M_SETPRV && prvPrv) == 1) ? true : false;
+ return ((PRV$M_SETPRV && prvPrv) == 1);
#else /* default */
String errorMsg = String("getgrgid_r failure : ") +
String(strerror(errno));
PEG_TRACE_STRING(TRC_OS_ABSTRACTION, Tracer::LEVEL2, errorMsg);
- Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
- errorMsg);
+ Logger::put(
+ Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
+ errorMsg);
throw InternalSystemError();
}
// Compare the user's group name to groupName.
- if ( strcmp (grp.gr_name, groupName) == 0 )
+ if (strcmp(grp.gr_name, groupName) == 0)
{
// User is a member of the group.
return true;
}
// if message greater then 4096 bytes results are undefined !
- if(zosMessageStringLength > 4095)
+ if (zosMessageStringLength > 4095)
{
// the temp buffer is already used !
if (tmpMessageString)
// to the same storage but the tmpMessageString is not const !
tmpMessageString[4095] = 0;
- } else {
+ }
+ else
+ {
// allocate an appropriate buffer, init with 0
tmpMessageString = (char*)calloc(4096,1);
memcpy(tmpMessageString,zosMessageString,4095);
CString identCString = ident.getCString();
// Issue important messages to the z/OS console
// and audit messages are not important
- if (!(severity & Logger::TRACE) &&
+ if (!(severity & Logger::TRACE) &&
!(strcmp("cimserver audit",identCString) == 0))
{
struct __cons_msg cons;
#define PEGASUS_MAX_NETWORK_INTERFACES 32
struct ifconf conf;
- conf.ifc_buf = (char *)calloc( PEGASUS_MAX_NETWORK_INTERFACES, sizeof(struct ifreq ) );
- conf.ifc_len = PEGASUS_MAX_NETWORK_INTERFACES * sizeof( struct ifreq ) ;
-
- if( -1 < ioctl(AF_INET, SIOCGIFCONF, &conf ) )
+ conf.ifc_buf =
+ (char *)calloc(PEGASUS_MAX_NETWORK_INTERFACES, sizeof(struct ifreq));
+ conf.ifc_len = PEGASUS_MAX_NETWORK_INTERFACES * sizeof(struct ifreq);
+
+ if (-1 < ioctl(AF_INET, SIOCGIFCONF, &conf))
{
- struct ifreq *r = conf.ifc_req;
- sockaddr_in *addr ;
- addr = (sockaddr_in *)&r->ifr_addr;
- while( addr->sin_addr.s_addr != 0 )
- {
- Uint32 ip = addr->sin_addr.s_addr;
- if (ip == inIP)
- {
- free(conf.ifc_buf);
- return true;
- }
- // next interface
- r++;
- addr = (sockaddr_in *) &r->ifr_addr;
- }
+ struct ifreq* r = conf.ifc_req;
+ sockaddr_in* addr ;
+ addr = (sockaddr_in *)&r->ifr_addr;
+ while (addr->sin_addr.s_addr != 0)
+ {
+ Uint32 ip = addr->sin_addr.s_addr;
+ if (ip == inIP)
+ {
+ free(conf.ifc_buf);
+ return true;
+ }
+ // next interface
+ r++;
+ addr = (sockaddr_in *) &r->ifr_addr;
+ }
}
free(conf.ifc_buf);
return false;
{
#if (_MSC_VER >= 1300) || defined(PEGASUS_WINDOWS_SDK_HOME)
- //Bug 3076 fix
- wchar_t fullUserName[UNLEN+1];
- DWORD userNameSize = sizeof(fullUserName)/sizeof(fullUserName[0]);
- wchar_t computerName[MAX_COMPUTERNAME_LENGTH+1];
- DWORD computerNameSize = sizeof(computerName)/sizeof(computerName[0]);
- wchar_t userName[UNLEN+1];
+ //Bug 3076 fix
+ wchar_t fullUserName[UNLEN+1];
+ DWORD userNameSize = sizeof(fullUserName)/sizeof(fullUserName[0]);
+ wchar_t computerName[MAX_COMPUTERNAME_LENGTH+1];
+ DWORD computerNameSize = sizeof(computerName)/sizeof(computerName[0]);
+ wchar_t userName[UNLEN+1];
wchar_t userDomain[UNLEN+1];
- String userId;
-
- if (!GetUserNameExW(NameSamCompatible, fullUserName, &userNameSize))
- {
- return String();
- }
-
- wchar_t* index = wcschr(fullUserName, '\\');
- *index = 0;
- wcscpy(userDomain, fullUserName);
- wcscpy(userName, index + 1);
-
- //The above function will return the system name as the domain if
- //the user is not on a real domain. Strip this out so that the rest of
- //our windows user functions work. What if the system name and the domain
- //name are the same?
+ String userId;
+
+ if (!GetUserNameExW(NameSamCompatible, fullUserName, &userNameSize))
+ {
+ return String();
+ }
+
+ wchar_t* index = wcschr(fullUserName, '\\');
+ *index = 0;
+ wcscpy(userDomain, fullUserName);
+ wcscpy(userName, index + 1);
+
+ //The above function will return the system name as the domain if
+ //the user is not on a real domain. Strip this out so that the rest of
+ //our windows user functions work. What if the system name and the domain
+ //name are the same?
GetComputerNameW(computerName, &computerNameSize);
-
- if (wcscmp(computerName, userDomain) != 0)
- {
+
+ if (wcscmp(computerName, userDomain) != 0)
+ {
//userId.append(userDomain);
Uint32 n = wcslen(userDomain);
- for(unsigned long i = 0; i < n; i++)
+ for (unsigned long i = 0; i < n; i++)
{
userId.append(Char16(userDomain[i]));
}
- userId.append("\\");
- //userId.append(userName);
+ userId.append("\\");
+ //userId.append(userName);
n = wcslen(userName);
- for(unsigned long i = 0; i < n; i++)
+ for (unsigned long i = 0; i < n; i++)
{
userId.append(Char16(userName[i]));
}
- } else
- {
- //userId.append(userName);
+ }
+ else
+ {
+ //userId.append(userName);
Uint32 n = wcslen(userName);
- for(unsigned long i = 0; i < n; i++)
+ for (unsigned long i = 0; i < n; i++)
{
userId.append(Char16(userName[i]));
}
- }
+ }
- return userId;
+ return userId;
#else //original getEffectiveUserName function
-
+
int retcode = 0;
// UNLEN (256) is the limit, not including null
}
String userId;
Uint32 n = wcslen(pUserName);
- for(unsigned long i = 0; i < n; i++)
+ for (unsigned long i = 0; i < n; i++)
{
userId.append(Char16(pUserName[i]));
}
-
return userId;
#endif
}
Boolean System::isSystemUser(const char* userName)
{
- if(processUserName.size() == 0)
+ if (processUserName.size() == 0)
{
// Lock and recheck the processUserName length in case two threads
// enter this block simultaneously
AutoMutex mut(processUserNameMut);
- if(processUserName.size() == 0)
+ if (processUserName.size() == 0)
{
processUserName = getEffectiveUserName();
}
}
- if(processUserName == userName)
+ if (processUserName == userName)
{
return true;
}
LPUSER_INFO_1 pUserInfo = NULL;
NET_API_STATUS nStatus = NULL;
- // Make a copy of the specified username, it cannot be used directly because it's
- // declared as const and strchr() may modify the string.
+ // Make a copy of the specified username, it cannot be used directly
+ // because it's declared as const and strchr() may modify the string.
strncpy(tUserName, userName, sizeof(tUserName) - 1);
tUserName[sizeof(tUserName)- 1] = '\0';
strcpy(mUserName, pbs+1);
usingDomain = true;
- } else if ((NULL != (pbs = (strchr(tUserName, '@')))) ||
- (NULL != (pbs = (strchr(tUserName, '.')))))
+ }
+ else if ((NULL != (pbs = (strchr(tUserName, '@')))) ||
+ (NULL != (pbs = (strchr(tUserName, '.')))))
{
*pbs = '\0';
strcpy(mDomainName, pbs+1);
strcpy(mUserName, tUserName);
usingDomain = true;
- } else
+ }
+ else
{
strcpy(mDomainName, ".");
strcpy(mUserName, tUserName);
}
//convert domain name to unicode
- if (!MultiByteToWideChar(CP_ACP, 0, mDomainName, -1, wDomainName, strlen(mDomainName)+1))
+ if (!MultiByteToWideChar(
+ CP_ACP, 0, mDomainName, -1, wDomainName, strlen(mDomainName) + 1))
{
return false;
}
//convert username to unicode
- if (!MultiByteToWideChar(CP_ACP, 0, mUserName, -1, wUserName, strlen(mUserName)+1))
+ if (!MultiByteToWideChar(
+ CP_ACP, 0, mUserName, -1, wUserName, strlen(mUserName) + 1))
{
return false;
}
DWORD rc = NetGetDCName(NULL, wDomainName, &pComputerName);
if (rc == NERR_Success)
{
- wcscpy(wDomainName, (LPWSTR) pComputerName); //this is automatically prefixed with "\\"
+ // this is automatically prefixed with "\\"
+ wcscpy(wDomainName, (LPWSTR) pComputerName);
}
/*
else
{
// failover
- // ATTN: This is commented out until there is resolution on Bugzilla 2236. -hns 2/2005
+ // ATTN: This is commented out until there is resolution on
+ // Bugzilla 2236. -hns 2/2005
// This needs to be more thoroughly tested when we uncomment it out.
PDOMAIN_CONTROLLER_INFO DomainControllerInfo = NULL;
mDomainName,
NULL,
NULL,
- DS_DIRECTORY_SERVICE_REQUIRED, //not sure what flags we want here
+ //not sure what flags we want here
+ DS_DIRECTORY_SERVICE_REQUIRED,
&DomainControllerInfo);
if (rc == ERROR_SUCCESS && DomainControllerInfo)
strcpy(mDomainName, DomainControllerInfo->DomainName);
NetApiBufferFree(DomainControllerInfo);
- if (!MultiByteToWideChar(CP_ACP, 0, mDomainName, -1, wDomainName, strlen(mDomainName)+1))
+ if (!MultiByteToWideChar(
+ CP_ACP, 0, mDomainName, -1, wDomainName,
+ strlen(mDomainName) + 1))
{
return false;
}
strcpy(mUserName, pbs+1);
usingDomain = true;
- } else if ((NULL != (pbs = (strchr(userStr, '@')))) ||
- (NULL != (pbs = (strchr(userStr, '.')))))
+ }
+ else if ((NULL != (pbs = (strchr(userStr, '@')))) ||
+ (NULL != (pbs = (strchr(userStr, '.')))))
{
*pbs = '\0';
strcpy(mDomainName, pbs+1);
strcpy(mUserName, userStr);
usingDomain = true;
- } else
+ }
+ else
{
strcpy(mDomainName, ".");
strcpy(mUserName, userStr);
}
//convert domain name to unicode
- if (!MultiByteToWideChar(CP_ACP, 0, mDomainName, -1, wDomainName, strlen(mDomainName)+1))
+ if (!MultiByteToWideChar(
+ CP_ACP, 0, mDomainName, -1, wDomainName, strlen(mDomainName) + 1))
{
return false;
}
//convert username to unicode
- if (!MultiByteToWideChar(CP_ACP, 0, mUserName, -1, wUserName, strlen(mUserName)+1))
+ if (!MultiByteToWideChar(
+ CP_ACP, 0, mUserName, -1, wUserName, strlen(mUserName) + 1))
{
return false;
}
DWORD rc = NetGetDCName(NULL, wDomainName, &pComputerName);
if (rc == NERR_Success)
{
- wcscpy(wDomainName, (LPWSTR) pComputerName); //this is automatically prefixed with "\\"
+ // this is automatically prefixed with "\\"
+ wcscpy(wDomainName, (LPWSTR) pComputerName);
}
/*
else
{
// failover
- // ATTN: This is commented out until there is resolution on Bugzilla 2236. -hns 2/2005
+ // ATTN: This is commented out until there is resolution on
+ // Bugzilla 2236. -hns 2/2005
// This needs to be more thoroughly tested when we uncomment it out.
PDOMAIN_CONTROLLER_INFO DomainControllerInfo = NULL;
mDomainName,
NULL,
NULL,
- DS_DIRECTORY_SERVICE_REQUIRED, //not sure what flags we want here
+ // not sure what flags we want here
+ DS_DIRECTORY_SERVICE_REQUIRED,
&DomainControllerInfo);
if (rc == ERROR_SUCCESS && DomainControllerInfo)
strcpy(mDomainName, DomainControllerInfo->DomainName);
NetApiBufferFree(DomainControllerInfo);
- if (!MultiByteToWideChar(CP_ACP, 0, mDomainName, -1, wDomainName, strlen(mDomainName)+1))
+ if (!MultiByteToWideChar(
+ CP_ACP, 0, mDomainName, -1, wDomainName,
+ strlen(mDomainName) + 1))
{
return false;
}
// ATTN-NB-03-20000304: Implement better way to get the privileged
// user on the system.
- return (String("Administrator"));
+ return String("Administrator");
}
Boolean System::isGroupMember(const char* userName, const char* groupName)
strncpy(path_slash, path, _MAX_PATH);
path_slash[_MAX_PATH-1] = '\0';
- for(p = path_slash; p < path_slash + strlen(path_slash); p++)
+ for (p = path_slash; p < path_slash + strlen(path_slash); p++)
if (*p == '/')
*p = '\\';
- return (strcasecmp(_fullpath( full, path_slash, _MAX_PATH ), path_slash) == 0) ? true : false;
+ return (strcasecmp(
+ _fullpath(full, path_slash, _MAX_PATH), path_slash) == 0);
}
// Changes file permissions on the given file.
unsigned long *bytes_returned=0;
char *output_buf = (char *)calloc(1, 256);
int buf_size = 256;
-
+
if ( 0 == (errcode = WSAIoctl(sock,
SIO_ADDRESS_LIST_QUERY,
NULL,
SOCKET_ADDRESS *addr;
Uint32 ip;
struct sockaddr_in *sin;
-
- addr_list = (SOCKET_ADDRESS_LIST *)output_buf;
+
+ addr_list = (SOCKET_ADDRESS_LIST *)output_buf;
addr = addr_list->Address;
-
+
sin = (struct sockaddr_in *)addr->lpSockaddr;
-
- for( ; interfaces < addr_list->iAddressCount; interfaces++)
+
+ for ( ; interfaces < addr_list->iAddressCount; interfaces++)
{
ip = sin->sin_addr.s_addr;
addr++;
{
free(output_buf);
closesocket(sock);
- return(true);
+ return true;
}
}
- } else {
+ }
+ else
+ {
free(output_buf);
return false;
}
#include <Pegasus/Common/Tracer.h>
#include <Pegasus/Common/SSLContextRep.h>
#include <Pegasus/Common/SSLContext.h>
-#include <Pegasus/Common/MessageLoader.h> //l10n
+#include <Pegasus/Common/MessageLoader.h>
#include <Pegasus/Common/FileSystem.h>
#include "TLS.h"
if (!( _SSLConnection = SSL_new(_SSLContext->_rep->getContext() )))
{
PEG_METHOD_EXIT();
- //l10n
- //throw( SSLException("Could not get SSL Connection Area"));
- MessageLoaderParms parms("Common.TLS.COULD_NOT_GET_SSL_CONNECTION_AREA",
- "Could not get SSL Connection Area");
+ MessageLoaderParms parms(
+ "Common.TLS.COULD_NOT_GET_SSL_CONNECTION_AREA",
+ "Could not get SSL Connection Area");
throw SSLException(parms);
}
// set the verification callback data
//
- //we are only storing one set of data, so we can just use index 0, this is defined in SSLContext.h
- //int index = SSL_get_ex_new_index(0, (void*)"pegasus", NULL, NULL, NULL);
+ // we are only storing one set of data, so we can just use index 0,
+ // this is defined in SSLContext.h
+ //int index = SSL_get_ex_new_index(
+ // 0, (void*)"pegasus", NULL, NULL, NULL);
//
// Create a new callback info for each new connection
//
- _SSLCallbackInfo.reset(new SSLCallbackInfo(_SSLContext->getSSLCertificateVerifyFunction()
+ _SSLCallbackInfo.reset(new SSLCallbackInfo(
+ _SSLContext->getSSLCertificateVerifyFunction()
#ifdef PEGASUS_ENABLE_SSL_CRL_VERIFICATION
- , _SSLContext->getCRLStore()));
+ , _SSLContext->getCRLStore()));
#else
- ));
+ ));
#endif
- if (SSL_set_ex_data(_SSLConnection, SSLCallbackInfo::SSL_CALLBACK_INDEX, _SSLCallbackInfo.get()))
+ if (SSL_set_ex_data(
+ _SSLConnection,
+ SSLCallbackInfo::SSL_CALLBACK_INDEX,
+ _SSLCallbackInfo.get()))
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "--->SSL: Set callback info");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "--->SSL: Set callback info");
}
else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "--->SSL: Error setting callback info");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "--->SSL: Error setting callback info");
}
//
if (!(SSL_set_fd(_SSLConnection, _socket) ))
{
PEG_METHOD_EXIT();
- //l10n
- //throw( SSLException("Could not link socket to SSL Connection"));
- MessageLoaderParms parms("Common.TLS.COULD_NOT_LINK_SOCKET",
- "Could not link socket to SSL Connection");
+ MessageLoaderParms parms(
+ "Common.TLS.COULD_NOT_LINK_SOCKET",
+ "Could not link socket to SSL Connection");
throw SSLException(parms);
}
}
- catch(...)
+ catch (...)
{
SSL_free(_SSLConnection);
throw;
Tracer::trace(TRC_SSL, Tracer::LEVEL4,
"In SSLSocket::incompleteReadOccurred : err = %d", err);
- return ((err == SSL_ERROR_SYSCALL) && (_sslReadErrno == EAGAIN || _sslReadErrno == EINTR)) ||
- err == SSL_ERROR_WANT_READ ||
- err == SSL_ERROR_WANT_WRITE;
+ return ((err == SSL_ERROR_SYSCALL) &&
+ (_sslReadErrno == EAGAIN || _sslReadErrno == EINTR)) ||
+ (err == SSL_ERROR_WANT_READ) ||
+ (err == SSL_ERROR_WANT_WRITE);
}
Sint32 SSLSocket::read(void* ptr, Uint32 size)
Sint32 rc;
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: (r) ");
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, SSL_state_string_long(_SSLConnection) );
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ SSL_state_string_long(_SSLConnection));
rc = SSL_read(_SSLConnection, (char *)ptr, size);
_sslReadErrno = errno;
while (1)
{
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> SSL: (w) ");
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
SSL_state_string_long(_SSLConnection) );
bytesWritten = SSL_write(_SSLConnection, (char *)ptr, size);
if (bytesWritten <= 0)
{
// if we already waited for the socket to get ready, bail out
- if( socketTimedOut )
+ if (socketTimedOut)
{
// bytesWritten contains the error indication
PEG_METHOD_EXIT();
// just interrupted by a signal, try again
#ifdef PEGASUS_OS_TYPE_WINDOWS
if (WSAGetLastError() == WSAEINTR) continue;
-#else
+#else
if (errno == EINTR) continue;
#endif
// socket not ready ...
#ifdef PEGASUS_OS_TYPE_WINDOWS
if (WSAGetLastError() == WSAEWOULDBLOCK)
-#else
+#else
if (errno == EAGAIN || errno == EWOULDBLOCK)
#endif
{
FD_SET(_socket, &fdwrite);
selreturn = select(FD_SETSIZE, NULL, &fdwrite, NULL, &tv);
if (selreturn == 0) socketTimedOut = true; // ran out of time
- continue;
+ continue;
}
// bytesWritten contains the error indication
PEG_METHOD_EXIT();
if (ssl_rc < 0)
{
- ssl_rsn = SSL_get_error(_SSLConnection, ssl_rc);
- Tracer::trace(TRC_SSL, Tracer::LEVEL3, "---> SSL: Not accepted %d", ssl_rsn );
+ ssl_rsn = SSL_get_error(_SSLConnection, ssl_rc);
+ Tracer::trace(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: Not accepted %d", ssl_rsn );
- if ((ssl_rsn == SSL_ERROR_WANT_READ) ||
- (ssl_rsn == SSL_ERROR_WANT_WRITE))
- {
- PEG_METHOD_EXIT();
- return 0;
- }
- else
- {
- PEG_METHOD_EXIT();
- return -1;
- }
+ if ((ssl_rsn == SSL_ERROR_WANT_READ) ||
+ (ssl_rsn == SSL_ERROR_WANT_WRITE))
+ {
+ PEG_METHOD_EXIT();
+ return 0;
+ }
+ else
+ {
+ PEG_METHOD_EXIT();
+ return -1;
+ }
}
else if (ssl_rc == 0)
{
//
if (_SSLContext->isPeerVerificationEnabled())
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "Attempting to certify client");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "Attempting to certify client");
//
// get client's certificate
// get certificate verification result
//
int verifyResult = SSL_get_verify_result(_SSLConnection);
- Tracer::trace(TRC_SSL, Tracer::LEVEL3, "Verification Result: %d", verifyResult );
+ Tracer::trace(TRC_SSL, Tracer::LEVEL3,
+ "Verification Result: %d", verifyResult );
if (verifyResult == X509_V_OK)
{
}
else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: Client certification disabled");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: Client certification disabled");
}
PEG_METHOD_EXIT();
if (ssl_rc < 0)
{
ssl_rsn = SSL_get_error(_SSLConnection, ssl_rc);
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: Not connected " + ssl_rsn );
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: Not connected " + ssl_rsn);
if ((ssl_rsn == SSL_ERROR_WANT_READ) ||
(ssl_rsn == SSL_ERROR_WANT_WRITE))
}
else if (ssl_rc == 0)
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: Shutdown SSL_connect()");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: Shutdown SSL_connect()");
PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
"Error string: " + String(ERR_error_string(ssl_rc, NULL)));
PEG_METHOD_EXIT();
if (_SSLContext->isPeerVerificationEnabled())
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "Attempting to verify server certificate.");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "Attempting to verify server certificate.");
- X509 * server_cert = SSL_get_peer_certificate(_SSLConnection);
+ X509* server_cert = SSL_get_peer_certificate(_SSLConnection);
if (server_cert != NULL)
{
//
- // Do not check the verification result using SSL_get_verify_result here to see whether or not to continue.
- // The prepareForCallback does not reset the verification result, so it will still contain the original error.
- // If the client chose to override the default error in the callback and return true, we got here and
- // should proceed with the transaction. Otherwise, the handshake was already terminated.
+ // Do not check the verification result using
+ // SSL_get_verify_result here to see whether or not to continue.
+ // The prepareForCallback does not reset the verification result,
+ // so it will still contain the original error. If the client
+ // chose to override the default error in the callback and
+ // return true, we got here and should proceed with the
+ // transaction. Otherwise, the handshake was already terminated.
//
if (SSL_get_verify_result(_SSLConnection) == X509_V_OK)
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "--->SSL: Server Certificate verified.");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "--->SSL: Server Certificate verified.");
}
else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "--->SSL: Server Certificate not verified, but the callback overrode the default error.");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "--->SSL: Server Certificate not verified, but the "
+ "callback overrode the default error.");
}
X509_free (server_cert);
}
else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "-->SSL: Server not certified, no certificate received.");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "-->SSL: Server not certified, no certificate received.");
PEG_METHOD_EXIT();
return -1;
}
}
else
{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3, "---> SSL: Server certification disabled");
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL3,
+ "---> SSL: Server certification disabled");
}
PEG_METHOD_EXIT();
Boolean SSLSocket::isPeerVerificationEnabled()
{
- return (_SSLContext->isPeerVerificationEnabled());
+ return _SSLContext->isPeerVerificationEnabled();
}
Array<SSLCertificateInfo*> SSLSocket::getPeerCertificateChain()
Boolean MP_Socket::incompleteReadOccurred(Sint32 retCode)
{
if (_isSecure)
- return(_sslsock->incompleteReadOccurred(retCode));
+ return _sslsock->incompleteReadOccurred(retCode);
return (retCode <= 0);
}
{
if (_isSecure)
{
- return (_sslsock->accept());
+ return _sslsock->accept();
}
return 1;
}
{
if (_isSecure)
{
- return (_sslsock->isPeerVerificationEnabled());
+ return _sslsock->isPeerVerificationEnabled();
}
return false;
}
{
if (_isSecure)
{
- return (_sslsock->isCertificateVerified());
+ return _sslsock->isCertificateVerified();
}
return false;
}
Socket::disableBlocking(_socket);
}
-Sint32 MP_Socket::accept()
-{
+Sint32 MP_Socket::accept()
+{
#ifndef PEGASUS_OS_ZOS
- return 1;
+ return 1;
#else
-PEG_METHOD_ENTER(TRC_SSL, "MP_Socket::accept()");
-// ****************************************************************************
-// This is a z/OS speciffic section. No other platform can port this.
-// Pegsus on z/OS has no OpenSSL but cat use a transparent layer called
-// AT-TLS ( Applicatin Transparent Transport Layer Security ) to handel
-// HTTTPS connections.
-// ****************************************************************************
+ PEG_METHOD_ENTER(TRC_SSL, "MP_Socket::accept()");
+ // ************************************************************************
+ // This is a z/OS specific section. No other platform can port this.
+ // Pegasus on z/OS has no OpenSSL but cat use a transparent layer called
+ // AT-TLS ( Applicatin Transparent Transport Layer Security ) to handle
+ // HTTPS connections.
+ // ************************************************************************
-int rc;
-
-if(isSecure())
-{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> HTTPS processing.");
- rc = ATTLS_zOS_query();
-} else
-{
- PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> Normal HTTP processing.");
- rc = 1;
-}
-PEG_METHOD_EXIT();
-return rc;
+ int rc;
+ if (isSecure())
+ {
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4, "---> HTTPS processing.");
+ rc = ATTLS_zOS_query();
+ }
+ else
+ {
+ PEG_TRACE_STRING(TRC_SSL, Tracer::LEVEL4,
+ "---> Normal HTTP processing.");
+ rc = 1;
+ }
+ PEG_METHOD_EXIT();
+ return rc;
#endif
-
}
Sint32 MP_Socket::connect() { return 0; }
Array<SSLCertificateInfo*> MP_Socket::getPeerCertificateChain()
{
-//
-// Return empty array
-//
-return Array<SSLCertificateInfo*>();
+ //
+ // Return empty array
+ //
+ return Array<SSLCertificateInfo*>();
}
Boolean MP_Socket::isCertificateVerified() { return false; }
#ifdef PEGASUS_OS_ZOS
// Return the authenicated user name
- String getAuthenticatedUser(){ return String(_username); }
- Boolean isClientAuthenticated(){ return _userAuthenticated; }
-#endif
-
+ String getAuthenticatedUser() { return String(_username); }
+ Boolean isClientAuthenticated() { return _userAuthenticated; }
+#endif
union {
SocketHandle _socket;
Boolean _isSecure;
Uint32 _socketWriteTimeout;
#ifdef PEGASUS_OS_ZOS
-
+
int ATTLS_zOS_query();
// The user name if authenticated through ATTLS.
char _username[10];
Boolean _userAuthenticated;
-#endif
+#endif
};
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "TSDKey.h"
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_TSDKey_h
#endif
}
-Boolean Thread::is_cancelled(void)
+Boolean Thread::is_cancelled()
{
return _cancelled;
}
Threads::sleep(msec);
}
-void Thread::join(void)
+void Thread::join()
{
if (!_is_detached && !Threads::null(_handle.thid))
pthread_join(_handle.thid.thread, &_exit_code);
Threads::clear(_handle.thid);
}
-void Thread::thread_init(void)
+void Thread::thread_init()
{
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
pthread_setintr(PTHREAD_INTR_ENABLE);
_cancel_enabled = true;
}
-void Thread::detach(void)
+void Thread::detach()
{
_is_detached = true;
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
Threads::Type type = _is_detached ? Threads::DETACHED : Threads::JOINABLE;
int rc = Threads::create(_handle.thid, type, _start_wrapper, arg);
- // On Linux distributions released prior 2005, the implementation of
+ // On Linux distributions released prior 2005, the implementation of
// Native POSIX Thread Library returns ENOMEM instead of EAGAIN when
- // there
+ // there
// are no insufficient memory. Hence we are checking for both. See bug
// 386.
return sig;
}
-Thread::Thread(ThreadReturnType(PEGASUS_THREAD_CDECL * start) (void *), void *parameter, Boolean detached):_is_detached(detached),
-_cancel_enabled(true),
-_cancelled(false),
-_start(start), _cleanup(), _tsd(), _thread_parm(parameter), _exit_code(0)
+Thread::Thread(
+ ThreadReturnType(PEGASUS_THREAD_CDECL* start) (void*),
+ void* parameter,
+ Boolean detached)
+ : _is_detached(detached),
+ _cancel_enabled(true),
+ _cancelled(false),
+ _start(start),
+ _cleanup(),
+ _tsd(),
+ _thread_parm(parameter),
+ _exit_code(0)
{
Threads::clear(_handle.thid);
}
join();
empty_tsd();
}
- catch(...)
+ catch (...)
{
// Do not allow the destructor to throw an exception
}
#if defined(PEGASUS_HAVE_WINDOWS_THREADS)
-ThreadStatus Thread::run(void)
+ThreadStatus Thread::run()
{
// Note: A Win32 thread ID is not the same thing as a pthread ID.
// Win32 threads have both a thread ID and a handle. The handle
return PEGASUS_THREAD_OK;
}
-void Thread::cancel(void)
+void Thread::cancel()
{
_cancelled = true;
}
-void Thread::test_cancel(void)
+void Thread::test_cancel()
{
if (_cancel_enabled && _cancelled)
{
}
}
-Boolean Thread::is_cancelled(void)
+Boolean Thread::is_cancelled()
{
return _cancelled;
}
-void Thread::thread_switch(void)
+void Thread::thread_switch()
{
Sleep(0);
}
Sleep(milliseconds);
}
-void Thread::join(void)
+void Thread::join()
{
if (!Threads::null(_handle.thid))
{
else
{
// Currently this is the only way to ensure this code does
- // not
+ // not
// hang forever.
if (WaitForSingleObject(_handle.thid.handle, 10000) ==
WAIT_TIMEOUT)
}
}
-void Thread::thread_init(void)
+void Thread::thread_init()
{
_cancel_enabled = true;
}
-void Thread::detach(void)
+void Thread::detach()
{
_is_detached = true;
}
join();
empty_tsd();
}
- catch(...)
+ catch (...)
{
}
}
{
cu.reset(_cleanup.remove_front());
}
- catch(IPCException &)
+ catch (IPCException &)
{
PEGASUS_ASSERT(0);
}
}
-//thread_data *Thread::put_tsd(const Sint8 *key, void (*delete_func)(void *), Uint32 size, void *value)
-
-
void Thread::exit_self(ThreadReturnType exit_code)
{
#ifndef PEGASUS_PLATFORM_AIX_RS_IBMCXX
{
cleanup_pop(true);
}
- catch(IPCException &)
+ catch (IPCException &)
{
PEGASUS_ASSERT(0);
break;
return acceptLangs;
}
-void Thread::setLanguages(AcceptLanguageList * langs) // l10n
+void Thread::setLanguages(AcceptLanguageList * langs)
{
PEG_METHOD_ENTER(TRC_THREAD, "Thread::setLanguages");
PEG_METHOD_EXIT();
}
-void Thread::clearLanguages() // l10n
+void Thread::clearLanguages()
{
PEG_METHOD_ENTER(TRC_THREAD, "Thread::clearLanguages");
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
-// Modified By: Markus Mueller
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2393
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Thread_h
# include <signal.h>
#endif
-PEGASUS_NAMESPACE_BEGIN
+PEGASUS_NAMESPACE_BEGIN
class PEGASUS_COMMON_LINKAGE cleanup_handler : public Linkable
{
_routine(_arg);
}
- cleanup_handler();
-
+ cleanup_handler();
+
void (*_routine)(void*);
void *_arg;
_data =::operator new(_size);
}
- thread_data(const char *key, size_t size, void *data) :
- _delete_func(default_delete), _size(size)
+ thread_data(const char *key, size_t size, void *data)
+ : _delete_func(default_delete), _size(size)
{
PEGASUS_ASSERT(key != NULL);
PEGASUS_ASSERT(data != NULL);
*
* @exception NullPointer
*/
- void put_data(void (*del) (void *), size_t size, void *data)
+ void put_data(void (*del) (void *), size_t size, void* data)
{
if (_data != NULL)
if (_delete_func != NULL)
return _size;
}
- /**
- * This function is used to retrieve data from the
- * TSD, the thread specific data.
- *
- * Be aware that there is NOTHING in place to stop
- * other users of the thread to change the data you
- * get from this function.
- *
- * You, the developer has to make sure that there are
- * no situations in which this can arise (ie, have a
- * lock for the function which manipulates the TSD.
- */
- void get_data(void **data, size_t * size)
+ /**
+ This function is used to retrieve data from the
+ TSD, the thread specific data.
+
+ Be aware that there is NOTHING in place to stop
+ other users of the thread to change the data you
+ get from this function.
+
+ You, the developer has to make sure that there are
+ no situations in which this can arise (ie, have a
+ lock for the function which manipulates the TSD.
+ */
+ void get_data(void** data, size_t* size)
{
if (data == NULL || size == NULL)
throw NullPointer();
*data = _data;
*size = _size;
- return;
-
}
// @exception NullPointer
- void copy_data(void **buf, size_t * size)
+ void copy_data(void** buf, size_t* size)
{
if ((buf == NULL) || (size == NULL))
throw NullPointer();
*buf =::operator new(_size);
*size = _size;
memcpy(*buf, _data, _size);
- return;
}
- inline Boolean operator==(const void *key) const
+ inline Boolean operator==(const void* key) const
{
if (!strcmp(_key.get(), reinterpret_cast < const char *>(key)))
- return (true);
- return (false);
+ return true;
+ return false;
}
- inline Boolean operator==(const thread_data & b) const
+ inline Boolean operator==(const thread_data& b) const
{
- return (operator==(b._key.get()));
+ return operator==(b._key.get());
}
- static bool equal(const thread_data * node, const void *key)
+ static bool equal(const thread_data* node, const void* key)
{
return ((thread_data *) node)->operator==(key);
}
private:
- void (*_delete_func) (void *data);
+ void (*_delete_func) (void* data);
thread_data();
- void *_data;
+ void* _data;
size_t _size;
- AutoArrayPtr < char >_key;
+ AutoArrayPtr<char> _key;
friend class Thread;
};
PEGASUS_THREAD_INSUFFICIENT_RESOURCES, /* Can't allocate a thread.
Not enough memory. Try
again later */
- PEGASUS_THREAD_SETUP_FAILURE, /* Could not allocate into the thread
+ PEGASUS_THREAD_SETUP_FAILURE, /* Could not allocate into the thread
specific data storage. */
PEGASUS_THREAD_UNAVAILABLE /* Service is being destroyed and no new
threads can be provided. */
///////////////////////////////////////////////////////////////////////////
-class PEGASUS_COMMON_LINKAGE Thread:public Linkable
+class PEGASUS_COMMON_LINKAGE Thread : public Linkable
{
- public:
+public:
- Thread(ThreadReturnType(PEGASUS_THREAD_CDECL * start) (void *),
- void *parameter, Boolean detached);
+ Thread(
+ ThreadReturnType(PEGASUS_THREAD_CDECL* start) (void*),
+ void* parameter,
+ Boolean detached);
~Thread();
/** Start the thread.
- @return PEGASUS_THREAD_OK if the thread is started successfully,
- PEGASUS_THREAD_INSUFFICIENT_RESOURCES if the resources necessary
- to start the thread are not currently available.
- PEGASUS_THREAD_SETUP_FAILURE if the thread could not
+ @return PEGASUS_THREAD_OK if the thread is started successfully,
+ PEGASUS_THREAD_INSUFFICIENT_RESOURCES if the resources necessary
+ to start the thread are not currently available.
+ PEGASUS_THREAD_SETUP_FAILURE if the thread could not
be create properly - check the 'errno' value for specific operating
system return code.
*/
// stack of functions to be called when thread terminates
// will be called last in first out (LIFO)
// @exception IPCException
- void cleanup_push(void (*routine) (void *), void *parm);
+ void cleanup_push(void (*routine) (void *), void* parm);
// @exception IPCException
void cleanup_pop(Boolean execute = true);
// create and initialize a tsd
// @exception IPCException
- inline void create_tsd(const char *key, int size, void *buffer)
+ inline void create_tsd(const char* key, int size, void* buffer)
{
- AutoPtr < thread_data > tsd(new thread_data(key, size, buffer));
+ AutoPtr<thread_data> tsd(new thread_data(key, size, buffer));
_tsd.insert_front(tsd.get());
tsd.release();
}
// get the buffer associated with the key
// NOTE: this call leaves the tsd LOCKED !!!!
// @exception IPCException
- inline void *reference_tsd(const char *key)
+ inline void *reference_tsd(const char* key)
{
_tsd.lock();
thread_data *tsd = _tsd.find(thread_data::equal, key);
if (tsd != NULL)
- return ((void *) (tsd->_data));
+ return (void *) (tsd->_data);
else
- return (NULL);
+ return NULL;
}
// @exception IPCException
_tsd.try_lock();
thread_data *tsd = _tsd.find(thread_data::equal, key);
if (tsd != NULL)
- return ((void *) (tsd->_data));
+ return (void *) (tsd->_data);
else
- return (NULL);
+ return NULL;
}
// create or re-initialize tsd associated with the key
// if the tsd already exists, delete the existing buffer
// @exception IPCException
- void put_tsd(const char *key, void (*delete_func) (void *), Uint32 size,
- void *value)
+ void put_tsd(
+ const char* key,
+ void (*delete_func) (void *),
+ Uint32 size,
+ void* value)
{
PEGASUS_ASSERT(key != NULL);
- AutoPtr < thread_data > tsd;
- tsd.reset(_tsd.remove(thread_data::equal, key)); // may throw
- // an IPC
- // exception
+ AutoPtr<thread_data> tsd;
+ // This may throw an IPCException
+ tsd.reset(_tsd.remove(thread_data::equal, key));
tsd.reset();
- AutoPtr < thread_data > ntsd(new thread_data(key));
+ AutoPtr<thread_data> ntsd(new thread_data(key));
ntsd->put_data(delete_func, size, value);
- try
- {
- _tsd.insert_front(ntsd.get());
- }
- catch(IPCException & e)
- {
- e = e;
- throw;
- }
+ // This may throw an IPCException
+ _tsd.insert_front(ntsd.get());
ntsd.release();
}
+
inline ThreadReturnType get_exit()
{
return _exit_code;
void detach();
- //
+ //
// Gets the Thread object associated with the caller's thread.
// Note: this may return NULL if no Thread object is associated
// with the caller's thread.
- //
- static Thread *getCurrent(); // l10n
+ //
+ static Thread *getCurrent();
- //
+ //
// Sets the Thread object associated with the caller's thread.
// Note: the Thread object must be placed on the heap.
- //
- static void setCurrent(Thread * thrd); // l10n
+ //
+ static void setCurrent(Thread* thrd);
- //
+ //
// Gets the AcceptLanguageList object associated with the caller's
// Thread.
// Note: this may return NULL if no Thread object, or no
// AcceptLanguageList object, is associated with the caller's thread.
- //
- static AcceptLanguageList *getLanguages(); // l10n
+ //
+ static AcceptLanguageList* getLanguages();
- //
+ //
// Sets the AcceptLanguageList object associated with the caller's
// Thread.
// Note: a Thread object must have been previously associated with
// the caller's thread.
// Note: the AcceptLanguageList object must be placed on the heap.
- //
- static void setLanguages(AcceptLanguageList * langs); // l10n
+ //
+ static void setLanguages(AcceptLanguageList* langs);
- //
+ //
// Removes the AcceptLanguageList object associated with the caller's
// Thread.
- //
- static void clearLanguages(); // l10n
+ //
+ static void clearLanguages();
- private:
+private:
Thread();
- static Sint8 initializeKey(); // l10n
+ static Sint8 initializeKey();
// @exception IPCException
inline void create_tsd(const char *key)
{
- AutoPtr < thread_data > tsd(new thread_data(key));
+ AutoPtr<thread_data> tsd(new thread_data(key));
_tsd.insert_front(tsd.get());
tsd.release();
}
+
ThreadHandle _handle;
Boolean _is_detached;
Boolean _cancel_enabled;
// always pass this * as the void * parameter to the thread
// store the user parameter in _thread_parm
- ThreadReturnType(PEGASUS_THREAD_CDECL * _start) (void *);
- List < cleanup_handler, Mutex > _cleanup;
- List < thread_data, Mutex > _tsd;
+ ThreadReturnType(PEGASUS_THREAD_CDECL* _start) (void *);
+ List<cleanup_handler, Mutex> _cleanup;
+ List<thread_data, Mutex> _tsd;
- void *_thread_parm;
+ void* _thread_parm;
ThreadReturnType _exit_code;
static Boolean _signals_blocked;
- static TSDKeyType _platform_thread_key; // l10n
- static Boolean _key_initialized; // l10n
- static Boolean _key_error; // l10n
+ static TSDKeyType _platform_thread_key;
+ static Boolean _key_initialized;
+ static Boolean _key_error;
};
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
-// Modified By: Rudy Schuet (rudy.schuet@compaq.com) 11/12/01
-// added nsk platform support
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "ThreadPool.h"
//
///////////////////////////////////////////////////////////////////////////////
-ThreadPool::ThreadPool(Sint16 initialSize,
- const char *key,
- Sint16 minThreads,
- Sint16 maxThreads,
- struct timeval
- &deallocateWait):_maxThreads(maxThreads),
-_minThreads(minThreads), _currentThreads(0), _idleThreads(),
-_runningThreads(), _dying(0)
+ThreadPool::ThreadPool(
+ Sint16 initialSize,
+ const char* key,
+ Sint16 minThreads,
+ Sint16 maxThreads,
+ struct timeval
+ &deallocateWait)
+ : _maxThreads(maxThreads),
+ _minThreads(minThreads),
+ _currentThreads(0),
+ _idleThreads(),
+ _runningThreads(),
+ _dying(0)
{
_deallocateWait.tv_sec = deallocateWait.tv_sec;
_deallocateWait.tv_usec = deallocateWait.tv_usec;
// entered
_dying++;
Tracer::trace(TRC_THREAD, Tracer::LEVEL2,
- "Cleaning up %d idle threads. ", _currentThreads.get());
+ "Cleaning up %d idle threads.", _currentThreads.get());
while (_currentThreads.get() > 0)
{
- Thread *thread = _idleThreads.remove_front();
+ Thread* thread = _idleThreads.remove_front();
if (thread != 0)
{
_cleanupThread(thread);
}
}
}
- catch(...)
+ catch (...)
{
}
}
-ThreadReturnType PEGASUS_THREAD_CDECL ThreadPool::_loop(void *parm)
+ThreadReturnType PEGASUS_THREAD_CDECL ThreadPool::_loop(void* parm)
{
PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::_loop");
myself->dereference_tsd();
PEGASUS_ASSERT(lastActivityTime != 0);
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::_loop: Failure getting sleep_sem or "
- "lastActivityTime.");
+ "ThreadPool::_loop: Failure getting sleep_sem or "
+ "lastActivityTime.");
PEGASUS_ASSERT(false);
pool->_idleThreads.remove(myself);
pool->_currentThreads--;
PEG_METHOD_EXIT();
- return ((ThreadReturnType) 1);
+ return (ThreadReturnType) 1;
}
while (1)
{
sleep_sem->wait();
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::_loop: failure on sleep_sem->wait().");
+ "ThreadPool::_loop: failure on sleep_sem->wait().");
PEGASUS_ASSERT(false);
pool->_idleThreads.remove(myself);
pool->_currentThreads--;
PEG_METHOD_EXIT();
- return ((ThreadReturnType) 1);
+ return (ThreadReturnType) 1;
}
// When we awaken we reside on the _runningThreads queue, not the
(Semaphore *) myself->reference_tsd("blocking sem");
myself->dereference_tsd();
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::_loop: Failure accessing work func, work parm, "
- "or blocking sem.");
+ "ThreadPool::_loop: Failure accessing work func, work "
+ "parm, or blocking sem.");
PEGASUS_ASSERT(false);
pool->_idleThreads.remove(myself);
pool->_currentThreads--;
PEG_METHOD_EXIT();
- return ((ThreadReturnType) 1);
+ return (ThreadReturnType) 1;
}
if (work == 0)
{
Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
- "ThreadPool::_loop: work func is 0, meaning we should exit.");
+ "ThreadPool::_loop: work func is 0, meaning we should "
+ "exit.");
break;
}
PEG_TRACE_STRING(TRC_THREAD, Tracer::LEVEL4,
"Work finished.");
}
- catch(Exception & e)
+ catch (Exception& e)
{
PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- String
- ("Exception from work in ThreadPool::_loop: ")
- + e.getMessage());
+ String("Exception from work in ThreadPool::_loop: ") +
+ e.getMessage());
}
#if !defined(PEGASUS_OS_LSB)
- catch(const exception & e)
+ catch (const exception& e)
{
PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- String
- ("Exception from work in ThreadPool::_loop: ")
- + e.what());
+ String("Exception from work in ThreadPool::_loop: ") +
+ e.what());
}
#endif
- catch(...)
+ catch (...)
{
PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "Unknown exception from work in ThreadPool::_loop.");
+ "Unknown exception from work in ThreadPool::_loop.");
}
// put myself back onto the available list
pool->_runningThreads.remove(myself);
pool->_idleThreads.insert_front(myself);
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::_loop: Adding thread to idle pool failed.");
+ "ThreadPool::_loop: Adding thread to idle pool failed.");
PEGASUS_ASSERT(false);
pool->_currentThreads--;
PEG_METHOD_EXIT();
- return ((ThreadReturnType) 1);
+ return (ThreadReturnType) 1;
}
}
}
- catch(const Exception & e)
+ catch (const Exception & e)
{
PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "Caught exception: \"" + e.getMessage() +
- "\". Exiting _loop.");
+ "Caught exception: \"" + e.getMessage() + "\". Exiting _loop.");
}
- catch(...)
+ catch (...)
{
PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "Caught unrecognized exception. Exiting _loop.");
+ "Caught unrecognized exception. Exiting _loop.");
}
PEG_METHOD_EXIT();
- return ((ThreadReturnType) 0);
+ return (ThreadReturnType) 0;
}
-ThreadStatus ThreadPool::allocate_and_awaken(void *parm,
- ThreadReturnType
- (PEGASUS_THREAD_CDECL *
- work) (void *),
- Semaphore * blocking)
+ThreadStatus ThreadPool::allocate_and_awaken(
+ void* parm,
+ ThreadReturnType (PEGASUS_THREAD_CDECL* work) (void*),
+ Semaphore* blocking)
{
PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::allocate_and_awaken");
if (_dying.get())
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::allocate_and_awaken: ThreadPool is dying(1).");
+ "ThreadPool::allocate_and_awaken: ThreadPool is dying(1).");
return PEGASUS_THREAD_UNAVAILABLE;
}
struct timeval start;
// initialize the thread data with the work function and parameters
Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
- "Initializing thread with work function and parameters: parm = %p",
- parm);
+ "Initializing thread with work function and parameters: parm = %p",
+ parm);
th->delete_tsd("work func");
th->put_tsd("work func", NULL,
sleep_sem->signal();
th->dereference_tsd();
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
"ThreadPool::allocate_and_awaken: Operation Failed.");
try_reference_tsd("last activity time");
PEGASUS_ASSERT(lastActivityTime != 0);
}
- catch(...)
+ catch (...)
{
PEGASUS_ASSERT(false);
_idleThreads.insert_back(thread);
PEG_METHOD_EXIT();
}
-Boolean ThreadPool::_timeIntervalExpired(struct timeval *start,
- struct timeval *interval)
+Boolean ThreadPool::_timeIntervalExpired(
+ struct timeval* start,
+ struct timeval* interval)
{
// never time out if the interval is zero
if (interval && (interval->tv_sec == 0) && (interval->tv_usec == 0))
// initial count is zero, loop function will sleep until
// we signal the semaphore
Semaphore *sleep_sem = (Semaphore *) new Semaphore(0);
- th->put_tsd("sleep sem", &_deleteSemaphore, sizeof (Semaphore),
- (void *) sleep_sem);
+ th->put_tsd(
+ "sleep sem", &_deleteSemaphore, sizeof(Semaphore), (void*) sleep_sem);
- struct timeval *lastActivityTime =
+ struct timeval* lastActivityTime =
(struct timeval *)::operator new(sizeof (struct timeval));
Time::gettimeofday(lastActivityTime);
- th->put_tsd("last activity time", thread_data::default_delete,
- sizeof (struct timeval), (void *) lastActivityTime);
+ th->put_tsd(
+ "last activity time",
+ thread_data::default_delete,
+ sizeof(struct timeval),
+ (void*) lastActivityTime);
// thread will enter _loop() and sleep on sleep_sem until we signal it
if (th->run() != PEGASUS_THREAD_OK)
{
Tracer::trace(TRC_THREAD, Tracer::LEVEL2,
- "Could not create thread. Error code is %d.", errno);
+ "Could not create thread. Error code is %d.", errno);
delete th;
return 0;
}
if (th == 0)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::_addToIdleThreadsQueue: Thread pointer is null.");
+ "ThreadPool::_addToIdleThreadsQueue: Thread pointer is null.");
throw NullPointer();
}
{
_idleThreads.insert_front(th);
}
- catch(...)
+ catch (...)
{
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
- "ThreadPool::_addToIdleThreadsQueue: _idleThreads.insert_front "
- "failed.");
+ "ThreadPool::_addToIdleThreadsQueue: _idleThreads.insert_front "
+ "failed.");
}
}
//
//==============================================================================
//
-// Author: Mike Day (mdday@us.ibm.com)
-//
-// Modified By: Markus Mueller
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2393
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_ThreadPool_h
#include <Pegasus/Common/Linkage.h>
#include <Pegasus/Common/Thread.h>
-PEGASUS_NAMESPACE_BEGIN
+PEGASUS_NAMESPACE_BEGIN
class PEGASUS_COMMON_LINKAGE ThreadPool
{
@param deallocateWait The minimum time that a thread should be idle
before it is removed from the pool and cleaned up.
*/
- ThreadPool(Sint16 initialSize,
- const char *key,
- Sint16 minThreads,
- Sint16 maxThreads, struct timeval &deallocateWait);
+ ThreadPool(
+ Sint16 initialSize,
+ const char* key,
+ Sint16 minThreads,
+ Sint16 maxThreads,
+ struct timeval& deallocateWait);
/**
Destructs the ThreadPool object.
@param blocking A pointer to an optional semaphore which, if
specified, is signaled after the thread finishes
executing the work function
- @return PEGASUS_THREAD_OK if the thread is started successfully,
- PEGASUS_THREAD_INSUFFICIENT_RESOURCES if the
+ @return PEGASUS_THREAD_OK if the thread is started successfully,
+ PEGASUS_THREAD_INSUFFICIENT_RESOURCES if the
resources necessary to start the thread are not currently
available. PEGASUS_THREAD_SETUP_FAILURE if the thread
could not be setup properly. PEGASUS_THREAD_UNAVAILABLE
be allocated.
@exception IPCException
*/
- ThreadStatus allocate_and_awaken(void *parm,
- ThreadReturnType(PEGASUS_THREAD_CDECL *
- work) (void *),
- Semaphore * blocking = 0);
+ ThreadStatus allocate_and_awaken(
+ void* parm,
+ ThreadReturnType(PEGASUS_THREAD_CDECL* work) (void*),
+ Semaphore* blocking = 0);
/**
Cleans up idle threads if they have been running longer than the
*/
Uint32 cleanupIdleThreads();
- void get_key(Sint8 * buf, int bufsize);
+ void get_key(Sint8* buf, int bufsize);
inline void setMinThreads(Sint16 min)
{
static ThreadReturnType PEGASUS_THREAD_CDECL _loop(void *);
- static Boolean _timeIntervalExpired(struct timeval *start,
- struct timeval *interval);
+ static Boolean _timeIntervalExpired(
+ struct timeval* start,
+ struct timeval* interval);
- static void _deleteSemaphore(void *p);
+ static void _deleteSemaphore(void* p);
- void _cleanupThread(Thread * thread);
- Thread *_initializeThread();
- void _addToIdleThreadsQueue(Thread * th);
+ void _cleanupThread(Thread* thread);
+ Thread* _initializeThread();
+ void _addToIdleThreadsQueue(Thread* th);
Sint16 _maxThreads;
Sint16 _minThreads;
AtomicInt _currentThreads;
struct timeval _deallocateWait;
char _key[17];
- List < Thread, Mutex > _idleThreads;
- List < Thread, Mutex > _runningThreads;
+ List<Thread, Mutex> _idleThreads;
+ List<Thread, Mutex> _runningThreads;
AtomicInt _dying;
};
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <errno.h>
else
{
loop = microsecs / 1000000;
- for(int i = 0; i < loop; i++)
+ for (int i = 0; i < loop; i++)
usleep(1000000);
if ((loop*1000000) < microsecs)
usleep(microsecs - (loop*1000000));
#elif defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
if (msec == 0)
- {
+ {
Sleep(0);
return;
}
{
Sleep(0);
_ftime(&now);
- }
- while( end.millitm > now.millitm && end.time >= now.time);
+ }
+ while (end.millitm > now.millitm && end.time >= now.time);
#elif defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
int seconds;
static int _multiplier = 0;
static MutexType _multiplier_mutex = PEGASUS_MUTEX_INITIALIZER;
- //
- // This code uses a, 'hidden' (non-documented), VMS only, logical
+ //
+ // This code uses a, 'hidden' (non-documented), VMS only, logical
// name (environment variable), PEGASUS_VMS_THREAD_STACK_MULTIPLIER,
// to allow in the field adjustment of the thread stack size.
//
// We only check for the logical name once to not have an
// impact on performance.
- //
+ //
// Note: This code may have problems in a multithreaded environment
// with the setting of doneOnce to true.
- //
+ //
// Current code in Cimserver and the clients do some serial thread
// creations first so this is not a problem now.
- //
+ //
if (_multiplier == 0)
{
#if defined(PEGASUS_HAVE_PTHREADS)
int Threads::create(
- ThreadType& thread,
+ ThreadType& thread,
Type type,
- void* (*start)(void*),
+ void* (*start)(void*),
void* arg)
{
// Initialize thread attributes:
return 0;
}
-ThreadType Threads::self()
+ThreadType Threads::self()
{
ThreadType tt;
tt.thread = pthread_self();
//
//==============================================================================
//
-// Author: Mike Brasher (m.brasher@inovadevelopment.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Threads_h
struct ThreadId
{
- // The character representation of a uint64 requires 22 bytes including the
+ // The character representation of a uint64 requires 22 bytes including the
// null terminator.
char buffer[22];
};
#if defined(PEGASUS_HAVE_WINDOWS_THREADS)
struct ThreadType
{
- ThreadType() : handle(NULL)
- {
+ ThreadType() : handle(NULL)
+ {
}
HANDLE handle;
enum Type { DETACHED, JOINABLE };
static int create(
- ThreadType& thread,
+ ThreadType& thread,
Type type,
- void* (*start)(void*),
+ void* (*start)(void*),
void* arg);
static ThreadType self();
#if defined(PEGASUS_HAVE_PTHREADS)
-inline bool Threads::equal(ThreadType x, ThreadType y)
-{
+inline bool Threads::equal(ThreadType x, ThreadType y)
+{
return pthread_equal(x.thread, y.thread);
}
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
const char* s = x.thread.__;
- sprintf(tid.buffer, "%X%X%X%X%X%X%X%X",
+ sprintf(tid.buffer, "%X%X%X%X%X%X%X%X",
s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]);
#else
- sprintf(tid.buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
+ sprintf(tid.buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
Uint64(x.thread));
#endif
#if defined(PEGASUS_HAVE_WINDOWS_THREADS)
-inline ThreadType Threads::self()
+inline ThreadType Threads::self()
{
ThreadType tt;
tt.handle = GetCurrentThread();
return tt;
}
-inline bool Threads::equal(ThreadType x, ThreadType y)
+inline bool Threads::equal(ThreadType x, ThreadType y)
{
return x.handle == y.handle;
}
{
ThreadId tmp;
- sprintf(tmp.buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
+ sprintf(tmp.buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
Uint64(x.handle));
return tmp;
{
#if defined(USE_GETTIMEOFDAY)
- if(tv == NULL)
+ if (tv == NULL)
return EINVAL;
struct timeval tmp;
int Time::subtract(timeval* result, timeval* x, timeval* y)
{
- /* Perform the carry for the later subtraction by updating Y. */
- if (x->tv_usec < y->tv_usec) {
- int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
- y->tv_usec -= 1000000 * nsec;
- y->tv_sec += nsec;
- }
- if (x->tv_usec - y->tv_usec > 1000000) {
- int nsec = (x->tv_usec - y->tv_usec) / 1000000;
- y->tv_usec += 1000000 * nsec;
- y->tv_sec -= nsec;
- }
-
- /* Compute the time remaining to wait.
- `tv_usec' is certainly positive. */
- result->tv_sec = x->tv_sec - y->tv_sec;
- result->tv_usec = x->tv_usec - y->tv_usec;
-
- /* Return 1 if result is negative. */
- return x->tv_sec < y->tv_sec;
+ /* Perform the carry for the later subtraction by updating Y. */
+ if (x->tv_usec < y->tv_usec)
+ {
+ int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
+ y->tv_usec -= 1000000 * nsec;
+ y->tv_sec += nsec;
+ }
+ if (x->tv_usec - y->tv_usec > 1000000)
+ {
+ int nsec = (x->tv_usec - y->tv_usec) / 1000000;
+ y->tv_usec += 1000000 * nsec;
+ y->tv_sec -= nsec;
+ }
+
+ /* Compute the time remaining to wait.
+ `tv_usec' is certainly positive. */
+ result->tv_sec = x->tv_sec - y->tv_sec;
+ result->tv_usec = x->tv_usec - y->tv_usec;
+
+ /* Return 1 if result is negative. */
+ return x->tv_sec < y->tv_sec;
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Config.h>
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_TimeValue_h
{
}
- TimeValue(Uint32 seconds, Uint32 microseconds)
- : _seconds(seconds), _microseconds(microseconds)
+ TimeValue(Uint32 seconds, Uint32 microseconds)
+ : _seconds(seconds), _microseconds(microseconds)
{
}
- Uint32 getSeconds() const
+ Uint32 getSeconds() const
{
- return _seconds;
+ return _seconds;
}
void setSeconds(Uint32 seconds)
{
- _seconds = seconds;
+ _seconds = seconds;
}
- Uint32 getMicroseconds() const
+ Uint32 getMicroseconds() const
{
- return _microseconds;
+ return _microseconds;
}
- Uint64 toMicroseconds() const
+ Uint64 toMicroseconds() const
{
- return (Uint64(_seconds) * Uint64(1000000)) + Uint64(_microseconds);
+ return (Uint64(_seconds) * Uint64(1000000)) + Uint64(_microseconds);
}
void setMicroseconds(Uint32 microseconds)
{
- _microseconds = microseconds;
+ _microseconds = microseconds;
}
void fromMilliseconds(Uint32 milliseconds)
{
- _seconds = milliseconds / 1000;
- _microseconds = (milliseconds % 1000) * 1000;
+ _seconds = milliseconds / 1000;
+ _microseconds = (milliseconds % 1000) * 1000;
}
- Uint32 toMilliseconds() const
+ Uint32 toMilliseconds() const
{
- return _seconds * 1000 + _microseconds / 1000;
+ return _seconds * 1000 + _microseconds / 1000;
}
static TimeValue getCurrentTime()
{
- Uint32 seconds;
- Uint32 microseconds;
- System::getCurrentTimeUsec(seconds, microseconds);
- return TimeValue(seconds, microseconds);
+ Uint32 seconds;
+ Uint32 microseconds;
+ System::getCurrentTimeUsec(seconds, microseconds);
+ return TimeValue(seconds, microseconds);
}
private:
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By: Yi Zhou (yi_zhou@hp.com)
-// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
// REVIEW: Ask how tracing works (note to myself).
/** Steps for adding tracing to a new component:
1. Identify whether the component being added belongs to an existing list
- of trace components. Refer to the trace component list
- (TRACE_COMPONENT_LIST []) defined in this file. If an appropriate
- component is found, note the component identifier (starts with a TRC_)
- from the list of TRACE_COMPONENT_IDs defined in this file and skip
+ of trace components. Refer to the trace component list
+ (TRACE_COMPONENT_LIST []) defined in this file. If an appropriate
+ component is found, note the component identifier (starts with a TRC_)
+ from the list of TRACE_COMPONENT_IDs defined in this file and skip
step 2. If there is no appropriate component available, move to step 2.
- 2. Add the new component to this file. This step includes adding a
+ 2. Add the new component to this file. This step includes adding a
component name and a component identifier.
- a. Add the <component name> to the TRACE_COMPONENT_LIST []. This name
+ a. Add the <component name> to the TRACE_COMPONENT_LIST []. This name
will be used to turn on tracing for the component.
- b. Add the component identifier to the TRACE_COMPONENT_ID list.
- The Component identifier must be formed by prefixing the component
- name with "TRC_"(E.g. TRC_<component name>). The developer should
- use the component identifier, to identify a component in all
+ b. Add the component identifier to the TRACE_COMPONENT_ID list.
+ The Component identifier must be formed by prefixing the component
+ name with "TRC_"(E.g. TRC_<component name>). The developer should
+ use the component identifier, to identify a component in all
trace calls.
- (NOTE: It is important that both the TRACE_COMPONENT_ID and
- TRACE_COMPONENT_LIST [] are updated appropriately to include the
+ (NOTE: It is important that both the TRACE_COMPONENT_ID and
+ TRACE_COMPONENT_LIST [] are updated appropriately to include the
new component.)
- 3. Add the trace calls to the component code. The TRACE_COMPONENT_ID
+ 3. Add the trace calls to the component code. The TRACE_COMPONENT_ID
should be used to identify a component in all trace calls.
-*/
+*/
-/** String constants for naming the various Trace components.
+/** String constants for naming the various Trace components.
These strings will used to while turning on tracing for the respective
- components. The component list needs to be updated whenever a new trace
- component needs to be added. An appropriate string constant should be
+ components. The component list needs to be updated whenever a new trace
+ component needs to be added. An appropriate string constant should be
defined to identify the component to be traced.
-
- Example:
- The following example shows the usage of trace component names.
- The setTraceComponents method is used to turn on tracing for the
- components, config and repository. The component names are passed as a
+
+ Example:
+ The following example shows the usage of trace component names.
+ The setTraceComponents method is used to turn on tracing for the
+ components, config and repository. The component names are passed as a
comma separated list.
-
+
Tracer::setTraceComponents( "Config,Repository");
-
+
*/
static char const* TRACE_COMPONENT_LIST[] =
{
"IndicationFormatter",
"StatisticalData"
};
-/** Constants identifying the Trace components. These constants are used by
+/** Constants identifying the Trace components. These constants are used by
the component to identify its Trace messages. The component ID needs to
- be updated whenever a new trace component needs to be added.
+ be updated whenever a new trace component needs to be added.
The constants need to be prepended with "TRC_". The position of the
constant identifier needs to correspond with the position of the constant
- string definition in the TRACE_COMPONENT_LIST.
-
- Example:
+ string definition in the TRACE_COMPONENT_LIST.
+
+ Example:
The Configuration framework component will be using the constant,
TRC_CONFIG while invoking the trace call.
-
+
PEG_METHOD_ENTER(TRC_CONFIG, "ConfigManager::updateCurrentValue()");
*/
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By: Rudy Schuet (rudy.schuet@compaq.com) 11/12/01
-// added nsk platform support
-// Amit K Arora, IBM (amita@in.ibm.com) for Bug#1527
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
-//#include <fstream>
-//#include <iostream>
#include <Pegasus/Common/FileSystem.h>
#include <Pegasus/Common/TraceFileHandler.h>
// Constructs TraceFileHandler
////////////////////////////////////////////////////////////////////////////////
-TraceFileHandler::TraceFileHandler ()
+TraceFileHandler::TraceFileHandler()
{
_fileName = 0;
_fileHandle = 0;
// Destructs TraceFileHandler
////////////////////////////////////////////////////////////////////////////////
-TraceFileHandler::~TraceFileHandler ()
+TraceFileHandler::~TraceFileHandler()
{
- // Close the File
+ // Close the File
if (_fileHandle)
{
fclose(_fileHandle);
if (!isValidFilePath(fileName))
{
- return 1;
+ return 1;
}
_fileHandle = _openFile(fileName);
if (!_fileHandle)
FileSystem::translateSlashes(fileName);
if (FileSystem::isDirectory(fileName))
{
- return 0;
+ return 0;
}
// Check if the file exists and is writable
{
if (!FileSystem::canWrite(fileName))
{
- return 0;
+ return 0;
}
- else
- {
- return 1;
+ else
+ {
+ return 1;
}
}
else
Uint32 index = fileName.reverseFind('/');
if (index != PEG_NOT_FOUND)
- {
+ {
String dirName = fileName.subString(0,index);
if (!FileSystem::isDirectory(dirName))
{
- return 0;
+ return 0;
}
if (!FileSystem::canWrite(dirName) )
{
- return 0;
+ return 0;
}
- else
- {
- return 1;
+ else
+ {
+ return 1;
}
}
- else
+ else
{
String currentDir;
if (!FileSystem::canWrite(currentDir))
{
- return 0;
+ return 0;
}
- else
- {
- return 1;
+ else
+ {
+ return 1;
}
}
}
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By: Amit K Arora, IBM (amita@in.ibm.com) for Bug#1527
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
PEGASUS_NAMESPACE_BEGIN
-/** TraceFileHandler implements logging of messages to file
+/** TraceFileHandler implements logging of messages to file
*/
-class PEGASUS_COMMON_LINKAGE TraceFileHandler
+class PEGASUS_COMMON_LINKAGE TraceFileHandler
{
private:
*/
FILE* _fileHandle;
- /* Flag to track writing of message to log
+ /* Flag to track writing of message to log
*/
Boolean _wroteToLog;
/** Sets the filename to the given filename and opens the file in append
mode
- @param fileName full path of the file
+ @param fileName full path of the file
@return 0 if the function is successful in opening the file
1 if an error occurs while opening the file
*/
Uint32 setFileName(const char* fileName);
/** Validates the File Path for the trace File
- @param filePath full path of the file
+ @param filePath full path of the file
@return 1 if the file path is valid
0 if the file path is invalid
*/
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By: Amit K Arora, IBM (amita@in.ibm.com) for Bug#1527
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#if defined(PEGASUS_OS_VMS)
// Set permissions on the trace file to 0400
- if (!FileSystem::
- changeFilePermissions(String(_fileName), (S_IRUSR | S_IWUSR)))
+ if (!FileSystem::changeFilePermissions(
+ String(_fileName), (S_IRUSR | S_IWUSR)))
{
- Logger::put_l(Logger::DEBUG_LOG, System::CIMSERVER,
- Logger::WARNING,
- "Common.TraceFileHandlerVms.FAILED_TO_SET_FILE_PERMISSIONS",
- "Failed to set permissions on file $0", _fileName);
+ Logger::put_l(
+ Logger::DEBUG_LOG, System::CIMSERVER, Logger::WARNING,
+ "Common.TraceFileHandlerVms.FAILED_TO_SET_FILE_PERMISSIONS",
+ "Failed to set permissions on file $0", _fileName);
return;
}
}
// Unable to open file, log a message
if (!_wroteToLog)
{
- Logger::put_l(Logger::DEBUG_LOG, System::CIMSERVER,
- Logger::WARNING,
- "Common.TraceFileHandler.FAILED_TO_OPEN_FILE",
- "Failed to open File $0", _fileName);
+ Logger::put_l(
+ Logger::DEBUG_LOG, System::CIMSERVER, Logger::WARNING,
+ "Common.TraceFileHandler.FAILED_TO_OPEN_FILE",
+ "Failed to open File $0", _fileName);
_wroteToLog = true;
}
return;
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By:
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <iostream>
PEGASUS_NAMESPACE_BEGIN
////////////////////////////////////////////////////////////////////////////////
-// Writes message to file.
+// Writes message to file.
// Implementation of this function is platform specific
-//
+//
// Note: The current implementation writes the message to the defined file.
// Will have to be enhanced to support synchronous write operations to
// the same file.
void TraceFileHandler::handleMessage(
const char* message,
const char* fmt,
- va_list argList)
+ va_list argList)
{
Uint32 retCode;
if (retCode < 0)
{
- // Unable to write message to file
- // Log message
- //l10n
- //Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,
- //"Unable to write trace message to File $0",_fileName);
- Logger::put_l(Logger::DEBUG_LOG,System::CIMSERVER,Logger::WARNING,
- "Common.TraceFileHandlerWindows.UNABLE_TO_WRITE_TRACE_TO_FILE",
- "Unable to write trace message to File $0",_fileName);
+ // Unable to write message to file
+ // Log message
+ Logger::put_l(Logger::DEBUG_LOG, System::CIMSERVER, Logger::WARNING,
+ "Common.TraceFileHandlerWindows.UNABLE_TO_WRITE_TRACE_TO_FILE",
+ "Unable to write trace message to File $0", _fileName);
}
- else
- {
+ else
+ {
fflush(_fileHandle);
}
}
else
{
- // Invalid file handle
- // Log message
- //l10n
- //Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,
- //"Invalid file handle for file $0",_fileName);
- Logger::put_l(Logger::DEBUG_LOG,System::CIMSERVER,Logger::WARNING,
- "Common.TraceFileHandlerWindows.INVALID_FILE_HANDLE",
- "Invalid file handle for file $0",_fileName);
+ // Invalid file handle
+ // Log message
+ Logger::put_l(Logger::DEBUG_LOG, System::CIMSERVER, Logger::WARNING,
+ "Common.TraceFileHandlerWindows.INVALID_FILE_HANDLE",
+ "Invalid file handle for file $0", _fileName);
}
-}
+}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By: Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2498
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-// Aruran, IBM (ashanmug@in.ibm.com) for Bug# 4547
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Config.h>
const char Tracer::_METHOD_EXIT_MSG[] = "Exiting method";
// Set Log messages
-const char Tracer::_LOG_MSG[] = "LEVEL1 may only be used with trace macros PEG_METHOD_ENTER/PEG_METHOD_EXIT.";
+const char Tracer::_LOG_MSG[] =
+ "LEVEL1 may only be used with trace macros "
+ "PEG_METHOD_ENTER/PEG_METHOD_EXIT.";
// Initialize singleton instance of Tracer
Tracer* Tracer::_tracerInstance = 0;
const char* fmt,
va_list argList)
{
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
- if (_isTraceEnabled(traceComponent,traceLevel))
+ if (_isTraceEnabled(traceComponent, traceLevel))
{
- _trace(traceComponent,"",fmt,argList);
+ _trace(traceComponent, "", fmt, argList);
}
}
}
{
char* message;
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
// Allocate memory for the message string
// Needs to be updated if additional info is added
//
- message = new char[ strlen(fileName) +
- _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];
+ message = new char[strlen(fileName) +
+ _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8];
sprintf(
message,
"[%d:%s:%s:%u]: ",
fileName,
lineNum);
- _trace(traceComponent,message,fmt,argList);
- delete []message;
+ _trace(traceComponent, message, fmt, argList);
+ delete [] message;
}
}
}
const char* data,
const Uint32 size)
{
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
- if (_isTraceEnabled(traceComponent,traceLevel))
+ if (_isTraceEnabled(traceComponent, traceLevel))
{
char* tmpBuf = new char[size+1];
- strncpy( tmpBuf, data, size );
+ strncpy(tmpBuf, data, size);
tmpBuf[size] = '\0';
- trace(traceComponent,traceLevel,"%s",tmpBuf);
+ trace(traceComponent, traceLevel, "%s", tmpBuf);
- delete []tmpBuf;
+ delete [] tmpBuf;
}
}
}
const char* data,
const Uint32 size)
{
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
- if ( _isTraceEnabled( traceComponent, traceLevel ) )
+ if (_isTraceEnabled(traceComponent, traceLevel))
{
char* tmpBuf = new char[size+1];
strncpy( tmpBuf, data, size );
tmpBuf[size] = '\0';
- trace(fileName,lineNum,traceComponent,traceLevel,"%s",tmpBuf);
+ trace(fileName, lineNum, traceComponent, traceLevel, "%s", tmpBuf);
- delete []tmpBuf;
+ delete [] tmpBuf;
}
}
}
//Traces the given string
////////////////////////////////////////////////////////////////////////////////
void Tracer::_traceString(
- const Uint32 traceComponent,
- const Uint32 traceLevel,
- const String& traceString)
+ const Uint32 traceComponent,
+ const Uint32 traceLevel,
+ const String& traceString)
{
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
if (_isTraceEnabled(traceComponent,traceLevel))
{
- trace(traceComponent,traceLevel,"%s",
+ trace(traceComponent, traceLevel, "%s",
(const char *)traceString.getCString());
}
}
//of trace origin.
////////////////////////////////////////////////////////////////////////////////
void Tracer::_traceString(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 traceLevel,
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 traceLevel,
const String& traceString)
{
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
- if ( _isTraceEnabled( traceComponent, traceLevel ) )
+ if (_isTraceEnabled(traceComponent, traceLevel))
{
- trace(fileName,lineNum,traceComponent,traceLevel,"%s",
+ trace(fileName, lineNum, traceComponent, traceLevel, "%s",
(const char *)traceString.getCString());
}
}
void Tracer::_traceCIMException(
const Uint32 traceComponent,
const Uint32 traceLevel,
- CIMException cimException)
+ const CIMException& cimException)
{
- if ( traceLevel == LEVEL1 )
+ if (traceLevel == LEVEL1)
{
- trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );
+ trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);
}
else
{
- if ( _isTraceEnabled( traceComponent, traceLevel ) )
+ if (_isTraceEnabled(traceComponent, traceLevel))
{
// get the CIMException trace message string
String traceMsg =
va_list argList;
char* message;
- if (_isTraceEnabled(traceComponent,LEVEL1))
+ if (_isTraceEnabled(traceComponent, LEVEL1))
{
- va_start(argList,fmt);
+ va_start(argList, fmt);
//
// Allocate memory for the message string
// Needs to be updated if additional info is added
//
message = new char[ strlen(fileName) +
- _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];
+ _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];
sprintf(
message,
"[%d:%s:%s:%u]: ",
System::getPID(),
- Threads::id().buffer,
+ Threads::id().buffer,
fileName,
lineNum);
- _trace(traceComponent,message,fmt,argList);
+ _trace(traceComponent, message, fmt, argList);
va_end(argList);
- delete []message;
+ delete [] message;
}
}
va_list argList;
char* message;
- if (_isTraceEnabled(traceComponent,LEVEL1))
+ if (_isTraceEnabled(traceComponent, LEVEL1))
{
- va_start(argList,fmt);
+ va_start(argList, fmt);
//
// Allocate memory for the message string
// Needs to be updated if additional info is added
//
- message = new char[ strlen(fileName) +
- _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];
+ message = new char[strlen(fileName) +
+ _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8];
sprintf(
message,
"[%d:%s:%s:%u]: ",
System::getPID(),
- Threads::id().buffer,
+ Threads::id().buffer,
fileName,
lineNum);
- _trace(traceComponent,message,fmt,argList);
+ _trace(traceComponent, message, fmt, argList);
va_end(argList);
- delete []message;
+ delete [] message;
}
}
////////////////////////////////////////////////////////////////////////////////
//Checks if trace is enabled for the given component and level
////////////////////////////////////////////////////////////////////////////////
-Boolean Tracer::_isTraceEnabled(const Uint32 traceComponent,
+Boolean Tracer::_isTraceEnabled(
+ const Uint32 traceComponent,
const Uint32 traceLevel)
{
Tracer* instance = _getInstance();
return false;
}
return (((instance->_traceComponentMask.get())[traceComponent]) &&
- (traceLevel & instance->_traceLevelMask));
+ (traceLevel & instance->_traceLevelMask));
}
////////////////////////////////////////////////////////////////////////////////
// timestamp: <component name> [file name:line number]
if (*message != '\0')
{
- // << Wed Jul 16 10:58:40 2003 mdd >> _STRLEN_MAX_PID_TID is not used in this format string
- msgHeader = new char [strlen(message)
- + strlen(TRACE_COMPONENT_LIST[traceComponent])
- + strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5];
+ // << Wed Jul 16 10:58:40 2003 mdd >> _STRLEN_MAX_PID_TID is not used
+ // in this format string
+ msgHeader = new char [strlen(message) +
+ strlen(TRACE_COMPONENT_LIST[traceComponent]) +
+ strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5];
- sprintf(msgHeader,"%s: %s %s",(const char*)timeStamp,
- TRACE_COMPONENT_LIST[traceComponent] ,message);
- //delete [] msgHeader;
+ sprintf(msgHeader, "%s: %s %s", (const char*)timeStamp,
+ TRACE_COMPONENT_LIST[traceComponent], message);
}
else
{
//
// Since the message is blank form a string using the pid and tid
//
- char* tmpBuffer;
+ char* tmpBuffer;
//
// Allocate messageHeader.
// Needs to be updated if additional info is added
//
tmpBuffer = new char[2 * _STRLEN_MAX_PID_TID + 6];
- sprintf(tmpBuffer, "[%u:%s]: ", System::getPID(), Threads::id().buffer);
- msgHeader = new char [ strlen(timeStamp) + strlen(TRACE_COMPONENT_LIST[traceComponent]) +
- strlen(tmpBuffer) + 1 + 5 ];
-
- sprintf(msgHeader,"%s: %s %s ",(const char*)timeStamp,
- TRACE_COMPONENT_LIST[traceComponent] ,tmpBuffer );
- delete []tmpBuffer;
- //delete [] msgHeader;
+ sprintf(tmpBuffer, "[%u:%s]: ",
+ System::getPID(), Threads::id().buffer);
+ msgHeader = new char[strlen(timeStamp) +
+ strlen(TRACE_COMPONENT_LIST[traceComponent]) +
+ strlen(tmpBuffer) + 1 + 5];
+ sprintf(msgHeader, "%s: %s %s ", (const char*)timeStamp,
+ TRACE_COMPONENT_LIST[traceComponent], tmpBuffer);
+ delete [] tmpBuffer;
}
// Call trace file handler to write message
String moduleName = _getInstance()->_moduleName;
if (moduleName == String::EMPTY)
{
- return (_getInstance()->_traceHandler->isValidFilePath(filePath));
+ return _getInstance()->_traceHandler->isValidFilePath(filePath);
}
else
{
String extendedFilePath = String(filePath) + "." + moduleName;
- return (_getInstance()->_traceHandler->isValidFilePath(
- extendedFilePath.getCString()));
+ return _getInstance()->_traceHandler->isValidFilePath(
+ extendedFilePath.getCString());
}
}
}
Boolean Tracer::isValidComponents(
- const String& traceComponents, String& invalidComponents)
+ const String& traceComponents,
+ String& invalidComponents)
{
// Validate the trace components and modify the traceComponents argument
// to reflect the invalid components
// Remove the searched componentname from the traceComponents
componentStr.remove(0,position+1);
- if ( !validComponent )
+ if (!validComponent)
{
invalidComponents.append(componentName);
invalidComponents.append(_COMPONENT_SEPARATOR);
// trace components is empty, it is a valid value so return true
return _SUCCESS;
}
- if ( invalidComponents != String::EMPTY )
+
+ if (invalidComponents != String::EMPTY)
{
retCode = false;
//
String moduleName = _getInstance()->_moduleName;
if (moduleName == String::EMPTY)
{
- return (_getInstance()->_traceHandler->setFileName(traceFile));
+ return _getInstance()->_traceHandler->setFileName(traceFile);
}
else
{
String extendedTraceFile = String(traceFile) + "." + moduleName;
- return (_getInstance()->_traceHandler->setFileName(
- extendedTraceFile.getCString()));
+ return _getInstance()->_traceHandler->setFileName(
+ extendedTraceFile.getCString());
}
}
// Check if ALL is specified
if (String::equalNoCase(componentStr,"ALL"))
{
- for (index=0; index < _NUM_COMPONENTS;
- (_getInstance()->_traceComponentMask.get())[index++] = true);
+ for (index = 0; index < _NUM_COMPONENTS; index++)
+ {
+ (_getInstance()->_traceComponentMask.get())[index] = true;
+ }
_traceOn = true;
- return ;
+ return;
}
- // initialise ComponentMask array to False
- for (index = 0;index < _NUM_COMPONENTS;
- (_getInstance()->_traceComponentMask.get())[index++] = false);
+ // initialize ComponentMask array to False
+ for (index = 0; index < _NUM_COMPONENTS; index++)
+ {
+ (_getInstance()->_traceComponentMask.get())[index] = false;
+ }
_traceOn = false;
// Append _COMPONENT_SEPARATOR to the end of the traceComponents
if (String::equalNoCase(
componentName,TRACE_COMPONENT_LIST[index]))
{
- (_getInstance()->_traceComponentMask.get())[index]=true;
+ (_getInstance()->_traceComponentMask.get())[index] = true;
_traceOn = true;
// Found component, break from the loop
else
{
// initialise ComponentMask array to False
- for (Uint32 index = 0;index < _NUM_COMPONENTS;
- (_getInstance()->_traceComponentMask.get())[index++] = false);
+ for (Uint32 index = 0;index < _NUM_COMPONENTS; index++)
+ {
+ (_getInstance()->_traceComponentMask.get())[index] = false;
+ }
_traceOn = 0;
}
return ;
}
-void Tracer::traceEnter(TracerToken& token, Uint32 traceComponent, const char* method)
+void Tracer::traceEnter(
+ TracerToken& token,
+ Uint32 traceComponent,
+ const char* method)
{
if (_traceOn)
{
- token.component = traceComponent;
- token.method = method;
+ token.component = traceComponent;
+ token.method = method;
- //Tracer::traceEnter("unknown", 0, component, method);
- _traceEnter( "unknown", 0, traceComponent, "%s %s",
- _METHOD_ENTER_MSG, method);
+ _traceEnter(
+ "unknown", 0, traceComponent, "%s %s", _METHOD_ENTER_MSG, method);
}
}
void Tracer::traceExit(TracerToken& token)
{
if (_traceOn)
-
- // KS Tracer::traceExit("unknown", 0, token.component, token.method);
- _traceExit( "unknown",0, token.component, "%s %s",
+ _traceExit(
+ "unknown",0, token.component, "%s %s",
_METHOD_EXIT_MSG, token.method);
}
void Tracer::traceEnter(
- TracerToken& token,
+ TracerToken& token,
const char* file,
size_t line,
- Uint32 traceComponent,
+ Uint32 traceComponent,
const char* method)
{
if (_traceOn)
{
- token.component = traceComponent;
- token.method = method;
+ token.component = traceComponent;
+ token.method = method;
- //Tracer::traceEnter(file, line, component, method);
- _traceEnter( file, line, traceComponent, "%s %s",
- _METHOD_ENTER_MSG, method);
+ _traceEnter(
+ file, line, traceComponent, "%s %s", _METHOD_ENTER_MSG, method);
}
}
size_t line)
{
if (_traceOn)
- //Tracer::traceExit(file, line, token.component, token.method);
- _traceExit( file, line, token.component, "%s %s",
- _METHOD_EXIT_MSG, token.method);
+ _traceExit(
+ file, line, token.component, "%s %s",
+ _METHOD_EXIT_MSG, token.method);
}
void Tracer::traceBuffer(
const Uint32 size)
{
if (_traceOn)
- _traceBuffer( traceComponent, traceLevel, data, size );
+ _traceBuffer(traceComponent, traceLevel, data, size);
}
void Tracer::traceBuffer(
{
if (_traceOn)
{
- _traceBuffer( fileName, lineNum,
- traceComponent, traceLevel, data, size );
+ _traceBuffer(
+ fileName, lineNum, traceComponent, traceLevel, data, size);
}
}
{
if (_traceOn)
{
- va_list argList;
+ va_list argList;
- va_start(argList,fmt);
- _trace(traceComponent,traceLevel,fmt,argList);
- va_end(argList);
+ va_start(argList,fmt);
+ _trace(traceComponent,traceLevel,fmt,argList);
+ va_end(argList);
}
}
{
if (_traceOn)
{
- va_list argList;
+ va_list argList;
- va_start(argList,fmt);
- _trace(fileName,lineNum,traceComponent,traceLevel,fmt,argList);
- va_end(argList);
+ va_start(argList,fmt);
+ _trace(fileName,lineNum,traceComponent,traceLevel,fmt,argList);
+ va_end(argList);
}
}
void Tracer::trace(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 traceLevel,
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 traceLevel,
const String& traceString)
{
if (_traceOn)
{
- _traceString( fileName, lineNum, traceComponent, traceLevel,
- traceString );
+ _traceString(
+ fileName, lineNum, traceComponent, traceLevel, traceString);
}
}
void Tracer::traceCIMException(
- const Uint32 traceComponent,
- const Uint32 traceLevel,
- CIMException cimException)
+ const Uint32 traceComponent,
+ const Uint32 traceLevel,
+ const CIMException& cimException)
{
if (_traceOn)
{
- _traceCIMException( traceComponent, traceLevel, cimException );
+ _traceCIMException(traceComponent, traceLevel, cimException);
}
}
void Tracer::trace(
- const Uint32 traceComponent,
- const Uint32 level,
+ const Uint32 traceComponent,
+ const Uint32 level,
const String& string)
{
trace("unknown", 0, traceComponent, level, string);
//
//==============================================================================
//
-// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
-//
-// Modified By: Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Tracer_h
static const Uint32 LEVEL4;
/** Traces the specified number of bytes in a given buffer
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param data buffer to be traced
- @param size number of bytes to be traced
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param data buffer to be traced
+ @param size number of bytes to be traced
*/
static void traceBuffer(
- const Uint32 traceComponent,
- const Uint32 level,
- const char* data,
- const Uint32 size);
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const char* data,
+ const Uint32 size);
/** Traces the specified number of bytes in a given buffer
- Overloaded to include the filename and the line number
- of trace origin.
- @param fileName filename of the trace originator
- @param lineNum line number of the trace originator
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param data buffer to be traced
- @param size size of the buffer
+ Overloaded to include the filename and the line number
+ of trace origin.
+ @param fileName filename of the trace originator
+ @param lineNum line number of the trace originator
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param data buffer to be traced
+ @param size size of the buffer
*/
static void traceBuffer(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 level,
- const char* data,
- const Uint32 size);
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const char* data,
+ const Uint32 size);
/** Traces the given message
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param *fmt printf style format string
- @param ... variable argument list
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param *fmt printf style format string
+ @param ... variable argument list
*/
static void trace(
- const Uint32 traceComponent,
- const Uint32 level,
- const char *fmt,
- ...);
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const char *fmt,
+ ...);
/** Traces the given message. Overloaded to include the filename and
- the line number of trace origin.
- @param fileName filename of the trace originator
- @param lineNum line number of the trace originator
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param *fmt printf style format string
- @param ... variable argument list
+ the line number of trace origin.
+ @param fileName filename of the trace originator
+ @param lineNum line number of the trace originator
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param *fmt printf style format string
+ @param ... variable argument list
*/
static void trace(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 level,
- const char* fmt,
- ...);
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const char* fmt,
+ ...);
/** Traces the given string. Overloaded to include the filename
- and line number of trace origin.
- @param fileName filename of the trace originator
- @param lineNum line number of the trace originator
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param string the string to be traced
+ and line number of trace origin.
+ @param fileName filename of the trace originator
+ @param lineNum line number of the trace originator
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param string the string to be traced
*/
static void trace(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 level,
- const String& string);
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const String& string);
/** Traces the given string.
- @param fileName filename of the trace originator
- @param lineNum line number of the trace originator
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param string the string to be traced
+ @param fileName filename of the trace originator
+ @param lineNum line number of the trace originator
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param string the string to be traced
*/
static void trace(
- const Uint32 traceComponent,
- const Uint32 level,
- const String& string);
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const String& string);
/** Traces the message in the given CIMException object. The message
- written to the trace file will include the source filename and
- line number of the CIMException originator.
- @param traceComponent component being traced
- @param level trace level of the trace message
- @param CIMException the CIMException to be traced.
+ written to the trace file will include the source filename and
+ line number of the CIMException originator.
+ @param traceComponent component being traced
+ @param level trace level of the trace message
+ @param CIMException the CIMException to be traced.
*/
static void traceCIMException(
- const Uint32 traceComponent,
- const Uint32 level,
- CIMException cimException);
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const CIMException& cimException);
/** Set the trace file to the given file
- @param traceFile full path of the trace file
- @return 0 if the filepath is valid
- 1 if the traceFile is an empty string or
- if an error occurs while opening the file
- in append mode
+ @param traceFile full path of the trace file
+ @return 0 if the filepath is valid
+ 1 if the traceFile is an empty string or
+ if an error occurs while opening the file
+ in append mode
*/
static Uint32 setTraceFile(const char* traceFile);
/** Set the trace level to the given level
- @param level trace level to be set
- @return 0 if trace level is valid
- 1 if trace level is invalid
+ @param level trace level to be set
+ @return 0 if trace level is valid
+ 1 if trace level is invalid
*/
static Uint32 setTraceLevel(const Uint32 level);
/** Set components to be traced
- @param traceComponents list of components to be traced,
- components should be separated by ','
+ @param traceComponents list of components to be traced,
+ components should be separated by ','
*/
static void setTraceComponents(
const String& traceComponents);
/** Traces method entry.
- @param token TracerToken
- @param traceComponent component being traced
- @param methodName method being traced
+ @param token TracerToken
+ @param traceComponent component being traced
+ @param methodName method being traced
*/
static void traceEnter(
- TracerToken& token,
- Uint32 component,
- const char* method);
+ TracerToken& token,
+ Uint32 component,
+ const char* method);
/** Traces method exit.
- @param token TracerToken containing component and method
+ @param token TracerToken containing component and method
*/
static void traceExit(
- TracerToken& token);
+ TracerToken& token);
/** Traces method entry.
- @param token TracerToken
- @param fileName filename of the trace originator
- @param lineNum line number of the trace originator
- @param traceComponent component being traced
- @param methodName method being traced
+ @param token TracerToken
+ @param fileName filename of the trace originator
+ @param lineNum line number of the trace originator
+ @param traceComponent component being traced
+ @param methodName method being traced
*/
static void traceEnter(
- TracerToken& token,
- const char* file,
- size_t line,
- Uint32 component,
- const char* method);
+ TracerToken& token,
+ const char* file,
+ size_t line,
+ Uint32 component,
+ const char* method);
/** Traces method exit.
- @param token TracerToken containing component and method
- @param fileName filename of the trace originator
- @param lineNum line number of the trace originator
+ @param token TracerToken containing component and method
+ @param fileName filename of the trace originator
+ @param lineNum line number of the trace originator
*/
static void traceExit(
- TracerToken& token,
- const char* file,
- size_t line);
+ TracerToken& token,
+ const char* file,
+ size_t line);
/** Validates the File Path for the trace File
- @param filePath full path of the file
- @return 1 if the file path is valid
- 0 if the file path is invalid
+ @param filePath full path of the file
+ @return 1 if the file path is valid
+ 0 if the file path is invalid
*/
static Boolean isValidFileName(const char* filePath);
/** Validates the trace components
- @param traceComponents comma separated list of trace components
- @return 1 if the components are valid
- 0 if one or more components are invalid
+ @param traceComponents comma separated list of trace components
+ @return 1 if the components are valid
+ 0 if one or more components are invalid
*/
static Boolean isValidComponents(const String& traceComponents);
/** Validates the trace components
- @param traceComponents comma separated list of trace components
- @param invalidComponents comma separated list of invalid components
- @return 1 if the components are valid
- 0 if one or more components are invalid
+ @param traceComponents comma separated list of trace components
+ @param invalidComponents comma separated list of invalid components
+ @return 1 if the components are valid
+ 0 if one or more components are invalid
*/
static Boolean isValidComponents(
const String& traceComponents,
/** Specify the name of the module being traced. If non-empty, this
value is used as an extension to the name of the trace file.
- @param moduleName Name of the module being traced.
+ @param moduleName Name of the module being traced.
*/
static void setModuleName(const String& moduleName);
// @return 0 if the component and level are not enabled
// 1 if the component and level are enabled
static Boolean _isTraceEnabled(
- const Uint32 traceComponent,
- const Uint32 level);
+ const Uint32 traceComponent,
+ const Uint32 level);
// Traces the given message
// @param traceComponent component being traced
// @param *fmt printf style format string
// @param argList variable argument list
static void _trace(
- const Uint32 traceComponent,
+ const Uint32 traceComponent,
const Uint32 level,
- const char* fmt,
- va_list argList);
+ const char* fmt,
+ va_list argList);
// Traces the given message. Overloaded to include the file name and the
// line number as one of the parameters.
// @param *fmt printf style format string
// @param argList variable argument list
static void _trace(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
const Uint32 level,
- const char* fmt,
- va_list argList);
+ const char* fmt,
+ va_list argList);
// Traces the specified number of bytes in a given buffer
// @param traceComponent component being traced
// @param data buffer to be traced
// @param size number of bytes to be traced
static void _traceBuffer(
- const Uint32 traceComponent,
+ const Uint32 traceComponent,
const Uint32 level,
- const char* data,
+ const char* data,
const Uint32 size);
// Traces the specified number of bytes in a given buffer
// @param data buffer to be traced
// @param size size of the buffer
static void _traceBuffer(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
const Uint32 level,
- const char* data,
+ const char* data,
const Uint32 size);
// Traces the given string.
// @param string the string to be traced
//
static void _traceString(
- const Uint32 traceComponent,
- const Uint32 level,
+ const Uint32 traceComponent,
+ const Uint32 level,
const String& string);
// Traces a given string. Overloaded to include the filename
// @param string the string to be traced
//
static void _traceString(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 level,
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 level,
const String& string);
// Traces the message in the given CIMException object. The message
// @param CIMException the CIMException to be traced.
//
static void _traceCIMException(
- const Uint32 traceComponent,
- const Uint32 level,
- CIMException cimException);
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const CIMException& cimException);
// Called by all the trace interfaces to log message to the
// trace file
// @param *fmt printf style format string
// @param argList variable argument list
static void _trace(
- const Uint32 traceComponent,
- const char* message,
- const char* fmt,
- va_list argList);
+ const Uint32 traceComponent,
+ const char* message,
+ const char* fmt,
+ va_list argList);
// Traces method enter
// @param fileName filename of the trace originator
// @param *fmt printf style format string
// @param ... variable argument list
static void _traceEnter(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const char* fmt,
- ...);
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const char* fmt,
+ ...);
// Traces method exit
// @param fileName filename of the trace originator
// @param *fmt printf style format string
// @param ... variable argument list
static void _traceExit(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const char* fmt,
- ...);
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const char* fmt,
+ ...);
// Tracer constructor
// Constructor is private to prevent construction of Tracer objects
}
inline void Tracer::trace(
- const char* fileName,
+ const char* fileName,
const Uint32 lineNum,
const Uint32 traceComponent,
const Uint32 level,
}
inline void Tracer::trace(
- const char* fileName,
- const Uint32 lineNum,
- const Uint32 traceComponent,
- const Uint32 level,
+ const char* fileName,
+ const Uint32 lineNum,
+ const Uint32 traceComponent,
+ const Uint32 level,
const String& string)
{
// empty function
}
inline void Tracer::trace(
- const Uint32 traceComponent,
- const Uint32 level,
+ const Uint32 traceComponent,
+ const Uint32 level,
const String& string)
{
// empty function
}
inline void Tracer::traceCIMException(
- const Uint32 traceComponent,
- const Uint32 level,
- CIMException cimException)
+ const Uint32 traceComponent,
+ const Uint32 level,
+ const CIMException& cimException)
{
// empty function
}
# define PEG_TRACE_STRING(comp, level, string) \
do \
{ \
- Tracer::trace(PEGASUS_FILE_LINE_COMMA comp, level, string); \
+ Tracer::trace(PEGASUS_FILE_LINE_COMMA comp, level, string); \
} \
while (0)
-// Macro for Trace variable number of arguments with format string. The trace test
-// is included becase of the possible cost of preparing the variable
+// Macro for Trace variable number of arguments with format string. The trace
+// test is included becase of the possible cost of preparing the variable
// number of arguments on each call. The d construct allows this to be
// treated as a single statement.
# define PEG_TRACE(VAR_ARGS) \
do \
{ \
- if (Tracer::isTraceOn()) \
- Tracer::trace VAR_ARGS; \
+ if (Tracer::isTraceOn()) \
+ Tracer::trace VAR_ARGS; \
} \
while (0)
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "Union.h"
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Dave Sudlik, IBM (dsudlik@us.ibm.com)
-// Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_Union_h
/** This union is used to represent the values of properties, qualifiers,
method return values, and method arguments. All of the types
- defined in CIMType.h are represented by a Union. The
+ defined in CIMType.h are represented by a Union. The
Union is used as the the basis for the CIMValue implementation.
*/
union Union
char _dateTimeValue[sizeof(void*)];
char _referenceValue[sizeof(void*)];
char _objectValue[sizeof(void*)];
-#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
char _instanceValue[sizeof(void*)];
-#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
char _booleanArray[sizeof(void*)];
char _uint8Array[sizeof(void*)];
char _dateTimeArray[sizeof(void*)];
char _referenceArray[sizeof(void*)];
char _objectArray[sizeof(void*)];
-#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
char _instanceArray[sizeof(void*)];
-#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
void* _voidPtr;
};
//
//==============================================================================
//
-// Author: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-//
-// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_XmlConstants_h
//
// This include file contains constants related to the CIM XML encoding,
-// including XML elements, and exception message strings appropriate for
+// including XML elements, and exception message strings appropriate for
// XML validation exception conditions.
//
* <MULTIREQ> element.
*
*/
-static const char MISSING_ELEMENT_REQ [] =
+static const char MISSING_ELEMENT_REQ [] =
"expected SIMPLEREQ or MULTIREQ element";
-
-//l10n
-static const char MISSING_ELEMENT_REQ_KEY [] =
- "Common.XmlConstants.MISSING_ELEMENT_REQ";
+
+static const char MISSING_ELEMENT_REQ_KEY [] =
+ "Common.XmlConstants.MISSING_ELEMENT_REQ";
/**
*
* <LOCALINSTANCEPATH> element.
*
*/
-static const char MISSING_ELEMENT_LOCALPATH [] =
+static const char MISSING_ELEMENT_LOCALPATH [] =
"expected LOCALCLASSPATH or LOCALINSTANCEPATH element";
-//l10n
static const char MISSING_ELEMENT_LOCALPATH_KEY [] =
- "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH_KEY";
+ "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH_KEY";
+
PEGASUS_NAMESPACE_END
#endif /* Pegasus_XmlConstants_h */
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// TODO:
//
-// ATTN: KS P1 4 Mar 2002. Review the following TODOs to see if there is
+// ATTN: KS P1 4 Mar 2002. Review the following TODOs to see if there is
// work. Handle <!DOCTYPE...> sections which are complicated (containing
// rules rather than references to files).
//
}
*/
-static MessageLoaderParms _formMessage(Uint32 code, Uint32 line, const String& message)
+static MessageLoaderParms _formMessage(
+ Uint32 code,
+ Uint32 line,
+ const String& message)
{
String dftMsg = _xmlMessages[Uint32(code) - 1];
String key = _xmlKeys[Uint32(code) - 1];
const String& message)
: XmlException(XmlException::VALIDATION_ERROR, lineNumber, message)
{
-
}
MessageLoaderParms& msgParms)
: XmlException(XmlException::VALIDATION_ERROR, lineNumber, msgParms)
{
-
}
const String& message)
: XmlException(XmlException::SEMANTIC_ERROR, lineNumber, message)
{
-
}
MessageLoaderParms& msgParms)
: XmlException(XmlException::SEMANTIC_ERROR, lineNumber, msgParms)
{
-
}
//
////////////////////////////////////////////////////////////////////////////////
-XmlParser::XmlParser(char* text) : _line(1), _text(text), _current(text),
- _restoreChar('\0'), _foundRoot(false)
+XmlParser::XmlParser(char* text)
+ : _line(1),
+ _text(text),
+ _current(text),
+ _restoreChar('\0'),
+ _foundRoot(false)
{
-
}
inline void _skipWhitespace(Uint32& line, char*& p)
}
}
- // We encountered a the end_char or a zero-terminator.
+ // We encountered a the end_char or a zero-terminator.
*q = *p;
}
// A-Za-z0-9_-:.
-static unsigned char _isInnerElementChar[] =
+static unsigned char _isInnerElementChar[] =
{
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_XmlParser_h
enum Code
{
- BAD_START_TAG = 1,
- BAD_END_TAG,
- BAD_ATTRIBUTE_NAME,
- EXPECTED_EQUAL_SIGN,
- BAD_ATTRIBUTE_VALUE,
- MINUS_MINUS_IN_COMMENT,
- UNTERMINATED_COMMENT,
- UNTERMINATED_CDATA,
- UNTERMINATED_DOCTYPE,
- TOO_MANY_ATTRIBUTES,
- MALFORMED_REFERENCE,
- EXPECTED_COMMENT_OR_CDATA,
- START_END_MISMATCH,
- UNCLOSED_TAGS,
- MULTIPLE_ROOTS,
- VALIDATION_ERROR,
- SEMANTIC_ERROR
+ BAD_START_TAG = 1,
+ BAD_END_TAG,
+ BAD_ATTRIBUTE_NAME,
+ EXPECTED_EQUAL_SIGN,
+ BAD_ATTRIBUTE_VALUE,
+ MINUS_MINUS_IN_COMMENT,
+ UNTERMINATED_COMMENT,
+ UNTERMINATED_CDATA,
+ UNTERMINATED_DOCTYPE,
+ TOO_MANY_ATTRIBUTES,
+ MALFORMED_REFERENCE,
+ EXPECTED_COMMENT_OR_CDATA,
+ START_END_MISMATCH,
+ UNCLOSED_TAGS,
+ MULTIPLE_ROOTS,
+ VALIDATION_ERROR,
+ SEMANTIC_ERROR
};
XmlException(
- Code code,
- Uint32 lineNumber,
- const String& message = String());
-
-
+ Code code,
+ Uint32 lineNumber,
+ const String& message = String());
+
+
XmlException(
- Code code,
- Uint32 lineNumber,
- MessageLoaderParms& msgParms);
+ Code code,
+ Uint32 lineNumber,
+ MessageLoaderParms& msgParms);
XmlException::Code getCode() const { return _code; }
public:
XmlValidationError(Uint32 lineNumber, const String& message);
- XmlValidationError(Uint32 lineNumber, MessageLoaderParms& msgParms);
+ XmlValidationError(Uint32 lineNumber, MessageLoaderParms& msgParms);
};
class PEGASUS_COMMON_LINKAGE XmlSemanticError : public XmlException
public:
XmlSemanticError(Uint32 lineNumber, const String& message);
- XmlSemanticError(Uint32 lineNumber, MessageLoaderParms& msgParms);
+ XmlSemanticError(Uint32 lineNumber, MessageLoaderParms& msgParms);
};
struct XmlAttribute
{
enum CIMType
{
- XML_DECLARATION,
- START_TAG,
- EMPTY_TAG,
- END_TAG,
- COMMENT,
- CDATA,
- DOCTYPE,
- CONTENT
+ XML_DECLARATION,
+ START_TAG,
+ EMPTY_TAG,
+ END_TAG,
+ COMMENT,
+ CDATA,
+ DOCTYPE,
+ CONTENT
};
enum { MAX_ATTRIBUTES = 10 };
};
PEGASUS_COMMON_LINKAGE void XmlAppendCString(
- Buffer& out,
+ Buffer& out,
const char* str);
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
-// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3103
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Config.h>
#include <errno.h>
#include <cstdio>
#include <cstdlib>
#if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
-#include <errno.h>
+# include <errno.h>
#endif
#include "CIMName.h"
#include "XmlReader.h"
#include "System.h"
#include "XmlConstants.h"
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
-#include "EBCDIC_OS400.h"
+# include "EBCDIC_OS400.h"
#endif
-// l10n
+
#include <Pegasus/Common/MessageLoader.h>
#include <Pegasus/Common/AutoPtr.h>
#include "CIMNameUnchecked.h"
//------------------------------------------------------------------------------
void XmlReader::getXmlDeclaration(
- XmlParser& parser,
+ XmlParser& parser,
const char*& xmlVersion,
const char*& xmlEncoding)
{
XmlEntry entry;
if (!parser.next(entry) ||
- entry.type != XmlEntry::XML_DECLARATION ||
- strcmp(entry.text, "xml") != 0)
+ entry.type != XmlEntry::XML_DECLARATION ||
+ strcmp(entry.text, "xml") != 0)
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected <?xml ... ?> style declaration");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",
- "Expected <?xml ... ?> style declaration");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_XML_STYLE",
+ "Expected <?xml ... ?> style declaration");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
- if (!entry.getAttributeValue("version", xmlVersion)) {
-
- // l10n
-
- // throw XmlValidationError(
- // parser.getLine(), "missing xml.version attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE",
- "missing xml.version attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("version", xmlVersion))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_XML_ATTRIBUTE",
+ "missing xml.version attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
if (!entry.getAttributeValue("encoding", xmlEncoding))
//------------------------------------------------------------------------------
void XmlReader::expectStartTag(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry,
const char* tagName)
{
if (!parser.next(entry) ||
- entry.type != XmlEntry::START_TAG ||
- strcmp(entry.text, tagName) != 0)
+ entry.type != XmlEntry::START_TAG ||
+ strcmp(entry.text, tagName) != 0)
{
- // l10n
-
- // char message[MESSAGE_SIZE];
- // sprintf(message, "Expected open of %s element", tagName);
- // throw XmlValidationError(parser.getLine(), message);
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
- "Expected open of $0 element",
- tagName);
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_OPEN",
+ "Expected open of $0 element",
+ tagName);
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
XmlEntry entry;
if (!parser.next(entry) ||
- entry.type != XmlEntry::END_TAG ||
- strcmp(entry.text, tagName) != 0)
+ entry.type != XmlEntry::END_TAG ||
+ strcmp(entry.text, tagName) != 0)
{
-
- // l10n
-
- // char message[MESSAGE_SIZE];
- // sprintf(message, "Expected close of %s element, got %s instead",
- // tagName,entry.text);
- // throw XmlValidationError(parser.getLine(), message);
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLOSE",
- "Expected close of $0 element, got $1 instead",
- tagName,entry.text);
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLOSE",
+ "Expected close of $0 element, got $1 instead",
+ tagName,entry.text);
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
//------------------------------------------------------------------------------
void XmlReader::expectStartTagOrEmptyTag(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry,
const char* tagName)
{
if (!parser.next(entry) ||
- (entry.type != XmlEntry::START_TAG &&
- entry.type != XmlEntry::EMPTY_TAG) ||
- strcmp(entry.text, tagName) != 0)
+ (entry.type != XmlEntry::START_TAG &&
+ entry.type != XmlEntry::EMPTY_TAG) ||
+ strcmp(entry.text, tagName) != 0)
{
- // l10n
-
- // char message[MESSAGE_SIZE];
- // sprintf(message,
- // "Expected either open or open/close %s element", tagName);
- // throw XmlValidationError(parser.getLine(), message);
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPENCLOSE",
- "Expected either open or open/close $0 element",
- tagName);
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_OPENCLOSE",
+ "Expected either open or open/close $0 element",
+ tagName);
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
//------------------------------------------------------------------------------
Boolean XmlReader::expectContentOrCData(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry)
{
if (!parser.next(entry) ||
- (entry.type != XmlEntry::CONTENT &&
- entry.type != XmlEntry::CDATA))
+ (entry.type != XmlEntry::CONTENT &&
+ entry.type != XmlEntry::CDATA))
{
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected content of CDATA");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",
- "Expected content of CDATA");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CDATA",
+ "Expected content of CDATA");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::testStartTag(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry,
const char* tagName)
{
if (!parser.next(entry) ||
- entry.type != XmlEntry::START_TAG ||
- strcmp(entry.text, tagName) != 0)
+ entry.type != XmlEntry::START_TAG ||
+ strcmp(entry.text, tagName) != 0)
{
- parser.putBack(entry);
- return false;
+ parser.putBack(entry);
+ return false;
}
return true;
XmlEntry entry;
if (!parser.next(entry) ||
- entry.type != XmlEntry::END_TAG ||
- strcmp(entry.text, tagName) != 0)
+ entry.type != XmlEntry::END_TAG ||
+ strcmp(entry.text, tagName) != 0)
{
- parser.putBack(entry);
- return false;
+ parser.putBack(entry);
+ return false;
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::testStartTagOrEmptyTag(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry,
const char* tagName)
{
if (!parser.next(entry) ||
(entry.type != XmlEntry::START_TAG &&
entry.type != XmlEntry::EMPTY_TAG) ||
- strcmp(entry.text, tagName) != 0)
+ strcmp(entry.text, tagName) != 0)
{
- parser.putBack(entry);
- return false;
+ parser.putBack(entry);
+ return false;
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::testStartTagOrEmptyTag(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry)
{
if (!parser.next(entry) ||
- (entry.type != XmlEntry::START_TAG &&
- entry.type != XmlEntry::EMPTY_TAG))
+ (entry.type != XmlEntry::START_TAG &&
+ entry.type != XmlEntry::EMPTY_TAG))
{
- parser.putBack(entry);
- return false;
+ parser.putBack(entry);
+ return false;
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::testContentOrCData(
- XmlParser& parser,
+ XmlParser& parser,
XmlEntry& entry)
{
if (!parser.next(entry) ||
- (entry.type != XmlEntry::CONTENT &&
- entry.type != XmlEntry::CDATA))
+ (entry.type != XmlEntry::CONTENT &&
+ entry.type != XmlEntry::CDATA))
{
- parser.putBack(entry);
- return false;
+ parser.putBack(entry);
+ return false;
}
return true;
// getCimStartTag()
//
// <!ELEMENT CIM (MESSAGE|DECLARATION)>
-// <!ATTRLIST CIM
+// <!ATTRLIST CIM
// CIMVERSION CDATA #REQUIRED
// DTDVERSION CDATA #REQUIRED>
//
//------------------------------------------------------------------------------
void XmlReader::getCimStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& cimVersion,
const char*& dtdVersion)
{
XmlEntry entry;
XmlReader::expectStartTag(parser, entry, "CIM");
- if (!entry.getAttributeValue("CIMVERSION", cimVersion)) {
-
- // l10n
-
- // throw XmlValidationError(
- // parser.getLine(), "missing CIM.CIMVERSION attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",
- "missing CIM.CIMVERSION attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("CIMVERSION", cimVersion))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",
+ "missing CIM.CIMVERSION attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
- if (!entry.getAttributeValue("DTDVERSION", dtdVersion)){
-
- // l10n
-
- // throw XmlValidationError(
- // parser.getLine(), "missing CIM.DTDVERSION attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",
- "missing CIM.DTDVERSION attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("DTDVERSION", dtdVersion))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",
+ "missing CIM.DTDVERSION attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
//------------------------------------------------------------------------------
CIMName XmlReader::getCimNameAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* elementName,
Boolean acceptNull)
String name;
if (!entry.getAttributeValue("NAME", name))
- {
-
- // l10n
-
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer, "missing %s.NAME attribute", elementName);
- // throw XmlValidationError(lineNumber, buffer);
-
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.NAME", elementName);
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
- "missing $0 attribute",
- buffer);
+ {
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.NAME", elementName);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_ATTRIBUTE",
+ "missing $0 attribute",
+ buffer);
- throw XmlValidationError(lineNumber, mlParms);
+ throw XmlValidationError(lineNumber, mlParms);
}
if (acceptNull && name.size() == 0)
- return CIMName ();
-
+ return CIMName ();
+
if (!CIMName::legal(name))
{
#ifdef PEGASUS_SNIA_INTEROP_TEST
// In testing, replace illegal CIMName with this value to avoid the
- // exception and let xml parsing continue. THIS IS TEMP.
+ // exception and let xml parsing continue. THIS IS TEMP.
name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT";
#else
- // l10n
-
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);
- // throw XmlSemanticError(lineNumber, buffer);
-
char buffer[MESSAGE_SIZE];
sprintf(buffer, "%s.NAME", elementName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
+
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
+
throw XmlSemanticError(lineNumber, mlParms);
#endif
//------------------------------------------------------------------------------
String XmlReader::getClassNameAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* elementName)
{
if (!entry.getAttributeValue("CLASSNAME", name))
{
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.CLASSNAME", elementName);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_ATTRIBUTE",
+ "missing $0 attribute",
+ buffer);
- // l10n
-
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);
- // throw XmlValidationError(lineNumber, buffer);
-
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.CLASSNAME", elementName);
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
- "missing $0 attribute",
- buffer);
-
- throw XmlValidationError(lineNumber, mlParms);
-
+ throw XmlValidationError(lineNumber, mlParms);
}
if (!CIMName::legal(name))
{
- // l10n
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.CLASSNAME", elementName);
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer,
- // "Illegal value for %s.CLASSNAME attribute", elementName);
- // throw XmlSemanticError(lineNumber, buffer);
-
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.CLASSNAME", elementName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
- throw XmlSemanticError(lineNumber, mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
+ throw XmlSemanticError(lineNumber, mlParms);
}
return name;
//------------------------------------------------------------------------------
CIMName XmlReader::getClassOriginAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* tagName)
{
String name;
if (!entry.getAttributeValue("CLASSORIGIN", name))
- return CIMName();
+ return CIMName();
if (!CIMName::legal(name))
{
- // l10n
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.CLASSORIGIN", tagName);
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer,
- // "Illegal value for %s.CLASSORIGIN attribute", tagName);
- // throw XmlSemanticError(lineNumber, buffer);
-
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.CLASSORIGIN", tagName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
- throw XmlSemanticError(lineNumber, mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
+ throw XmlSemanticError(lineNumber, mlParms);
}
return name;
//------------------------------------------------------------------------------
String XmlReader::getEmbeddedObjectAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* elementName)
{
String embeddedObject;
if (!entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))
- return String();
+ return String();
// The embeddedObject attribute, if present, must have the string
// value "object" or "instance".
if (!(String::equal(embeddedObject, "object") ||
- String::equal(embeddedObject, "instance")
- )
- )
+ String::equal(embeddedObject, "instance")))
{
- // l10n
-
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer,
- // "Illegal value for %s.EMBEDDEDOBJECT attribute", elementName);
- // throw XmlSemanticError(lineNumber, buffer);
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.EMBEDDEDOBJECT", elementName);
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.EMBEDDEDOBJECT", elementName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
- throw XmlSemanticError(lineNumber, mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
+ throw XmlSemanticError(lineNumber, mlParms);
}
return embeddedObject;
//------------------------------------------------------------------------------
CIMName XmlReader::getReferenceClassAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* elementName)
{
String name;
if (!entry.getAttributeValue("REFERENCECLASS", name))
- return CIMName();
+ return CIMName();
if (!CIMName::legal(name))
{
#ifdef PEGASUS_SNIA_INTEROP_TEST
- name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";
- return name;
-#endif
-
- // l10n
+ name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";
+ return name;
+#endif
- // char buffer[MESSAGE_SIZE];
- // sprintf(buffer,
- // "Illegal value for %s.REFERENCECLASS attribute", elementName);
- // throw XmlSemanticError(lineNumber, buffer);
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.REFERENCECLASS", elementName);
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.REFERENCECLASS", elementName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
- throw XmlSemanticError(lineNumber, mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
+ throw XmlSemanticError(lineNumber, mlParms);
}
return name;
//------------------------------------------------------------------------------
CIMName XmlReader::getSuperClassAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* tagName)
{
String superClass;
if (!entry.getAttributeValue("SUPERCLASS", superClass))
- return CIMName();
+ return CIMName();
if (!CIMName::legal(superClass))
{
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.SUPERCLASS", tagName);
- // l10n
-
- // char buffer[MESSAGE_SIZE];
- // sprintf(
- // buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);
- // throw XmlSemanticError(lineNumber, buffer);
-
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.SUPERCLASS", tagName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
- throw XmlSemanticError(lineNumber, mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
+ throw XmlSemanticError(lineNumber, mlParms);
}
return superClass;
//------------------------------------------------------------------------------
Boolean XmlReader::getCimTypeAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
+ Uint32 lineNumber,
+ const XmlEntry& entry,
CIMType& cimType, // Output parameter
const char* tagName,
const char* attributeName,
if (!entry.getAttributeValue(attributeName, typeName))
{
if (required)
- {
-
- // l10n
-
- // char message[MESSAGE_SIZE];
- // sprintf(message, "missing %s.%s attribute", tagName, attributeName);
- // throw XmlValidationError(lineNumber, message);
-
- char message[MESSAGE_SIZE];
- sprintf(message, "%s.%s", tagName, attributeName);
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
- "missing $0 attribute",
- message);
-
- throw XmlValidationError(lineNumber, mlParms);
-
- }
- else
- {
- return false;
- }
+ {
+ char message[MESSAGE_SIZE];
+ sprintf(message, "%s.%s", tagName, attributeName);
+
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_ATTRIBUTE",
+ "missing $0 attribute",
+ message);
+ throw XmlValidationError(lineNumber, mlParms);
+ }
+ else
+ {
+ return false;
+ }
}
CIMType type = CIMTYPE_BOOLEAN;
Boolean unrecognizedType = false;
if (strcmp(typeName, "boolean") == 0)
- type = CIMTYPE_BOOLEAN;
+ type = CIMTYPE_BOOLEAN;
else if (strcmp(typeName, "string") == 0)
- type = CIMTYPE_STRING;
+ type = CIMTYPE_STRING;
else if (strcmp(typeName, "char16") == 0)
- type = CIMTYPE_CHAR16;
+ type = CIMTYPE_CHAR16;
else if (strcmp(typeName, "uint8") == 0)
- type = CIMTYPE_UINT8;
+ type = CIMTYPE_UINT8;
else if (strcmp(typeName, "sint8") == 0)
- type = CIMTYPE_SINT8;
+ type = CIMTYPE_SINT8;
else if (strcmp(typeName, "uint16") == 0)
- type = CIMTYPE_UINT16;
+ type = CIMTYPE_UINT16;
else if (strcmp(typeName, "sint16") == 0)
- type = CIMTYPE_SINT16;
+ type = CIMTYPE_SINT16;
else if (strcmp(typeName, "uint32") == 0)
- type = CIMTYPE_UINT32;
+ type = CIMTYPE_UINT32;
else if (strcmp(typeName, "sint32") == 0)
- type = CIMTYPE_SINT32;
+ type = CIMTYPE_SINT32;
else if (strcmp(typeName, "uint64") == 0)
- type = CIMTYPE_UINT64;
+ type = CIMTYPE_UINT64;
else if (strcmp(typeName, "sint64") == 0)
- type = CIMTYPE_SINT64;
+ type = CIMTYPE_SINT64;
else if (strcmp(typeName, "datetime") == 0)
- type = CIMTYPE_DATETIME;
+ type = CIMTYPE_DATETIME;
else if (strcmp(typeName, "real32") == 0)
- type = CIMTYPE_REAL32;
+ type = CIMTYPE_REAL32;
else if (strcmp(typeName, "real64") == 0)
- type = CIMTYPE_REAL64;
+ type = CIMTYPE_REAL64;
else if (strcmp(typeName, "reference") == 0)
- type = CIMTYPE_REFERENCE;
+ type = CIMTYPE_REFERENCE;
// PEP 194:
// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
-// Pegasus internal representation of an embedded object, so it won't be found here.
+// Pegasus internal representation of an embedded object, so it won't be
+// found here.
else unrecognizedType = true;
if (unrecognizedType ||
((type == CIMTYPE_REFERENCE) &&
(strcmp(attributeName, "PARAMTYPE") != 0)))
{
- // l10n
+ char buffer[MESSAGE_SIZE];
+ sprintf(buffer, "%s.%s", tagName, attributeName);
- // char message[MESSAGE_SIZE];
- // sprintf(message, "Illegal value for %s.%s attribute", tagName,
- // attributeName);
- // throw XmlSemanticError(lineNumber, message);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
+ "Illegal value for $0 attribute",
+ buffer);
- char buffer[MESSAGE_SIZE];
- sprintf(buffer, "%s.%s", tagName, attributeName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
- "Illegal value for $0 attribute",
- buffer);
-
- throw XmlSemanticError(lineNumber, mlParms);
+ throw XmlSemanticError(lineNumber, mlParms);
}
cimType = type;
if (!entry.getAttributeValue(attributeName, tmp))
{
- if (!required)
- return defaultValue;
+ if (!required)
+ return defaultValue;
- // l10n
+ char buffer[62];
+ sprintf(buffer, "%s.%s", attributeName, tagName);
- // char buffer[62];
- // sprintf(buffer, "missing required %s.%s attribute",
- // attributeName, tagName);
-
- // throw XmlValidationError(lineNumber, buffer);
-
- char buffer[62];
- sprintf(buffer, "%s.%s", attributeName, tagName);
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
- "missing required $0 attribute",
- buffer);
-
- throw XmlValidationError(lineNumber, mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
+ "missing required $0 attribute",
+ buffer);
+ throw XmlValidationError(lineNumber, mlParms);
}
if (strcmp(tmp, "true") == 0)
- return true;
+ return true;
else if (strcmp(tmp, "false") == 0)
- return false;
-
- // l10n
-
- // char buffer[62];
- // sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName);
- // throw XmlSemanticError(lineNumber, buffer);
+ return false;
char buffer[62];
sprintf(buffer, "%s.%s", attributeName, tagName);
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE",
- "Invalid $0 attribute value",
- buffer);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_ATTRIBUTE",
+ "Invalid $0 attribute value",
+ buffer);
throw XmlSemanticError(lineNumber, mlParms);
//
// SringToReal()
//
-// [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
-// [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
+// [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
+// [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
//
//------------------------------------------------------------------------------
const char* p = stringValue;
if (!*p)
- return false;
+ return false;
// Skip optional sign:
if (*p == '+' || *p == '-')
- p++;
+ p++;
// Skip optional first set of digits:
while (isdigit(*p))
- p++;
+ p++;
// Test required dot:
if (*p++ != '.')
- return false;
+ return false;
// One or more digits required:
if (!isdigit(*p++))
- return false;
+ return false;
while (isdigit(*p))
- p++;
+ p++;
// If there is an exponent now:
if (*p)
{
- // Test exponent:
+ // Test exponent:
- if (*p != 'e' && *p != 'E')
- return false;
+ if (*p != 'e' && *p != 'E')
+ return false;
- p++;
+ p++;
- // Skip optional sign:
+ // Skip optional sign:
- if (*p == '+' || *p == '-')
- p++;
+ if (*p == '+' || *p == '-')
+ p++;
- // One or more digits required:
+ // One or more digits required:
- if (!isdigit(*p++))
- return false;
+ if (!isdigit(*p++))
+ return false;
- while (isdigit(*p))
- p++;
+ while (isdigit(*p))
+ p++;
}
if (*p)
- return false;
+ return false;
//
// Do the conversion
{
Uint32 i;
- Array<Uint8> utf8Chars;
+ Array<Uint8> utf8Chars;
for (i=0; i<uriString.size(); i++)
{
{
if (i+2 >= uriString.size())
{
- // l10n
-
- // throw ParseError("Invalid URI encoding");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",
- "Invalid URI encoding");
-
- throw ParseError(MessageLoader::getMessage(mlParms));
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_URI_ENCODING",
+ "Invalid URI encoding");
+ throw ParseError(MessageLoader::getMessage(mlParms));
}
Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
if ( (digit1 > 15) || (digit2 > 15) )
{
- // l10n
-
- // throw ParseError("Invalid URI encoding");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",
- "Invalid URI encoding");
-
- throw ParseError(MessageLoader::getMessage(mlParms));
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_URI_ENCODING",
+ "Invalid URI encoding");
+ throw ParseError(MessageLoader::getMessage(mlParms));
}
Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
- utf8Chars.append((Uint8)decodedChar);
+ utf8Chars.append((Uint8)decodedChar);
}
else
{
- utf8Chars.append((Uint8)uriString[i]);
+ utf8Chars.append((Uint8)uriString[i]);
}
}
//
// stringToSignedInteger
//
-// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
+// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
// or
// [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit
//
//------------------------------------------------------------------------------
Boolean XmlReader::stringToSignedInteger(
- const char* stringValue,
+ const char* stringValue,
Sint64& x)
{
x = 0;
const char* p = stringValue;
if (!p || !*p)
- return false;
+ return false;
// Skip optional sign:
Boolean negative = *p == '-';
if (negative || *p == '+')
- p++;
+ p++;
if (*p == '0')
{
else
{
// A decimal string that starts with '0' must be exactly "0".
- return p[1] == '\0';
+ return p[1] == '\0';
}
}
// If we found a non-decimal digit, report an error
if (*p)
- return false;
+ return false;
// Return the integer to positive, if necessary, checking for an
// overflow error
//
// stringToUnsignedInteger
//
-// ( positiveDecimalDigit *decimalDigit | "0" )
+// ( positiveDecimalDigit *decimalDigit | "0" )
// or
// ( "0x" | "0X" ) 1*hexDigit
//
//------------------------------------------------------------------------------
Boolean XmlReader::stringToUnsignedInteger(
- const char* stringValue,
+ const char* stringValue,
Uint64& x)
{
x = 0;
const char* p = stringValue;
if (!p || !*p)
- return false;
+ return false;
if (*p == '0')
{
else
{
// A decimal string that starts with '0' must be exactly "0".
- return p[1] == '\0';
+ return p[1] == '\0';
}
}
// If we found a non-decimal digit, report an error
if (*p)
- return false;
+ return false;
return true;
}
//
// Return: CIMValue. If the string input is zero length creates a CIMValue
// with value defined by the type. Else the value is inserted.
-//
+//
// Note that this does not set the CIMValue Null if the string is empty.
//
//------------------------------------------------------------------------------
CIMValue XmlReader::stringToValue(
- Uint32 lineNumber,
- const char* valueString,
+ Uint32 lineNumber,
+ const char* valueString,
CIMType type)
{
// ATTN-B: accepting only UTF-8 for now! (affects string and char16):
// Create value per type
switch (type)
{
- case CIMTYPE_BOOLEAN:
- {
- if (System::strcasecmp(valueString, "TRUE") == 0)
- return CIMValue(true);
- else if (System::strcasecmp(valueString, "FALSE") == 0)
- return CIMValue(false);
- else {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Invalid boolean value");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE",
- "Invalid boolean value");
-
- throw XmlSemanticError(lineNumber, mlParms);
-
- }
- }
+ case CIMTYPE_BOOLEAN:
+ {
+ if (System::strcasecmp(valueString, "TRUE") == 0)
+ return CIMValue(true);
+ else if (System::strcasecmp(valueString, "FALSE") == 0)
+ return CIMValue(false);
+ else
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_BOOLEAN_VALUE",
+ "Invalid boolean value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ }
- case CIMTYPE_STRING:
- {
- return CIMValue(String(valueString));
- }
+ case CIMTYPE_STRING:
+ {
+ return CIMValue(String(valueString));
+ }
- case CIMTYPE_CHAR16:
- {
+ case CIMTYPE_CHAR16:
+ {
// remove this test, utf-8 can be up to 6 bytes per char
/*
- if (strlen(valueString) != 1) {
- // l10n
-
- // throw XmlSemanticError(lineNumber, "Invalid char16 value");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",
- "Invalid char16 value");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
+ if (strlen(valueString) != 1)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_CHAR16_VALUE",
+ "Invalid char16 value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
*/
- // Converts UTF-8 to UTF-16
- String tmp(valueString);
- if (tmp.size() != 1)
- {
- // l10n
-
- // throw XmlSemanticError(lineNumber, "Invalid char16 value");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",
- "Invalid char16 value");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
-
- return CIMValue(tmp[0]);
- }
-
- case CIMTYPE_UINT8:
- case CIMTYPE_UINT16:
- case CIMTYPE_UINT32:
- case CIMTYPE_UINT64:
- {
- Uint64 x;
-
- if (!stringToUnsignedInteger(valueString, x))
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Invalid unsigned integer value");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE",
- "Invalid unsigned integer value");
-
- throw XmlSemanticError(lineNumber, mlParms);
-
- }
-
- switch (type)
- {
- case CIMTYPE_UINT8:
+ // Converts UTF-8 to UTF-16
+ String tmp(valueString);
+ if (tmp.size() != 1)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_CHAR16_VALUE",
+ "Invalid char16 value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+
+ return CIMValue(tmp[0]);
+ }
+
+ case CIMTYPE_UINT8:
+ case CIMTYPE_UINT16:
+ case CIMTYPE_UINT32:
+ case CIMTYPE_UINT64:
+ {
+ Uint64 x;
+
+ if (!stringToUnsignedInteger(valueString, x))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_UI_VALUE",
+ "Invalid unsigned integer value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+
+ switch (type)
+ {
+ case CIMTYPE_UINT8:
{
if (x >= (Uint64(1)<<8))
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Uint8 value out of range");
-
- MessageLoaderParms mlParms("Common.XmlReader.U8_VALUE_OUT_OF_RANGE",
- "Uint8 value out of range");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(Uint8(x));
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.U8_VALUE_OUT_OF_RANGE",
+ "Uint8 value out of range");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Uint8(x));
}
- case CIMTYPE_UINT16:
+ case CIMTYPE_UINT16:
{
if (x >= (Uint64(1)<<16))
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Uint16 value out of range");
-
- MessageLoaderParms mlParms("Common.XmlReader.U16_VALUE_OUT_OF_RANGE",
- "Uint16 value out of range");
-
- throw XmlSemanticError(lineNumber, mlParms);
-
- }
- return CIMValue(Uint16(x));
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.U16_VALUE_OUT_OF_RANGE",
+ "Uint16 value out of range");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Uint16(x));
}
- case CIMTYPE_UINT32:
+ case CIMTYPE_UINT32:
{
if (x >= (Uint64(1)<<32))
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Uint32 value out of range");
-
- MessageLoaderParms mlParms("Common.XmlReader.U32_VALUE_OUT_OF_RANGE",
- "Uint32 value out of range");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(Uint32(x));
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.U32_VALUE_OUT_OF_RANGE",
+ "Uint32 value out of range");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Uint32(x));
}
- case CIMTYPE_UINT64: return CIMValue(Uint64(x));
- default: break;
- }
- }
-
- case CIMTYPE_SINT8:
- case CIMTYPE_SINT16:
- case CIMTYPE_SINT32:
- case CIMTYPE_SINT64:
- {
- Sint64 x;
-
- if (!stringToSignedInteger(valueString, x))
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Invalid signed integer value");
+ case CIMTYPE_UINT64: return CIMValue(Uint64(x));
+ default: break;
+ }
+ }
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE",
- "Invalid signed integer value");
-
- throw XmlSemanticError(lineNumber, mlParms);
+ case CIMTYPE_SINT8:
+ case CIMTYPE_SINT16:
+ case CIMTYPE_SINT32:
+ case CIMTYPE_SINT64:
+ {
+ Sint64 x;
- }
+ if (!stringToSignedInteger(valueString, x))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_SI_VALUE",
+ "Invalid signed integer value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
- switch (type)
- {
- case CIMTYPE_SINT8:
+ switch (type)
+ {
+ case CIMTYPE_SINT8:
{
- if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Sint8 value out of range");
-
- MessageLoaderParms mlParms("Common.XmlReader.S8_VALUE_OUT_OF_RANGE",
- "Sint8 value out of range");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(Sint8(x));
+ if ((x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.S8_VALUE_OUT_OF_RANGE",
+ "Sint8 value out of range");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Sint8(x));
}
- case CIMTYPE_SINT16:
+ case CIMTYPE_SINT16:
{
- if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )
- {
-
- // l10n
-
- // throw XmlSemanticError(
- // lineNumber, "Sint16 value out of range");
-
- MessageLoaderParms mlParms("Common.XmlReader.S16_VALUE_OUT_OF_RANGE",
- "Sint16 value out of range");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(Sint16(x));
+ if ((x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.S16_VALUE_OUT_OF_RANGE",
+ "Sint16 value out of range");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Sint16(x));
}
- case CIMTYPE_SINT32:
+ case CIMTYPE_SINT32:
{
- if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )
- {
-
- // l10n
+ if ((x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.S32_VALUE_OUT_OF_RANGE",
+ "Sint32 value out of range");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Sint32(x));
+ }
+ case CIMTYPE_SINT64: return CIMValue(Sint64(x));
+ default: break;
+ }
+ }
- // throw XmlSemanticError(
- // lineNumber, "Sint32 value out of range");
+ case CIMTYPE_DATETIME:
+ {
+ CIMDateTime tmp;
- MessageLoaderParms mlParms("Common.XmlReader.S32_VALUE_OUT_OF_RANGE",
- "Sint32 value out of range");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(Sint32(x));
- }
- case CIMTYPE_SINT64: return CIMValue(Sint64(x));
- default: break;
- }
- }
-
- case CIMTYPE_DATETIME:
- {
- CIMDateTime tmp;
-
- try
- {
- // KS 20021002 - Exception if no datatime value. Test for
- // zero length and leave the NULL value in the variable
- // Bugzilla 137 Adds the following if line.
- // Expect this to become permanent but test only for now
+ try
+ {
+ // KS 20021002 - Exception if no datetime value. Test for
+ // zero length and leave the NULL value in the variable
+ // Bugzilla 137 Adds the following if line.
+ // Expect this to become permanent but test only for now
#ifdef PEGASUS_SNIA_INTEROP_TEST
- if (strlen(valueString) != 0)
+ if (strlen(valueString) != 0)
#endif
- tmp.set(valueString);
- }
- catch (InvalidDateTimeFormatException&)
- {
-
- // l10n
-
- // throw XmlSemanticError(lineNumber, "Invalid datetime value");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE",
- "Invalid datetime value");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
-
- return CIMValue(tmp);
- }
-
- case CIMTYPE_REAL32:
- {
- Real64 x;
-
- if (!stringToReal(valueString, x)) {
-
- // l10n
-
- // throw XmlSemanticError(lineNumber, "Invalid real number value");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",
- "Invalid real number value");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(Real32(x));
- }
+ tmp.set(valueString);
+ }
+ catch (InvalidDateTimeFormatException&)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_DATETIME_VALUE",
+ "Invalid datetime value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
- case CIMTYPE_REAL64:
- {
- Real64 x;
+ return CIMValue(tmp);
+ }
- if (!stringToReal(valueString, x)) {
+ case CIMTYPE_REAL32:
+ {
+ Real64 x;
- // l10n
+ if (!stringToReal(valueString, x))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_RN_VALUE",
+ "Invalid real number value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(Real32(x));
+ }
- // throw XmlSemanticError(lineNumber, "Invalid real number value");
+ case CIMTYPE_REAL64:
+ {
+ Real64 x;
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",
- "Invalid real number value");
-
- throw XmlSemanticError(lineNumber, mlParms);
- }
- return CIMValue(x);
- }
+ if (!stringToReal(valueString, x))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_RN_VALUE",
+ "Invalid real number value");
+ throw XmlSemanticError(lineNumber, mlParms);
+ }
+ return CIMValue(x);
+ }
// PEP 194:
-// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a
-// Pegasus internal representation of an embedded object. However, this case is
-// used when decoding string representations of embedded objects.
- case CIMTYPE_OBJECT:
+// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but
+// just a Pegasus internal representation of an embedded object. However,
+// this case is used when decoding string representations of embedded objects.
+ case CIMTYPE_OBJECT:
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- case CIMTYPE_INSTANCE:
+ case CIMTYPE_INSTANCE:
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- {
- CIMObject x;
-
- if (*valueString == '\0')
- {
- return CIMValue(type, false, 0);
- }
- else
{
- // Convert the non-NULL string to a CIMObject (containing either a
- // CIMInstance or a CIMClass).
-
- // First we need to create a new "temporary" XmlParser that is
- // just the value of the Embedded Object in String representation.
- AutoArrayPtr<char> tmp_buffer(new char[strlen(valueString) + 1]);
- strcpy(tmp_buffer.get(), valueString);
- XmlParser tmp_parser(tmp_buffer.get());
-
- // The next bit of logic constructs a CIMObject from the Embedded Object String.
- // It is similar to the method XmlReader::getValueObjectElement().
- CIMInstance cimInstance;
- CIMClass cimClass;
-
- if (XmlReader::getInstanceElement(tmp_parser, cimInstance))
- {
-#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- if(type == CIMTYPE_INSTANCE)
- return CIMValue(cimInstance);
-#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- x = CIMObject(cimInstance);
- }
- else if (XmlReader::getClassElement(tmp_parser, cimClass))
+ CIMObject x;
+
+ if (*valueString == '\0')
{
- x = CIMObject(cimClass);
+ return CIMValue(type, false, 0);
}
else
{
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected INSTANCE or CLASS element");
+ // Convert the non-NULL string to a CIMObject (containing
+ // either a CIMInstance or a CIMClass).
+
+ // First we need to create a new "temporary" XmlParser that is
+ // just the value of the Embedded Object in String
+ // representation.
+ AutoArrayPtr<char> tmp_buffer(
+ new char[strlen(valueString) + 1]);
+ strcpy(tmp_buffer.get(), valueString);
+ XmlParser tmp_parser(tmp_buffer.get());
+
+ // The next bit of logic constructs a CIMObject from the
+ // Embedded Object String. It is similar to the method
+ // XmlReader::getValueObjectElement().
+ CIMInstance cimInstance;
+ CIMClass cimClass;
+
+ if (XmlReader::getInstanceElement(tmp_parser, cimInstance))
+ {
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- if(type == CIMTYPE_OBJECT)
+ if (type == CIMTYPE_INSTANCE)
+ return CIMValue(cimInstance);
+#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+ x = CIMObject(cimInstance);
+ }
+ else if (XmlReader::getClassElement(tmp_parser, cimClass))
{
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
- "Expected INSTANCE or CLASS element"); // change "element" to "embedded object"
-
- throw XmlValidationError(lineNumber, mlParms);
+ x = CIMObject(cimClass);
}
else
{
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
- "Expected INSTANCE element"); // change "element" to "embedded object"
- throw XmlValidationError(lineNumber, mlParms);
- }
+#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+ if (type == CIMTYPE_OBJECT)
+ {
+ // change "element" to "embedded object"
+ MessageLoaderParms mlParms(
+ "Common.XmlReader."
+ "EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
+ "Expected INSTANCE or CLASS element");
+ throw XmlValidationError(lineNumber, mlParms);
+ }
+ else
+ {
+ // change "element" to "embedded object"
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
+ "Expected INSTANCE element");
+ throw XmlValidationError(lineNumber, mlParms);
+ }
#else
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
- "Expected INSTANCE or CLASS element"); // change "element" to "embedded object"
- throw XmlValidationError(lineNumber, mlParms);
+ // change "element" to "embedded object"
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
+ "Expected INSTANCE or CLASS element");
+ throw XmlValidationError(lineNumber, mlParms);
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
+ }
+ // Ok, now we can delete the storage for the temporary
+ // XmlParser.
+ tmp_buffer.reset();
}
- // Ok, now we can delete the storage for the temporary XmlParser.
- tmp_buffer.reset();
+ return CIMValue(x);
}
- return CIMValue(x);
- }
- default:
- break;
+ default:
+ break;
}
- // l10n
-
- // throw XmlSemanticError(lineNumber, "malformed XML");
-
- MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML",
- "malformed XML");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MALFORMED_XML",
+ "malformed XML");
throw XmlSemanticError(lineNumber, mlParms);
return false;
if (entry.type == XmlEntry::EMPTY_TAG)
{
- return;
+ return;
}
while (testStartTagOrEmptyTag(parser, entry))
{
- skipElement(parser, entry);
+ skipElement(parser, entry);
}
if (testContentOrCData(parser, entry))
//------------------------------------------------------------------------------
Boolean XmlReader::getValueElement(
- XmlParser& parser,
- CIMType type,
+ XmlParser& parser,
+ CIMType type,
CIMValue& value)
{
// Get VALUE start tag: Return false if no VALUE start Tag
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
{
- return false;
+ return false;
}
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
if (!empty)
#endif
value = stringToValue(parser.getLine(), valueString,type);
-
+
return true;
}
//------------------------------------------------------------------------------
Boolean XmlReader::getStringValueElement(
- XmlParser& parser,
+ XmlParser& parser,
String& str,
Boolean required)
{
if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
{
- if (required) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),"Expected VALUE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
- "Expected VALUE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
-
- }
- return false;
+ if (required)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
+ "Expected VALUE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ return false;
}
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
if (!empty)
{
- if (testContentOrCData(parser, entry))
- valueString = entry.text;
+ if (testContentOrCData(parser, entry))
+ valueString = entry.text;
- expectEndTag(parser, "VALUE");
+ expectEndTag(parser, "VALUE");
}
str = String(valueString);
// PropertyValue is one of:
//
//
-// <!ELEMENT VALUE.ARRAY (VALUE*)>
+// <!ELEMENT VALUE.ARRAY (VALUE*)>
//
-// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
+// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
// <!ELEMENT VALUE.ARRAY (VALUE*)>
//
// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
//
//----------------------------------------------------------------------------
Boolean XmlReader::getPropertyValue(
- XmlParser& parser,
+ XmlParser& parser,
CIMValue& cimValue)
{
// Can not test for value type, so assume String
// Test for VALUE element
if (XmlReader::getValueElement(parser, type, cimValue))
{
- return true;
+ return true;
}
// Test for VALUE.ARRAY element
template<class T>
CIMValue StringArrayToValueAux(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const Array<const char*>& stringArray,
CIMType type,
T*)
for (Uint32 i = 0, n = stringArray.size(); i < n; i++)
{
- CIMValue value = XmlReader::stringToValue(
- lineNumber, stringArray[i], type);
+ CIMValue value = XmlReader::stringToValue(
+ lineNumber, stringArray[i], type);
- T x;
- value.get(x);
- array.append(x);
+ T x;
+ value.get(x);
+ array.append(x);
}
return CIMValue(array);
}
CIMValue XmlReader::stringArrayToValue(
- Uint32 lineNumber,
- const Array<const char*>& array,
+ Uint32 lineNumber,
+ const Array<const char*>& array,
CIMType type)
{
switch (type)
{
- case CIMTYPE_BOOLEAN:
- return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
+ case CIMTYPE_BOOLEAN:
+ return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
- case CIMTYPE_STRING:
- return StringArrayToValueAux(lineNumber, array, type, (String*)0);
+ case CIMTYPE_STRING:
+ return StringArrayToValueAux(lineNumber, array, type, (String*)0);
- case CIMTYPE_CHAR16:
- return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
+ case CIMTYPE_CHAR16:
+ return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
- case CIMTYPE_UINT8:
- return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
+ case CIMTYPE_UINT8:
+ return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
- case CIMTYPE_UINT16:
- return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
+ case CIMTYPE_UINT16:
+ return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
- case CIMTYPE_UINT32:
- return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
+ case CIMTYPE_UINT32:
+ return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
- case CIMTYPE_UINT64:
- return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
+ case CIMTYPE_UINT64:
+ return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
- case CIMTYPE_SINT8:
- return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
+ case CIMTYPE_SINT8:
+ return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
- case CIMTYPE_SINT16:
- return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
+ case CIMTYPE_SINT16:
+ return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
- case CIMTYPE_SINT32:
- return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
+ case CIMTYPE_SINT32:
+ return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
- case CIMTYPE_SINT64:
- return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
+ case CIMTYPE_SINT64:
+ return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
- case CIMTYPE_DATETIME:
- return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);
+ case CIMTYPE_DATETIME:
+ return StringArrayToValueAux(
+ lineNumber, array, type, (CIMDateTime*)0);
- case CIMTYPE_REAL32:
- return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
+ case CIMTYPE_REAL32:
+ return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
- case CIMTYPE_REAL64:
- return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
+ case CIMTYPE_REAL64:
+ return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
// PEP 194:
-// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a
-// Pegasus internal representation of an embedded object. However, this case is
-// used when decoding string representations of embedded objects.
- case CIMTYPE_OBJECT:
- return StringArrayToValueAux(lineNumber, array, type, (CIMObject*)0);
+// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but
+// just a Pegasus internal representation of an embedded object. However,
+// this case is used when decoding string representations of embedded objects.
+ case CIMTYPE_OBJECT:
+ return StringArrayToValueAux(
+ lineNumber, array, type, (CIMObject*)0);
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- case CIMTYPE_INSTANCE:
- return StringArrayToValueAux(lineNumber, array, type, (CIMInstance*)0);
+ case CIMTYPE_INSTANCE:
+ return StringArrayToValueAux(
+ lineNumber, array, type, (CIMInstance*)0);
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- default:
- break;
+ default:
+ break;
}
// Unreachable:
//------------------------------------------------------------------------------
Boolean XmlReader::getValueArrayElement(
- XmlParser& parser,
- CIMType type,
+ XmlParser& parser,
+ CIMType type,
CIMValue& value)
{
// Clears any values from the Array. Assumes this is array CIMValue
// If no VALUE.ARRAY start tag, return false
if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
- return false;
+ return false;
if (entry.type != XmlEntry::EMPTY_TAG)
{
//
// getFlavor()
//
-// <!ENTITY % QualifierFlavor
+// <!ENTITY % QualifierFlavor
// "OVERRIDABLE (true|false) 'true'
// TOSUBCLASS (true|false) 'true'
// TOINSTANCE (true|false) 'false'
//------------------------------------------------------------------------------
CIMFlavor XmlReader::getFlavor(
- XmlEntry& entry,
- Uint32 lineNumber,
+ XmlEntry& entry,
+ Uint32 lineNumber,
const char* tagName)
{
// Get QUALIFIER.OVERRIDABLE
Boolean overridable = getCimBooleanAttribute(
- lineNumber, entry, tagName, "OVERRIDABLE", true, false);
+ lineNumber, entry, tagName, "OVERRIDABLE", true, false);
// Get QUALIFIER.TOSUBCLASS
Boolean toSubClass = getCimBooleanAttribute(
- lineNumber, entry, tagName, "TOSUBCLASS", true, false);
+ lineNumber, entry, tagName, "TOSUBCLASS", true, false);
// Get QUALIFIER.TOINSTANCE
Boolean toInstance = getCimBooleanAttribute(
- lineNumber, entry, tagName, "TOINSTANCE", false, false);
+ lineNumber, entry, tagName, "TOINSTANCE", false, false);
// Get QUALIFIER.TRANSLATABLE
Boolean translatable = getCimBooleanAttribute(
- lineNumber, entry, tagName, "TRANSLATABLE", false, false);
+ lineNumber, entry, tagName, "TRANSLATABLE", false, false);
// Start with CIMFlavor::NONE. Defaults are specified in the
// getCimBooleanAttribute() calls above.
//
// DTD:
// <!ELEMENT SCOPE EMPTY>
-// <!ATTLIST SCOPE
+// <!ATTLIST SCOPE
// CLASS (true|false) 'false'
// ASSOCIATION (true|false) 'false'
// REFERENCE (true|false) 'false'
CIMScope scope;
if (!parser.next(entry))
- return scope; // No SCOPE element found; return the empty scope
+ return scope; // No SCOPE element found; return the empty scope
Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;
- if ((!isEmptyTag &&
- entry.type != XmlEntry::START_TAG) ||
- strcmp(entry.text, "SCOPE") != 0)
+ if ((!isEmptyTag &&
+ entry.type != XmlEntry::START_TAG) ||
+ strcmp(entry.text, "SCOPE") != 0)
{
- // No SCOPE element found; return the empty scope
- parser.putBack(entry);
- return scope;
+ // No SCOPE element found; return the empty scope
+ parser.putBack(entry);
+ return scope;
}
Uint32 line = parser.getLine();
if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))
- scope.addScope (CIMScope::CLASS);
+ scope.addScope (CIMScope::CLASS);
if (getCimBooleanAttribute(
- line, entry, "SCOPE", "ASSOCIATION", false, false))
- scope.addScope (CIMScope::ASSOCIATION);
+ line, entry, "SCOPE", "ASSOCIATION", false, false))
+ scope.addScope (CIMScope::ASSOCIATION);
if (getCimBooleanAttribute(
- line, entry, "SCOPE", "REFERENCE", false, false))
- scope.addScope (CIMScope::REFERENCE);
+ line, entry, "SCOPE", "REFERENCE", false, false))
+ scope.addScope (CIMScope::REFERENCE);
if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))
- scope.addScope (CIMScope::PROPERTY);
+ scope.addScope (CIMScope::PROPERTY);
if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))
- scope.addScope (CIMScope::METHOD);
+ scope.addScope (CIMScope::METHOD);
if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))
- scope.addScope (CIMScope::PARAMETER);
+ scope.addScope (CIMScope::PARAMETER);
if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))
- scope.addScope (CIMScope::INDICATION);
+ scope.addScope (CIMScope::INDICATION);
if (!isEmptyTag)
- expectEndTag(parser, "SCOPE");
+ expectEndTag(parser, "SCOPE");
return scope;
}
//------------------------------------------------------------------------------
Boolean XmlReader::getQualifierElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMQualifier& qualifier)
{
// Get QUALIFIER element:
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get QUALIFIER.PROPAGATED
Boolean propagated = getCimBooleanAttribute(
- parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
+ parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
// Get flavor oriented attributes:
else
{
if (!getValueElement(parser, type, value) &&
- !getValueArrayElement(parser, type, value))
+ !getValueArrayElement(parser, type, value))
{
value.setNullValue(type, false);
}
while (XmlReader::getQualifierElement(parser, qualifier))
{
- try
- {
- container.addQualifier(qualifier);
- }
- catch (AlreadyExistsException&)
- {
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
-
- MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER",
- "duplicate qualifier");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
- }
+ try
+ {
+ container.addQualifier(qualifier);
+ }
+ catch (AlreadyExistsException&)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.DUPLICATE_QUALIFIER",
+ "duplicate qualifier");
+ throw XmlSemanticError(parser.getLine(), mlParms);
+ }
}
}
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PROPERTY.CLASSORIGIN attribute:
- CIMName classOrigin =
- getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
+ CIMName classOrigin =
+ getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
// Get PROPERTY.PROPAGATED
Boolean propagated = getCimBooleanAttribute(
- parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
+ parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
// Get PROPERTY.EMBEDDEDOBJECT attribute:
String embeddedObject = getEmbeddedObjectAttribute(
- parser.getLine(), entry, "PROPERTY");
+ parser.getLine(), entry, "PROPERTY");
// Get PROPERTY.TYPE attribute:
if (!empty)
{
- // Get qualifiers. We need to do this before checking for the property as an
- // embedded object, because we need to also check for the EmbeddedObject qualifier.
- getQualifierElements(parser, property);
+ // Get qualifiers. We need to do this before checking for the
+ // property as an embedded object, because we need to also check
+ // for the EmbeddedObject qualifier.
+ getQualifierElements(parser, property);
}
Boolean embeddedObjectQualifierValue = false;
ix = property.findQualifier(CIMName("EmbeddedInstance"));
if (ix != PEG_NOT_FOUND)
{
- property.getQualifier(ix).getValue().get(embeddedInstanceQualifierValue);
+ property.getQualifier(ix).getValue().get(
+ embeddedInstanceQualifierValue);
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- // If the EMBEDDEDOBJECT attribute is present with value "object"
+ // If the EMBEDDEDOBJECT attribute is present with value "object"
// or the EmbeddedObject qualifier exists on this property with value "true"
// then
// Convert the EmbeddedObject-encoded string into a CIMObject
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||
- embeddedObjectQualifierValue;
+ embeddedObjectQualifierValue;
Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||
- embeddedInstanceQualifierValue.size() > 0;
+ embeddedInstanceQualifierValue.size() > 0;
if (isEmbeddedObject || isEmbeddedInstance)
{
- // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
+ // The EMBEDDEDOBJECT attribute is only valid on Properties of type
+ // string
if (type == CIMTYPE_STRING)
{
- if(isEmbeddedObject)
- type = CIMTYPE_OBJECT;
+ if (isEmbeddedObject)
+ type = CIMTYPE_OBJECT;
else
- type = CIMTYPE_INSTANCE;
+ type = CIMTYPE_INSTANCE;
CIMValue new_value(type, false);
- CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);
-
- // Copy the qualifiers from the String property to the CIMObject property.
+ CIMProperty new_property = CIMProperty(
+ name, new_value, 0, CIMName(), classOrigin, propagated);
+
+ // Copy the qualifiers from the String property to the CIMObject
+ // property.
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
{
- // All properties are copied, including the EmbeddedObject qualifier.
- // This way we don't have to keep track to know that the EmbeddedObject
- // qualifier needs to be added back during the encode step.
+ // All properties are copied, including the EmbeddedObject
+ // qualifier. This way we don't have to keep track to know
+ // that the EmbeddedObject qualifier needs to be added back
+ // during the encode step.
new_property.addQualifier(property.getQualifier(ix));
}
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on string types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
#else
if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)
{
- // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
+ // The EMBEDDEDOBJECT attribute is only valid on Properties of type
+ // string
if (type == CIMTYPE_STRING)
{
type = CIMTYPE_OBJECT;
CIMValue new_value(type, false);
- CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);
-
- // Copy the qualifiers from the String property to the CIMObject property.
+ CIMProperty new_property = CIMProperty(
+ name, new_value, 0, CIMName(), classOrigin, propagated);
+
+ // Copy the qualifiers from the String property to the CIMObject
+ // property.
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
{
- // All properties are copied, including the EmbeddedObject qualifier.
- // This way we don't have to keep track to know that the EmbeddedObject
- // qualifier needs to be added back during the encode step.
+ // All properties are copied, including the EmbeddedObject
+ // qualifier. This way we don't have to keep track to know
+ // that the EmbeddedObject qualifier needs to be added back
+ // during the encode step.
new_property.addQualifier(property.getQualifier(ix));
}
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on string types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
const char* tmp;
if (!entry.getAttributeValue("ARRAYSIZE", tmp))
- return false;
+ return false;
Uint64 arraySize;
if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
{
- // l10n
-
- // char message[128];
- // sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");
- // throw XmlSemanticError(lineNumber, message);
+ char message[128];
+ sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
- char message[128];
- sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE",
- "Illegal value for $0",
- message);
-
- throw XmlSemanticError(lineNumber, mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE",
+ "Illegal value for $0",
+ message);
+ throw XmlSemanticError(lineNumber, mlParms);
}
value = Uint32(arraySize);
//------------------------------------------------------------------------------
Boolean XmlReader::getPropertyArrayElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMProperty& property)
{
// Get PROPERTY element:
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PROPERTY.NAME attribute:
- CIMName name =
- getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
+ CIMName name =
+ getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
// Get PROPERTY.TYPE attribute:
// Get PROPERTY.CLASSORIGIN attribute:
- CIMName classOrigin = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
+ CIMName classOrigin =
+ getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
// Get PROPERTY.ARRAY.PROPAGATED
- Boolean propagated = getCimBooleanAttribute(parser.getLine()
- ,entry
- ,"PROPERTY.ARRAY"
- ,"PROPAGATED"
- ,false
- ,false);
+ Boolean propagated = getCimBooleanAttribute(
+ parser.getLine(),
+ entry,
+ "PROPERTY.ARRAY",
+ "PROPAGATED",
+ false,
+ false);
// Get PROPERTY.EMBEDDEDOBJECT attribute:
- String embeddedObject = getEmbeddedObjectAttribute(parser.getLine()
- ,entry
- ,"PROPERTY.ARRAY");
+ String embeddedObject = getEmbeddedObjectAttribute(
+ parser.getLine(), entry, "PROPERTY.ARRAY");
// Create property:
CIMValue value(type, true, arraySize);
- property = CIMProperty(name, value, arraySize, CIMName(), classOrigin, propagated);
+ property = CIMProperty(
+ name, value, arraySize, CIMName(), classOrigin, propagated);
if (!empty)
{
ix = property.findQualifier(CIMName("EmbeddedInstance"));
if (ix != PEG_NOT_FOUND)
{
- property.getQualifier(ix).getValue().get(embeddedInstanceQualifierValue);
+ property.getQualifier(ix).getValue().get(
+ embeddedInstanceQualifierValue);
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
- // If the EMBEDDEDOBJECT attribute is present with value "object"
+ // If the EMBEDDEDOBJECT attribute is present with value "object"
// or the EmbeddedObject qualifier exists on this property with value "true"
// then
// Convert the EmbeddedObject-encoded string into a CIMObject
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||
- embeddedObjectQualifierValue;
+ embeddedObjectQualifierValue;
Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||
- embeddedInstanceQualifierValue.size() > 0;
+ embeddedInstanceQualifierValue.size() > 0;
if (isEmbeddedObject || isEmbeddedInstance)
{
- // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
+ // The EMBEDDEDOBJECT attribute is only valid on Properties of type
+ // string
if (type == CIMTYPE_STRING)
{
- if(isEmbeddedObject)
- type = CIMTYPE_OBJECT;
+ if (isEmbeddedObject)
+ type = CIMTYPE_OBJECT;
else
- type = CIMTYPE_INSTANCE;
+ type = CIMTYPE_INSTANCE;
CIMValue new_value(type, true, arraySize);
- CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);
-
- // Copy the qualifiers from the String property to the CIMObject property.
+ CIMProperty new_property = CIMProperty(
+ name, new_value, arraySize, CIMName(), classOrigin, propagated);
+
+ // Copy the qualifiers from the String property to the CIMObject
+ // property.
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
{
- // All properties are copied, including the EmbeddedObject qualifier.
- // This way we don't have to keep track to know that the EmbeddedObject
- // qualifier needs to be added back during the encode step.
+ // All properties are copied, including the EmbeddedObject
+ // qualifier. This way we don't have to keep track to know
+ // that the EmbeddedObject qualifier needs to be added back
+ // during the encode step.
new_property.addQualifier(property.getQualifier(ix));
}
-
+
value = new_value;
property = new_property;
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on string types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
#else
if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)
{
- // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
+ // The EMBEDDEDOBJECT attribute is only valid on Properties of type
+ // string
if (type == CIMTYPE_STRING)
{
type = CIMTYPE_OBJECT;
CIMValue new_value(type, true, arraySize);
- CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);
-
- // Copy the qualifiers from the String property to the CIMObject property.
+ CIMProperty new_property = CIMProperty(
+ name, new_value, arraySize, CIMName(), classOrigin, propagated);
+
+ // Copy the qualifiers from the String property to the CIMObject
+ // property.
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
{
- // All properties are copied, including the EmbeddedObject qualifier.
- // This way we don't have to keep track to know that the EmbeddedObject
- // qualifier needs to be added back during the encode step.
+ // All properties are copied, including the EmbeddedObject
+ // qualifier. This way we don't have to keep track to know
+ // that the EmbeddedObject qualifier needs to be added back
+ // during the encode step.
new_property.addQualifier(property.getQualifier(ix));
}
-
+
value = new_value;
property = new_property;
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on string types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
{
if (arraySize && arraySize != value.getArraySize())
{
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(),
- // "ARRAYSIZE attribute and value-array size are different");
-
- MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",
- "ARRAYSIZE attribute and value-array size are different");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ARRAY_SIZE_DIFFERENT",
+ "ARRAYSIZE attribute and value-array size are different");
+ throw XmlSemanticError(parser.getLine(), mlParms);
}
property.setValue(value);
}
expectEndTag(parser, "PROPERTY.ARRAY");
}
-
+
return true;
}
XmlEntry entry;
if (!testStartTag(parser, entry, "HOST"))
- return false;
+ return false;
#ifdef PEGASUS_SNIA_INTEROP_TEST
// Temp code to allow empty HOST field.
// SNIA CIMOMs return empty field particularly on enumerateinstance.
// Simply substitute a string for the empty.
- if (!parser.next(entry))
- throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
+ if (!parser.next(entry))
+ throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
- if (entry.type == XmlEntry::CONTENT)
- host = String(entry.text);
- else
+ if (entry.type == XmlEntry::CONTENT)
+ host = String(entry.text);
+ else
{
- parser.putBack(entry);
+ parser.putBack(entry);
host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";
}
if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected content of HOST element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
- "expected content of HOST element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
+ "expected content of HOST element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
host = String(entry.text);
//------------------------------------------------------------------------------
//
// getNameSpaceElement()
-//
+//
// <!ELEMENT NAMESPACE EMPTY>
// <!ATTLIST NAMESPACE %CIMName;>
//
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
nameSpaceComponent = getCimNameAttribute(
- parser.getLine(), entry, "NAMESPACE");
+ parser.getLine(), entry, "NAMESPACE");
if (!empty)
- expectEndTag(parser, "NAMESPACE");
+ expectEndTag(parser, "NAMESPACE");
return true;
}
//------------------------------------------------------------------------------
//
// getLocalNameSpacePathElement()
-//
+//
// <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
//
//------------------------------------------------------------------------------
XmlEntry entry;
if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
- return false;
+ return false;
CIMName nameSpaceComponent;
while (getNameSpaceElement(parser, nameSpaceComponent))
{
- if (nameSpace.size())
- nameSpace.append('/');
+ if (nameSpace.size())
+ nameSpace.append('/');
- nameSpace.append(nameSpaceComponent.getString());
+ nameSpace.append(nameSpaceComponent.getString());
}
if (!nameSpace.size())
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected one or more NAMESPACE elements within "
- // "LOCALNAMESPACEPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
- "Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
+ "Expected one or more NAMESPACE elements within "
+ "LOCALNAMESPACEPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
expectEndTag(parser, "LOCALNAMESPACEPATH");
XmlEntry entry;
if (!testStartTag(parser, entry, "NAMESPACEPATH"))
- return false;
-
- if (!getHostElement(parser, host)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(), "expected HOST element");
+ return false;
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT",
- "expected HOST element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!getHostElement(parser, host))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_HOST_ELEMENT",
+ "expected HOST element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
if (!getLocalNameSpacePathElement(parser, nameSpace))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected LOCALNAMESPACEPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
- "expected LOCALNAMESPACEPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
+ "expected LOCALNAMESPACEPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
expectEndTag(parser, "NAMESPACEPATH");
if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
{
- if (required)
- {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected CLASSNAME element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
- "expected CLASSNAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
- else
- return false;
+ if (required)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
+ "expected CLASSNAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ else
+ return false;
}
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
className = getCimNameAttribute(
- parser.getLine(), entry, "CLASSNAME", false);
+ parser.getLine(), entry, "CLASSNAME", false);
if (!empty)
- expectEndTag(parser, "CLASSNAME");
+ expectEndTag(parser, "CLASSNAME");
return true;
}
//------------------------------------------------------------------------------
CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
- Uint32 lineNumber,
+ Uint32 lineNumber,
const XmlEntry& entry,
const char* elementName)
{
String tmp;
if (!entry.getAttributeValue("VALUETYPE", tmp))
- return CIMKeyBinding::STRING;
+ return CIMKeyBinding::STRING;
if (String::equal(tmp, "string"))
- return CIMKeyBinding::STRING;
+ return CIMKeyBinding::STRING;
else if (String::equal(tmp, "boolean"))
- return CIMKeyBinding::BOOLEAN;
+ return CIMKeyBinding::BOOLEAN;
else if (String::equal(tmp, "numeric"))
- return CIMKeyBinding::NUMERIC;
-
- // char buffer[MESSAGE_SIZE];
-
- // sprintf(buffer,
- // "Illegal value for %s.VALUETYPE attribute; "
- // "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",
- // elementName);
-
- // throw XmlSemanticError(lineNumber, buffer);
-
+ return CIMKeyBinding::NUMERIC;
char buffer[MESSAGE_SIZE];
sprintf(buffer, "%s.VALUETYPE", elementName);
-
- MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
- "Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer);
-
+
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
+ "Illegal value for $0 attribute; CIMValue must be one of \"string\", "
+ "\"boolean\", or \"numeric\"",
+ buffer);
throw XmlSemanticError(lineNumber, mlParms);
return CIMKeyBinding::BOOLEAN;
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
if (!empty)
{
- if (!parser.next(entry))
- throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
+ if (!parser.next(entry))
+ throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
- if (entry.type == XmlEntry::CONTENT)
- value = String(entry.text);
- else
- parser.putBack(entry);
+ if (entry.type == XmlEntry::CONTENT)
+ value = String(entry.text);
+ else
+ parser.putBack(entry);
- expectEndTag(parser, "KEYVALUE");
+ expectEndTag(parser, "KEYVALUE");
}
return true;
XmlEntry entry;
if (!testStartTag(parser, entry, "KEYBINDING"))
- return false;
+ return false;
name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
if (!getValueReferenceElement(parser, reference))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected KEYVALUE or VALUE.REFERENCE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
- "Expected KEYVALUE or VALUE.REFERENCE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
+ "Expected KEYVALUE or VALUE.REFERENCE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
type = CIMKeyBinding::REFERENCE;
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "INSTANCENAME"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
}
else
{
- while (getKeyBindingElement(parser, name, value, type))
- keyBindings.append(CIMKeyBinding(name, value, type));
+ while (getKeyBindingElement(parser, name, value, type))
+ keyBindings.append(CIMKeyBinding(name, value, type));
}
expectEndTag(parser, "INSTANCENAME");
Array<CIMKeyBinding> keyBindings;
if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
- return false;
+ return false;
instanceName.set(String(), CIMNamespaceName(), className, keyBindings);
return true;
XmlEntry entry;
if (!testStartTag(parser, entry, "INSTANCEPATH"))
- return false;
+ return false;
String host;
String nameSpace;
if (!getNameSpacePathElement(parser, host, nameSpace))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected NAMESPACEPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
- "expected NAMESPACEPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
+ "expected NAMESPACEPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
String className;
if (!getInstanceNameElement(parser, className, keyBindings))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected INSTANCENAME element");
-
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
- "expected INSTANCENAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
+ "expected INSTANCENAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
reference.set(host, nameSpace, className, keyBindings);
XmlEntry entry;
if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
- return false;
+ return false;
String nameSpace;
if (!getLocalNameSpacePathElement(parser, nameSpace))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected LOCALNAMESPACEPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
- "expected LOCALNAMESPACEPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
+ "expected LOCALNAMESPACEPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
String className;
if (!getInstanceNameElement(parser, className, keyBindings))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected INSTANCENAME element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
- "expected INSTANCENAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
+ "expected INSTANCENAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
reference.set(String(), nameSpace, className, keyBindings);
XmlEntry entry;
if (!testStartTag(parser, entry, "CLASSPATH"))
- return false;
+ return false;
String host;
String nameSpace;
if (!getNameSpacePathElement(parser, host, nameSpace))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected NAMESPACEPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
- "expected NAMESPACEPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
+ "expected NAMESPACEPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
CIMName className;
if (!getClassNameElement(parser, className))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected CLASSNAME element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
- "expected CLASSNAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
+ "expected CLASSNAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
reference.set(host, nameSpace, className);
XmlEntry entry;
if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
- return false;
+ return false;
String nameSpace;
if (!getLocalNameSpacePathElement(parser, nameSpace))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected LOCALNAMESPACEPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
- "expected LOCALNAMESPACEPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
+ "expected LOCALNAMESPACEPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
CIMName className;
if (!getClassNameElement(parser, className))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected CLASSNAME element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
- "expected CLASSNAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
+ "expected CLASSNAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
reference.set(String(), nameSpace, className);
XmlEntry entry;
if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
- return false;
+ return false;
if (!parser.next(entry))
- throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
+ throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
- if (entry.type != XmlEntry::START_TAG &&
- entry.type != XmlEntry::EMPTY_TAG)
+ if (entry.type != XmlEntry::START_TAG &&
+ entry.type != XmlEntry::EMPTY_TAG)
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected one of the following start tags: "
- // "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "
- // "LOCALINSTANCEPATH, INSTANCENAME");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",
- "Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_START_TAGS",
+ "Expected one of the following start tags: CLASSPATH, "
+ "LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, "
+ "INSTANCENAME");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
if (strcmp(entry.text, "CLASSPATH") == 0)
{
- parser.putBack(entry);
- getClassPathElement(parser, reference);
+ parser.putBack(entry);
+ getClassPathElement(parser, reference);
}
else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
{
- parser.putBack(entry);
- getLocalClassPathElement(parser, reference);
+ parser.putBack(entry);
+ getLocalClassPathElement(parser, reference);
}
else if (strcmp(entry.text, "CLASSNAME") == 0)
{
- parser.putBack(entry);
- CIMName className;
- getClassNameElement(parser, className);
- reference.set(String(), CIMNamespaceName(), className);
+ parser.putBack(entry);
+ CIMName className;
+ getClassNameElement(parser, className);
+ reference.set(String(), CIMNamespaceName(), className);
}
else if (strcmp(entry.text, "INSTANCEPATH") == 0)
{
- parser.putBack(entry);
- getInstancePathElement(parser, reference);
+ parser.putBack(entry);
+ getInstancePathElement(parser, reference);
}
else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
{
- parser.putBack(entry);
- getLocalInstancePathElement(parser, reference);
+ parser.putBack(entry);
+ getLocalInstancePathElement(parser, reference);
}
else if (strcmp(entry.text, "INSTANCENAME") == 0)
{
- parser.putBack(entry);
- String className;
- Array<CIMKeyBinding> keyBindings;
- getInstanceNameElement(parser, className, keyBindings);
- reference.set(String(), CIMNamespaceName(), className, keyBindings);
+ parser.putBack(entry);
+ String className;
+ Array<CIMKeyBinding> keyBindings;
+ getInstanceNameElement(parser, className, keyBindings);
+ reference.set(String(), CIMNamespaceName(), className, keyBindings);
}
expectEndTag(parser, "VALUE.REFERENCE");
//------------------------------------------------------------------------------
Boolean XmlReader::getValueReferenceArrayElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMValue& value)
{
XmlEntry entry;
// Get VALUE.REFARRAY open tag:
if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
- return false;
+ return false;
if (entry.type != XmlEntry::EMPTY_TAG)
{
while (getValueReferenceElement(parser, reference))
{
- referenceArray.append(reference);
+ referenceArray.append(reference);
}
expectEndTag(parser, "VALUE.REFARRAY");
//------------------------------------------------------------------------------
Boolean XmlReader::getPropertyReferenceElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMProperty& property)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PROPERTY.NAME attribute:
CIMName name = getCimNameAttribute(
- parser.getLine(), entry, "PROPERTY.REFERENCE");
+ parser.getLine(), entry, "PROPERTY.REFERENCE");
// Get PROPERTY.REFERENCECLASS attribute:
CIMName referenceClass = getReferenceClassAttribute(
- parser.getLine(), entry, "PROPERTY.REFERENCE");
+ parser.getLine(), entry, "PROPERTY.REFERENCE");
// Get PROPERTY.CLASSORIGIN attribute:
- CIMName classOrigin =
- getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
+ CIMName classOrigin =
+ getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
// Get PROPERTY.PROPAGATED
- Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
- "PROPERTY.REFERENCE", "PROPAGATED", false, false);
+ Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
+ "PROPERTY.REFERENCE", "PROPAGATED", false, false);
// Create property:
CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);
// value.set(CIMObjectPath());
property = CIMProperty(
- name, value, 0, referenceClass, classOrigin, propagated);
+ name, value, 0, referenceClass, classOrigin, propagated);
if (!empty)
{
- getQualifierElements(parser, property);
+ getQualifierElements(parser, property);
- CIMObjectPath reference;
+ CIMObjectPath reference;
- if (getValueReferenceElement(parser, reference))
- property.setValue(reference);
+ if (getValueReferenceElement(parser, reference))
+ property.setValue(reference);
- expectEndTag(parser, "PROPERTY.REFERENCE");
+ expectEndTag(parser, "PROPERTY.REFERENCE");
}
return true;
CIMProperty property;
while (XmlReader::getPropertyElement(parser, property) ||
- XmlReader::getPropertyArrayElement(parser, property) ||
- XmlReader::getPropertyReferenceElement(parser, property))
+ XmlReader::getPropertyArrayElement(parser, property) ||
+ XmlReader::getPropertyReferenceElement(parser, property))
{
- try
- {
- container.addProperty(property);
- }
- catch (AlreadyExistsException&)
- {
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(), "duplicate property");
-
- MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY",
- "duplicate property");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
- }
+ try
+ {
+ container.addProperty(property);
+ }
+ catch (AlreadyExistsException&)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.DUPLICATE_PROPERTY",
+ "duplicate property");
+ throw XmlSemanticError(parser.getLine(), mlParms);
+ }
}
}
//------------------------------------------------------------------------------
Boolean XmlReader::getParameterElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMParameter& parameter)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
if (!empty)
{
- getQualifierElements(parser, parameter);
+ getQualifierElements(parser, parameter);
- expectEndTag(parser, "PARAMETER");
+ expectEndTag(parser, "PARAMETER");
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::getParameterArrayElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMParameter& parameter)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PARAMETER.ARRAY.NAME attribute:
CIMName name = getCimNameAttribute(
- parser.getLine(), entry, "PARAMETER.ARRAY");
+ parser.getLine(), entry, "PARAMETER.ARRAY");
// Get PARAMETER.ARRAY.TYPE attribute:
if (!empty)
{
- getQualifierElements(parser, parameter);
+ getQualifierElements(parser, parameter);
- expectEndTag(parser, "PARAMETER.ARRAY");
+ expectEndTag(parser, "PARAMETER.ARRAY");
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::getParameterReferenceElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMParameter& parameter)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PARAMETER.NAME attribute:
CIMName name = getCimNameAttribute(
- parser.getLine(), entry, "PARAMETER.REFERENCE");
+ parser.getLine(), entry, "PARAMETER.REFERENCE");
// Get PARAMETER.REFERENCECLASS attribute:
CIMName referenceClass = getReferenceClassAttribute(
- parser.getLine(), entry, "PARAMETER.REFERENCE");
+ parser.getLine(), entry, "PARAMETER.REFERENCE");
// Create parameter:
if (!empty)
{
- getQualifierElements(parser, parameter);
- expectEndTag(parser, "PARAMETER.REFERENCE");
+ getQualifierElements(parser, parameter);
+ expectEndTag(parser, "PARAMETER.REFERENCE");
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::getParameterReferenceArrayElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMParameter& parameter)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PARAMETER.NAME attribute:
CIMName name = getCimNameAttribute(
- parser.getLine(), entry, "PARAMETER.REFARRAY");
+ parser.getLine(), entry, "PARAMETER.REFARRAY");
// Get PARAMETER.REFERENCECLASS attribute:
CIMName referenceClass = getReferenceClassAttribute(
- parser.getLine(), entry, "PARAMETER.REFARRAY");
+ parser.getLine(), entry, "PARAMETER.REFARRAY");
// Get PARAMETER.ARRAYSIZE attribute:
Uint32 arraySize = 0;
- getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",
- arraySize);
+ getArraySizeAttribute(
+ parser.getLine(), entry, "PARAMETER.REFARRAY", arraySize);
// Create parameter:
- parameter = CIMParameter(name, CIMTYPE_REFERENCE, true, arraySize,
- referenceClass);
+ parameter = CIMParameter(
+ name, CIMTYPE_REFERENCE, true, arraySize, referenceClass);
if (!empty)
{
- getQualifierElements(parser, parameter);
- expectEndTag(parser, "PARAMETER.REFARRAY");
+ getQualifierElements(parser, parameter);
+ expectEndTag(parser, "PARAMETER.REFARRAY");
}
return true;
CIMParameter parameter;
while (XmlReader::getParameterElement(parser, parameter) ||
- XmlReader::getParameterArrayElement(parser, parameter) ||
- XmlReader::getParameterReferenceElement(parser, parameter) ||
- XmlReader::getParameterReferenceArrayElement(parser, parameter))
+ XmlReader::getParameterArrayElement(parser, parameter) ||
+ XmlReader::getParameterReferenceElement(parser, parameter) ||
+ XmlReader::getParameterReferenceArrayElement(parser, parameter))
{
- try
- {
- container.addParameter(parameter);
- }
- catch (AlreadyExistsException&)
- {
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(), "duplicate parameter");
-
- MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER",
- "duplicate parameter");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
- }
+ try
+ {
+ container.addParameter(parameter);
+ }
+ catch (AlreadyExistsException&)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.DUPLICATE_PARAMETER",
+ "duplicate parameter");
+ throw XmlSemanticError(parser.getLine(), mlParms);
+ }
}
}
// getQualifierDeclElement()
//
// <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
-// <!ATTLIST QUALIFIER.DECLARATION
-// %CIMName;
+// <!ATTLIST QUALIFIER.DECLARATION
+// %CIMName;
// %CIMType; #REQUIRED
// ISARRAY (true|false) #IMPLIED
// %ArraySize;
// %QualifierFlavor;>
-//
+//
//------------------------------------------------------------------------------
Boolean XmlReader::getQualifierDeclElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMQualifierDecl& qualifierDecl)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get NAME attribute:
CIMName name = getCimNameAttribute(
- parser.getLine(), entry, "QUALIFIER.DECLARATION");
+ parser.getLine(), entry, "QUALIFIER.DECLARATION");
// Get TYPE attribute:
Boolean isArray = getCimBooleanAttribute(
parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",
- false, false);
+ false, false);
// Get ARRAYSIZE attribute:
Uint32 arraySize = 0;
Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),
- entry, "QUALIFIER.DECLARATION", arraySize);
+ entry, "QUALIFIER.DECLARATION", arraySize);
// Get flavor oriented attributes:
- CIMFlavor flavor = getFlavor (entry, parser.getLine (),
+ CIMFlavor flavor = getFlavor (entry, parser.getLine (),
"QUALIFIER.DECLARATION");
// No need to look for interior elements if empty tag:
if (!empty)
{
- // Get the option SCOPE element:
-
- scope = getOptionalScope(parser);
-
- // Get VALUE or VALUE.ARRAY element:
+ // Get the option SCOPE element:
- if (getValueArrayElement(parser, type, value))
- {
- if (!isArray)
- {
+ scope = getOptionalScope(parser);
- // l10n
+ // Get VALUE or VALUE.ARRAY element:
- // throw XmlSemanticError(parser.getLine(),
- // "VALUE.ARRAY element encountered without "
- // "ISARRAY attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
- "VALUE.ARRAY element encountered without ISARRAY attribute");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
- }
-
- if (arraySize && arraySize != value.getArraySize())
- {
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(),
- // "VALUE.ARRAY size is not the same as "
- // "ARRAYSIZE attribute");
+ if (getValueArrayElement(parser, type, value))
+ {
+ if (!isArray)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
+ "VALUE.ARRAY element encountered without ISARRAY "
+ "attribute");
+ throw XmlSemanticError(parser.getLine(), mlParms);
+ }
- MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",
- "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
- }
+ if (arraySize && arraySize != value.getArraySize())
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ARRAY_SIZE_NOT_SAME",
+ "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
+ throw XmlSemanticError(parser.getLine(), mlParms);
+ }
gotValue = true;
- }
- else if (getValueElement(parser, type, value))
- {
- if (isArray)
- {
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(),
- // "ISARRAY attribute used but VALUE element encountered");
-
- MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
- "ISARRAY attribute used but VALUE element encountered");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
- }
+ }
+ else if (getValueElement(parser, type, value))
+ {
+ if (isArray)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
+ "ISARRAY attribute used but VALUE element encountered");
+ throw XmlSemanticError(parser.getLine(), mlParms);
+ }
gotValue = true;
- }
+ }
- // Now get the closing tag:
+ // Now get the closing tag:
- expectEndTag(parser, "QUALIFIER.DECLARATION");
+ expectEndTag(parser, "QUALIFIER.DECLARATION");
}
if (!gotValue)
{
- if (isArray)
- value.setNullValue(type, true, arraySize);
- else
- value.setNullValue(type, false);
+ if (isArray)
+ value.setNullValue(type, true, arraySize);
+ else
+ value.setNullValue(type, false);
}
CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
CIMType type;
getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
- CIMName classOrigin =
- getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
+ CIMName classOrigin =
+ getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
Boolean propagated = getCimBooleanAttribute(
- parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
+ parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
method = CIMMethod(name, type, classOrigin, propagated);
{
// ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
// ordering of qualifiers and parameters.
- getQualifierElements(parser, method);
+ getQualifierElements(parser, method);
- GetParameterElements(parser, method);
+ GetParameterElements(parser, method);
- expectEndTag(parser, "METHOD");
+ expectEndTag(parser, "METHOD");
}
return true;
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))
- return false;
+ return false;
CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
- CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
+ CIMName superClass =
+ getSuperClassAttribute(parser.getLine(), entry,"CLASS");
cimClass = CIMClass(name, superClass);
- if(entry.type != XmlEntry::EMPTY_TAG)
- {
+ if (entry.type != XmlEntry::EMPTY_TAG)
+ {
+ // Get QUALIFIER elements:
- // Get QUALIFIER elements:
+ getQualifierElements(parser, cimClass);
- getQualifierElements(parser, cimClass);
+ // Get PROPERTY elements:
- // Get PROPERTY elements:
+ GetPropertyElements(parser, cimClass);
- GetPropertyElements(parser, cimClass);
+ // Get METHOD elements:
- // Get METHOD elements:
+ CIMMethod method;
- CIMMethod method;
+ while (getMethodElement(parser, method))
+ cimClass.addMethod(method);
- while (getMethodElement(parser, method))
- cimClass.addMethod(method);
+ // Get CLASS end tag:
- // Get CLASS end tag:
-
- expectEndTag(parser, "CLASS");
- }
+ expectEndTag(parser, "CLASS");
+ }
return true;
}
//------------------------------------------------------------------------------
Boolean XmlReader::getInstanceElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMInstance& cimInstance)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
String className = getClassNameAttribute(
- parser.getLine(), entry, "INSTANCE");
+ parser.getLine(), entry, "INSTANCE");
cimInstance = CIMInstance(className);
//------------------------------------------------------------------------------
Boolean XmlReader::getNamedInstanceElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMInstance& namedInstance)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
- return false;
+ return false;
CIMObjectPath instanceName;
if (!getInstanceNameElement(parser, instanceName))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected INSTANCENAME element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
- "expected INSTANCENAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
+ "expected INSTANCENAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
// Get INSTANCE elements:
if (!getInstanceElement(parser, namedInstance))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected INSTANCE element");
-
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
- "expected INSTANCE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
+ "expected INSTANCE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
// Get VALUE.NAMEDINSTANCE end tag:
{
if (!getClassElement(parser, x))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected CLASS element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
- "expected CLASS element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
+ "expected CLASS element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
{
if (!getInstanceElement(parser, x))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected INSTANCE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
- "expected INSTANCE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
+ "expected INSTANCE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
{
if (!getQualifierDeclElement(parser, x))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected QUALIFIER.DECLARATION element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
- "expected QUALIFIER.DECLARATION element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
+ "expected QUALIFIER.DECLARATION element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
//------------------------------------------------------------------------------
Boolean XmlReader::getMessageStartTag(
- XmlParser& parser,
+ XmlParser& parser,
String& id,
String& protocolVersion)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "MESSAGE"))
- return false;
+ return false;
// Get MESSAGE.ID:
- if (!entry.getAttributeValue("ID", id)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Invalid or missing MESSAGE.ID attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
- "Invalid or missing MESSAGE.ID attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
+ if (!entry.getAttributeValue("ID", id))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
+ "Invalid or missing MESSAGE.ID attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
// Get MESSAGE.PROTOCOLVERSION:
- if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
- "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
+ "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
-
+
return true;
}
//------------------------------------------------------------------------------
Boolean XmlReader::getIMethodCallStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "IMETHODCALL"))
- return false;
+ return false;
// Get IMETHODCALL.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing IMETHODCALL.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
- "Missing IMETHODCALL.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
+ "Missing IMETHODCALL.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
//------------------------------------------------------------------------------
Boolean XmlReader::getIMethodResponseStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name,
Boolean& isEmptyTag)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
- return false;
+ return false;
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
// Get IMETHODRESPONSE.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing IMETHODRESPONSE.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
- "Missing IMETHODRESPONSE.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
+ "Missing IMETHODRESPONSE.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
//------------------------------------------------------------------------------
Boolean XmlReader::getIParamValueTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name,
Boolean& isEmptyTag)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
- return false;
+ return false;
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
// Get IPARAMVALUE.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing IPARAMVALUE.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
- "Missing IPARAMVALUE.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
+ "Missing IPARAMVALUE.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
return true;
//------------------------------------------------------------------------------
void XmlReader::rejectNullIParamValue(
- XmlParser& parser,
+ XmlParser& parser,
Boolean isEmptyTag,
const char* paramName)
{
//------------------------------------------------------------------------------
Boolean XmlReader::getBooleanValueElement(
- XmlParser& parser,
+ XmlParser& parser,
Boolean& result,
Boolean required)
{
if (!testStartTag(parser, entry, "VALUE"))
{
- if (required)
- {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected VALUE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
- "Expected VALUE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
- return false;
+ if (required)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
+ "Expected VALUE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ return false;
}
expectContentOrCData(parser, entry);
if (System::strcasecmp(entry.text, "TRUE") == 0)
- result = true;
+ result = true;
else if (System::strcasecmp(entry.text, "FALSE") == 0)
- result = false;
- else {
-
- // l10n
-
- // throw XmlSemanticError(parser.getLine(),
- // "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
- "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
-
- throw XmlSemanticError(parser.getLine(), mlParms);
+ result = false;
+ else
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
+ "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
+ throw XmlSemanticError(parser.getLine(), mlParms);
}
expectEndTag(parser, "VALUE");
// DMTF CR Pending
//
// <!ELEMENT ERROR (INSTANCE*)>
-// <!ATTLIST ERROR
+// <!ATTLIST ERROR
// CODE CDATA #REQUIRED
// DESCRIPTION CDATA #IMPLIED>
//
//------------------------------------------------------------------------------
Boolean XmlReader::getErrorElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMException& cimException,
Boolean required)
{
if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
{
- if (required) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),"Expected ERROR element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT",
- "Expected ERROR element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
- }
- return false;
+ if (required)
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_ERROR_ELEMENT",
+ "Expected ERROR element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ return false;
}
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
Uint32 tmpCode;
- if (!entry.getAttributeValue("CODE", tmpCode)) {
-
-
- // l10n
-
- // throw XmlValidationError(
- // parser.getLine(), "missing ERROR.CODE attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
- "missing ERROR.CODE attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ if (!entry.getAttributeValue("CODE", tmpCode))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
+ "missing ERROR.CODE attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
// Get ERROR.DESCRIPTION:
entry.getAttributeValue("DESCRIPTION", tmpDescription);
- cimException =
- PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
+ cimException =
+ PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
if (!empty)
{
- CIMInstance instance;
+ CIMInstance instance;
- while (getInstanceElement(parser, instance))
- {
- cimException.addError(instance);
- }
+ while (getInstanceElement(parser, instance))
+ {
+ cimException.addError(instance);
+ }
- expectEndTag(parser, "ERROR");
+ expectEndTag(parser, "ERROR");
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::getValueObjectElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMObject& object)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "VALUE.OBJECT"))
- return false;
+ return false;
CIMInstance cimInstance;
CIMClass cimClass;
if (XmlReader::getInstanceElement(parser, cimInstance))
{
- object = CIMObject(cimInstance);
+ object = CIMObject(cimInstance);
}
else if (XmlReader::getClassElement(parser, cimClass))
{
- object = CIMObject(cimClass);
+ object = CIMObject(cimClass);
}
else
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected INSTANCE or CLASS element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
- "Expected INSTANCE or CLASS element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
+ "Expected INSTANCE or CLASS element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
expectEndTag(parser, "VALUE.OBJECT");
//------------------------------------------------------------------------------
Boolean XmlReader::getValueObjectWithPathElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMObject& objectWithPath)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
- return false;
+ return false;
CIMObjectPath reference;
Boolean isInstance = false;
if (XmlReader::getInstancePathElement(parser, reference))
- isInstance = true;
+ isInstance = true;
else if (!XmlReader::getClassPathElement(parser, reference))
{
-
- // l10n 485
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected INSTANCEPATH or CLASSPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
- "Expected INSTANCEPATH or CLASSPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
+ "Expected INSTANCEPATH or CLASSPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
if (isInstance)
{
- CIMInstance cimInstance;
-
- if (!XmlReader::getInstanceElement(parser, cimInstance))
- {
-
- // l10n
+ CIMInstance cimInstance;
- // throw XmlValidationError(parser.getLine(),
- // "Expected INSTANCE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
- "Expected INSTANCE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
- objectWithPath = CIMObject (cimInstance);
+ if (!XmlReader::getInstanceElement(parser, cimInstance))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
+ "Expected INSTANCE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ objectWithPath = CIMObject (cimInstance);
objectWithPath.setPath (reference);
}
else
{
- CIMClass cimClass;
-
- if (!XmlReader::getClassElement(parser, cimClass))
- {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected CLASS element");
+ CIMClass cimClass;
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
- "Expected CLASS element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
- objectWithPath = CIMObject (cimClass);
+ if (!XmlReader::getClassElement(parser, cimClass))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
+ "Expected CLASS element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ objectWithPath = CIMObject (cimClass);
objectWithPath.setPath (reference);
}
//------------------------------------------------------------------------------
Boolean XmlReader::getValueObjectWithLocalPathElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMObject& objectWithPath)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
- return false;
+ return false;
CIMObjectPath reference;
Boolean isInstance = false;
if (XmlReader::getLocalInstancePathElement(parser, reference))
- isInstance = true;
+ isInstance = true;
else if (!XmlReader::getLocalClassPathElement(parser, reference))
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
-
- //l10n updated
- MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
- MISSING_ELEMENT_LOCALPATH);
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
+ MISSING_ELEMENT_LOCALPATH);
+ throw XmlValidationError(parser.getLine(), mlParms);
}
if (isInstance)
{
- CIMInstance cimInstance;
-
- if (!XmlReader::getInstanceElement(parser, cimInstance))
- {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Expected INSTANCE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
- "Expected INSTANCE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ CIMInstance cimInstance;
- }
- objectWithPath = CIMObject (cimInstance);
- objectWithPath.setPath (reference);
+ if (!XmlReader::getInstanceElement(parser, cimInstance))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
+ "Expected INSTANCE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ objectWithPath = CIMObject (cimInstance);
+ objectWithPath.setPath (reference);
}
else
{
- CIMClass cimClass;
-
- if (!XmlReader::getClassElement(parser, cimClass))
- {
-
- // l10n
+ CIMClass cimClass;
- // throw XmlValidationError(parser.getLine(),
- // "Expected CLASS element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
- "Expected CLASS element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
-
- }
- objectWithPath = CIMObject (cimClass);
- objectWithPath.setPath (reference);
+ if (!XmlReader::getClassElement(parser, cimClass))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
+ "Expected CLASS element");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
+ objectWithPath = CIMObject (cimClass);
+ objectWithPath.setPath (reference);
}
expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
//------------------------------------------------------------------------------
void XmlReader::getObjectArray(
- XmlParser& parser,
+ XmlParser& parser,
Array<CIMObject>& objectArray)
{
CIMObject object;
//------------------------------------------------------------------------------
Boolean XmlReader::getObjectNameElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMObjectPath& objectName)
{
CIMName className;
if (getClassNameElement(parser, className, false))
{
- objectName.set(String(), CIMNamespaceName(), className);
- return true;
+ objectName.set(String(), CIMNamespaceName(), className);
+ return true;
}
else if (getInstanceNameElement(parser, objectName))
- return true;
+ return true;
else
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected CLASSNAME or INSTANCENAME element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
- "Expected CLASSNAME or INSTANCENAME element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
+ "Expected CLASSNAME or INSTANCENAME element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
PEGASUS_UNREACHABLE( return false; )
//------------------------------------------------------------------------------
Boolean XmlReader::getObjectPathElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMObjectPath& objectPath)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "OBJECTPATH"))
- return false;
+ return false;
if (getClassPathElement(parser, objectPath))
{
- expectEndTag(parser, "OBJECTPATH");
- return true;
+ expectEndTag(parser, "OBJECTPATH");
+ return true;
}
else if (getInstancePathElement(parser, objectPath))
{
- expectEndTag(parser, "OBJECTPATH");
- return true;
+ expectEndTag(parser, "OBJECTPATH");
+ return true;
}
else
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected INSTANCEPATH or CLASSPATH element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
- "expected INSTANCEPATH or CLASSPATH element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
+ "expected INSTANCEPATH or CLASSPATH element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
- PEGASUS_UNREACHABLE ( return false; )
+ PEGASUS_UNREACHABLE(return false;)
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Boolean XmlReader::getEMethodCallStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "EXPMETHODCALL"))
- return false;
+ return false;
// Get EXPMETHODCALL.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing EXPMETHODCALL.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
- "Missing EXPMETHODCALL.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
+ "Missing EXPMETHODCALL.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
return true;
}
//------------------------------------------------------------------------------
Boolean XmlReader::getEMethodResponseStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name,
Boolean& isEmptyTag)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
- return false;
+ return false;
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
// Get EXPMETHODRESPONSE.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
- // l10n
-
- // throw XmlValidationError(
- // parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
- "Missing EXPMETHODRESPONSE.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
- }
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
+ "Missing EXPMETHODRESPONSE.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
+ }
return true;
}
//------------------------------------------------------------------------------
Boolean XmlReader::getEParamValueTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "EXPPARAMVALUE"))
- return false;
+ return false;
// Get EXPPARAMVALUE.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing EXPPARAMVALUE.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
- "Missing EXPPARAMVALUE.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
+ "Missing EXPPARAMVALUE.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
//------------------------------------------------------------------------------
Boolean XmlReader::getMethodCallStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name)
{
XmlEntry entry;
if (!testStartTag(parser, entry, "METHODCALL"))
- return false;
+ return false;
// Get METHODCALL.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing METHODCALL.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
- "Missing METHODCALL.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
+ "Missing METHODCALL.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
//------------------------------------------------------------------------------
Boolean XmlReader::getMethodResponseStartTag(
- XmlParser& parser,
+ XmlParser& parser,
const char*& name,
Boolean& isEmptyTag)
{
XmlEntry entry;
if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
- return false;
+ return false;
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
// Get METHODRESPONSE.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing METHODRESPONSE.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
- "Missing METHODRESPONSE.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
+ "Missing METHODRESPONSE.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::getParamValueElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMParamValue& paramValue)
{
XmlEntry entry;
CIMValue value;
if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
- return false;
+ return false;
Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
// Get PARAMVALUE.NAME attribute:
- if (!entry.getAttributeValue("NAME", name)) {
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "Missing PARAMVALUE.NAME attribute");
-
- MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
- "Missing PARAMVALUE.NAME attribute");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ if (!entry.getAttributeValue("NAME", name))
+ {
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
+ "Missing PARAMVALUE.NAME attribute");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
-
+
// Get PROPERTY.EMBEDDEDOBJECT
String embeddedObject = getEmbeddedObjectAttribute(
- parser.getLine(), entry, "PARAMVALUE");
+ parser.getLine(), entry, "PARAMVALUE");
// Get PARAMVALUE.PARAMTYPE attribute:
if ( (type == CIMTYPE_REFERENCE) || !gotType )
{
CIMObjectPath reference;
- if (XmlReader::getValueReferenceElement(parser, reference))
- {
- value.set(reference);
- type = CIMTYPE_REFERENCE;
+ if (XmlReader::getValueReferenceElement(parser, reference))
+ {
+ value.set(reference);
+ type = CIMTYPE_REFERENCE;
gotType = true;
- }
+ }
else if (XmlReader::getValueReferenceArrayElement(parser, value))
- {
- type = CIMTYPE_REFERENCE;
+ {
+ type = CIMTYPE_REFERENCE;
gotType = true;
- }
+ }
// If type==reference but no VALUE.REFERENCE found, use null value
}
{
CIMType effectiveType;
if (!gotType)
- {
- // If we don't know what type the value is, read it as a String
- effectiveType = CIMTYPE_STRING;
- }
+ {
+ // If we don't know what type the value is, read it as a String
+ effectiveType = CIMTYPE_STRING;
+ }
else
- {
- effectiveType = type;
- }
+ {
+ effectiveType = type;
+ }
- // If the EMBEDDEDOBJECT attribute is present with value "object"
+ // If the EMBEDDEDOBJECT attribute is present with value "object"
// then
// Convert the EmbeddedObject-encoded string into a CIMObject
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
Boolean isEmbeddedObject = String::equal(embeddedObject, "object");
- Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");
- if(isEmbeddedObject || isEmbeddedInstance)
+ Boolean isEmbeddedInstance =
+ String::equal(embeddedObject, "instance");
+ if (isEmbeddedObject || isEmbeddedInstance)
{
- // The EMBEDDEDOBJECT attribute is only valid on Parameters of type string
+ // The EMBEDDEDOBJECT attribute is only valid on Parameters
+ // of type string
// The type must have been specified.
if (gotType && (type == CIMTYPE_STRING))
{
- if(isEmbeddedObject)
- effectiveType = CIMTYPE_OBJECT; // Used below by getValueElement() or getValueArrayElement()
+ if (isEmbeddedObject)
+ // Used below by getValueElement() or
+ // getValueArrayElement()
+ effectiveType = CIMTYPE_OBJECT;
else
- effectiveType = CIMTYPE_INSTANCE;
+ effectiveType = CIMTYPE_INSTANCE;
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on "
+ "string types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
#else
- if (String::equal(embeddedObject, "object"))
+ if (String::equal(embeddedObject, "object"))
{
- // The EMBEDDEDOBJECT attribute is only valid on Parameters of type string
+ // The EMBEDDEDOBJECT attribute is only valid on Parameters
+ // of type string
// The type must have been specified.
if (gotType && (type == CIMTYPE_STRING))
{
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on "
+ "string types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
-
- if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
- !XmlReader::getValueElement(parser, effectiveType, value) )
+
+ if (!XmlReader::getValueArrayElement(parser, effectiveType, value)
+ && !XmlReader::getValueElement(parser, effectiveType, value))
{
gotType = false; // Can't distinguish array and non-array types
value.clear(); // Isn't necessary; should already be cleared
}
-
}
expectEndTag(parser, "PARAMVALUE");
}
-
paramValue = CIMParamValue(name, value, gotType);
return true;
//------------------------------------------------------------------------------
Boolean XmlReader::getReturnValueElement(
- XmlParser& parser,
+ XmlParser& parser,
CIMValue& returnValue)
{
XmlEntry entry;
CIMValue value;
if (!testStartTag(parser, entry, "RETURNVALUE"))
- return false;
+ return false;
// Get PROPERTY.EMBEDDEDOBJECT
String embeddedObject = getEmbeddedObjectAttribute(
- parser.getLine(), entry, "RETURNVALUE");
+ parser.getLine(), entry, "RETURNVALUE");
// Get RETURNVALUE.PARAMTYPE attribute:
// NOTE: Array type return values are not allowed (2/20/02)
}
else if (type == CIMTYPE_REFERENCE)
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected VALUE.REFERENCE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
- "expected VALUE.REFERENCE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
+ "expected VALUE.REFERENCE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
Boolean isEmbeddedObject = String::equal(embeddedObject, "object");
Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");
- if(isEmbeddedObject || isEmbeddedInstance)
+ if (isEmbeddedObject || isEmbeddedInstance)
{
if (gotType && (type == CIMTYPE_STRING))
{
- if(isEmbeddedObject)
- type = CIMTYPE_OBJECT; // Used below by getValueElement() or getValueArrayElement()
+ if (isEmbeddedObject)
+ // Used below by getValueElement() or getValueArrayElement()
+ type = CIMTYPE_OBJECT;
else
type = CIMTYPE_INSTANCE;
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on string "
+ "types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
#else
- if (String::equal(embeddedObject, "object"))
+ if (String::equal(embeddedObject, "object"))
{
if (gotType && (type == CIMTYPE_STRING))
{
}
else
{
- // Error -- throw exception
- // (the EmbeddedObject attribute may be applied only to entities that have the type String)
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected string type");
-
- MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
- "The EMBEDDEDOBJECT attribute is only valid on string types.");
-
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
+ "The EMBEDDEDOBJECT attribute is only valid on string "
+ "types.");
throw XmlValidationError(parser.getLine(), mlParms);
}
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
if ( !XmlReader::getValueElement(parser, type, returnValue) )
{
-
- // l10n
-
- // throw XmlValidationError(parser.getLine(),
- // "expected VALUE element");
-
- MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
- "expected VALUE element");
-
- throw XmlValidationError(parser.getLine(), mlParms);
+ MessageLoaderParms mlParms(
+ "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
+ "expected VALUE element");
+ throw XmlValidationError(parser.getLine(), mlParms);
}
}
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_XmlReader_h
public:
static void getXmlDeclaration(
- XmlParser& parser,
- const char*& xmlVersion,
- const char*& xmlEncoding);
+ XmlParser& parser,
+ const char*& xmlVersion,
+ const char*& xmlEncoding);
- static Boolean testXmlDeclaration (
- XmlParser& parser,
- XmlEntry& entry);
+ static Boolean testXmlDeclaration(
+ XmlParser& parser,
+ XmlEntry& entry);
static void expectStartTag(
- XmlParser& parser,
- XmlEntry& entry,
- const char* tagName);
+ XmlParser& parser,
+ XmlEntry& entry,
+ const char* tagName);
static void expectEndTag(
- XmlParser& parser,
- const char* tagName);
+ XmlParser& parser,
+ const char* tagName);
static void expectStartTagOrEmptyTag(
- XmlParser& parser,
- XmlEntry& entry,
- const char* tagName);
+ XmlParser& parser,
+ XmlEntry& entry,
+ const char* tagName);
static void skipElement(
- XmlParser& parser,
- XmlEntry& entry);
+ XmlParser& parser,
+ XmlEntry& entry);
static Boolean expectContentOrCData(
- XmlParser& parser,
- XmlEntry& entry);
+ XmlParser& parser,
+ XmlEntry& entry);
static Boolean testStartTag(
- XmlParser& parser,
- XmlEntry& entry,
- const char* tagName);
+ XmlParser& parser,
+ XmlEntry& entry,
+ const char* tagName);
static Boolean testEndTag(
- XmlParser& parser,
- const char* tagName);
+ XmlParser& parser,
+ const char* tagName);
static Boolean testStartTagOrEmptyTag(
- XmlParser& parser,
- XmlEntry& entry,
- const char* tagName);
+ XmlParser& parser,
+ XmlEntry& entry,
+ const char* tagName);
static Boolean testStartTagOrEmptyTag(
- XmlParser& parser,
- XmlEntry& entry);
+ XmlParser& parser,
+ XmlEntry& entry);
static Boolean testContentOrCData(
- XmlParser& parser,
- XmlEntry& entry);
+ XmlParser& parser,
+ XmlEntry& entry);
static void getCimStartTag(
- XmlParser& parser,
- const char*& cimVersion,
- const char*& dtdVersion);
+ XmlParser& parser,
+ const char*& cimVersion,
+ const char*& dtdVersion);
static CIMName getCimNameAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* elementName,
- Boolean acceptNull = false);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* elementName,
+ Boolean acceptNull = false);
static String getClassNameAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* elementName);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* elementName);
static CIMName getClassOriginAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* tagName);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* tagName);
static String getEmbeddedObjectAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* tagName);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* tagName);
static CIMName getReferenceClassAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* elementName);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* elementName);
static CIMName getSuperClassAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* tagName);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* tagName);
static Boolean getCimTypeAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
+ Uint32 lineNumber,
+ const XmlEntry& entry,
CIMType& cimType, // Output parameter
- const char* tagName,
- const char* attributeName = "TYPE",
- Boolean required = true);
+ const char* tagName,
+ const char* attributeName = "TYPE",
+ Boolean required = true);
static Boolean getCimBooleanAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* tagName,
- const char* attributeName,
- Boolean defaultValue,
- Boolean required);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* tagName,
+ const char* attributeName,
+ Boolean defaultValue,
+ Boolean required);
static String decodeURICharacters(String uriString);
static Boolean stringToReal(
- const char* stringValue,
- Real64& x);
+ const char* stringValue,
+ Real64& x);
static Boolean stringToSignedInteger(
- const char* stringValue,
- Sint64& x);
+ const char* stringValue,
+ Sint64& x);
static Boolean stringToUnsignedInteger(
- const char* stringValue,
- Uint64& x);
+ const char* stringValue,
+ Uint64& x);
static CIMValue stringToValue(
- Uint32 lineNumber,
- const char* valueString,
- CIMType type);
+ Uint32 lineNumber,
+ const char* valueString,
+ CIMType type);
/* getValueElement - Gets the CIMType and CIMValue for a single
XML Value element. It expects <VALUE> as the start tag.
- @return Returns True if the value element exists
+ @return Returns True if the value element exists
*/
static Boolean getValueElement(
- XmlParser& parser,
- CIMType type,
- CIMValue& value);
+ XmlParser& parser,
+ CIMType type,
+ CIMValue& value);
static Boolean getStringValueElement(
- XmlParser& parser,
- String& str,
- Boolean required);
+ XmlParser& parser,
+ String& str,
+ Boolean required);
static CIMValue stringArrayToValue(
- Uint32 lineNumber,
- const Array<const char*>& array,
- CIMType type);
+ Uint32 lineNumber,
+ const Array<const char*>& array,
+ CIMType type);
static Boolean getValueArrayElement(
- XmlParser& parser,
- CIMType type,
- CIMValue& value);
+ XmlParser& parser,
+ CIMType type,
+ CIMValue& value);
static CIMFlavor getFlavor(
- XmlEntry& entry,
- Uint32 lineNumber,
- const char* tagName);
+ XmlEntry& entry,
+ Uint32 lineNumber,
+ const char* tagName);
static CIMScope getOptionalScope(
- XmlParser& parser);
+ XmlParser& parser);
static Boolean getQualifierElement(
- XmlParser& parser,
- CIMQualifier& qualifier);
+ XmlParser& parser,
+ CIMQualifier& qualifier);
static Boolean getPropertyElement(
- XmlParser& parser,
- CIMProperty& property);
+ XmlParser& parser,
+ CIMProperty& property);
static Boolean getArraySizeAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* tagName,
- Uint32& value);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* tagName,
+ Uint32& value);
static Boolean getPropertyArrayElement(
- XmlParser& parser,
- CIMProperty& property);
+ XmlParser& parser,
+ CIMProperty& property);
static Boolean getHostElement(
- XmlParser& parser,
- String& host);
+ XmlParser& parser,
+ String& host);
static Boolean getNameSpaceElement(
- XmlParser& parser,
- CIMName& nameSpaceComponent);
+ XmlParser& parser,
+ CIMName& nameSpaceComponent);
static Boolean getLocalNameSpacePathElement(
- XmlParser& parser,
- String& nameSpace);
+ XmlParser& parser,
+ String& nameSpace);
static Boolean getNameSpacePathElement(
- XmlParser& parser,
- String& host,
- String& nameSpace);
+ XmlParser& parser,
+ String& host,
+ String& nameSpace);
static Boolean getClassNameElement(
- XmlParser& parser,
- CIMName& className,
- Boolean required = false);
+ XmlParser& parser,
+ CIMName& className,
+ Boolean required = false);
static CIMKeyBinding::Type getValueTypeAttribute(
- Uint32 lineNumber,
- const XmlEntry& entry,
- const char* elementName);
+ Uint32 lineNumber,
+ const XmlEntry& entry,
+ const char* elementName);
static Boolean getKeyValueElement(
- XmlParser& parser,
- CIMKeyBinding::Type& type,
- String& value);
+ XmlParser& parser,
+ CIMKeyBinding::Type& type,
+ String& value);
static Boolean getKeyBindingElement(
- XmlParser& parser,
- CIMName& name,
- String& value,
- CIMKeyBinding::Type& type);
+ XmlParser& parser,
+ CIMName& name,
+ String& value,
+ CIMKeyBinding::Type& type);
static Boolean getInstanceNameElement(
- XmlParser& parser,
- String& className,
- Array<CIMKeyBinding>& keyBindings);
+ XmlParser& parser,
+ String& className,
+ Array<CIMKeyBinding>& keyBindings);
static Boolean getInstanceNameElement(
- XmlParser& parser,
- CIMObjectPath& instanceName);
+ XmlParser& parser,
+ CIMObjectPath& instanceName);
static Boolean getInstancePathElement(
- XmlParser& parser,
- CIMObjectPath& reference);
+ XmlParser& parser,
+ CIMObjectPath& reference);
static Boolean getLocalInstancePathElement(
- XmlParser& parser,
- CIMObjectPath& reference);
+ XmlParser& parser,
+ CIMObjectPath& reference);
static Boolean getClassPathElement(
- XmlParser& parser,
- CIMObjectPath& reference);
+ XmlParser& parser,
+ CIMObjectPath& reference);
static Boolean getLocalClassPathElement(
- XmlParser& parser,
- CIMObjectPath& reference);
+ XmlParser& parser,
+ CIMObjectPath& reference);
static Boolean getValueReferenceElement(
- XmlParser& parser,
- CIMObjectPath& reference);
+ XmlParser& parser,
+ CIMObjectPath& reference);
static Boolean getValueReferenceArrayElement(
- XmlParser& parser,
- CIMValue& value);
+ XmlParser& parser,
+ CIMValue& value);
static Boolean getPropertyReferenceElement(
- XmlParser& parser,
- CIMProperty& property);
+ XmlParser& parser,
+ CIMProperty& property);
static Boolean getParameterElement(
- XmlParser& parser,
- CIMParameter& parameter);
+ XmlParser& parser,
+ CIMParameter& parameter);
static Boolean getParameterArrayElement(
- XmlParser& parser,
- CIMParameter& parameter);
+ XmlParser& parser,
+ CIMParameter& parameter);
static Boolean getParameterReferenceElement(
- XmlParser& parser,
- CIMParameter& parameter);
+ XmlParser& parser,
+ CIMParameter& parameter);
static Boolean getParameterReferenceArrayElement(
- XmlParser& parser,
- CIMParameter& parameter);
+ XmlParser& parser,
+ CIMParameter& parameter);
static Boolean getQualifierDeclElement(
- XmlParser& parser,
- CIMQualifierDecl& qualifierDecl);
+ XmlParser& parser,
+ CIMQualifierDecl& qualifierDecl);
static Boolean getMethodElement(
- XmlParser& parser,
- CIMMethod& method);
+ XmlParser& parser,
+ CIMMethod& method);
static Boolean getClassElement(
- XmlParser& parser,
- CIMClass& cimClass);
+ XmlParser& parser,
+ CIMClass& cimClass);
static Boolean getInstanceElement(
- XmlParser& parser,
- CIMInstance& cimInstance);
+ XmlParser& parser,
+ CIMInstance& cimInstance);
static Boolean getNamedInstanceElement(
- XmlParser& parser,
- CIMInstance& namedInstance);
+ XmlParser& parser,
+ CIMInstance& namedInstance);
static void getObject(XmlParser& parser, CIMClass& x);
static void getObject(XmlParser& parser, CIMQualifierDecl& x);
static Boolean getMessageStartTag(
- XmlParser& parser,
- String& id,
- String& protocolVersion);
+ XmlParser& parser,
+ String& id,
+ String& protocolVersion);
static Boolean getIMethodCallStartTag(
- XmlParser& parser,
- const char*& name);
+ XmlParser& parser,
+ const char*& name);
static Boolean getIMethodResponseStartTag(
XmlParser& parser,
Boolean& isEmptyTag);
static Boolean getIParamValueTag(
- XmlParser& parser,
- const char*& name,
- Boolean& isEmptyTag);
+ XmlParser& parser,
+ const char*& name,
+ Boolean& isEmptyTag);
static void rejectNullIParamValue(
XmlParser& parser,
const char* paramName);
static Boolean getPropertyValue(
- XmlParser& parser,
- CIMValue& cimValue);
+ XmlParser& parser,
+ CIMValue& cimValue);
static Boolean getBooleanValueElement(
- XmlParser& parser,
- Boolean& result,
- Boolean required = false);
+ XmlParser& parser,
+ Boolean& result,
+ Boolean required = false);
static Boolean getErrorElement(
- XmlParser& parser,
- CIMException& cimException,
- Boolean required = false);
+ XmlParser& parser,
+ CIMException& cimException,
+ Boolean required = false);
static Boolean getValueObjectElement(
- XmlParser& parser,
- CIMObject& object);
+ XmlParser& parser,
+ CIMObject& object);
static Boolean getValueObjectWithPathElement(
- XmlParser& parser,
- CIMObject& objectWithPath);
+ XmlParser& parser,
+ CIMObject& objectWithPath);
static Boolean getValueObjectWithLocalPathElement(
- XmlParser& parser,
- CIMObject& objectWithPath);
+ XmlParser& parser,
+ CIMObject& objectWithPath);
static void getObjectArray(
- XmlParser& parser,
- Array<CIMObject>& objectArray);
+ XmlParser& parser,
+ Array<CIMObject>& objectArray);
static Boolean getObjectNameElement(
- XmlParser& parser,
- CIMObjectPath& objectName);
+ XmlParser& parser,
+ CIMObjectPath& objectName);
static Boolean getObjectPathElement(
- XmlParser& parser,
- CIMObjectPath& objectPath);
+ XmlParser& parser,
+ CIMObjectPath& objectPath);
static Boolean getEMethodCallStartTag(
- XmlParser& parser,
- const char*& name);
+ XmlParser& parser,
+ const char*& name);
static Boolean getEMethodResponseStartTag(
XmlParser& parser,
Boolean& isEmptyTag);
static Boolean getEParamValueTag(
- XmlParser& parser,
- const char*& name);
+ XmlParser& parser,
+ const char*& name);
static Boolean getMethodCallStartTag(
- XmlParser& parser,
- const char*& name);
+ XmlParser& parser,
+ const char*& name);
static Boolean getMethodResponseStartTag(
XmlParser& parser,
Boolean& isEmptyTag);
static Boolean getParamValueElement(
- XmlParser& parser,
- CIMParamValue& paramValue);
+ XmlParser& parser,
+ CIMParamValue& paramValue);
static Boolean getReturnValueElement(
- XmlParser& parser,
- CIMValue& returnValue);
+ XmlParser& parser,
+ CIMValue& returnValue);
private:
- XmlReader()
- {
+ XmlReader()
+ {
}
};
//
//==============================================================================
//
-// Author: Adrian Schuur schuur@de-ibm.com
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#include "XmlWriter.h"
PEGASUS_NAMESPACE_BEGIN
-void XmlStreamer::encode(Buffer& out, const CIMClass& cls) {
- XmlWriter::appendClassElement(out, cls);
+void XmlStreamer::encode(Buffer& out, const CIMClass& cls)
+{
+ XmlWriter::appendClassElement(out, cls);
}
-void XmlStreamer::encode(Buffer& out, const CIMInstance& inst) {
- XmlWriter::appendInstanceElement(out, inst);
+void XmlStreamer::encode(Buffer& out, const CIMInstance& inst)
+{
+ XmlWriter::appendInstanceElement(out, inst);
}
-void XmlStreamer::encode(Buffer& out, const CIMQualifierDecl& qual) {
- XmlWriter::appendQualifierDeclElement(out, qual);
+void XmlStreamer::encode(Buffer& out, const CIMQualifierDecl& qual)
+{
+ XmlWriter::appendQualifierDeclElement(out, qual);
}
-void XmlStreamer::decode(const Buffer& in, unsigned int pos, CIMClass& cls) {
+void XmlStreamer::decode(
+ const Buffer& in,
+ unsigned int pos,
+ CIMClass& cls)
+{
XmlParser parser(((char*)in.getData())+pos);
XmlReader::getObject(parser, cls);
}
-void XmlStreamer::decode(const Buffer& in, unsigned int pos, CIMInstance& inst) {
- XmlParser parser(((char*)in.getData())+pos);
- XmlReader::getObject(parser, inst);
+void XmlStreamer::decode(
+ const Buffer& in,
+ unsigned int pos,
+ CIMInstance& inst)
+{
+ XmlParser parser(((char*)in.getData())+pos);
+ XmlReader::getObject(parser, inst);
}
-void XmlStreamer::decode(const Buffer& in, unsigned int pos, CIMQualifierDecl& qual) {
- XmlParser parser(((char*)in.getData())+pos);
- XmlReader::getObject(parser, qual);
+void XmlStreamer::decode(
+ const Buffer& in,
+ unsigned int pos,
+ CIMQualifierDecl& qual)
+{
+ XmlParser parser(((char*)in.getData())+pos);
+ XmlReader::getObject(parser, qual);
}
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Adrian Schuur (schuur@de.ibm.com) PEP 164
-//
-// Modified By: David Dillard, VERITAS Software Corp.
-// (david.dillard@veritas.com)
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef XmlStreamer_h
PEGASUS_NAMESPACE_BEGIN
-class PEGASUS_COMMON_LINKAGE XmlStreamer : public ObjectStreamer {
-
+class PEGASUS_COMMON_LINKAGE XmlStreamer : public ObjectStreamer
+{
public:
- XmlStreamer() {}
-
- ~XmlStreamer() {}
+ XmlStreamer() {}
- void encode(Buffer& out, const CIMClass& cls);
- void encode(Buffer& out, const CIMInstance& inst);
- void encode(Buffer& out, const CIMQualifierDecl& qual);
+ ~XmlStreamer() {}
- void decode(const Buffer& in, unsigned int pos, CIMClass& cls);
- void decode(const Buffer& in, unsigned int pos, CIMInstance& inst);
- void decode(const Buffer& in, unsigned int pos, CIMQualifierDecl& qual);
+ void encode(Buffer& out, const CIMClass& cls);
+ void encode(Buffer& out, const CIMInstance& inst);
+ void encode(Buffer& out, const CIMQualifierDecl& qual);
+ void decode(const Buffer& in, unsigned int pos, CIMClass& cls);
+ void decode(const Buffer& in, unsigned int pos, CIMInstance& inst);
+ void decode(const Buffer& in, unsigned int pos, CIMQualifierDecl& qual);
};
PEGASUS_NAMESPACE_END
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
-// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
-// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
-// Willis White (whiwill@us.ibm.com) PEP 127 and 128
-// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
-// Dave Sudlik, IBM (dsudlik@us.ibm.com)
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-// Vijay Eli, vijayeli@in.ibm.com, fix for #2571
-//
//%/////////////////////////////////////////////////////////////////////////////
#include <Pegasus/Common/Config.h>
// messages can be very large. This overwriting shortcut allows us to NOT have
// to repackage a large message later.
-#define OUTPUT_CONTENTLENGTH \
-{ \
- char contentLengthP[11]; \
- int n = sprintf(contentLengthP,"%.10u", contentLength); \
- out << STRLIT("content-length: "); \
- out.append(contentLengthP, n); \
- out << STRLIT("\r\n"); \
+#define OUTPUT_CONTENTLENGTH \
+{ \
+ char contentLengthP[11]; \
+ int n = sprintf(contentLengthP,"%.10u", contentLength); \
+ out << STRLIT("content-length: "); \
+ out.append(contentLengthP, n); \
+ out << STRLIT("\r\n"); \
}
////////////////////////////////////////////////////////////////////////////////
}
-// l10n
Buffer& operator<<(Buffer& out, const AcceptLanguageList& al)
{
XmlWriter::append(out, LanguageParser::buildAcceptLanguageHeader(al));
return out;
}
-// l10n
Buffer& operator<<(Buffer& out, const ContentLanguageList& cl)
{
XmlWriter::append(out, LanguageParser::buildContentLanguageHeader(cl));
Uint8 *strtgt = (Uint8 *)str;
Uint8 *endtgt = (Uint8 *)&str[5];
- UTF16toUTF8(&strsrc,
- endsrc,
- &strtgt,
- endtgt);
+ UTF16toUTF8(
+ &strsrc,
+ endsrc,
+ &strtgt,
+ endtgt);
out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);
}
Uint8 *strtgt = (Uint8 *)str;
Uint8 *endtgt = (Uint8 *)&str[5];
- UTF16toUTF8(&strsrc,
- endsrc,
- &strtgt,
- endtgt);
+ UTF16toUTF8(
+ &strsrc,
+ endsrc,
+ &strtgt,
+ endtgt);
Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
out.append(str,number1);
void XmlWriter::append(Buffer& out, Real64 x)
{
char buffer[128];
- // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format
- // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
- // (8 byte IEEE floating point)
+ // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible
+ // with the format given in the CIM/XML spec, and the precision required
+ // by the CIM 2.2 spec (8 byte IEEE floating point)
sprintf(buffer, "%.16e", x);
append(out, buffer);
}
while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)
{
- out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
- p += 8;
- n -= 8;
+ out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
+ p += 8;
+ n -= 8;
}
while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)
{
- out.append(p[0], p[1], p[2], p[3]);
- p += 4;
- n -= 4;
+ out.append(p[0], p[1], p[2], p[3]);
+ p += 4;
+ n -= 4;
}
while (n--)
{
- Uint16 c = *p++;
+ Uint16 c = *p++;
- // Special processing for UTF8 case:
+ // Special processing for UTF8 case:
- if (c < 128)
- {
- out.append(c);
- continue;
- }
+ if (c < 128)
+ {
+ out.append(c);
+ continue;
+ }
- // Hanlde UTF8 case (if reached).
+ // Handle UTF8 case (if reached).
- if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
- ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
- {
- Char16 highSurrogate = p[-1];
- Char16 lowSurrogate = p[0];
- p++;
- n--;
+ if (((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
+ ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
+ {
+ Char16 highSurrogate = p[-1];
+ Char16 lowSurrogate = p[0];
+ p++;
+ n--;
- _xmlWritter_appendSurrogatePair(
- out, Uint16(highSurrogate),Uint16(lowSurrogate));
- }
- else
- {
- _xmlWritter_appendChar(out, c);
- }
+ _xmlWritter_appendSurrogatePair(
+ out, Uint16(highSurrogate),Uint16(lowSurrogate));
+ }
+ else
+ {
+ _xmlWritter_appendChar(out, c);
+ }
}
}
void XmlWriter::append(Buffer& out, const Indentor& x)
{
for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
- out.append(' ');
+ out.append(' ');
}
void XmlWriter::appendSpecial(Buffer& out, const Char16& x)
void XmlWriter::appendSpecial(Buffer& out, const char* str)
{
while (*str)
- _appendSpecialChar7(out, *str++);
+ _appendSpecialChar7(out, *str++);
}
void XmlWriter::appendSpecial(Buffer& out, const String& str)
{
if (c < 128)
{
- if (_isSpecialChar7[c])
+ if (_isSpecialChar7[c])
{
// Write the character reference for the special character
out.append(
}
else
{
- // Handle UTF8 case
+ // Handle UTF8 case
if ((((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE))) &&
{
Uint16 c = uriString[i];
- if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
- ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
+ if (((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
+ ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
{
Char16 highSurrogate = uriString[i];
Char16 lowSurrogate = uriString[++i];
- _xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
+ _xmlWritter_appendSurrogatePair(
+ utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
}
else
{
for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
{
out << STRLIT("<KEYBINDING NAME=\"");
- out << keyBindings[i].getName() << STRLIT("\">\n");
+ out << keyBindings[i].getName() << STRLIT("\">\n");
if (keyBindings[i].getType() == CIMKeyBinding::REFERENCE)
{
CIMObjectPath ref = keyBindings[i].getValue();
appendValueReferenceElement(out, ref, true);
}
- else {
+ else
+ {
out << STRLIT("<KEYVALUE VALUETYPE=\"");
out << keyBindingTypeToString(keyBindings[i].getType());
out << STRLIT("\">");
case CIMTYPE_STRING:
{
- const String* data;
- Uint32 size;
- value._get(data, size);
+ const String* data;
+ Uint32 size;
+ value._get(data, size);
_xmlWritter_appendValueArray(out, data, size);
break;
}
OUTPUT_CONTENTLENGTH;
if (acceptLanguages.size() > 0)
{
- out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
+ out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
}
if (contentLanguages.size() > 0)
{
- out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
+ out << STRLIT("Content-Language: ") << contentLanguages <<
+ STRLIT("\r\n");
}
#ifdef PEGASUS_DEBUG
- // backdoor environment variable to turn OFF client requesting transfer
- // encoding. The default is on. to turn off, set this variable to zero.
- // This should be removed when stable. This should only be turned off in
- // a debugging/testing environment.
+ // backdoor environment variable to turn OFF client requesting transfer
+ // encoding. The default is on. to turn off, set this variable to zero.
+ // This should be removed when stable. This should only be turned off in
+ // a debugging/testing environment.
- static const char *clientTransferEncodingOff =
- getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
+ static const char *clientTransferEncodingOff =
+ getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
- if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
+ if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
#endif
- out << STRLIT("TE: chunked, trailers\r\n");
+ out << STRLIT("TE: chunked, trailers\r\n");
if (httpMethod == HTTP_METHOD_M_POST)
{
out << nn << STRLIT("-CIMMethod: ")
<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");
out << nn << STRLIT("-CIMObject: ") << encodeURICharacters(cimObject)
- << STRLIT("\r\n");
+ << STRLIT("\r\n");
}
else
{
out << STRLIT("CIMOperation: MethodCall\r\n");
- out << STRLIT("CIMMethod: ") << encodeURICharacters(cimMethod.getString())
+ out << STRLIT("CIMMethod: ")
+ << encodeURICharacters(cimMethod.getString())
<< STRLIT("\r\n");
out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject)
- << STRLIT("\r\n");
+ << STRLIT("\r\n");
}
if (authenticationHeader.size())
if (contentLanguages.size() > 0)
{
- out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
+ out << STRLIT("Content-Language: ") << contentLanguages <<
+ STRLIT("\r\n");
}
if (httpMethod == HTTP_METHOD_M_POST)
{
// is usually intended to have content. But, for Kerberos this
// may not always be the case so we need to indicate that there
// is no content
- Uint32 contentLength = 0;
- OUTPUT_CONTENTLENGTH;
+ Uint32 contentLength = 0;
+ OUTPUT_CONTENTLENGTH;
out << content << STRLIT("\r\n");
out << STRLIT("\r\n");
{
out << STRLIT(" DESCRIPTION=\"");
appendSpecial(out, description);
- out.append('"');
+ out.append('"');
}
if (cimException.getErrorCount())
CIMType type = value.getType();
// If the property type is CIMObject, then
- // encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute
- // (there is not currently a CIM-XML "object" datatype)
+ // encode the property in CIM-XML as a string with the EMBEDDEDOBJECT
+ // attribute (there is not currently a CIM-XML "object" datatype)
// else
// output the real type
if (type == CIMTYPE_OBJECT)
else
{
out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type);
- out.append('"');
+ out.append('"');
}
out << STRLIT(">\n");
//
if (objectName.getKeyBindings ().size () == 0)
{
- XmlWriter::appendClassNameIParameter(
- out, name, objectName.getClassName());
+ XmlWriter::appendClassNameIParameter(
+ out, name, objectName.getClassName());
}
else
{
- XmlWriter::appendInstanceNameIParameter(
- out, name, objectName);
+ XmlWriter::appendInstanceNameIParameter(
+ out, name, objectName);
}
}
_appendMessageElementEnd(out);
appendMethodCallHeader(
- tmp,
- host,
- methodName,
- localObjectPath.toString(),
+ tmp,
+ host,
+ methodName,
+ localObjectPath.toString(),
authenticationHeader,
httpMethod,
httpAcceptLanguages,
httpContentLanguages,
- out.size());
+ out.size());
tmp << out;
return tmp;
HttpMethod httpMethod,
const ContentLanguageList& httpContentLanguages,
const Buffer& body,
- Uint64 serverResponseTime,
- Boolean isFirst,
- Boolean isLast)
+ Uint64 serverResponseTime,
+ Boolean isFirst,
+ Boolean isLast)
{
- Buffer out;
+ Buffer out;
- if (isFirst == true)
- {
- // NOTE: temporarily put zero for content length. the http code
- // will later decide to fill in the length or remove it altogether
- appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
- serverResponseTime);
- _appendMessageElementBegin(out, messageId);
- _appendSimpleRspElementBegin(out);
- _appendMethodResponseElementBegin(out, methodName);
- }
+ if (isFirst == true)
+ {
+ // NOTE: temporarily put zero for content length. the http code
+ // will later decide to fill in the length or remove it altogether
+ appendMethodResponseHeader(
+ out, httpMethod, httpContentLanguages, 0, serverResponseTime);
+ _appendMessageElementBegin(out, messageId);
+ _appendSimpleRspElementBegin(out);
+ _appendMethodResponseElementBegin(out, methodName);
+ }
- if (body.size() != 0)
- {
- out << body;
- }
+ if (body.size() != 0)
+ {
+ out << body;
+ }
- if (isLast == true)
- {
- _appendMethodResponseElementEnd(out);
- _appendSimpleRspElementEnd(out);
- _appendMessageElementEnd(out);
- }
+ if (isLast == true)
+ {
+ _appendMethodResponseElementEnd(out);
+ _appendSimpleRspElementEnd(out);
+ _appendMessageElementEnd(out);
+ }
- return out;
+ return out;
}
-
//------------------------------------------------------------------------------
//
// XmlWriter::formatSimpleMethodErrorRspMessage()
_appendSimpleRspElementEnd(out);
_appendMessageElementEnd(out);
-// l10n
- appendMethodResponseHeader(tmp,
- httpMethod,
- cimException.getContentLanguages(),
- out.size());
+ appendMethodResponseHeader(
+ tmp,
+ httpMethod,
+ cimException.getContentLanguages(),
+ out.size());
tmp << out;
return tmp;
_appendMessageElementEnd(out);
appendMethodCallHeader(
- tmp,
- host,
- iMethodName,
- nameSpace.getString(),
+ tmp,
+ host,
+ iMethodName,
+ nameSpace.getString(),
authenticationHeader,
httpMethod,
httpAcceptLanguages,
httpContentLanguages,
- out.size());
+ out.size());
tmp << out;
return tmp;
{
Buffer out;
- if (isFirst == true)
- {
- // NOTE: temporarily put zero for content length. the http code
- // will later decide to fill in the length or remove it altogether
- appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
- serverResponseTime);
- _appendMessageElementBegin(out, messageId);
- _appendSimpleRspElementBegin(out);
- _appendIMethodResponseElementBegin(out, iMethodName);
-
- // output the start of the return tag. Test if there is response data by:
- // 1. there is data on the first chunk OR
- // 2. there is no data on the first chunk but isLast is false implying
- // there is more non-empty data to come. If all subsequent chunks
- // are empty, then this generates and empty response.
- if (body.size() != 0 || isLast == false)
- _appendIReturnValueElementBegin(out);
- }
+ if (isFirst == true)
+ {
+ // NOTE: temporarily put zero for content length. the http code
+ // will later decide to fill in the length or remove it altogether
+ appendMethodResponseHeader(
+ out, httpMethod, httpContentLanguages, 0, serverResponseTime);
+ _appendMessageElementBegin(out, messageId);
+ _appendSimpleRspElementBegin(out);
+ _appendIMethodResponseElementBegin(out, iMethodName);
+
+ // output the start of the return tag. Test if there is response data
+ // by:
+ // 1. there is data on the first chunk OR
+ // 2. there is no data on the first chunk but isLast is false implying
+ // there is more non-empty data to come. If all subsequent chunks
+ // are empty, then this generates and empty response.
+ if (body.size() != 0 || isLast == false)
+ _appendIReturnValueElementBegin(out);
+ }
if (body.size() != 0)
{
- out << body;
+ out << body;
}
- if (isLast == true)
- {
- if (body.size() != 0 || isFirst == false)
- _appendIReturnValueElementEnd(out);
- _appendIMethodResponseElementEnd(out);
- _appendSimpleRspElementEnd(out);
- _appendMessageElementEnd(out);
- }
+ if (isLast == true)
+ {
+ if (body.size() != 0 || isFirst == false)
+ _appendIReturnValueElementEnd(out);
+ _appendIMethodResponseElementEnd(out);
+ _appendSimpleRspElementEnd(out);
+ _appendMessageElementEnd(out);
+ }
return out;
}
_appendSimpleRspElementEnd(out);
_appendMessageElementEnd(out);
-// l10n
appendMethodResponseHeader(tmp,
- httpMethod,
- cimException.getContentLanguages(),
- out.size());
+ httpMethod,
+ cimException.getContentLanguages(),
+ out.size());
tmp << out;
return tmp;
if (acceptLanguages.size() > 0)
{
- out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
+ out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
}
if (contentLanguages.size() > 0)
{
- out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
+ out << STRLIT("Content-Language: ") << contentLanguages <<
+ STRLIT("\r\n");
}
#ifdef PEGASUS_DEBUG
- // backdoor environment variable to turn OFF client requesting transfer
- // encoding. The default is on. to turn off, set this variable to zero.
- // This should be removed when stable. This should only be turned off in
- // a debugging/testing environment.
-
- static const char *clientTransferEncodingOff =
- getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
- if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
+ // backdoor environment variable to turn OFF client requesting transfer
+ // encoding. The default is on. to turn off, set this variable to zero.
+ // This should be removed when stable. This should only be turned off in
+ // a debugging/testing environment.
+
+ static const char *clientTransferEncodingOff =
+ getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
+ if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
#endif
- out << STRLIT("TE: chunked, trailers\r\n");
+ out << STRLIT("TE: chunked, trailers\r\n");
if (httpMethod == HTTP_METHOD_M_POST)
{
- out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
+ out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
out << nn << STRLIT("\r\n");
out << nn << STRLIT("-CIMExport: MethodRequest\r\n");
- out << nn << STRLIT("-CIMExportMethod: ") << cimMethod << STRLIT("\r\n");
+ out << nn << STRLIT("-CIMExportMethod: ") << cimMethod <<
+ STRLIT("\r\n");
}
else
{
if (contentLanguages.size() > 0)
{
- out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
+ out << STRLIT("Content-Language: ") << contentLanguages <<
+ STRLIT("\r\n");
}
if (httpMethod == HTTP_METHOD_M_POST)
{
authenticationHeader,
httpAcceptLanguages,
httpContentLanguages,
- out.size());
+ out.size());
tmp << out;
return tmp;
_appendMessageElementEnd(out);
appendEMethodResponseHeader(tmp,
- httpMethod,
- httpContentLanguages,
- out.size());
+ httpMethod,
+ httpContentLanguages,
+ out.size());
tmp << out;
return tmp;
_appendSimpleExportRspElementEnd(out);
_appendMessageElementEnd(out);
-// l10n
- appendEMethodResponseHeader(tmp,
- httpMethod,
- cimException.getContentLanguages(),
- out.size());
+ appendEMethodResponseHeader(
+ tmp,
+ httpMethod,
+ cimException.getContentLanguages(),
+ out.size());
tmp << out;
return tmp;
{
for (Uint32 i = 0; i < attributeCount; i++)
{
- os << attributes[i].name << "=";
+ os << attributes[i].name << "=";
- os << '"';
- _xmlWritter_appendSpecial(os, attributes[i].value);
- os << '"';
+ os << '"';
+ _xmlWritter_appendSpecial(os, attributes[i].value);
+ os << '"';
- if (i + 1 != attributeCount)
- os << ' ';
+ if (i + 1 != attributeCount)
+ os << ' ';
}
}
//
//------------------------------------------------------------------------------
-void _xmlWritter_indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
+void _xmlWritter_indent(
+ PEGASUS_STD(ostream)& os,
+ Uint32 level,
+ Uint32 indentChars)
{
Uint32 n = level * indentChars;
for (Uint32 i = 0; i < n; i++)
- os << ' ';
+ os << ' ';
}
//------------------------------------------------------------------------------
while (parser.next(entry))
{
- switch (entry.type)
- {
- case XmlEntry::XML_DECLARATION:
- {
- _xmlWritter_indent(os, stack.size(), indentChars);
-
- os << "<?" << entry.text << " ";
- _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
- os << "?>";
- break;
- }
-
- case XmlEntry::START_TAG:
- {
- _xmlWritter_indent(os, stack.size(), indentChars);
-
- os << "<" << entry.text;
-
- if (entry.attributeCount)
- os << ' ';
-
- _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
- os << ">";
- stack.push(entry.text);
- break;
- }
-
- case XmlEntry::EMPTY_TAG:
- {
- _xmlWritter_indent(os, stack.size(), indentChars);
-
- os << "<" << entry.text << " ";
- _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
- os << "/>";
- break;
- }
-
- case XmlEntry::END_TAG:
- {
- if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
- stack.pop();
-
- _xmlWritter_indent(os, stack.size(), indentChars);
-
- os << "</" << entry.text << ">";
- break;
- }
-
- case XmlEntry::COMMENT:
- {
-
- _xmlWritter_indent(os, stack.size(), indentChars);
- os << "<!--";
- _xmlWritter_appendSpecial(os, entry.text);
- os << "-->";
- break;
- }
-
- case XmlEntry::CONTENT:
- {
- _xmlWritter_indent(os, stack.size(), indentChars);
- _xmlWritter_appendSpecial(os, entry.text);
- break;
- }
-
- case XmlEntry::CDATA:
- {
- _xmlWritter_indent(os, stack.size(), indentChars);
- os << "<![CDATA[" << entry.text << "]]>";
- break;
- }
-
- case XmlEntry::DOCTYPE:
- {
- _xmlWritter_indent(os, stack.size(), indentChars);
- os << "<!DOCTYPE...>";
- break;
- }
- }
-
- os << PEGASUS_STD(endl);
- }
+ switch (entry.type)
+ {
+ case XmlEntry::XML_DECLARATION:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+
+ os << "<?" << entry.text << " ";
+ _xmlWritter_printAttributes(
+ os, entry.attributes, entry.attributeCount);
+ os << "?>";
+ break;
+ }
+
+ case XmlEntry::START_TAG:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+
+ os << "<" << entry.text;
+
+ if (entry.attributeCount)
+ os << ' ';
+
+ _xmlWritter_printAttributes(
+ os, entry.attributes, entry.attributeCount);
+ os << ">";
+ stack.push(entry.text);
+ break;
+ }
+
+ case XmlEntry::EMPTY_TAG:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+
+ os << "<" << entry.text << " ";
+ _xmlWritter_printAttributes(
+ os, entry.attributes, entry.attributeCount);
+ os << "/>";
+ break;
+ }
+
+ case XmlEntry::END_TAG:
+ {
+ if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
+ stack.pop();
+ _xmlWritter_indent(os, stack.size(), indentChars);
+
+ os << "</" << entry.text << ">";
+ break;
+ }
+
+ case XmlEntry::COMMENT:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+ os << "<!--";
+ _xmlWritter_appendSpecial(os, entry.text);
+ os << "-->";
+ break;
+ }
+
+ case XmlEntry::CONTENT:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+ _xmlWritter_appendSpecial(os, entry.text);
+ break;
+ }
+
+ case XmlEntry::CDATA:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+ os << "<![CDATA[" << entry.text << "]]>";
+ break;
+ }
+
+ case XmlEntry::DOCTYPE:
+ {
+ _xmlWritter_indent(os, stack.size(), indentChars);
+ os << "<!DOCTYPE...>";
+ break;
+ }
+ }
+
+ os << PEGASUS_STD(endl);
+ }
}
//------------------------------------------------------------------------------
//
//==============================================================================
//
-// Author: Mike Brasher (mbrasher@bmc.com)
-//
-// Modified By:
-// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
-// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
-// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
-// Carol Ann Krug Graves, Hewlett-Packard Company
-// (carolann_graves@hp.com)
-// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
-// Willis White (whiwill@us.ibm.com) PEP 127 and 128
-// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
-// David Dillard, Symantec Corp. (david_dillard@symantec.com)
-// Vijay Eli, vijayeli@in.ibm.com, fix for #2571
-//
//%/////////////////////////////////////////////////////////////////////////////
#ifndef Pegasus_XmlWriter_h
const AcceptLanguageList& httpAcceptLanguages,
const ContentLanguageList& httpContentLanguages);
- //PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in respons header
+ // PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in
+ // response header
static Buffer formatSimpleMethodRspMessage(
const CIMName& methodName,
const String& messageId,
const ContentLanguageList& httpContentLanguages,
const Buffer& body);
- //PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in respons header
+ // PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in
+ // response header
static Buffer formatSimpleIMethodRspMessage(
const CIMName& iMethodName,
const String& messageId,
git.samba.org / tpot / pegasus / .git / commitdiff