pegasus/src/Pegasus/Common/Tracer.cpp - diff

Return to Tracer.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Tracer.cpp between version 1.1.2.1 and 1.48

version 1.1.2.1, 2001/07/31 23:57:08

version 1.48, 2008/05/12 09:17:34

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 21

Line 29

//==============================================================================

// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)

// Modified By:

//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Common/Destroyer.h>

#include <Pegasus/Common/Thread.h>

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/HTTPMessage.h>

PEGASUS_USING_STD;

Line 38

Line 45

// These levels will be compared against a trace level mask to determine

// if a specific trace level is enabled

const Uint32 Tracer::LEVEL0 = 0;

const Uint32 Tracer::LEVEL1 = (1 << 0);

const Uint32 Tracer::LEVEL2 = (1 << 1);

const Uint32 Tracer::LEVEL3 = (1 << 2);

const Uint32 Tracer::LEVEL4 = (1 << 3);

const Uint32 Tracer::LEVEL5 = (1 << 4);

// Set the Enter and Exit messages

const char Tracer::_FUNC_ENTER_MSG[] = "Entering method";

const char Tracer::_METHOD_ENTER_MSG[] = "Entering method";

const char Tracer::_FUNC_EXIT_MSG[] = "Exiting method";

const char Tracer::_METHOD_EXIT_MSG[] = "Exiting method";

// Set Log messages

const char Tracer::_LOG_MSG1[] = "LEVEL1 not enabled with Tracer::trace call.";

const char Tracer::_LOG_MSG2[]="Use trace macros, PEG_FUNC_ENTER/PEG_FUNC_EXIT";

// Initialize singleton instance of Tracer

Tracer* Tracer::_tracerInstance = 0;

Line 61

Line 66

const Uint32 Tracer::_NUM_COMPONENTS =

sizeof(TRACE_COMPONENT_LIST)/sizeof(TRACE_COMPONENT_LIST[0]);

// Set the line maximum

const Uint32 Tracer::_STRLEN_MAX_UNSIGNED_INT = 21;

// Set the max PID and Thread ID Length

const Uint32 Tracer::_STRLEN_MAX_PID_TID = 21;

// Initialize public indicator of trace state

Boolean Tracer::_traceOn = false;

////////////////////////////////////////////////////////////////////////////////

// Tracer constructor

// Constructor is private to preclude construction of Tracer objects

// Single Instance of Tracer is maintained for each process.

////////////////////////////////////////////////////////////////////////////////

Tracer::Tracer()

: _traceComponentMask(new Boolean[_NUM_COMPONENTS]),

_traceLevelMask(0),

_traceHandler(new TraceFileHandler())

{

// Initialize Trace File Handler

_traceHandler=new TraceFileHandler();

_traceLevelMask=0;

_traceComponentMask=new Boolean[_NUM_COMPONENTS];

// Initialize ComponentMask array to false

for (int index=0;index < _NUM_COMPONENTS;

for (Uint32 index=0;index < _NUM_COMPONENTS;

_traceComponentMask[index++]=false);

(_traceComponentMask.get())[index++]=false);

// NO componets are set

_componentsAreSet=false;

}

////////////////////////////////////////////////////////////////////////////////

Line 83

Line 97

////////////////////////////////////////////////////////////////////////////////

Tracer::~Tracer()

{

delete []_traceComponentMask;

delete _traceHandler;

delete _tracerInstance;

}

////////////////////////////////////////////////////////////////////////////////

//Traces the given message

////////////////////////////////////////////////////////////////////////////////

void Tracer::_trace(

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* fmt,

va_list argList)

{

if ( traceLevel == LEVEL1 )

{

// ATTN: Setting the Log file type to DEBUG_LOG

// May need to change to an appropriate log file type

Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,"$0 $1",

_LOG_MSG1,_LOG_MSG2);

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

{

_trace(traceComponent,"",fmt,argList);

}

////////////////////////////////////////////////////////////////////////////////

//Traces the given message - Overloaded for including FileName and Line number

////////////////////////////////////////////////////////////////////////////////

void Tracer::_trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* fmt,

va_list argList)

{

char* message;

// 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];

sprintf(

message,

"[%d:%s:%s:%u]: ",

System::getPID(),

Threads::id().buffer,

fileName,

lineNum);

if ( traceLevel == LEVEL1 )

{

Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,"$0 $1",

_LOG_MSG1,_LOG_MSG2);

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

{

message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6];

sprintf(message,"[%s:%d]: ",fileName,lineNum);

_trace(traceComponent,message,fmt,argList);

delete []message;

}

////////////////////////////////////////////////////////////////////////////////

//Traces method entry

//Traces the message in the given CIMException object.

////////////////////////////////////////////////////////////////////////////////

void Tracer::_traceEnter(

void Tracer::_traceCIMException(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt,

const CIMException& cimException)

...)

{

va_list argList;

// get the CIMException trace message string

char* message;

CString traceMsg =

TraceableCIMException(cimException).getTraceDescription().getCString();

// trace the string

_traceCString(traceComponent, "", (const char*) traceMsg);

}

if (_isTraceEnabled(traceComponent,LEVEL1))

SharedArrayPtr<char> Tracer::getHTTPRequestMessage(

const Buffer& requestMessage)

{

va_start(argList,fmt);

const Uint32 requestSize = requestMessage.size();

message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6];

sprintf(message,"[%s:%d]: ",fileName,lineNum);

// Make a copy of the request message.

_trace(traceComponent,message,fmt,argList);

SharedArrayPtr<char>

va_end(argList);

requestBuf(new char [requestSize + 1]);

delete []message;

strncpy(requestBuf.get(), requestMessage.getData(), requestSize);

requestBuf.get()[requestSize] = 0;

// Check if requestBuffer contains a Basic authorization header.

// If true, suppress the user/passwd info in the request buffer.

char* sep;

const char* line = requestBuf.get();

while ((sep = HTTPMessage::findSeparator(

line, (Uint32)(requestSize - (line - requestBuf.get())))) &&

(line != sep))

{

if (HTTPMessage::expectHeaderToken(line, "Authorization") &&

HTTPMessage::expectHeaderToken(line, ":") &&

HTTPMessage::expectHeaderToken(line, "Basic"))

{

// Suppress the user/passwd info

HTTPMessage::skipHeaderWhitespace(line);

for ( char* userpass = (char*)line ;

userpass < sep;

*userpass = 'X', userpass++);

break;

}

line = sep + ((*sep == '\r') ? 2 : 1);

}

return requestBuf;

}

////////////////////////////////////////////////////////////////////////////////

//Traces method exit

//Traces method entry and exit

////////////////////////////////////////////////////////////////////////////////

void Tracer::_traceExit(

void Tracer::_traceMethod(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt

const char* methodEntryExit,

...)

const char* method)

{

va_list argList;

char* message;

if (_isTraceEnabled(traceComponent,LEVEL1))

{

// Allocate memory for the message string

va_start(argList,fmt);

// Needs to be updated if additional info is added

message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6];

sprintf(message,"[%s:%d]: ",fileName,lineNum);

// assume Method entry/exit string 15 characters long

_trace(traceComponent,message,fmt,argList);

// +1 space character

va_end(argList);

message = new char[ strlen(fileName) +

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8

+ 16];

sprintf(

message,

"[%d:%s:%s:%u]: %s ",

System::getPID(),

Threads::id().buffer,

fileName,

lineNum,

methodEntryExit);

_traceCString(traceComponent, message, method);

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

if ((traceComponent < 0) || (traceComponent >= _NUM_COMPONENTS ))

if (traceComponent >= _NUM_COMPONENTS)

{

return false;

}

return ((instance->_traceComponentMask[traceComponent]) &&

return (((instance->_traceComponentMask.get())[traceComponent]) &&

(traceLevel & instance->_traceLevelMask));

}

////////////////////////////////////////////////////////////////////////////////

//Called by all trace interfaces to log message to trace file

//Called by all trace interfaces with variable arguments

//to log message to trace file

////////////////////////////////////////////////////////////////////////////////

void Tracer::_trace(

const Uint32 traceComponent,

Line 217

Line 249

va_list argList)

{

char* msgHeader;

Uint32 retCode;

// Get the current system time and prepend to message

String currentTime = System::getCurrentASCIITime();

ArrayDestroyer<char> timeStamp(currentTime.allocateCString());

CString timeStamp = currentTime.getCString();

// Allocate messageHeader.

msgHeader = new char [strlen(message)

// Needs to be updated if additional info is added

+ strlen(TRACE_COMPONENT_LIST[traceComponent])

+ strlen(timeStamp.getPointer()) + 6];

// Construct the message header

// The message header is in the following format

// timestamp: <component name> [file name:line number]

if (strcmp(message,"") != 0)

if (*message != '\0')

{

sprintf(msgHeader,"%s: %s %s",timeStamp.getPointer(),

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

}

else

{

sprintf(msgHeader,"%s: %s ",timeStamp.getPointer(),

TRACE_COMPONENT_LIST[traceComponent] );

// Since the message is blank, form a string using the pid and tid

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;

}

// Call trace file handler to write message

_getInstance()->_traceHandler->handleMessage(msgHeader,fmt,argList);

delete []msgHeader;

}

////////////////////////////////////////////////////////////////////////////////

//Set the trace file

//Called by all trace interfaces using a character string without format string

//to log message to trace file

////////////////////////////////////////////////////////////////////////////////

Uint32 Tracer::setTraceFile(const char* traceFile)

void Tracer::_traceCString(

const Uint32 traceComponent,

const char* message,

const char* cstring)

{

ofstream outFile;

char* completeMessage;

Uint32 retCode = 0;

// Get the current system time and prepend to message

String currentTime = System::getCurrentASCIITime();

CString timeStamp = currentTime.getCString();

// Allocate completeMessage.

// Needs to be updated if additional info is added

// Check if the file can be opened in append mode

// Construct the message header

if (traceFile)

// The message header is in the following format

// timestamp: <component name> [file name:line number]

if (*message != '\0')

{

outFile.open(traceFile,ofstream::app);

// << Wed Jul 16 10:58:40 2003 mdd >> _STRLEN_MAX_PID_TID is not used

// in this format string

completeMessage = new char [strlen(message) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5 +

strlen(cstring) ];

if (outFile.good())

sprintf(completeMessage, "%s: %s %s%s", (const char*)timeStamp,

TRACE_COMPONENT_LIST[traceComponent], message, cstring);

}

else

{

_getInstance()->_traceHandler->setFileName (traceFile);

outFile.close();

// Since the message is blank, form a string using the pid and tid

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

completeMessage = new char[strlen(timeStamp) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(tmpBuffer) + 1 + 5 +

strlen(cstring)];

sprintf(completeMessage, "%s: %s %s %s", (const char*)timeStamp,

TRACE_COMPONENT_LIST[traceComponent], tmpBuffer, cstring);

delete [] tmpBuffer;

}

// Call trace file handler to write message

_getInstance()->_traceHandler->handleMessage(completeMessage);

delete [] completeMessage;

}

////////////////////////////////////////////////////////////////////////////////

//Validate the trace file

////////////////////////////////////////////////////////////////////////////////

Boolean Tracer::isValidFileName(const char* filePath)

{

String moduleName = _getInstance()->_moduleName;

if (moduleName == String::EMPTY)

{

return _getInstance()->_traceHandler->isValidFilePath(filePath);

}

else

{

outFile.close();

String extendedFilePath = String(filePath) + "." + moduleName;

retCode = 1;

return _getInstance()->_traceHandler->isValidFilePath(

extendedFilePath.getCString());

}

////////////////////////////////////////////////////////////////////////////////

//Validate the trace components

////////////////////////////////////////////////////////////////////////////////

Boolean Tracer::isValidComponents(const String& traceComponents)

{

String invalidComponents;

return isValidComponents(traceComponents, invalidComponents);

}

Boolean Tracer::isValidComponents(

const String& traceComponents,

String& invalidComponents)

{

// Validate the trace components and modify the traceComponents argument

// to reflect the invalid components

Uint32 position=0;

Uint32 index=0;

String componentName;

String componentStr;

Boolean validComponent=false;

Boolean retCode=true;

componentStr = traceComponents;

invalidComponents = String::EMPTY;

if (componentStr != String::EMPTY)

{

// Check if ALL is specified

if (String::equalNoCase(componentStr,"ALL"))

{

return true;

}

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

componentStr.append(_COMPONENT_SEPARATOR);

while (componentStr != String::EMPTY)

{

// Get the Component name from traceComponents.

// Components are separated by _COMPONENT_SEPARATOR

position = componentStr.find(_COMPONENT_SEPARATOR);

componentName = componentStr.subString(0,(position));

// Lookup the index for Component name in TRACE_COMPONENT_LIST

index = 0;

validComponent = false;

while (index < _NUM_COMPONENTS)

{

if (String::equalNoCase(

componentName, TRACE_COMPONENT_LIST[index]))

{

// Found component, break from the loop

validComponent = true;

break;

}

else

{

index++;

}

// Remove the searched componentname from the traceComponents

componentStr.remove(0,position+1);

if (!validComponent)

{

invalidComponents.append(componentName);

invalidComponents.append(_COMPONENT_SEPARATOR);

}

else

{

retCode=1;

// trace components is empty, it is a valid value so return true

return true;

}

if (invalidComponents != String::EMPTY)

{

retCode = false;

// Remove the extra ',' at the end

invalidComponents.remove(

invalidComponents.reverseFind(_COMPONENT_SEPARATOR));

}

return retCode;

}

////////////////////////////////////////////////////////////////////////////////

//Set the name of the module being traced

////////////////////////////////////////////////////////////////////////////////

void Tracer::setModuleName(const String& moduleName)

{

_getInstance()->_moduleName = moduleName;

}

////////////////////////////////////////////////////////////////////////////////

//Returns the Singleton instance of the Tracer

////////////////////////////////////////////////////////////////////////////////

Tracer* Tracer::_getInstance()

{

if (_tracerInstance == 0)

{

_tracerInstance = new Tracer();

}

return _tracerInstance;

}

// PEGASUS_REMOVE_TRACE defines the compile time inclusion of the Trace

// interfaces. This section defines the trace functions IF the remove

// trace flag is NOT set. If it is set, they are defined as empty functions

// in the header file.

#ifndef PEGASUS_REMOVE_TRACE

////////////////////////////////////////////////////////////////////////////////

//Set the trace file

////////////////////////////////////////////////////////////////////////////////

Uint32 Tracer::setTraceFile(const char* traceFile)

{

if (*traceFile == 0)

{

return 1;

}

String moduleName = _getInstance()->_moduleName;

if (moduleName == String::EMPTY)

{

return _getInstance()->_traceHandler->setFileName(traceFile);

}

else

{

String extendedTraceFile = String(traceFile) + "." + moduleName;

return _getInstance()->_traceHandler->setFileName(

extendedTraceFile.getCString());

}

////////////////////////////////////////////////////////////////////////////////

//Set the trace level

////////////////////////////////////////////////////////////////////////////////

Uint32 Tracer::setTraceLevel(const Uint32 traceLevel)

Line 287

Line 538

switch (traceLevel)

{

case LEVEL0:

_getInstance()->_traceLevelMask = 0x00;

break;

case LEVEL1:

_getInstance()->_traceLevelMask = 0x01;

break;

Line 303

Line 558

_getInstance()->_traceLevelMask = 0x0F;

break;

case LEVEL5:

_getInstance()->_traceLevelMask = 0x1F;

break;

default:

_getInstance()->_traceLevelMask = 0;

_getInstance()->_traceLevelMask = 0x00;

retCode = 1;

}

if (_getInstance()->_componentsAreSet &&

_getInstance()->_traceLevelMask )

{

_traceOn = true;

}

else

{

_traceOn = false;

}

return retCode;

}

////////////////////////////////////////////////////////////////////////////////

//Set components to be traced.

//The String traceComponents will be updated within the function.

////////////////////////////////////////////////////////////////////////////////

void Tracer::setTraceComponents(String traceComponents)

void Tracer::setTraceComponents(const String& traceComponents)

{

Uint32 position=0;

Tracer* instance = _getInstance();

Uint32 index=0;

String componentName;

if (traceComponents != String::EMPTY)

{

// Check if ALL is specified

if (traceComponents == "ALL")

if (String::equalNoCase(traceComponents,"ALL"))

{

for (Uint32 index = 0; index < _NUM_COMPONENTS; index++)

{

for (int index=0; index < _NUM_COMPONENTS;

(instance->_traceComponentMask.get())[index] = true;

_getInstance()->_traceComponentMask[index++] = true);

}

instance->_componentsAreSet=true;

// If tracing isn't turned off by a traceLevel of zero, let's

// turn on the flag that activates tracing.

_traceOn = (instance->_traceLevelMask != LEVEL0);

return;

}

// initialise ComponentMask array to False

// initialize ComponentMask array to False

for (int index = 0;index < _NUM_COMPONENTS;

for (Uint32 index = 0; index < _NUM_COMPONENTS; index++)

_getInstance()->_traceComponentMask[index++] = false);

{

(instance->_traceComponentMask.get())[index] = false;

}

_traceOn = false;

instance->_componentsAreSet=false;

if (traceComponents != String::EMPTY)

{

Uint32 index = 0;

Uint32 position = 0;

String componentName;

String componentStr = traceComponents;

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

traceComponents += _COMPONENT_SEPARATOR;

componentStr.append(_COMPONENT_SEPARATOR);

while (traceComponents != String::EMPTY)

while (componentStr != String::EMPTY)

{

// Get the Component name from traceComponents.

// Components are separated by _COMPONENT_SEPARATOR

position = traceComponents.find(_COMPONENT_SEPARATOR);

position = componentStr.find(_COMPONENT_SEPARATOR);

componentName = traceComponents.subString(0,(position));

componentName = componentStr.subString(0,(position));

// Lookup the index for Component name in TRACE_COMPONENT_LIST

index = 0;

while (index < _NUM_COMPONENTS)

{

if (componentName == TRACE_COMPONENT_LIST[index])

if (String::equalNoCase(

componentName,TRACE_COMPONENT_LIST[index]))

{

_getInstance()->_traceComponentMask[index]=true;

(instance->_traceComponentMask.get())[index] = true;

instance->_componentsAreSet=true;

// Found component, break from the loop

break;

Line 362

Line 651

}

// Remove the searched componentname from the traceComponents

traceComponents.remove(0,position+1);

componentStr.remove(0,position+1);

}

// If one of the components was set for tracing and the traceLevel

// is not zero, then turn on tracing.

_traceOn = (instance->_componentsAreSet &&

(instance->_traceLevelMask != LEVEL0));

}

else

return ;

}

void Tracer::traceEnter(

TracerToken& token,

const char* file,

size_t line,

Uint32 traceComponent,

const char* method)

{

token.component = traceComponent;

token.method = method;

if (isTraceEnabled(traceComponent, LEVEL5))

{

// initialise ComponentMask array to False

_traceMethod(

for (int index = 0;index < _NUM_COMPONENTS;

file, (Uint32)line, traceComponent,

_getInstance()->_traceComponentMask[index++] = false);

_METHOD_ENTER_MSG, method);

}

void Tracer::traceExit(

TracerToken& token,

const char* file,

size_t line)

{

if (isTraceEnabled(token.component, LEVEL5) && token.method)

_traceMethod(

file, (Uint32)line, token.component,

_METHOD_EXIT_MSG, token.method);

}

////////////////////////////////////////////////////////////////////////////////

//Returns the Singleton instance of the Tracer

//Traces the given string - Overloaded to include the fileName and line number

//of trace origin.

////////////////////////////////////////////////////////////////////////////////

Tracer* Tracer::_getInstance()

void Tracer::traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* cstring)

{

if (_tracerInstance == 0)

char* message;

// 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];

sprintf(

message,

"[%d:%s:%s:%u]: ",

System::getPID(),

Threads::id().buffer,

fileName,

lineNum);

_traceCString(traceComponent, message, cstring);

delete [] message;

}

void Tracer::traceCIMException(

const Uint32 traceComponent,

const Uint32 traceLevel,

const CIMException& cimException)

{

_tracerInstance = new Tracer();

if (isTraceEnabled(traceComponent, traceLevel))

{

_traceCIMException(traceComponent, cimException);

}

return _tracerInstance;

}

#endif /* !PEGASUS_REMOVE_TRACE */

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.1.2.1
changed lines
	Added in v.1.48

No CVS admin address has been configured