version 1.79.2.2, 2006/07/28 17:41:27
|
version 1.109, 2015/03/14 13:56:48
|
|
|
//%2006//////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// 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 |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
// 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 |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
// Source License; you may not use this file except in compliance with the |
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// License. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// |
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Permission is hereby granted, free of charge, to any person obtaining a |
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// 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. |
|
// |
|
//============================================================================== |
|
// |
|
// Author: Mike Brasher (mbrasher@bmc.com) |
|
// |
|
// Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) |
|
// Carol Ann Krug Graves, Hewlett-Packard Company |
|
// (carolann_graves@hp.com) |
|
// Mike Day (mdday@us.ibm.com) |
|
// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
|
// Arthur Pichlkostner (via Markus: sedgewick_de@yahoo.de) |
|
// Willis White (whiwill@us.ibm.com) PEP 127 and 128 |
|
// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1 |
|
// Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090 |
|
// John Alex, IBM (johnalex@us.ibm.com) - Bug#2290 |
|
// | // |
|
////////////////////////////////////////////////////////////////////////// |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
#include <iostream> | #include <iostream> |
#include <cstring> | #include <cstring> |
#include <Pegasus/Common/InternalException.h> | #include <Pegasus/Common/InternalException.h> |
#include <Pegasus/Common/StatisticalData.h> |
|
#include <Pegasus/Common/Linkage.h> | #include <Pegasus/Common/Linkage.h> |
#include <Pegasus/Common/TimeValue.h> |
|
#include <Pegasus/Common/CIMOperationType.h> | #include <Pegasus/Common/CIMOperationType.h> |
#include <Pegasus/Common/Linkable.h> | #include <Pegasus/Common/Linkable.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
// REVIEW: could class be renamed to MessageMask (coding standard) |
class PEGASUS_COMMON_LINKAGE MessageMask |
|
|
class PEGASUS_COMMON_LINKAGE message_mask |
|
{ | { |
public: | public: |
|
// Message handling is indicated by the high order 12 bits. For example: |
static Uint32 type_legacy; |
// Uint32 messageHandling = flags & 0xfff00000; |
static Uint32 type_CIMOperation; |
|
static Uint32 type_CIMAsyncOperation; |
|
static Uint32 type_export; |
|
static Uint32 type_lifetime; |
|
static Uint32 type_socket; |
|
static Uint32 type_connection; |
|
static Uint32 type_http; |
|
static Uint32 type_http_error; |
|
static Uint32 type_cimom; |
|
static Uint32 type_control; |
|
static Uint32 type_service; |
|
static Uint32 type_broadcast; |
|
static Uint32 type_client_exception; |
|
|
|
static Uint32 ha_no_delete; |
|
static Uint32 ha_request; | static Uint32 ha_request; |
static Uint32 ha_reply; | static Uint32 ha_reply; |
static Uint32 ha_synchronous; |
|
static Uint32 ha_async; | static Uint32 ha_async; |
static Uint32 ha_wait; |
|
|
|
|
|
// more for documentation than for use |
|
|
|
inline Uint32 get_type(Uint32 flags) |
|
{ |
|
return (flags & 0x000fffff); |
|
} |
|
|
|
inline Uint32 get_handling(Uint32 flags) |
|
{ |
|
return( flags & 0xfff00000); |
|
} |
|
}; | }; |
| |
class cimom; |
|
class MessageQueue; |
|
class MessageQueueService; |
|
class AsyncLegacyOperationStart; |
|
class AsyncLegacyOperationResult; |
|
|
|
enum HttpMethod | enum HttpMethod |
{ | { |
HTTP_METHOD__POST, | HTTP_METHOD__POST, |
HTTP_METHOD_M_POST | HTTP_METHOD_M_POST |
|
#ifdef PEGASUS_ENABLE_PROTOCOL_WEB |
|
,HTTP_METHOD_GET, |
|
HTTP_METHOD_HEAD |
|
#endif /* PEGASUS_ENABLE_PROTOCOL_WEB */ |
}; | }; |
| |
/** The Message class and derived classes are used to pass messages between |
|
modules. Messages are passed between modules using the message queues |
|
(see MessageQueue class). Derived classes may add their own fields. |
|
This base class defines a common type field, which is the type of |
|
the message. |
|
|
|
The Message class also provides previous and next pointers which are |
|
used to place the messages on a queue by the MessageQueue class. |
|
*/ |
|
class PEGASUS_COMMON_LINKAGE Message : public Linkable |
|
{ |
|
public: |
|
|
|
Message( |
|
Uint32 type, |
|
Uint32 destination = 0, |
|
Uint32 mask = message_mask::type_legacy) |
|
: |
|
_type(type), |
|
_mask(mask), |
|
_httpMethod (HTTP_METHOD__POST), |
|
_close_connect(false), |
|
_last_thread_id(Threads::self()), |
|
_next(0), |
|
_prev(0), |
|
_async(0), |
|
dest(destination), |
|
_isComplete(true), |
|
_index(0) |
|
{ |
|
|
|
} |
|
|
|
Message & operator = ( const Message & msg) |
|
{ |
|
if (this != &msg) |
|
{ |
|
_type = msg._type; |
|
_mask = msg._mask; |
|
_last_thread_id = msg._last_thread_id; |
|
_next = _prev = _async = 0; |
|
dest = msg.dest; |
|
_httpMethod = msg._httpMethod; |
|
_index = msg._index; |
|
_isComplete = msg._isComplete; |
|
|
|
} |
|
return *this; |
|
} |
|
|
|
|
|
virtual ~Message(); |
|
Boolean getCloseConnect() const { return _close_connect; } |
|
void setCloseConnect(Boolean close_connect) |
|
{ |
|
_close_connect = close_connect; |
|
} |
|
|
|
Uint32 getType() const { return _type; } |
|
|
|
void setType(Uint32 type) { _type = type; } |
|
|
|
Uint32 getMask() const { return _mask; } |
|
|
|
void setMask(Uint32 mask) { _mask = mask; } |
|
|
|
HttpMethod getHttpMethod() const { return _httpMethod; } |
|
|
|
void setHttpMethod(HttpMethod httpMethod) {_httpMethod = httpMethod;} |
|
|
|
|
|
#ifndef PEGASUS_DISABLE_PERFINST |
|
// |
|
// Needed for performance measurement |
|
// |
|
|
|
void startServer(); |
|
|
|
void endServer(); |
|
|
|
void startProvider(); |
|
|
|
void endProvider(); |
|
|
|
TimeValue getStartServerTime() const { return _timeServerStart; } |
|
|
|
void setStartServerTime(TimeValue timeServerStart) |
|
{ |
|
_timeServerStart = timeServerStart; |
|
} |
|
|
|
TimeValue getStartProviderTime() const { return _timeProviderStart; } |
|
|
|
void setStartProviderTime(TimeValue timeProviderStart) |
|
{ |
|
_timeProviderStart = timeProviderStart; |
|
} |
|
|
|
TimeValue getEndServerTime() const { return _timeServerEnd; } |
|
|
|
void setEndServerTime (TimeValue timeServerEnd) |
|
{ |
|
_timeServerEnd = timeServerEnd; |
|
} |
|
|
|
TimeValue getEndProviderTime() const { return _timeProviderEnd; } |
|
|
|
void setEndProviderTime(TimeValue timeProviderEnd) |
|
{ |
|
_timeProviderEnd = timeProviderEnd; |
|
} |
|
|
|
TimeValue getServerTime() { return _serverTime; } |
|
// |
|
#endif |
|
|
|
Message* getNext() { return _next; } |
|
|
|
const Message* getNext() const { return _next; } |
|
|
|
Message* getPrevious() { return _prev; } |
|
|
|
const Message* getPrevious() const { return _prev; } |
|
|
|
static CIMOperationType convertMessageTypetoCIMOpType(Uint32 type); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
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 |
|
TimeValue _timeServerStart; |
|
TimeValue _timeServerEnd; |
|
TimeValue _timeProviderStart; |
|
TimeValue _timeProviderEnd; |
|
TimeValue _serverTime; |
|
Boolean _close_connect; |
|
|
|
// |
|
|
|
// << Tue Jul 1 11:02:35 2003 mdd >> pep_88 and helper for i18n and l10n |
|
ThreadType _last_thread_id; |
|
|
|
Message* _next; |
|
Message* _prev; |
|
|
|
protected: |
|
|
|
public: |
|
Message *_async; |
|
Uint32 dest; |
|
//needed for PEP 128 - transmitting Server Response Time to Client |
|
Uint64 totServerTime; |
|
|
|
private: |
|
MessageQueue* _owner; |
|
Boolean _isComplete; |
|
Uint32 _index; |
|
|
|
friend class cimom; |
|
friend class MessageQueue; |
|
friend class MessageQueueService; |
|
friend class AsyncLegacyOperationStart; |
|
friend class AsyncLegacyOperationResult; |
|
|
|
}; |
|
|
|
|
|
enum MessageType | enum MessageType |
{ | { |
DUMMY_MESSAGE, | DUMMY_MESSAGE, |
|
|
CIM_ENABLE_MODULE_RESPONSE_MESSAGE, | CIM_ENABLE_MODULE_RESPONSE_MESSAGE, |
CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE, // 70 | CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE, // 70 |
| |
|
// EXP_PULL_BEGIN |
|
// CIM Pull Operations |
|
|
|
CIM_OPEN_ENUMERATE_INSTANCES_REQUEST_MESSAGE, // 71 |
|
CIM_OPEN_ENUMERATE_INSTANCE_PATHS_REQUEST_MESSAGE, |
|
CIM_OPEN_ASSOCIATOR_INSTANCES_REQUEST_MESSAGE, |
|
CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_REQUEST_MESSAGE, |
|
CIM_OPEN_REFERENCE_INSTANCES_REQUEST_MESSAGE, |
|
CIM_OPEN_REFERENCE_INSTANCE_PATHS_REQUEST_MESSAGE, |
|
CIM_OPEN_QUERY_INSTANCES_REQUEST_MESSAGE, |
|
CIM_PULL_INSTANCES_WITH_PATH_REQUEST_MESSAGE, |
|
CIM_PULL_INSTANCE_PATHS_REQUEST_MESSAGE, |
|
CIM_PULL_INSTANCES_REQUEST_MESSAGE, // 80 |
|
CIM_CLOSE_ENUMERATION_REQUEST_MESSAGE, |
|
CIM_ENUMERATION_COUNT_REQUEST_MESSAGE, |
|
|
|
CIM_OPEN_ENUMERATE_INSTANCES_RESPONSE_MESSAGE, // 83 |
|
CIM_OPEN_ENUMERATE_INSTANCE_PATHS_RESPONSE_MESSAGE, |
|
CIM_OPEN_ASSOCIATOR_INSTANCES_RESPONSE_MESSAGE, |
|
CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_RESPONSE_MESSAGE, |
|
CIM_OPEN_REFERENCE_INSTANCES_RESPONSE_MESSAGE, |
|
CIM_OPEN_REFERENCE_INSTANCE_PATHS_RESPONSE_MESSAGE, |
|
CIM_OPEN_QUERY_INSTANCES_RESPONSE_MESSAGE, |
|
CIM_PULL_INSTANCES_WITH_PATH_RESPONSE_MESSAGE, // 90 |
|
CIM_PULL_INSTANCE_PATHS_RESPONSE_MESSAGE, |
|
CIM_PULL_INSTANCES_RESPONSE_MESSAGE, |
|
CIM_CLOSE_ENUMERATION_RESPONSE_MESSAGE, |
|
CIM_ENUMERATION_COUNT_RESPONSE_MESSAGE, // 94 |
|
// EXP_PULL_END |
|
|
// Monitor-related messages: | // Monitor-related messages: |
| |
SOCKET_MESSAGE, | SOCKET_MESSAGE, |
|
|
| |
CLIENT_EXCEPTION_MESSAGE, | CLIENT_EXCEPTION_MESSAGE, |
| |
ASYNC_REGISTER_CIM_SERVICE, |
ASYNC_IOCLOSE, // 100 |
ASYNC_DEREGISTER_CIM_SERVICE, |
ASYNC_CIMSERVICE_START, |
ASYNC_UPDATE_CIM_SERVICE, |
|
ASYNC_IOCTL, |
|
ASYNC_CIMSERVICE_START, // 80 |
|
ASYNC_CIMSERVICE_STOP, | ASYNC_CIMSERVICE_STOP, |
ASYNC_CIMSERVICE_PAUSE, |
|
ASYNC_CIMSERVICE_RESUME, |
|
| |
ASYNC_ASYNC_OP_START, | ASYNC_ASYNC_OP_START, |
ASYNC_ASYNC_OP_RESULT, |
ASYNC_ASYNC_OP_RESULT, // 105 |
ASYNC_ASYNC_LEGACY_OP_START, | ASYNC_ASYNC_LEGACY_OP_START, |
ASYNC_ASYNC_LEGACY_OP_RESULT, | ASYNC_ASYNC_LEGACY_OP_RESULT, |
| |
ASYNC_FIND_SERVICE_Q, |
|
ASYNC_FIND_SERVICE_Q_RESULT, |
|
ASYNC_ENUMERATE_SERVICE, // 90 |
|
ASYNC_ENUMERATE_SERVICE_RESULT, |
|
|
|
ASYNC_REGISTERED_MODULE, |
|
ASYNC_DEREGISTERED_MODULE, |
|
ASYNC_FIND_MODULE_IN_SERVICE, |
|
ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE, |
|
|
|
ASYNC_ASYNC_MODULE_OP_START, | ASYNC_ASYNC_MODULE_OP_START, |
ASYNC_ASYNC_MODULE_OP_RESULT, | ASYNC_ASYNC_MODULE_OP_RESULT, |
| |
CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE, |
CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE, //110 |
CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE, | CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE, |
| |
CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE, // 100 |
CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE, |
CIM_NOTIFY_PROVIDER_FAIL_RESPONSE_MESSAGE, | CIM_NOTIFY_PROVIDER_FAIL_RESPONSE_MESSAGE, |
| |
CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE, |
|
CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE, |
|
|
|
CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE, | CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE, |
CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE, |
CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE, // 115 |
| |
CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE, | CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE, |
CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE, | CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE, |
|
|
CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE, | CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE, |
CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE, | CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE, |
| |
|
CIM_INDICATION_SERVICE_DISABLED_REQUEST_MESSAGE, // 120 |
|
CIM_INDICATION_SERVICE_DISABLED_RESPONSE_MESSAGE, |
|
|
|
PROVAGT_GET_SCMOCLASS_REQUEST_MESSAGE, |
|
PROVAGT_GET_SCMOCLASS_RESPONSE_MESSAGE, |
|
|
|
CIM_NOTIFY_SUBSCRIPTION_NOT_ACTIVE_REQUEST_MESSAGE, |
|
CIM_NOTIFY_SUBSCRIPTION_NOT_ACTIVE_RESPONSE_MESSAGE, |
|
|
|
CIM_NOTIFY_LISTENER_NOT_ACTIVE_REQUEST_MESSAGE, |
|
CIM_NOTIFY_LISTENER_NOT_ACTIVE_RESPONSE_MESSAGE, |
|
|
|
WSMAN_EXPORT_INDICATION_REQUEST_MESSAGE, |
|
WSMAN_EXPORT_INDICATION_RESPONSE_MESSAGE, |
|
|
NUMBER_OF_MESSAGES | NUMBER_OF_MESSAGES |
}; | }; |
| |
PEGASUS_COMMON_LINKAGE const char* MessageTypeToString(Uint32 messageType); |
PEGASUS_COMMON_LINKAGE const char* MessageTypeToString(MessageType messageType); |
|
|
|
|
|
/** The Message class and derived classes are used to pass messages between |
|
modules. Messages are passed between modules using the message queues |
|
(see MessageQueue class). Derived classes may add their own fields. |
|
This base class defines a common type field, which is the type of |
|
the message. |
|
*/ |
|
class PEGASUS_COMMON_LINKAGE Message : public Linkable |
|
{ |
|
public: |
|
|
|
Message( |
|
MessageType type, |
|
Uint32 destination = 0, |
|
Uint32 mask = 0) |
|
: |
|
dest(destination), |
|
_type(type), |
|
_mask(mask), |
|
_httpMethod(HTTP_METHOD__POST), |
|
_httpCloseConnect(false), |
|
_isComplete(true), |
|
_index(0), |
|
_async(0) |
|
{ |
|
} |
|
|
|
virtual ~Message(); |
|
|
|
// NOTE: The compiler default implementation of the copy constructor |
|
// is used for this class. |
|
|
|
Boolean getCloseConnect() const { return _httpCloseConnect; } |
|
void setCloseConnect(Boolean httpCloseConnect) |
|
{ |
|
_httpCloseConnect = httpCloseConnect; |
|
} |
|
|
|
MessageType getType() const { return _type; } |
|
|
|
Uint32 getMask() const { return _mask; } |
|
|
|
void setMask(Uint32 mask) { _mask = mask; } |
|
|
|
HttpMethod getHttpMethod() const { return _httpMethod; } |
|
|
|
void setHttpMethod(HttpMethod httpMethod) {_httpMethod = httpMethod;} |
|
|
|
static CIMOperationType convertMessageTypetoCIMOpType(MessageType type); |
|
|
|
|
|
virtual void print( |
|
PEGASUS_STD(ostream)& os, |
|
Boolean printHeader = true) const; |
|
|
|
|
|
Message* get_async() |
|
{ |
|
Message *ret = _async; |
|
_async = 0; |
|
return ret; |
|
} |
|
|
|
void put_async(Message* msg) |
|
{ |
|
_async = msg; |
|
} |
|
|
|
// set the message index indicating what piece (or sequence) this is |
|
// message indexes start at zero |
|
void setIndex(Uint32 index) { _index = index; } |
|
|
|
// 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; } |
|
|
|
// set the complete flag indicating whether this message piece is the last |
|
void setComplete(Boolean isComplete) |
|
{ |
|
_isComplete = isComplete; |
|
} |
|
|
|
// is this message complete? (i.e the last in a one or more sequence) |
|
Boolean isComplete() const { return _isComplete; } |
|
|
|
// diagnostic tests magic number in context to see if valid object |
|
Boolean valid() const; |
|
|
|
|
|
Uint32 dest; |
|
|
|
private: |
|
|
|
Message& operator=(const Message& msg); |
|
|
|
MessageType _type; |
|
Uint32 _mask; |
|
|
|
HttpMethod _httpMethod; |
|
Boolean _httpCloseConnect; |
|
|
|
Boolean _isComplete; |
|
Uint32 _index; |
|
|
|
Message* _async; |
|
}; |
|
|
| |
/** This class implements a stack of queue-ids. Many messages must keep a | /** This class implements a stack of queue-ids. Many messages must keep a |
stack of queue-ids of queues which they must be returned to. This provides | stack of queue-ids of queues which they must be returned to. This provides |
|
|
| |
QueueIdStack(const QueueIdStack& x); | QueueIdStack(const QueueIdStack& x); |
| |
PEGASUS_EXPLICIT QueueIdStack(Uint32 x); |
explicit QueueIdStack(Uint32 x); |
| |
PEGASUS_EXPLICIT QueueIdStack(Uint32 x1, Uint32 x2); |
explicit QueueIdStack(Uint32 x1, Uint32 x2); |
| |
~QueueIdStack() | ~QueueIdStack() |
{ | { |
|
|
/** Make a copy of this stack and then pop the top element. */ | /** Make a copy of this stack and then pop the top element. */ |
QueueIdStack copyAndPop() const; | QueueIdStack copyAndPop() const; |
| |
|
Uint32 operator[](Uint32 i) const { return _items[i]; } |
|
|
private: | private: |
| |
// Copy the given stack but then pop the top element: | // Copy the given stack but then pop the top element: |