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

Return to BinaryCodec.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/BinaryCodec.cpp between version 1.2 and 1.12.2.4

version 1.2, 2008/11/25 23:46:58

version 1.12.2.4, 2012/02/15 17:47:06

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

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

// License.

// EMC Corporation; VERITAS Software 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"),

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

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

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

// and/or sell copies of the Software, and to permit persons to whom the

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

// Software is furnished to do so, subject to the following conditions:

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// The above copyright notice and this permission notice shall be included

// sell copies of the Software, and to permit persons to whom the Software is

// in all copies or substantial portions of the Software.

// furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// 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.

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

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

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

Line 51

Line 49

#define INCLUDE_QUALIFIERS (1 << 1)

#define INCLUDE_CLASS_ORIGIN (1 << 2)

#define DEEP_INHERITANCE (1 << 3)

#define CONTINUE_ON_ERROR (1 << 4)

PEGASUS_NAMESPACE_BEGIN

Line 93

Line 92

OP_DeleteQualifier,

OP_EnumerateQualifiers,

OP_InvokeMethod,

// EXP_PULL_BEGIN

OP_OpenEnumerateInstances,

OP_OpenEnumerateInstancePaths,

OP_OpenReferenceInstances,

OP_OpenReferenceInstancePaths,

OP_OpenAssociatorInstances,

OP_OpenAssociatorInstancePaths,

OP_PullInstancesWithPath,

OP_PullInstancePaths,

OP_CloseEnumeration,

OP_EnumerationCount,

// EXP_PULL_END

OP_Count

};

struct CIMBufferReleaser

{

CIMBufferReleaser(CIMBuffer& buf) : _buf(buf)

{

}

~CIMBufferReleaser()

{

_buf.release();

}

private:

CIMBuffer& _buf;

};

static Operation _NameToOp(const CIMName& name)

{

const String& s = name.getString();

Line 128

Line 124

return OP_CreateInstance;

if (_EQUAL(s, "CreateClass"))

return OP_CreateClass;

//EXP_PULL_BEGIN

if (_EQUAL(s, "CloseEnumeration"))

return OP_CloseEnumeration;

// EXP_PULL_END

break;

case 'D':

if (_EQUAL(s, "DeleteInstance"))

Line 173

if (_EQUAL(s, "ModifyClass"))

return OP_ModifyClass;

break;

// EXP_PULL_BEGIN

case 'O':

if (_EQUAL(s, "OpenEnumerateInstances"))

return OP_OpenEnumerateInstances;

if (_EQUAL(s, "OpenEnumerateInstancePaths"))

return OP_OpenEnumerateInstancePaths;

if (_EQUAL(s, "OpenReferenceInstances"))

return OP_OpenReferenceInstances;

if (_EQUAL(s, "OpenReferenceInstancePaths"))

return OP_OpenReferenceInstancePaths;

if (_EQUAL(s, "OpenAssociatorInstances"))

return OP_OpenAssociatorInstances;

if (_EQUAL(s, "OpenAssociatorInstancePaths"))

return OP_OpenAssociatorInstancePaths;

break;

case 'P':

if (_EQUAL(s, "PullInstancesWithPath"))

return OP_PullInstancesWithPath;

if (_EQUAL(s, "PullInstancePaths"))

return OP_PullInstancePaths;

break;

// EXP_PULL_END

case 'R':

if (_EQUAL(s, "References"))

return OP_References;

Line 280

Line 302

Uint32 flags = 0;

if (msg->localOnly)

flags |= LOCAL_ONLY;

if (msg->deepInheritance)

flags |= DEEP_INHERITANCE;

Line 343

Line 362

nameSpace,

className,

deepInheritance,

false, // Bug 1985 localOnly is deprecated

#ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS

false,

#else

Line 362

Line 380

static void _encodeEnumerateInstancesResponseBody(

CIMBuffer& out,

CIMEnumerateInstancesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

CIMName& name,

bool isFirst)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("EnumerateInstances");

name = NAME;

if (msg->resolveCallback && msg->binaryEncoding)

// Only write the property list on the first provider response

{

if (isFirst)

const Array<Uint8>& data = msg->binaryData;

out.putBytes((char*)data.getData(), data.size());

}

else

{

out.putInstanceA(msg->getNamedInstances(), false);

// [PROPERTY-LIST]

out.putPropertyList(data.getPropertyList());

}

data.encodeBinaryResponse(out);

}

static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Array<CIMInstance> instances;

while (in.more())

{

Array<CIMInstance> tmp;

if (!in.getInstanceA(tmp))

return 0;

instances.append(tmp.getData(), tmp.size());

}

CIMEnumerateInstancesResponseMessage* msg;

CIMException cimException;

Line 408

Line 410

cimException,

QueueIdStack());

msg->setNamedInstances(instances);

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstances, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

// [PROPERTY-LIST]

CIMPropertyList propertyList;

if (!in.getPropertyList(propertyList))

{

return 0;

}

responseData.setPropertyList(propertyList);

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

}

Line 424

Line 444

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

STAT_GETSTARTTIME

Line 458

Line 477

static CIMEnumerateInstanceNamesResponseMessage*

_decodeEnumerateInstanceNamesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

Array<CIMObjectPath> instanceNames;

while (in.more())

{

Array<CIMObjectPath> tmp;

if (!in.getObjectPathA(tmp))

return 0;

instanceNames.append(tmp.getData(), tmp.size());

}

CIMEnumerateInstanceNamesResponseMessage* msg;

CIMException cimException;

msg = new CIMEnumerateInstanceNamesResponseMessage(

messageId,

cimException,

QueueIdStack(),

QueueIdStack());

instanceNames);

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstanceNames, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

Line 507

Line 522

static void _encodeEnumerateInstanceNamesResponseBody(

CIMBuffer& out,

CIMEnumerateInstanceNamesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

static const CIMName NAME("EnumerateInstanceNames");

name = NAME;

out.putObjectPathA(msg->instanceNames, false);

data.encodeBinaryResponse(out);

}

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

Line 558

Line 573

messageId,

nameSpace,

instanceName,

false, // Bug 1985 localOnly is deprecated

#ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS

false,

#else

Line 577

Line 591

static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

CIMInstance instance;

if (!in.getInstance(instance))

return 0;

CIMGetInstanceResponseMessage* msg;

CIMException cimException;

Line 593

Line 601

cimException,

QueueIdStack());

msg->setCimInstance(instance);

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstances, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

}

Line 610

Line 627

Uint32 flags = 0;

if (msg->localOnly)

flags |= LOCAL_ONLY;

if (msg->includeQualifiers)

flags |= INCLUDE_QUALIFIERS;

Line 633

Line 647

static void _encodeGetInstanceResponseBody(

CIMBuffer& out,

CIMGetInstanceResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

static const CIMName NAME("GetInstance");

name = NAME;

if (msg->resolveCallback && msg->binaryEncoding)

data.encodeBinaryResponse(out);

{

const Array<Uint8>& data = msg->binaryData;

out.putBytes((char*)data.getData(), data.size());

}

else

{

out.putInstance(msg->getCimInstance(), false, false);

}

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

Line 678

Line 684

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

STAT_GETSTARTTIME

Line 724

Line 729

static CIMCreateInstanceResponseMessage* _decodeCreateInstanceResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

CIMObjectPath instanceName;

Line 829

Line 833

}

static void _encodeModifyInstanceResponseBody(

CIMBuffer& out,

CIMModifyInstanceResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 841

Line 843

static CIMModifyInstanceResponseMessage* _decodeModifyInstanceResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 900

Line 901

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 934

}

static void _encodeDeleteInstanceResponseBody(

CIMBuffer& out,

CIMDeleteInstanceResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 945

Line 943

}

static CIMDeleteInstanceResponseMessage* _decodeDeleteInstanceResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 1098

Line 1094

static void _encodeAssociatorsResponseBody(

CIMBuffer& out,

CIMAssociatorsResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 1106

Line 1102

static const CIMName NAME("Associators");

name = NAME;

out.putObjectA(msg->cimObjects);

data.encodeBinaryResponse(out);

}

static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Array<CIMObject> cimObjects;

while (in.more())

{

Array<CIMObject> tmp;

if (!in.getObjectA(tmp))

return 0;

cimObjects.append(tmp.getData(), tmp.size());

}

CIMAssociatorsResponseMessage* msg;

CIMException cimException;

msg = new CIMAssociatorsResponseMessage(

messageId,

cimException,

QueueIdStack(),

QueueIdStack());

cimObjects);

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getObjects, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

Line 1185

Line 1176

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 1253

Line 1243

static void _encodeAssociatorNamesResponseBody(

CIMBuffer& out,

CIMAssociatorNamesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("AssociatorNames");

name = NAME;

data.encodeBinaryResponse(out);

out.putObjectPathA(msg->objectNames);

}

static CIMAssociatorNamesResponseMessage* _decodeAssociatorNamesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Array<CIMObjectPath> objectNames;

while (in.more())

{

Array<CIMObjectPath> tmp;

if (!in.getObjectPathA(tmp))

return 0;

objectNames.append(tmp.getData(), tmp.size());

}

CIMAssociatorNamesResponseMessage* msg;

CIMException cimException;

msg = new CIMAssociatorNamesResponseMessage(

messageId,

cimException,

QueueIdStack(),

QueueIdStack());

objectNames);

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstanceNames, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

Line 1410

Line 1393

static void _encodeReferencesResponseBody(

CIMBuffer& out,

CIMReferencesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 1418

Line 1401

static const CIMName NAME("References");

name = NAME;

out.putObjectA(msg->cimObjects);

data.encodeBinaryResponse(out);

}

static CIMReferencesResponseMessage* _decodeReferencesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Array<CIMObject> cimObjects;

while (in.more())

{

Array<CIMObject> tmp;

if (!in.getObjectA(tmp))

{

return 0;

}

cimObjects.append(tmp.getData(), tmp.size());

}

CIMReferencesResponseMessage* msg;

CIMException cimException;

msg = new CIMReferencesResponseMessage(

messageId,

cimException,

QueueIdStack(),

QueueIdStack());

cimObjects);

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

Line 1493

Line 1468

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 1545

Line 1519

static void _encodeReferenceNamesResponseBody(

CIMBuffer& out,

CIMReferenceNamesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("ReferenceNames");

name = NAME;

data.encodeBinaryResponse(out);

out.putObjectPathA(msg->objectNames);

}

static CIMReferenceNamesResponseMessage* _decodeReferenceNamesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Array<CIMObjectPath> objectNames;

while (in.more())

{

Array<CIMObjectPath> tmp;

if (!in.getObjectPathA(tmp))

return 0;

objectNames.append(tmp.getData(), tmp.size());

}

CIMReferenceNamesResponseMessage* msg;

CIMException cimException;

msg = new CIMReferenceNamesResponseMessage(

messageId,

cimException,

QueueIdStack(),

QueueIdStack());

objectNames);

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstanceNames, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

}

Line 1694

Line 1664

static CIMGetClassResponseMessage* _decodeGetClassResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 1820

Line 1789

static CIMEnumerateClassesResponseMessage* _decodeEnumerateClassesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 1939

Line 1907

static CIMEnumerateClassNamesResponseMessage*

_decodeEnumerateClassNamesResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 1999

Line 1966

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2034

Line 2000

}

static void _encodeCreateClassResponseBody(

CIMBuffer& out,

CIMCreateClassResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 2045

Line 2009

}

static CIMCreateClassResponseMessage* _decodeCreateClassResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2093

Line 2055

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2128

Line 2089

}

static void _encodeDeleteClassResponseBody(

CIMBuffer& out,

CIMDeleteClassResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 2139

Line 2098

}

static CIMDeleteClassResponseMessage* _decodeDeleteClassResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2187

Line 2144

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2222

Line 2178

}

static void _encodeModifyClassResponseBody(

CIMBuffer& out,

CIMModifyClassResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 2233

Line 2187

}

static CIMModifyClassResponseMessage* _decodeModifyClassResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2281

Line 2233

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2317

Line 2268

}

static void _encodeSetQualifierResponseBody(

CIMBuffer& out,

CIMSetQualifierResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 2328

Line 2277

}

static CIMSetQualifierResponseMessage* _decodeSetQualifierResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2376

Line 2323

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2425

Line 2371

static CIMGetQualifierResponseMessage* _decodeGetQualifierResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2478

Line 2423

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2513

Line 2457

}

static void _encodeDeleteQualifierResponseBody(

CIMBuffer& out,

CIMDeleteQualifierResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 2524

Line 2466

}

static CIMDeleteQualifierResponseMessage* _decodeDeleteQualifierResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2569

Line 2509

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2612

Line 2551

static CIMEnumerateQualifiersResponseMessage*

_decodeEnumerateQualifiersResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2675

Line 2613

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2732

Line 2669

static CIMGetPropertyResponseMessage* _decodeGetPropertyResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2803

Line 2739

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2855

Line 2790

}

static void _encodeSetPropertyResponseBody(

CIMBuffer& out,

CIMSetPropertyResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 2866

Line 2799

}

static CIMSetPropertyResponseMessage* _decodeSetPropertyResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 2919

Line 2850

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 2991

Line 2921

static CIMInvokeMethodResponseMessage* _decodeInvokeMethodResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Line 3066

Line 2995

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

Line 3109

Line 3037

static void _encodeExecQueryResponseBody(

CIMBuffer& out,

CIMExecQueryResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

Line 3117

Line 3045

static const CIMName NAME("ExecQuery");

name = NAME;

out.putObjectA(msg->cimObjects, false);

data.encodeBinaryResponse(out);

}

static CIMExecQueryResponseMessage* _decodeExecQueryResponse(

CIMBuffer& in,

Uint32 flags,

const String& messageId)

{

/* See ../Client/CIMOperationResponseDecoder.cpp */

Array<CIMObject> cimObjects;

while (in.more())

{

Array<CIMObject> tmp;

if (!in.getObjectA(tmp))

return 0;

cimObjects.append(tmp.getData(), tmp.size());

}

CIMExecQueryResponseMessage* msg;

CIMException cimException;

msg = new CIMExecQueryResponseMessage(

messageId,

cimException,

QueueIdStack(),

QueueIdStack());

cimObjects);

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest = true;

return msg;

}

// EXP_PULL_BEGIN

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

// BinaryCodec::hexDump()

// OpenEnumerateInstances

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

#if defined(PEGASUS_DEBUG)

static void _encodeOpenEnumerateInstancesRequest(

CIMBuffer& buf,

void BinaryCodec::hexDump(const void* data, size_t size)

CIMOpenEnumerateInstancesRequestMessage* msg,

CIMName& name)

{

unsigned char* p = (unsigned char*)data;

/* See ../Client/CIMOperationRequestEncoder.cpp */

unsigned char buf[16];

size_t n = 0;

for (size_t i = 0, col = 0; i < size; i++)

static const CIMName NAME("OpenEnumerateInstances");

{

name = NAME;

unsigned char c = p[i];

buf[n++] = c;

if (col == 0)

// [HEADER]

printf("%06X ", (unsigned int)i);

printf("%02X ", c);

Uint32 flags = 0;

if (col + 1 == sizeof(buf) || i + 1 == size)

if (msg->deepInheritance)

{

flags |= DEEP_INHERITANCE;

for (size_t j = col + 1; j < sizeof(buf); j++)

printf(" ");

for (size_t j = 0; j < n; j++)

if (msg->includeClassOrigin)

{

flags |= INCLUDE_CLASS_ORIGIN;

c = buf[j];

if (c >= ' ' && c <= '~')

if (msg->continueOnError)

printf("%c", buf[j]);

flags |= CONTINUE_ON_ERROR;

else

printf(".");

}

printf("\n");

_putHeader(buf, flags, msg->messageId, OP_OpenEnumerateInstances);

n = 0;

}

if (col + 1 == sizeof(buf))

// [NAMESPACE]

col = 0;

buf.putNamespaceName(msg->nameSpace);

else

col++;

}

printf("\n");

// [CLASSNAME]

}

buf.putName(msg->className);

#endif /* defined(PEGASUS_DEBUG) */

// [PROPERTY-LIST]

buf.putPropertyList(msg->propertyList);

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

buf.putUint32Arg(msg->maxObjectCount);

buf.putUint32Arg(msg->operationTimeout);

// BinaryCodec::decodeRequest()

buf.putString(msg->filterQueryLanguage);

buf.putString(msg->filterQuery);

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

}

CIMOperationRequestMessage* BinaryCodec::decodeRequest(

static CIMOpenEnumerateInstancesRequestMessage*

const Buffer& in,

_decodeOpenEnumerateInstancesRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId)

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

Boolean deepInheritance = flags & DEEP_INHERITANCE;

Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;

Boolean continueOnError = flags & CONTINUE_ON_ERROR;

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [CLASSNAME]

CIMName className;

if (!in.getName(className))

return 0;

// [PROPERTY-LIST]

CIMPropertyList propertyList;

if (!in.getPropertyList(propertyList))

return 0;

// These can all be one common function.

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

Uint32Arg operationTimeout;

if (!in.getUint32Arg(operationTimeout))

return 0;

String filterQueryLanguage;

if (!in.getString(filterQueryLanguage))

return 0;

String filterQuery;

if (!in.getString(filterQuery))

return 0;

AutoPtr<CIMOpenEnumerateInstancesRequestMessage> request(

new CIMOpenEnumerateInstancesRequestMessage(

messageId,

nameSpace,

className,

deepInheritance,

includeClassOrigin,

propertyList,

filterQueryLanguage,

filterQuery,

operationTimeout,

continueOnError,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodeOpenEnumerateInstancesResponseBody(

CIMBuffer& out,

CIMOpenEnumerateInstancesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("OpenEnumerateInstances");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMOpenEnumerateInstancesResponseMessage*

_decodeOpenEnumerateInstancesResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

// KS_TODO Should we set validation???

// Turn on validation: This is a debugging tool

//#if defined(ENABLE_VALIDATION)

// buf.setValidate(true);

//#endif

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMOpenEnumerateInstancesResponseMessage* msg =

new CIMOpenEnumerateInstancesResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstances, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// OpenEnumerateInstancesPaths

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

static void _encodeOpenEnumerateInstancePathsRequest(

CIMBuffer& buf,

CIMOpenEnumerateInstancePathsRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("OpenEnumerateInstancePaths");

name = NAME;

// [HEADER]

Uint32 flags = 0;

if (msg->continueOnError)

flags |= CONTINUE_ON_ERROR;

_putHeader(buf, flags, msg->messageId, OP_OpenEnumerateInstancePaths);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [CLASSNAME]

buf.putName(msg->className);

buf.putUint32Arg(msg->maxObjectCount);

buf.putUint32Arg(msg->operationTimeout);

buf.putString(msg->filterQueryLanguage);

buf.putString(msg->filterQuery);

}

static CIMOpenEnumerateInstancePathsRequestMessage*

_decodeOpenEnumerateInstancePathsRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

Boolean continueOnError = flags & CONTINUE_ON_ERROR;

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [CLASSNAME]

CIMName className;

if (!in.getName(className))

return 0;

// These can all be one common function.

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

Uint32Arg operationTimeout;

if (!in.getUint32Arg(operationTimeout))

return 0;

String filterQueryLanguage;

if (!in.getString(filterQueryLanguage))

return 0;

String filterQuery;

if (!in.getString(filterQuery))

return 0;

AutoPtr<CIMOpenEnumerateInstancePathsRequestMessage> request(

new CIMOpenEnumerateInstancePathsRequestMessage(

messageId,

nameSpace,

className,

filterQueryLanguage,

filterQuery,

operationTimeout,

continueOnError,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodeOpenEnumerateInstancePathsResponseBody(

CIMBuffer& out,

CIMOpenEnumerateInstancePathsResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("OpenEnumerateInstancePaths");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMOpenEnumerateInstancePathsResponseMessage*

_decodeOpenEnumerateInstancePathsResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

{

return 0;

}

CIMOpenEnumerateInstancePathsResponseMessage* msg =

new CIMOpenEnumerateInstancePathsResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstanceNames, which

// resolves the binary data as it is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// OpenReferenceInstances

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

static void _encodeOpenReferenceInstancesRequest(

CIMBuffer& buf,

CIMOpenReferenceInstancesRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("OpenReferenceInstances");

name = NAME;

// [HEADER]

Uint32 flags = 0;

if (msg->includeClassOrigin)

flags |= INCLUDE_CLASS_ORIGIN;

if (msg->continueOnError)

flags |= CONTINUE_ON_ERROR;

_putHeader(buf, flags, msg->messageId, OP_OpenReferenceInstances);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [OBJECT-NAME]

buf.putObjectPath(msg->objectName);

// [RESULT-CLASS]

buf.putName(msg->resultClass);

// [ROLE]

buf.putString(msg->role);

// [PROPERTY-LIST]

buf.putPropertyList(msg->propertyList);

buf.putUint32Arg(msg->maxObjectCount);

buf.putUint32Arg(msg->operationTimeout);

buf.putString(msg->filterQueryLanguage);

buf.putString(msg->filterQuery);

}

static CIMOpenReferenceInstancesRequestMessage*

_decodeOpenReferenceInstancesRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;

Boolean continueOnError = flags & CONTINUE_ON_ERROR;

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [OBJECT-NAME]

CIMObjectPath objectName;

if (!in.getObjectPath(objectName))

return 0;

// [RESULT-CLASS]

CIMName resultClass;

if (!in.getName(resultClass))

return 0;

// [ROLE]

String role;

if (!in.getString(role))

return 0;

// [PROPERTY-LIST]

CIMPropertyList propertyList;

if (!in.getPropertyList(propertyList))

return 0;

// These can all be one common function.

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

Uint32Arg operationTimeout;

if (!in.getUint32Arg(operationTimeout))

return 0;

String filterQueryLanguage;

if (!in.getString(filterQueryLanguage))

return 0;

String filterQuery;

if (!in.getString(filterQuery))

return 0;

AutoPtr<CIMOpenReferenceInstancesRequestMessage> request(

new CIMOpenReferenceInstancesRequestMessage(

messageId,

nameSpace,

objectName,

resultClass,

role,

includeClassOrigin,

propertyList,

filterQueryLanguage,

filterQuery,

operationTimeout,

continueOnError,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodeOpenReferenceInstancesResponseBody(

CIMBuffer& out,

CIMOpenReferenceInstancesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("OpenReferenceInstances");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMOpenReferenceInstancesResponseMessage*

_decodeOpenReferenceInstancesResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMOpenReferenceInstancesResponseMessage* msg =

new CIMOpenReferenceInstancesResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to CIMResponseData::getInstances, which

// resolves the binary data is passed to the next interface.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// OpenReferenceInstancePaths

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

static void _encodeOpenReferenceInstancePathsRequest(

CIMBuffer& buf,

CIMOpenReferenceInstancePathsRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("OpenReferenceInstancePaths");

name = NAME;

// [HEADER]

Uint32 flags = 0;

if (msg->continueOnError)

flags |= CONTINUE_ON_ERROR;

_putHeader(buf, flags, msg->messageId, OP_OpenReferenceInstancePaths);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [OBJECT-NAME]

buf.putObjectPath(msg->objectName);

// [RESULT-CLASS]

buf.putName(msg->resultClass);

// [ROLE]

buf.putString(msg->role);

buf.putUint32Arg(msg->maxObjectCount);

buf.putUint32Arg(msg->operationTimeout);

buf.putString(msg->filterQueryLanguage);

buf.putString(msg->filterQuery);

}

static CIMOpenReferenceInstancePathsRequestMessage*

_decodeOpenReferenceInstancePathsRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../

Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

Boolean continueOnError = flags & CONTINUE_ON_ERROR;

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [OBJECT-NAME]

CIMObjectPath objectName;

if (!in.getObjectPath(objectName))

return 0;

// [RESULT-CLASS]

CIMName resultClass;

if (!in.getName(resultClass))

return 0;

// [ROLE]

String role;

if (!in.getString(role))

return 0;

// These can all be one common function.

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

Uint32Arg operationTimeout;

if (!in.getUint32Arg(operationTimeout))

return 0;

String filterQueryLanguage;

if (!in.getString(filterQueryLanguage))

return 0;

String filterQuery;

if (!in.getString(filterQuery))

return 0;

AutoPtr<CIMOpenReferenceInstancePathsRequestMessage> request(

new CIMOpenReferenceInstancePathsRequestMessage(

messageId,

nameSpace,

objectName,

resultClass,

role,

filterQueryLanguage,

filterQuery,

operationTimeout,

continueOnError,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodeOpenReferenceInstancePathsResponseBody(

CIMBuffer& out,

CIMOpenReferenceInstancePathsResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("OpenReferenceInstancePaths");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMOpenReferenceInstancePathsResponseMessage*

_decodeOpenReferenceInstancePathsResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMOpenReferenceInstancePathsResponseMessage* msg =

new CIMOpenReferenceInstancePathsResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// OpenAssociatorInstances

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

static void _encodeOpenAssociatorInstancesRequest(

CIMBuffer& buf,

CIMOpenAssociatorInstancesRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("OpenAssociatorInstances");

name = NAME;

// [HEADER]

Uint32 flags = 0;

if (msg->includeClassOrigin)

flags |= INCLUDE_CLASS_ORIGIN;

if (msg->continueOnError)

flags |= CONTINUE_ON_ERROR;

_putHeader(buf, flags, msg->messageId, OP_OpenAssociatorInstances);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [OBJECT-NAME]

buf.putObjectPath(msg->objectName);

// [ASSOC-CLASS]

buf.putName(msg->assocClass);

// [RESULT-CLASS]

buf.putName(msg->resultClass);

// [ROLE]

buf.putString(msg->role);

// [RESULT-ROLE]

buf.putString(msg->resultRole);

// [PROPERTY-LIST]

buf.putPropertyList(msg->propertyList);

buf.putUint32Arg(msg->maxObjectCount);

buf.putUint32Arg(msg->operationTimeout);

buf.putString(msg->filterQueryLanguage);

buf.putString(msg->filterQuery);

}

static CIMOpenAssociatorInstancesRequestMessage*

_decodeOpenAssociatorInstancesRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;

Boolean continueOnError = flags & CONTINUE_ON_ERROR;

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [OBJECT-NAME]

CIMObjectPath objectName;

if (!in.getObjectPath(objectName))

return 0;

// [ASSOC-CLASS]

CIMName assocClass;

if (!in.getName(assocClass))

return 0;

// [RESULT-CLASS]

CIMName resultClass;

if (!in.getName(resultClass))

return 0;

// [ROLE]

String role;

if (!in.getString(role))

return 0;

// [RESULT-ROLE]

String resultRole;

if (!in.getString(resultRole))

return 0;

// [PROPERTY-LIST]

CIMPropertyList propertyList;

if (!in.getPropertyList(propertyList))

return 0;

// These can all be one common function.

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

Uint32Arg operationTimeout;

if (!in.getUint32Arg(operationTimeout))

return 0;

String filterQueryLanguage;

if (!in.getString(filterQueryLanguage))

return 0;

String filterQuery;

if (!in.getString(filterQuery))

return 0;

AutoPtr<CIMOpenAssociatorInstancesRequestMessage> request(

new CIMOpenAssociatorInstancesRequestMessage(

messageId,

nameSpace,

objectName,

assocClass,

resultClass,

role,

resultRole,

includeClassOrigin,

propertyList,

filterQueryLanguage,

filterQuery,

operationTimeout,

continueOnError,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodeOpenAssociatorInstancesResponseBody(

CIMBuffer& out,

CIMOpenAssociatorInstancesResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("OpenAssociatorInstances");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMOpenAssociatorInstancesResponseMessage*

_decodeOpenAssociatorInstancesResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMOpenAssociatorInstancesResponseMessage* msg =

new CIMOpenAssociatorInstancesResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// OpenAssociatorInstancePaths

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

static void _encodeOpenAssociatorInstancePathsRequest(

CIMBuffer& buf,

CIMOpenAssociatorInstancePathsRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("OpenAssociatorInstancePaths");

name = NAME;

// [HEADER]

Uint32 flags = 0;

if (msg->continueOnError)

flags |= CONTINUE_ON_ERROR;

_putHeader(buf, flags, msg->messageId, OP_OpenAssociatorInstancePaths);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [OBJECT-NAME]

buf.putObjectPath(msg->objectName);

// [ASSOC-CLASS]

buf.putName(msg->assocClass);

// [RESULT-CLASS]

buf.putName(msg->resultClass);

// [ROLE]

buf.putString(msg->role);

// [RESULT-ROLE]

buf.putString(msg->resultRole);

buf.putUint32Arg(msg->maxObjectCount);

buf.putUint32Arg(msg->operationTimeout);

buf.putString(msg->filterQueryLanguage);

buf.putString(msg->filterQuery);

}

static CIMOpenAssociatorInstancePathsRequestMessage*

_decodeOpenAssociatorInstancePathsRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

Boolean continueOnError = flags & CONTINUE_ON_ERROR;

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [OBJECT-NAME]

CIMObjectPath objectName;

if (!in.getObjectPath(objectName))

return 0;

// [ASSOC-CLASS]

CIMName assocClass;

if (!in.getName(assocClass))

return 0;

// [RESULT-CLASS]

CIMName resultClass;

if (!in.getName(resultClass))

return 0;

// [ROLE]

String role;

if (!in.getString(role))

return 0;

// [RESULT-ROLE]

String resultRole;

if (!in.getString(resultRole))

return 0;

// These can all be one common function.

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

Uint32Arg operationTimeout;

if (!in.getUint32Arg(operationTimeout))

return 0;

String filterQueryLanguage;

if (!in.getString(filterQueryLanguage))

return 0;

String filterQuery;

if (!in.getString(filterQuery))

return 0;

AutoPtr<CIMOpenAssociatorInstancePathsRequestMessage> request(

new CIMOpenAssociatorInstancePathsRequestMessage(

messageId,

nameSpace,

objectName,

assocClass,

resultClass,

role,

resultRole,

filterQueryLanguage,

filterQuery,

operationTimeout,

continueOnError,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

static void _encodeOpenAssociatorInstancePathsResponseBody(

CIMBuffer& out,

CIMOpenAssociatorInstancePathsResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("OpenAssociatorInstancePaths");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMOpenAssociatorInstancePathsResponseMessage*

_decodeOpenAssociatorInstancePathsResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMOpenAssociatorInstancePathsResponseMessage* msg =

new CIMOpenAssociatorInstancePathsResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// PullInstancesWithPath

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

static void _encodePullInstancesWithPathRequest(

CIMBuffer& buf,

CIMPullInstancesWithPathRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("PullInstancesWithPath");

name = NAME;

// [HEADER]

Uint32 flags = 0;

_putHeader(buf, flags, msg->messageId, OP_PullInstancesWithPath);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [EnumerationContext]

buf.putString(msg->enumerationContext);

buf.putUint32Arg(msg->maxObjectCount);

}

static CIMPullInstancesWithPathRequestMessage*

_decodePullInstancesWithPathRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [EnumerationContext]

String enumerationContext;

if (!in.getString(enumerationContext))

{

return 0;

}

// [MACTCOUNT]

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

AutoPtr<CIMPullInstancesWithPathRequestMessage> request(

new CIMPullInstancesWithPathRequestMessage(

messageId,

nameSpace,

enumerationContext,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodePullInstancesWithPathResponseBody(

CIMBuffer& out,

CIMPullInstancesWithPathResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("PullInstancesWithPath");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMPullInstancesWithPathResponseMessage*

_decodePullInstancesWithPathResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMPullInstancesWithPathResponseMessage* msg =

new CIMPullInstancesWithPathResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// PullInstancePaths

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

static void _encodePullInstancePathsRequest(

CIMBuffer& buf,

CIMPullInstancePathsRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("PullInstancePaths");

name = NAME;

// [HEADER]

Uint32 flags = 0;

_putHeader(buf, flags, msg->messageId, OP_PullInstancePaths);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [EnumerationContext]

buf.putString(msg->enumerationContext);

buf.putUint32Arg(msg->maxObjectCount);

}

static CIMPullInstancePathsRequestMessage*

_decodePullInstancePathsRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [EnumerationContext]

String enumerationContext;

if (!in.getString(enumerationContext))

{

return 0;

}

// [MAXOBJECTCOUNT]

Uint32Arg maxObjectCount;

if (!in.getUint32Arg(maxObjectCount))

return 0;

AutoPtr<CIMPullInstancePathsRequestMessage> request(

new CIMPullInstancePathsRequestMessage(

messageId,

nameSpace,

enumerationContext,

maxObjectCount,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

// For the pull Response messages the interface is the message and the,

// not just the responseData.

static void _encodePullInstancePathsResponseBody(

CIMBuffer& out,

CIMPullInstancePathsResponseMessage* msg,

CIMResponseData& data,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("PullInstancePaths");

name = NAME;

// [endOfSequence]

out.putBoolean(msg->endOfSequence);

// [enumerationContext]

out.putString(msg->enumerationContext);

data.encodeBinaryResponse(out);

}

static CIMPullInstancePathsResponseMessage*

_decodePullInstancePathsResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Boolean endOfSequence;

if (!in.getBoolean(endOfSequence))

return 0;

String enumerationContext;

if (!in.getString(enumerationContext))

return 0;

CIMPullInstancePathsResponseMessage* msg =

new CIMPullInstancePathsResponseMessage(

messageId,

cimException,

endOfSequence,

enumerationContext,

QueueIdStack());

// Instead of resolving the binary data right here, we delegate this

// to a later point in time when the data is actually retrieved through

// a call to getNamedInstances, which is going to resolve the binary

// data when the callback function is registered.

// This allows an alternate client implementation to gain direct access

// to the binary data and pass this for example to the JNI implementation

// of the JSR48 CIM Client for Java.

CIMResponseData& responseData = msg->getResponseData();

responseData.setRemainingBinaryData(in);

msg->binaryRequest=true;

return msg;

}

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

// CloseEnumeration

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

static void _encodeCloseEnumerationRequest(

CIMBuffer& buf,

CIMCloseEnumerationRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("CloseEnumeration");

name = NAME;

// [HEADER]

Uint32 flags = 0;

_putHeader(buf, flags, msg->messageId, OP_CloseEnumeration);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [EnumerationContext]

buf.putString(msg->enumerationContext);

}

static CIMCloseEnumerationRequestMessage* _decodeCloseEnumerationRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [EnumerationContext]

String enumerationContext;

if (!in.getString(enumerationContext))

{

return 0;

}

AutoPtr<CIMCloseEnumerationRequestMessage> request(

new CIMCloseEnumerationRequestMessage(

messageId,

nameSpace,

enumerationContext,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

static void _encodeCloseEnumerationResponseBody(

CIMBuffer& out,

CIMCloseEnumerationResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("CloseEnumeration");

name = NAME;

}

static CIMCloseEnumerationResponseMessage*

_decodeCloseEnumerationResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

CIMCloseEnumerationResponseMessage* msg =

new CIMCloseEnumerationResponseMessage(

messageId,

cimException,

QueueIdStack());

msg->binaryRequest=true;

return msg;

}

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

// EnumerationCount

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

static void _encodeEnumerationCountRequest(

CIMBuffer& buf,

CIMEnumerationCountRequestMessage* msg,

CIMName& name)

{

/* See ../Client/CIMOperationRequestEncoder.cpp */

static const CIMName NAME("EnumerationCount");

name = NAME;

// [HEADER]

Uint32 flags = 0;

_putHeader(buf, flags, msg->messageId, OP_EnumerationCount);

// [NAMESPACE]

buf.putNamespaceName(msg->nameSpace);

// [EnumerationContext]

buf.putString(msg->enumerationContext);

}

static CIMEnumerationCountRequestMessage* _decodeEnumerationCountRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId,

Uint32 flags,

const String& messageId)

{

/* See ../Server/CIMOperationRequestDecoder.cpp */

STAT_GETSTARTTIME

// [NAMESPACE]

CIMNamespaceName nameSpace;

if (!in.getNamespaceName(nameSpace))

return 0;

// [EnumerationContext]

String enumerationContext;

if (!in.getString(enumerationContext))

{

return 0;

}

AutoPtr<CIMEnumerationCountRequestMessage> request(

new CIMEnumerationCountRequestMessage(

messageId,

nameSpace,

enumerationContext,

QueueIdStack(queueId, returnQueueId)));

request->binaryRequest = true;

STAT_SERVERSTART

return request.release();

}

static void _encodeEnumerationCountResponseBody(

CIMBuffer& out,

CIMEnumerationCountResponseMessage* msg,

CIMName& name)

{

/* See ../Server/CIMOperationResponseEncoder.cpp */

static const CIMName NAME("EnumerationCount");

name = NAME;

// [count]

out.putUint64Arg(msg->count);

}

static CIMEnumerationCountResponseMessage*

_decodeEnumerationCountResponse(

CIMBuffer& in,

const String& messageId)

{

CIMException cimException;

Uint64 count;

if (!in.getUint64(count))

return 0;

CIMEnumerationCountResponseMessage* msg =

new CIMEnumerationCountResponseMessage(

messageId,

cimException,

QueueIdStack(),

count);

msg->binaryRequest=true;

return msg;

}

// EXP_PULL_END

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

// BinaryCodec::hexDump()

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

#if defined(PEGASUS_DEBUG)

void BinaryCodec::hexDump(const void* data, size_t size)

{

unsigned char* p = (unsigned char*)data;

unsigned char buf[16];

size_t n = 0;

for (size_t i = 0, col = 0; i < size; i++)

{

unsigned char c = p[i];

buf[n++] = c;

if (col == 0)

printf("%06X ", (unsigned int)i);

printf("%02X ", c);

if (col + 1 == sizeof(buf) || i + 1 == size)

{

for (size_t j = col + 1; j < sizeof(buf); j++)

printf(" ");

for (size_t j = 0; j < n; j++)

{

c = buf[j];

if (c >= ' ' && c <= '~')

printf("%c", buf[j]);

else

printf(".");

}

printf("\n");

n = 0;

}

if (col + 1 == sizeof(buf))

col = 0;

else

col++;

}

printf("\n");

}

#endif /* defined(PEGASUS_DEBUG) */

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

// BinaryCodec::decodeRequest()

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

CIMOperationRequestMessage* BinaryCodec::decodeRequest(

CIMBuffer& in,

Uint32 queueId,

Uint32 returnQueueId)

{

CIMBuffer buf((char*)in.getData(), in.size());

CIMBufferReleaser buf_(buf);

// Turn on validation:

#if defined(ENABLE_VALIDATION)

buf.setValidate(true);

in.setValidate(true);

#endif

Uint32 flags;

Line 3230

Line 4718

Operation operation;

if (!_getHeader(buf, flags, messageId, operation))

if (!_getHeader(in, flags, messageId, operation))

{

return 0;

}

Line 3239

Line 4727

{

case OP_EnumerateInstances:

return _decodeEnumerateInstancesRequest(