(file) Return to CimomMessage.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CimomMessage.cpp between version 1.26 and 1.34

version 1.26, 2006/08/15 18:08:45 version 1.34, 2008/12/01 17:49:51
Line 1 
Line 1 
 //%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.  
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // EMC Corporation; Symantec Corporation; The Open Group.  
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // Permission is hereby granted, free of charge, to any person obtaining a
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // 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.  
 // //
 //==============================================================================  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 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 36 
Line 34 
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 const Uint32 async_results::OK =                        0x00000000; const Uint32 async_results::OK =                        0x00000000;
 const Uint32 async_results::PARAMETER_ERROR =           0x00000001;  const Uint32 async_results::CIM_NAK =                   0x00000001;
 const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002;  const Uint32 async_results::CIM_SERVICE_STOPPED =       0x00000002;
 const Uint32 async_results::MODULE_NOT_FOUND =          0x00000003;  
 const Uint32 async_results::INTERNAL_ERROR =            0x00000004;  
   
 const Uint32 async_results::ASYNC_STARTED =             0x00000005;  
 const Uint32 async_results::ASYNC_PROCESSING =          0x00000006;  
 const Uint32 async_results::ASYNC_COMPLETE =            0x00000007;  
 const Uint32 async_results::ASYNC_CANCELLED =           0x00000008;  
 const Uint32 async_results::ASYNC_PAUSED =              0x00000009;  
 const Uint32 async_results::ASYNC_RESUMED =             0x0000000a;  
   
 const Uint32 async_results::CIM_SERVICE_STARTED =       0x0000000b;  
 const Uint32 async_results::CIM_SERVICE_STOPPED  =      0x0000000c;  
   
 const Uint32 async_results::CIM_SERVICE_PAUSED  =       0x0000000d;  
 const Uint32 async_results::CIM_SERVICE_RESUMED =       0x0000000e;  
 const Uint32 async_results::CIM_NAK =                   0x0000000f;  
   
 const Uint32 async_results::ASYNC_PHASE_COMPLETE =      0x00000010;  
 const Uint32 async_results::ASYNC_CHILD_COMPLETE =      0x00000011;  
 const Uint32 async_results::ASYNC_PHASE_STARTED =       0x00000012;  
 const Uint32 async_results::ASYNC_CHILD_STARTED =       0x00000013;  
 const Uint32 async_results::CIM_PAUSED =                0x00000014;  
 const Uint32 async_results::CIM_STOPPED =               0x00000015;  
   
   
 const Uint32 async_messages::HEARTBEAT =                DUMMY_MESSAGE;  
 const Uint32 async_messages::REPLY =                    DUMMY_MESSAGE;  
 const Uint32 async_messages::REGISTER_CIM_SERVICE =     ASYNC_REGISTER_CIM_SERVICE;  
 const Uint32 async_messages::DEREGISTER_CIM_SERVICE =   ASYNC_DEREGISTER_CIM_SERVICE;  
 const Uint32 async_messages::UPDATE_CIM_SERVICE =       ASYNC_UPDATE_CIM_SERVICE;  
 const Uint32 async_messages::IOCTL =                    ASYNC_IOCTL;  
 const Uint32 async_messages::CIMSERVICE_START =         ASYNC_CIMSERVICE_START;  
 const Uint32 async_messages::CIMSERVICE_STOP =          ASYNC_CIMSERVICE_STOP;  
 const Uint32 async_messages::CIMSERVICE_PAUSE =         ASYNC_CIMSERVICE_PAUSE;  
 const Uint32 async_messages::CIMSERVICE_RESUME =        ASYNC_CIMSERVICE_RESUME;  
   
 const Uint32 async_messages::ASYNC_OP_START =           ASYNC_ASYNC_OP_START;  
 const Uint32 async_messages::ASYNC_OP_RESULT =          ASYNC_ASYNC_OP_RESULT;  
 const Uint32 async_messages::ASYNC_LEGACY_OP_START =    ASYNC_ASYNC_LEGACY_OP_START;  
 const Uint32 async_messages::ASYNC_LEGACY_OP_RESULT =   ASYNC_ASYNC_LEGACY_OP_RESULT;  
   
 const Uint32 async_messages::FIND_SERVICE_Q =           ASYNC_FIND_SERVICE_Q;  
 const Uint32 async_messages::FIND_SERVICE_Q_RESULT =    ASYNC_FIND_SERVICE_Q_RESULT;  
 const Uint32 async_messages::ENUMERATE_SERVICE =        ASYNC_ENUMERATE_SERVICE;  
 const Uint32 async_messages::ENUMERATE_SERVICE_RESULT = ASYNC_ENUMERATE_SERVICE_RESULT;  
   
 const Uint32 async_messages::REGISTERED_MODULE =        ASYNC_REGISTERED_MODULE;  
 const Uint32 async_messages::DEREGISTERED_MODULE =      ASYNC_DEREGISTERED_MODULE;  
 const Uint32 async_messages::FIND_MODULE_IN_SERVICE =   ASYNC_FIND_MODULE_IN_SERVICE;  
 const Uint32 async_messages::FIND_MODULE_IN_SERVICE_RESPONSE = ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE;  
 const Uint32 async_messages::ASYNC_MODULE_OP_START =    ASYNC_ASYNC_MODULE_OP_START;  
 const Uint32 async_messages::ASYNC_MODULE_OP_RESULT  =  ASYNC_ASYNC_MODULE_OP_RESULT;  
  
  
 AsyncMessage::AsyncMessage( AsyncMessage::AsyncMessage(
     Uint32 type,      MessageType type,
     Uint32 destination,     Uint32 destination,
     Uint32 mask,     Uint32 mask,
     AsyncOpNode* operation)     AsyncOpNode* operation)
     : Message(type, destination, mask | message_mask::ha_async),      : Message(type, destination, mask | MessageMask::ha_async),
       op(operation)       op(operation)
 { {
 } }
  
 AsyncRequest::AsyncRequest( AsyncRequest::AsyncRequest(
     Uint32 type,      MessageType type,
     Uint32 mask,     Uint32 mask,
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,     Uint32 destination,
     Uint32 response,     Uint32 response,
     Boolean blocking)     Boolean blocking)
     : AsyncMessage(     : AsyncMessage(
           type, destination, mask | message_mask::ha_request, operation),            type, destination, mask | MessageMask::ha_request, operation),
       resp(response),       resp(response),
       block(blocking)       block(blocking)
 { {
Line 119 
Line 65 
 } }
  
 AsyncReply::AsyncReply( AsyncReply::AsyncReply(
     Uint32 type,      MessageType type,
     Uint32 mask,     Uint32 mask,
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 resultCode,     Uint32 resultCode,
     Uint32 destination,     Uint32 destination,
     Boolean blocking)     Boolean blocking)
     : AsyncMessage(     : AsyncMessage(
           type, destination, mask | message_mask::ha_reply, operation),            type, destination, mask | MessageMask::ha_reply, operation),
       result(resultCode),       result(resultCode),
       block(blocking)       block(blocking)
 { {
Line 134 
Line 80 
         op->setResponse(this);         op->setResponse(this);
 } }
  
 RegisterCimService::RegisterCimService(  AsyncIoClose::AsyncIoClose(
     AsyncOpNode* operation,  
     Boolean blocking,  
     const String& serviceName,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask,  
     Uint32 serviceQueue)  
     : AsyncRequest(  
           async_messages::REGISTER_CIM_SERVICE,  
           0, operation, CIMOM_Q_ID,  
           serviceQueue, blocking),  
       name(serviceName),  
       capabilities(serviceCapabilities),  
       mask(serviceMask),  
       queue(serviceQueue)  
 {  
 }  
   
   
 DeRegisterCimService::DeRegisterCimService(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 serviceQueue)  
     : AsyncRequest(  
           async_messages::DEREGISTER_CIM_SERVICE,  
           0, operation, CIMOM_Q_ID,  
           serviceQueue, blocking),  
       queue(serviceQueue)  
 {  
 }  
   
   
 UpdateCimService::UpdateCimService(  
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Boolean blocking,  
     Uint32 serviceQueue,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask)  
     : AsyncRequest(  
           async_messages::UPDATE_CIM_SERVICE,  
           0, operation, CIMOM_Q_ID,  
           serviceQueue, blocking),  
       queue(serviceQueue),  
       capabilities(serviceCapabilities),  
       mask(serviceMask)  
 {  
 }  
   
 RegisteredModule::RegisteredModule(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 serviceQueue,  
     const String& newModule)  
     : AsyncRequest(  
           async_messages::REGISTERED_MODULE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           serviceQueue,  
           blocking),  
       _module(newModule)  
 {  
 }  
   
 DeRegisteredModule::DeRegisteredModule(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 serviceQueue,  
     const String& removedModule)  
     : AsyncRequest(  
           async_messages::DEREGISTERED_MODULE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           serviceQueue,  
           blocking),  
       _module(removedModule)  
 {  
 }  
   
   
 FindModuleInService::FindModuleInService(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 responseQueue,  
     const String& module)  
     : AsyncRequest(  
           async_messages::FIND_MODULE_IN_SERVICE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           responseQueue,  
           blocking),  
       _module(module)  
 {  
 }  
   
 FindModuleInServiceResponse::FindModuleInServiceResponse(  
     AsyncOpNode* operation,  
     Uint32 resultCode,  
     Uint32 destination,     Uint32 destination,
     Boolean blocking,      Uint32 response,
     Uint32 moduleServiceQueue)      Boolean blocking)
     : AsyncReply(      : AsyncRequest(
           async_messages::FIND_MODULE_IN_SERVICE_RESPONSE,            ASYNC_IOCLOSE,
           0,           0,
           operation,           operation,
           resultCode,  
           destination,           destination,
           blocking),            response,
       _module_service_queue(moduleServiceQueue)            blocking)
 {  
 }  
   
 AsyncIoctl::AsyncIoctl(  
     AsyncOpNode* operation,  
     Uint32 destination,  
     Uint32 response,  
     Boolean blocking,  
     Uint32 code,  
     Uint32 intParam,  
     void* pParam)  
     : AsyncRequest(  
           async_messages::IOCTL,  
           0, operation,  
           destination, response, blocking),  
       ctl(code),  
       intp(intParam),  
       voidp(pParam)  
 { {
 } }
  
   
 CimServiceStart::CimServiceStart( CimServiceStart::CimServiceStart(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,     Uint32 destination,
     Uint32 response,     Uint32 response,
     Boolean blocking)     Boolean blocking)
     : AsyncRequest(     : AsyncRequest(
           async_messages::CIMSERVICE_START,            ASYNC_CIMSERVICE_START,
           0, operation, destination,           0, operation, destination,
           response, blocking)           response, blocking)
 { {
Line 286 
Line 114 
     Uint32 response,     Uint32 response,
     Boolean blocking)     Boolean blocking)
     : AsyncRequest(     : AsyncRequest(
           async_messages::CIMSERVICE_STOP,            ASYNC_CIMSERVICE_STOP,
           0, operation, destination,  
           response, blocking)  
 {  
 }  
   
   
 CimServicePause::CimServicePause(  
     AsyncOpNode* operation,  
     Uint32 destination,  
     Uint32 response,  
     Boolean blocking)  
     : AsyncRequest(  
           async_messages::CIMSERVICE_PAUSE,  
           0, operation, destination,  
           response, blocking)  
 {  
 }  
   
   
 CimServiceResume::CimServiceResume(  
     AsyncOpNode* operation,  
     Uint32 destination,  
     Uint32 response,  
     Boolean blocking)  
     : AsyncRequest(  
           async_messages::CIMSERVICE_RESUME,  
           0, operation, destination,           0, operation, destination,
           response, blocking)           response, blocking)
 { {
Line 325 
Line 127 
     Boolean blocking,     Boolean blocking,
     Message* action)     Message* action)
     : AsyncRequest(     : AsyncRequest(
           async_messages::ASYNC_OP_START,            ASYNC_ASYNC_OP_START,
           0,           0,
           operation,           operation,
           destination, response, blocking),           destination, response, blocking),
Line 347 
Line 149 
     Uint32 destination,     Uint32 destination,
     Boolean blocking)     Boolean blocking)
     : AsyncReply(     : AsyncReply(
           async_messages::ASYNC_OP_RESULT,            ASYNC_ASYNC_OP_RESULT,
           0,           0,
           operation,           operation,
           resultCode,           resultCode,
Line 365 
Line 167 
     const String& targetModule,     const String& targetModule,
     Message* action)     Message* action)
     : AsyncRequest(     : AsyncRequest(
           async_messages::ASYNC_MODULE_OP_START,            ASYNC_ASYNC_MODULE_OP_START,
           0,           0,
           operation,           operation,
           destination,           destination,
Line 394 
Line 196 
     const String& targetModule,     const String& targetModule,
     Message* result)     Message* result)
     : AsyncReply(     : AsyncReply(
           async_messages::ASYNC_MODULE_OP_RESULT,            ASYNC_ASYNC_MODULE_OP_RESULT,
           0,           0,
           operation, resultCode, destination,           operation, resultCode, destination,
           blocking),           blocking),
Line 416 
Line 218 
 AsyncLegacyOperationStart::AsyncLegacyOperationStart( AsyncLegacyOperationStart::AsyncLegacyOperationStart(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,     Uint32 destination,
     Message* action,      Message* action)
     Uint32 actionDestination)  
     : AsyncRequest(     : AsyncRequest(
           async_messages::ASYNC_LEGACY_OP_START,            ASYNC_ASYNC_LEGACY_OP_START,
           0,           0,
           operation, destination, CIMOM_Q_ID, false),           operation, destination, CIMOM_Q_ID, false),
       _act(action),        _act(action)
       _legacy_destination(actionDestination)  
 { {
     _act->put_async(this);     _act->put_async(this);
 } }
Line 442 
Line 242 
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Message* result)     Message* result)
     : AsyncReply(     : AsyncReply(
           async_messages::ASYNC_LEGACY_OP_RESULT,            ASYNC_ASYNC_LEGACY_OP_RESULT,
           0, operation,           0, operation,
           0, CIMOM_Q_ID, false),           0, CIMOM_Q_ID, false),
       _res(result)       _res(result)
Line 458 
Line 258 
     return ret;     return ret;
 } }
  
 FindServiceQueue::FindServiceQueue(  
     AsyncOpNode* operation,  
     Uint32 response,  
     Boolean blocking,  
     const String& serviceName,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask)  
     : AsyncRequest(  
           async_messages::FIND_SERVICE_Q,  
           0, operation,  
           CIMOM_Q_ID,  
           response,  
           blocking),  
       name(serviceName),  
       capabilities(serviceCapabilities),  
       mask(serviceMask)  
 {  
 }  
   
   
 FindServiceQueueResult::FindServiceQueueResult(  
     AsyncOpNode* operation,  
     Uint32 resultCode,  
     Uint32 destination,  
     Boolean blocking,  
     Array<Uint32> queueIds)  
     : AsyncReply(  
           async_messages::FIND_SERVICE_Q_RESULT,  
           0, operation,  
           resultCode, destination, blocking),  
       qids(queueIds)  
 {  
 }  
   
 EnumerateService::EnumerateService(  
     AsyncOpNode* operation,  
     Uint32 response,  
     Boolean blocking,  
     Uint32 queueId)  
     : AsyncRequest(  
           async_messages::ENUMERATE_SERVICE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           response,  
           blocking),  
       qid(queueId)  
 {  
 }  
   
 EnumerateServiceResponse::EnumerateServiceResponse(  
     AsyncOpNode* operation,  
     Uint32 resultCode,  
     Uint32 response,  
     Boolean blocking,  
     const String& serviceName,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask,  
     Uint32 serviceQid)  
     : AsyncReply(  
           async_messages::ENUMERATE_SERVICE_RESULT,  
           0,  
           operation,  
           resultCode,  
           response,  
           blocking),  
       name(serviceName),  
       capabilities(serviceCapabilities),  
       mask(serviceMask),  
       qid(serviceQid)  
 {  
 }  
   
 AsyncMessage::~AsyncMessage() AsyncMessage::~AsyncMessage()
 { {
 } }

Legend:
Removed from v.1.26  
changed lines
  Added in v.1.34
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2