1 karl  1.5 //%2006////////////////////////////////////////////////////////////////////////

  2 kumpf 1.1 //

  3 karl  1.2 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
  4           // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
  5           // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;

  6 kumpf 1.1 // IBM Corp.; EMC Corporation, The Open Group.

  7 karl  1.2 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8           // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

  9 karl  1.3 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10           // EMC Corporation; VERITAS Software Corporation; The Open Group.

 11 karl  1.5 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 12           // EMC Corporation; Symantec Corporation; The Open Group.

 13 kumpf 1.1 //
 14           // Permission is hereby granted, free of charge, to any person obtaining a copy
 15           // of this software and associated documentation files (the "Software"), to
 16           // deal in the Software without restriction, including without limitation the
 17           // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 18           // sell copies of the Software, and to permit persons to whom the Software is
 19           // furnished to do so, subject to the following conditions:

 20 karl  1.5 // 

 21 kumpf 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 22           // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 23           // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 24           // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 25           // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 26           // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 27           // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 28           // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 29           //
 30           //==============================================================================
 31           //
 32           // Author: Chip Vincent (cvincent@us.ibm.com)
 33           //

 34 chip  1.4 // Modified By:
 35           //      Carol Ann Krug Graves, Hewlett-Packard Company (carolann_graves@hp.com)
 36           //      Mike Day, IBM (mdday@us.ibm.com)
 37           //      Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

 38 kumpf 1.1 //
 39           //%/////////////////////////////////////////////////////////////////////////////
 40           
 41           #include <Pegasus/Common/Config.h>

 42 chip  1.4 #include <Pegasus/Common/CIMMessage.h>

 43 kumpf 1.1 #include <Pegasus/Common/IPC.h>
 44           #include <Pegasus/Common/OperationContext.h>
 45           #include <Pegasus/Common/DQueue.h>
 46           #include <Pegasus/Common/MessageQueueService.h>
 47           
 48           #ifdef PEGASUS_OS_OS400
 49           #include <qycmutilu2.H>
 50           #include "OS400ConvertChar.h"
 51           #include "CIMOMHandleOS400UserState.h"
 52           #include "CIMOMHandleOS400SystemState.h"
 53           #endif
 54           
 55           #include "CIMOMHandleRep.h"
 56           
 57           PEGASUS_NAMESPACE_BEGIN
 58           

 59 chip  1.4 class InternalCIMOMHandleMessageQueue : public MessageQueue
 60           {
 61           public:
 62               InternalCIMOMHandleMessageQueue();
 63               virtual ~InternalCIMOMHandleMessageQueue();
 64           
 65               virtual void handleEnqueue();
 66           
 67               CIMResponseMessage * sendRequest(CIMRequestMessage * request);
 68           
 69           private:
 70               Uint32 _output_qid;
 71               Uint32 _return_qid;
 72           
 73               Mutex _mutex;
 74               AsyncDQueue<Message> _response;
 75           
 76           };
 77           

 78 kumpf 1.1 /**
 79               InternalCIMOMHandleRep is the default, in-process CIMOMHandle
 80               implementation.  The code was extracted from CIMOMHandle.cpp to allow
 81               for polymorphic CIMOMHandleRep implementations.
 82            */

 83 chip  1.4 class InternalCIMOMHandleRep : public CIMOMHandleRep

 84 kumpf 1.1 {
 85           public:
 86               InternalCIMOMHandleRep();

 87 chip  1.4     #ifdef PEGASUS_OS_OS400

 88 kumpf 1.1     InternalCIMOMHandleRep(Uint32 os400key);

 89 chip  1.4     #endif

 90 kumpf 1.1     virtual ~InternalCIMOMHandleRep();
 91           
 92               virtual CIMClass getClass(
 93                   const OperationContext & context,
 94                   const CIMNamespaceName& nameSpace,
 95                   const CIMName& className,
 96                   Boolean localOnly,
 97                   Boolean includeQualifiers,
 98                   Boolean includeClassOrigin,
 99                   const CIMPropertyList& propertyList);
100           
101               virtual Array<CIMClass> enumerateClasses(
102                   const OperationContext & context,
103                   const CIMNamespaceName& nameSpace,
104                   const CIMName& className,
105                   Boolean deepInheritance,
106                   Boolean localOnly,
107                   Boolean includeQualifiers,
108                   Boolean includeClassOrigin);
109           
110               virtual Array<CIMName> enumerateClassNames(
111 kumpf 1.1         const OperationContext & context,
112                   const CIMNamespaceName& nameSpace,
113                   const CIMName& className,
114                   Boolean deepInheritance);
115           
116               virtual void createClass(
117                   const OperationContext & context,
118                   const CIMNamespaceName& nameSpace,
119                   const CIMClass& newClass);
120           
121               virtual void modifyClass(
122                   const OperationContext & context,
123                   const CIMNamespaceName& nameSpace,
124                   const CIMClass& modifiedClass);
125           
126               virtual void deleteClass(
127                   const OperationContext & context,
128                   const CIMNamespaceName& nameSpace,
129                   const CIMName& className);
130           
131               virtual CIMInstance getInstance(
132 kumpf 1.1         const OperationContext & context,
133                   const CIMNamespaceName& nameSpace,
134                   const CIMObjectPath& instanceName,
135                   Boolean localOnly,
136                   Boolean includeQualifiers,
137                   Boolean includeClassOrigin,
138                   const CIMPropertyList& propertyList);
139           
140               virtual Array<CIMInstance> enumerateInstances(
141                   const OperationContext & context,
142                   const CIMNamespaceName& nameSpace,
143                   const CIMName& className,
144                   Boolean deepInheritance,
145                   Boolean localOnly,
146                   Boolean includeQualifiers,
147                   Boolean includeClassOrigin,
148                   const CIMPropertyList& propertyList);
149           
150               virtual Array<CIMObjectPath> enumerateInstanceNames(
151                   const OperationContext & context,
152                   const CIMNamespaceName& nameSpace,
153 kumpf 1.1         const CIMName& className);
154           
155               virtual CIMObjectPath createInstance(
156                   const OperationContext & context,
157                   const CIMNamespaceName& nameSpace,
158                   const CIMInstance& newInstance);
159           
160               virtual void modifyInstance(
161                   const OperationContext & context,
162                   const CIMNamespaceName& nameSpace,
163                   const CIMInstance& modifiedInstance,
164                   Boolean includeQualifiers,
165                   const CIMPropertyList& propertyList);
166           
167               virtual void deleteInstance(
168                   const OperationContext & context,
169                   const CIMNamespaceName& nameSpace,
170                   const CIMObjectPath& instanceName);
171           
172               virtual Array<CIMObject> execQuery(
173                   const OperationContext & context,
174 kumpf 1.1         const CIMNamespaceName& nameSpace,
175                   const String& queryLanguage,
176                   const String& query);
177           
178               virtual Array<CIMObject> associators(
179                   const OperationContext & context,
180                   const CIMNamespaceName& nameSpace,
181                   const CIMObjectPath& objectName,
182                   const CIMName& assocClass,
183                   const CIMName& resultClass,
184                   const String& role,
185                   const String& resultRole,
186                   Boolean includeQualifiers,
187                   Boolean includeClassOrigin,
188                   const CIMPropertyList& propertyList);
189           
190               virtual Array<CIMObjectPath> associatorNames(
191                   const OperationContext & context,
192                   const CIMNamespaceName& nameSpace,
193                   const CIMObjectPath& objectName,
194                   const CIMName& assocClass,
195 kumpf 1.1         const CIMName& resultClass,
196                   const String& role,
197                   const String& resultRole);
198           
199               virtual Array<CIMObject> references(
200                   const OperationContext & context,
201                   const CIMNamespaceName& nameSpace,
202                   const CIMObjectPath& objectName,
203                   const CIMName& resultClass,
204                   const String& role,
205                   Boolean includeQualifiers,
206                   Boolean includeClassOrigin,
207                   const CIMPropertyList& propertyList);
208           
209               virtual Array<CIMObjectPath> referenceNames(
210                   const OperationContext & context,
211                   const CIMNamespaceName& nameSpace,
212                   const CIMObjectPath& objectName,
213                   const CIMName& resultClass,
214                   const String& role);
215           
216 kumpf 1.1     // property operations
217               virtual CIMValue getProperty(
218                   const OperationContext & context,
219                   const CIMNamespaceName& nameSpace,
220                   const CIMObjectPath& instanceName,
221                   const CIMName& propertyName);
222           
223               virtual void setProperty(
224                   const OperationContext & context,
225                   const CIMNamespaceName& nameSpace,
226                   const CIMObjectPath& instanceName,
227                   const CIMName& propertyName,
228                   const CIMValue& newValue);
229           
230               virtual CIMValue invokeMethod(
231                   const OperationContext & context,
232                   const CIMNamespaceName& nameSpace,
233                   const CIMObjectPath& instanceName,
234                   const CIMName& methodName,
235                   const Array<CIMParamValue>& inParameters,
236                   Array<CIMParamValue>& outParameters);
237 kumpf 1.1 
238               virtual void disallowProviderUnload();  // Overload for OS/400
239               virtual void allowProviderUnload();  // Overload for OS/400
240               virtual OperationContext getResponseContext();
241           

242 chip  1.4     #ifdef PEGASUS_OS_OS400

243 kumpf 1.1     virtual void setOS400ProfileHandle(const char* profileHandle);

244 chip  1.4     #endif

245 kumpf 1.1 
246           private:
247               InternalCIMOMHandleRep(const InternalCIMOMHandleRep& rep);
248               InternalCIMOMHandleRep& operator=(const InternalCIMOMHandleRep& rep);
249           

250 chip  1.4     CIMResponseMessage* do_request(CIMRequestMessage* request);

251 kumpf 1.1 

252 chip  1.4 private:
253               #ifdef PEGASUS_OS_OS400

254 kumpf 1.1     char os400PH[12];
255               CIMOMHandleOS400UserState _chOS400;

256 chip  1.4     #endif
257           
258               InternalCIMOMHandleMessageQueue _queue;
259           

260 kumpf 1.1 };
261           
262           PEGASUS_NAMESPACE_END