1 karl 1.82 //%2006////////////////////////////////////////////////////////////////////////
|
2 marek 1.63 //
3 // 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 // IBM Corp.; EMC Corporation, The Open Group.
7 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.82 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 marek 1.63 //
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.82 //
|
21 marek 1.63 // 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 //%/////////////////////////////////////////////////////////////////////////////
|
33 r.kieninger 1.104.4.2 // NOCHKSRC
|
34 marek 1.63
35 #include "CMPI_Version.h"
36
37 #include "CMPIProviderManager.h"
38
39 #include "CMPI_Object.h"
40 #include "CMPI_ContextArgs.h"
41 #include "CMPI_Instance.h"
42 #include "CMPI_ObjectPath.h"
43 #include "CMPI_Result.h"
44 #include "CMPI_SelectExp.h"
45
46 #include <Pegasus/Common/CIMMessage.h>
47 #include <Pegasus/Common/OperationContext.h>
|
48 a.dunfey 1.85 #include <Pegasus/Common/OperationContextInternal.h>
|
49 marek 1.63 #include <Pegasus/Common/Tracer.h>
50 #include <Pegasus/Common/StatisticalData.h>
51 #include <Pegasus/Common/Logger.h>
|
52 kumpf 1.79 #include <Pegasus/Common/LanguageParser.h>
|
53 marek 1.63 #include <Pegasus/Common/MessageLoader.h> //l10n
54 #include <Pegasus/Common/Constants.h>
|
55 thilo.boehm 1.89 #include <Pegasus/Common/FileSystem.h>
|
56 marek 1.63
57 #include <Pegasus/Config/ConfigManager.h>
58
59 #include <Pegasus/Provider/CIMOMHandleQueryContext.h>
|
60 a.dunfey 1.85 #include <Pegasus/ProviderManager2/CIMOMHandleContext.h>
|
61 marek 1.63 #include <Pegasus/ProviderManager2/ProviderName.h>
|
62 kumpf 1.93 #include <Pegasus/ProviderManager2/AutoPThreadSecurity.h>
|
63 marek 1.63 #include <Pegasus/ProviderManager2/CMPI/CMPIProviderModule.h>
64 #include <Pegasus/ProviderManager2/CMPI/CMPIProvider.h>
65
|
66 kumpf 1.93 PEGASUS_USING_STD;
|
67 marek 1.63
68 PEGASUS_NAMESPACE_BEGIN
69
70 int _cmpi_trace=0;
71
|
72 dave.sudlik 1.96 //Function to throw exception if provider has not been correctly created.
73 void _throw_MINotInitializedException()
74 {
75 MessageLoaderParms parms("ProviderManager.CMPI.CMPIProviderManager.PROVIDER_LOAD_FAILURE","ProviderLoadFailure: Cannot find _Create<mi-type>MI symbol.");
76
77 throw CIMException(CIM_ERR_FAILED,MessageLoader::getMessage(parms));
78 }
79
80
|
81 marek 1.63 #define DDD(x) if (_cmpi_trace) x;
82
|
83 marek 1.95 ReadWriteSem CMPIProviderManager::rwSemProvTab;
84 ReadWriteSem CMPIProviderManager::rwSemSelxTab;
|
85 marek 1.63 CMPIProviderManager::IndProvTab CMPIProviderManager::provTab;
86 CMPIProviderManager::IndSelectTab CMPIProviderManager::selxTab;
87 CMPIProviderManager::ProvRegistrar CMPIProviderManager::provReg;
|
88 marek 1.95
|
89 marek 1.63 class CMPIPropertyList {
90 char **props;
91 int pCount;
92 public:
|
93 w.otsuka 1.86 CMPIPropertyList(CIMPropertyList &propertyList) : props(0), pCount(0) {
|
94 marek 1.63 if (!propertyList.isNull()) {
95 Array<CIMName> p=propertyList.getPropertyNameArray();
96 pCount=p.size();
|
97 aruran.ms 1.71 props = new char*[1+pCount];
|
98 marek 1.63 for (int i=0; i<pCount; i++) {
99 props[i]=strdup(p[i].getString().getCString());
100 }
101 props[pCount]=NULL;
102 }
103 else props=NULL;
104 }
105 ~CMPIPropertyList() {
106 if (props) {
107 for (int i=0; i<pCount; i++)
108 free(props[i]);
|
109 aruran.ms 1.72 delete [] props;
|
110 marek 1.63 }
111 }
|
112 konrad.r 1.64 char **getList() {
|
113 marek 1.63 return props;
114 }
115 };
116
117 CMPIProviderManager::CMPIProviderManager(Mode m)
118 {
119 mode=m;
|
120 w.white 1.75 #ifdef PEGASUS_DEBUG
|
121 konrad.r 1.73 if (getenv("PEGASUS_CMPI_TRACE")) _cmpi_trace=1;
|
122 marek 1.63 else _cmpi_trace=0;
|
123 w.white 1.75 #endif
|
124 marek 1.63 _subscriptionInitComplete = false;
|
125 konrad.r 1.73 DDD(cerr << "-- CMPI Provider Manager activated" << endl);
|
126 marek 1.63 }
127
128 CMPIProviderManager::~CMPIProviderManager(void)
129 {
130 /* Clean up the hash-tables */
131 indProvRecord *prec=NULL;
|
132 marek 1.95 {
133 WriteLock writeLock(rwSemProvTab);
|
134 marek 1.63 for (IndProvTab::Iterator i = provTab.start(); i; i++)
135 {
136 provTab.lookup(i.key(),prec);
137 if (prec->handler)
138 delete prec->handler;
139 delete prec;
|
140 marek 1.78 //Remove is not neccessary, since the hashtable destructor takes care
141 //of this already. But instead removing entries while iterating the
142 //hashtable sometimes causes a segmentation fault!!!
143 //provTab.remove(i.key());
|
144 marek 1.63 prec=NULL;
145 }
|
146 marek 1.95 }
147
|
148 marek 1.63 indSelectRecord *selx=NULL;
|
149 marek 1.95 {
150 WriteLock writeLock(rwSemSelxTab);
|
151 marek 1.63 for (IndSelectTab::Iterator i = selxTab.start(); i; i++)
152 {
153 selxTab.lookup(i.key(), selx);
154 if (selx->eSelx)
155 delete selx->eSelx;
156 if (selx->qContext)
157 delete selx->qContext;
158 delete selx;
|
159 marek 1.78 //Same as above!
160 //selxTab.remove(i.key());
|
161 marek 1.63 selx=NULL;
162 }
|
163 marek 1.95 }
|
164 marek 1.63 }
165
166 Boolean CMPIProviderManager::insertProvider(const ProviderName & name,
167 const String &ns, const String &cn)
168 {
169 String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());
170 return provReg.insert(key,name);
171 }
172
173
174 Message * CMPIProviderManager::processMessage(Message * request)
175 {
176 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
177 "CMPIProviderManager::processMessage()");
178
179 Message * response = 0;
180
181 // pass the request message to a handler method based on message type
182 switch(request->getType())
183 {
184 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
185 marek 1.63 response = handleGetInstanceRequest(request);
186
187 break;
188 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
189 response = handleEnumerateInstancesRequest(request);
190
191 break;
192 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
193 response = handleEnumerateInstanceNamesRequest(request);
194
195 break;
196 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
197 response = handleCreateInstanceRequest(request);
198
199 break;
200 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
201 response = handleModifyInstanceRequest(request);
202
203 break;
204 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
205 response = handleDeleteInstanceRequest(request);
206 marek 1.63
207 break;
208 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
209 response = handleExecQueryRequest(request);
210
211 break;
212 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
213 response = handleAssociatorsRequest(request);
214
215 break;
216 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
217 response = handleAssociatorNamesRequest(request);
218
219 break;
220 case CIM_REFERENCES_REQUEST_MESSAGE:
221 response = handleReferencesRequest(request);
222
223 break;
224 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
225 response = handleReferenceNamesRequest(request);
226
227 marek 1.63 break;
228 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
229 response = handleInvokeMethodRequest(request);
230
231 break;
232 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
233 response = handleCreateSubscriptionRequest(request);
234
235 break;
236 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
237 response = handleModifySubscriptionRequest(request);
238
239 break;
240 */ case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
241 response = handleDeleteSubscriptionRequest(request);
242
243 break;
244 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
245 response = handleExportIndicationRequest(request);
246 break;
247 */
248 marek 1.63 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
249 response = handleDisableModuleRequest(request);
250
251 break;
252 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
253 response = handleEnableModuleRequest(request);
254
255 break;
256 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
257 response = handleStopAllProvidersRequest(request);
258
259 break;
260 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
261 response = handleInitializeProviderRequest(request);
262
263 break;
264 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
265 response = handleSubscriptionInitCompleteRequest (request);
266
267 break;
|
268 dave.sudlik 1.98 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
269 response = handleGetPropertyRequest(request);
270
271 break;
272 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
273 response = handleSetPropertyRequest(request);
274
275 break;
|
276 marek 1.63 default:
277 response = handleUnsupportedRequest(request);
278
279 break;
280 }
281
282 PEG_METHOD_EXIT();
283
284 return(response);
285 }
286
287 Boolean CMPIProviderManager::hasActiveProviders()
288 {
289 return providerManager.hasActiveProviders();
290 }
291
292 void CMPIProviderManager::unloadIdleProviders()
293 {
294 providerManager.unloadIdleProviders();
295 }
296
297 marek 1.63
298 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
299
300
|
301 kumpf 1.92 #define HandlerIntroBase(type,type1,message,request,response,handler) \
|
302 marek 1.63 CIM##type##RequestMessage * request = \
303 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
304 PEGASUS_ASSERT(request != 0); \
305 CIM##type##ResponseMessage * response = \
|
306 kumpf 1.92 dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \
|
307 marek 1.63 PEGASUS_ASSERT(response != 0); \
|
308 kumpf 1.84 type1##ResponseHandler handler(request, response, _responseChunkCallback);
|
309 marek 1.63
310 #define HandlerIntroInd(type,message,request,response,handler) \
|
311 kumpf 1.92 HandlerIntroBase(type,Operation,message,request,response,handler)
|
312 marek 1.63
313 #define HandlerIntroInit(type,message,request,response,handler) \
|
314 kumpf 1.92 HandlerIntroBase(type,Operation,message,request,response,handler)
|
315 marek 1.63
|
316 kumpf 1.92 #define HandlerIntro(type,message,request,response,handler) \
317 HandlerIntroBase(type,type,message,request,response,handler)
|
318 marek 1.63
319 #define HandlerCatch(handler) \
|
320 konrad.r 1.64 catch(const CIMException & e) \
|
321 marek 1.63 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
322 "Exception: " + e.getMessage()); \
|
323 dave.sudlik 1.103 handler.setCIMException(e); \
|
324 marek 1.63 } \
|
325 konrad.r 1.64 catch(const Exception & e) \
|
326 marek 1.63 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
327 "Exception: " + e.getMessage()); \
328 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
329 } \
330 catch(...) \
|
331 marek 1.104.4.1 { PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
|
332 marek 1.63 "Exception: Unknown"); \
333 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
334 }
335
336
337
338 Message * CMPIProviderManager::handleGetInstanceRequest(const Message * message)
339 {
340 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
341 "CMPIProviderManager::handleGetInstanceRequest");
342
|
343 kumpf 1.92 HandlerIntro(GetInstance,message,request,response,handler);
|
344 marek 1.63
345 try {
346 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
347 "CmpiProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
348 System::getHostName(),
349 request->nameSpace.getString(),
350 request->instanceName.getClassName().getString());
351
352 // make target object path
353 CIMObjectPath objectPath(
354 System::getHostName(),
355 request->nameSpace,
356 request->instanceName.getClassName(),
357 request->instanceName.getKeyBindings());
358
359 Boolean remote=false;
360 CMPIProvider::OpProviderHolder ph;
361
362 // resolve provider name
363 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
|
364 a.dunfey 1.85
|
365 marek 1.63 ProviderName name = _resolveProviderName(pidc);
366
367 if ((remote=pidc.isRemoteNameSpace())) {
368 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
|
369 a.dunfey 1.85 }
370 else {
371 // get cached or load new provider module
372 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
|
373 marek 1.63 }
374
375 // convert arguments
376 OperationContext context;
377
378 context.insert(request->operationContext.get(IdentityContainer::NAME));
379 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
380 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
381 // forward request
382 CMPIProvider & pr=ph.GetProvider();
383
|
384 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
385 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
386 // If normalization is enabled, then the normalizer will take care of
387 // any EmbeddedInstance / EmbeddedObject mismatches, and we don't need
388 // to add a NormalizerContextContainer. The presence of an
389 // ObjectNormalizer is determined by the presence of the
390 // CachedClassDefinitionContainer
|
391 a.dunfey 1.88 if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
392 {
|
393 a.dunfey 1.85 request->operationContext.get(CachedClassDefinitionContainer::NAME);
394 }
|
395 a.dunfey 1.88 else
|
396 a.dunfey 1.85 #endif // PEGASUS_ENABLE_OBJECT_NORMALIZATION
397 {
398 // If a mechanism is needed to correct mismatches between the
399 // EmbeddedInstance and EmbeddedObject types, then insert
400 // containers for the class definition and a NormalizerContext.
401 AutoPtr<NormalizerContext> tmpNormalizerContext(
402 new CIMOMHandleContext(*pr._cimom_handle));
403 CIMClass classDef(tmpNormalizerContext->getClass(
404 request->nameSpace, request->className));
405 request->operationContext.insert(CachedClassDefinitionContainer(classDef));
406 request->operationContext.insert(
407 NormalizerContextContainer(tmpNormalizerContext));
408 }
409 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
410
|
411 marek 1.63 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
412 "Calling provider.getInstance: " + pr.getName());
413
414 DDD(cerr<<"--- CMPIProviderManager::getInstance"<<endl);
415
416 CMPIStatus rc={CMPI_RC_OK,NULL};
417 CMPI_ContextOnStack eCtx(context);
418 CMPI_ObjectPathOnStack eRef(objectPath);
419 CMPI_ResultOnStack eRes(handler,&pr.broker);
420 CMPI_ThreadContext thr(&pr.broker,&eCtx);
421
422 CMPIPropertyList props(request->propertyList);
423
424 CMPIFlags flgs=0;
425 if (request->includeQualifiers) flgs|=CMPI_FLAG_IncludeQualifiers;
426 if (request->includeClassOrigin) flgs|=CMPI_FLAG_IncludeClassOrigin;
427 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
428
429 const IdentityContainer container =
430 request->operationContext.get(IdentityContainer::NAME);
431 eCtx.ft->addEntry(&eCtx,
432 marek 1.63 CMPIPrincipal,
433 (CMPIValue*)(const char*)container.getUserName().getCString(),
434 CMPI_chars);
435
|
436 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
437 request->operationContext.get(AcceptLanguageListContainer::NAME);
|
438 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
439 konrad.r 1.67
|
440 kumpf 1.79 eCtx.ft->addEntry(
441 &eCtx,
|
442 dave.sudlik 1.99 CMPIAcceptLanguage,
|
443 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
444 acceptLangs).getCString(),
445 CMPI_chars);
|
446 konrad.r 1.65
|
447 marek 1.63 if (remote) {
448 CString info=pidc.getRemoteInfo().getCString();
449 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
450 }
451
452 CMPIProvider::pm_service_op_lock op_lock(&pr);
453
|
454 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
455 marek 1.63
|
456 dave.sudlik 1.96 if (pr.miVector.instMI==0)
457 {
458 _throw_MINotInitializedException();
459 }
460
|
461 kumpf 1.92 {
462 StatProviderTimeMeasurement providerTime(response);
|
463 marek 1.63
|
464 kumpf 1.92 rc = pr.miVector.instMI->ft->getInstance(
465 pr.miVector.instMI,&eCtx,&eRes,&eRef,
466 (const char **)props.getList());
467 }
|
468 marek 1.63
|
469 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
470 // Do this before checking rc from provider to throw exception in case
471 // rc.msg is also localized.
472 CMPIStatus tmprc={CMPI_RC_OK,NULL};
473 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
474 if (tmprc.rc == CMPI_RC_OK)
475 {
476 response->operationContext.set(
477 ContentLanguageListContainer(
478 ContentLanguageList(
|
479 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
480 CMGetCharPtr(cldata.value.string)))));
481 handler.setContext(response->operationContext);
|
482 dave.sudlik 1.99 }
483
|
484 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
485 dave.sudlik 1.102 {
486 CIMException cimException(
487 (CIMStatusCode)rc.rc,
|
488 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
489 dave.sudlik 1.102
490 if (eRes.resError)
491 {
492 for (CMPI_Error* currErr=eRes.resError;
493 currErr!=NULL;
494 currErr=currErr->nextError)
495 {
496 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
497 }
498 }
499 throw cimException;
500 }
|
501 marek 1.63 }
502 HandlerCatch(handler);
503
504 PEG_METHOD_EXIT();
505
506 return(response);
507 }
508
509 Message * CMPIProviderManager::handleEnumerateInstancesRequest(const Message * message)
510 {
511 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
512 "CMPIProviderManager::handleEnumerateInstanceRequest");
513
|
514 kumpf 1.92 HandlerIntro(EnumerateInstances,message,request,response,handler);
|
515 marek 1.63 try {
516 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
517 "CMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
518 System::getHostName(),
519 request->nameSpace.getString(),
520 request->className.getString());
521
522 // make target object path
523 CIMObjectPath objectPath(
524 System::getHostName(),
525 request->nameSpace,
526 request->className);
527
528 Boolean remote=false;
529 CMPIProvider::OpProviderHolder ph;
530
531 // resolve provider name
532 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
533 ProviderName name = _resolveProviderName(pidc);
534
535 if ((remote=pidc.isRemoteNameSpace())) {
536 marek 1.63 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
537 }
538 else {
539 // get cached or load new provider module
540 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
541 }
542
543 // convert arguments
544 OperationContext context;
545
546 context.insert(request->operationContext.get(IdentityContainer::NAME));
547 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
548 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
549
550 CIMPropertyList propertyList(request->propertyList);
551
552 // forward request
553 CMPIProvider & pr=ph.GetProvider();
554
|
555 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
556 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
557 // If normalization is enabled, then the normalizer will take care of
558 // any EmbeddedInstance / EmbeddedObject mismatches, and we don't need
559 // to add a NormalizerContextContainer. The presence of an
560 // ObjectNormalizer is determined by the presence of the
561 // CachedClassDefinitionContainer
|
562 a.dunfey 1.88 if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
563 {
|
564 a.dunfey 1.85 request->operationContext.get(CachedClassDefinitionContainer::NAME);
565 }
|
566 a.dunfey 1.88 else
|
567 a.dunfey 1.85 #endif // PEGASUS_ENABLE_OBJECT_NORMALIZATION
568 {
569 // If a mechanism is needed to correct mismatches between the
570 // EmbeddedInstance and EmbeddedObject types, then insert
571 // containers for the class definition and a NormalizerContext.
572 AutoPtr<NormalizerContext> tmpNormalizerContext(
573 new CIMOMHandleContext(*pr._cimom_handle));
574 CIMClass classDef(tmpNormalizerContext->getClass(
575 request->nameSpace, request->className));
576 request->operationContext.insert(CachedClassDefinitionContainer(classDef));
577 request->operationContext.insert(
578 NormalizerContextContainer(tmpNormalizerContext));
579 }
580 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
581
|
582 marek 1.63 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
583 "Calling provider.enumerateInstances: " + pr.getName());
584
585 DDD(cerr<<"--- CMPIProviderManager::enumerateInstances"<<endl);
586
587 CMPIStatus rc={CMPI_RC_OK,NULL};
588 CMPI_ContextOnStack eCtx(context);
589 CMPI_ObjectPathOnStack eRef(objectPath);
590 CMPI_ResultOnStack eRes(handler,&pr.broker);
591 CMPI_ThreadContext thr(&pr.broker,&eCtx);
592
593 CMPIPropertyList props(propertyList);
594
595 CMPIFlags flgs=0;
596 if (request->includeQualifiers) flgs|=CMPI_FLAG_IncludeQualifiers;
597 if (request->includeClassOrigin) flgs|=CMPI_FLAG_IncludeClassOrigin;
598 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
599
600 const IdentityContainer container =
601 request->operationContext.get(IdentityContainer::NAME);
602 eCtx.ft->addEntry(&eCtx,
603 marek 1.63 CMPIPrincipal,
604 (CMPIValue*)(const char*)container.getUserName().getCString(),
605 CMPI_chars);
606
|
607 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
608 request->operationContext.get(AcceptLanguageListContainer::NAME);
609
|
610 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
611 kumpf 1.79 eCtx.ft->addEntry(
612 &eCtx,
|
613 dave.sudlik 1.99 CMPIAcceptLanguage,
|
614 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
615 acceptLangs).getCString(),
616 CMPI_chars);
|
617 marek 1.63 if (remote) {
618 CString info=pidc.getRemoteInfo().getCString();
619 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
620 }
621
622 CMPIProvider::pm_service_op_lock op_lock(&pr);
623
|
624 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
625 marek 1.63
|
626 dave.sudlik 1.96 if (pr.miVector.instMI==0)
627 {
628 _throw_MINotInitializedException();
629 }
630
|
631 kumpf 1.92 {
632 StatProviderTimeMeasurement providerTime(response);
|
633 marek 1.63
|
634 kumpf 1.92 rc = pr.miVector.instMI->ft->enumInstances(
635 pr.miVector.instMI,&eCtx,&eRes,&eRef,
636 (const char **)props.getList());
637 }
|
638 marek 1.63
|
639 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
640 // Do this before checking rc from provider to throw exception in case
641 // rc.msg is also localized.
642 CMPIStatus tmprc={CMPI_RC_OK,NULL};
643 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
644 if (tmprc.rc == CMPI_RC_OK)
645 {
646 response->operationContext.set(
647 ContentLanguageListContainer(
648 ContentLanguageList(
|
649 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
650 CMGetCharPtr(cldata.value.string)))));
651 handler.setContext(response->operationContext);
|
652 dave.sudlik 1.99 }
653
|
654 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
655 dave.sudlik 1.102 {
656 CIMException cimException(
657 (CIMStatusCode)rc.rc,
|
658 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
659
|
660 dave.sudlik 1.102 if (eRes.resError)
661 {
662 for (CMPI_Error* currErr=eRes.resError;
663 currErr!=NULL;
664 currErr=currErr->nextError)
665 {
666 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
667 }
668 }
669 throw cimException;
670 }
671
|
672 marek 1.63 }
673 HandlerCatch(handler);
674
675 PEG_METHOD_EXIT();
676
677 return(response);
678 }
679
680 Message * CMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message)
681 {
682 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleEnumerateInstanceNamesRequest");
683
|
684 kumpf 1.92 HandlerIntro(EnumerateInstanceNames,message,request,response,handler);
|
685 marek 1.63 try {
686 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
687 "CMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
688 System::getHostName(),
689 request->nameSpace.getString(),
690 request->className.getString());
691
692 // make target object path
693 CIMObjectPath objectPath(
694 System::getHostName(),
695 request->nameSpace,
696 request->className);
697
698 Boolean remote=false;
699 CMPIProvider::OpProviderHolder ph;
700
701 // resolve provider name
702 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
703 ProviderName name = _resolveProviderName(pidc);
704
705 if ((remote=pidc.isRemoteNameSpace())) {
706 marek 1.63 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
707 }
708 else {
709 // get cached or load new provider module
710 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
711 }
712
713 // convert arguments
714 OperationContext context;
715
716 context.insert(request->operationContext.get(IdentityContainer::NAME));
717 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
718 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
719 CMPIProvider & pr=ph.GetProvider();
720
721 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
722 "Calling provider.enumerateInstanceNames: " + pr.getName());
723
724 DDD(cerr<<"--- CMPIProviderManager::enumerateInstanceNames"<<endl);
725
726 CMPIStatus rc={CMPI_RC_OK,NULL};
727 marek 1.63 CMPI_ContextOnStack eCtx(context);
728 CMPI_ObjectPathOnStack eRef(objectPath);
729 CMPI_ResultOnStack eRes(handler,&pr.broker);
730 CMPI_ThreadContext thr(&pr.broker,&eCtx);
731
732 CMPIFlags flgs=0;
733 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
734
735 const IdentityContainer container =
736 request->operationContext.get(IdentityContainer::NAME);
737 eCtx.ft->addEntry(&eCtx,
738 CMPIPrincipal,
739 (CMPIValue*)(const char*)container.getUserName().getCString(),
740 CMPI_chars);
741
|
742 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
743 request->operationContext.get(AcceptLanguageListContainer::NAME);
744
|
745 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
746 kumpf 1.79 eCtx.ft->addEntry(
747 &eCtx,
|
748 dave.sudlik 1.99 CMPIAcceptLanguage,
|
749 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
750 acceptLangs).getCString(),
751 CMPI_chars);
|
752 marek 1.63 if (remote) {
753 CString info=pidc.getRemoteInfo().getCString();
754 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
755 }
756
757 CMPIProvider::pm_service_op_lock op_lock(&pr);
758
|
759 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
760 marek 1.90
|
761 dave.sudlik 1.96 if (pr.miVector.instMI==0)
762 {
763 _throw_MINotInitializedException();
764 }
765
|
766 kumpf 1.92 {
767 StatProviderTimeMeasurement providerTime(response);
|
768 marek 1.63
|
769 kumpf 1.92 rc = pr.miVector.instMI->ft->enumInstanceNames(
770 pr.miVector.instMI,&eCtx,&eRes,&eRef);
771 }
|
772 marek 1.63
|
773 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
774 // Do this before checking rc from provider to throw exception in case
775 // rc.msg is also localized.
776 CMPIStatus tmprc={CMPI_RC_OK,NULL};
777 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
778 if (tmprc.rc == CMPI_RC_OK)
779 {
780 response->operationContext.set(
781 ContentLanguageListContainer(
782 ContentLanguageList(
|
783 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
784 CMGetCharPtr(cldata.value.string)))));
785 handler.setContext(response->operationContext);
|
786 dave.sudlik 1.99 }
787
|
788 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
789 dave.sudlik 1.102 {
790 CIMException cimException(
791 (CIMStatusCode)rc.rc,
|
792 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
793 dave.sudlik 1.102
794 if (eRes.resError)
795 {
796 for (CMPI_Error* currErr=eRes.resError;
797 currErr!=NULL;
798 currErr=currErr->nextError)
799 {
800 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
801 }
802 }
803 throw cimException;
804 }
|
805 marek 1.63 }
806 HandlerCatch(handler);
807
808 PEG_METHOD_EXIT();
809
810 return(response);
811 }
812
813 Message * CMPIProviderManager::handleCreateInstanceRequest(const Message * message)
814 {
815 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
816 "CMPIProviderManager::handleCreateInstanceRequest");
817
|
818 kumpf 1.92 HandlerIntro(CreateInstance,message,request,response,handler);
|
819 marek 1.63 try {
820 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
821 "CMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
822 System::getHostName(),
823 request->nameSpace.getString(),
824 request->newInstance.getPath().getClassName().getString());
825
826 // make target object path
827 CIMObjectPath objectPath(
828 System::getHostName(),
829 request->nameSpace,
830 request->newInstance.getPath().getClassName(),
831 request->newInstance.getPath().getKeyBindings());
832 request->newInstance.setPath(objectPath);
833
834 Boolean remote=false;
835 CMPIProvider::OpProviderHolder ph;
836
837 // resolve provider name
838 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
839 ProviderName name = _resolveProviderName(pidc);
840 marek 1.63
841 if ((remote=pidc.isRemoteNameSpace())) {
842 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
843 }
844 else {
845 // get cached or load new provider module
846 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
847 }
848
849 // convert arguments
850 OperationContext context;
851
852 context.insert(request->operationContext.get(IdentityContainer::NAME));
853 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
854 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
855 // forward request
856 CMPIProvider & pr=ph.GetProvider();
857
858 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
859 "Calling provider.createInstance: " +
860 ph.GetProvider().getName());
861 marek 1.63
862 DDD(cerr<<"--- CMPIProviderManager::createInstances"<<endl);
863 CMPIStatus rc={CMPI_RC_OK,NULL};
864 CMPI_ContextOnStack eCtx(context);
865 CMPI_ObjectPathOnStack eRef(objectPath);
866 CMPI_ResultOnStack eRes(handler,&pr.broker);
867 CMPI_InstanceOnStack eInst(request->newInstance);
868 CMPI_ThreadContext thr(&pr.broker,&eCtx);
869
870 CMPIFlags flgs=0;
871 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
872
873 const IdentityContainer container =
874 request->operationContext.get(IdentityContainer::NAME);
875 eCtx.ft->addEntry(&eCtx,
876 CMPIPrincipal,
877 (CMPIValue*)(const char*)container.getUserName().getCString(),
878 CMPI_chars);
879
|
880 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
881 request->operationContext.get(AcceptLanguageListContainer::NAME);
882
|
883 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
884 kumpf 1.79 eCtx.ft->addEntry(
885 &eCtx,
|
886 dave.sudlik 1.99 CMPIAcceptLanguage,
|
887 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
888 acceptLangs).getCString(),
889 CMPI_chars);
|
890 marek 1.63 if (remote) {
891 CString info=pidc.getRemoteInfo().getCString();
892 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
893 }
894
895 CMPIProvider::pm_service_op_lock op_lock(&pr);
896
|
897 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
898 marek 1.63
|
899 dave.sudlik 1.96 if (pr.miVector.instMI==0)
900 {
901 _throw_MINotInitializedException();
902 }
903
|
904 kumpf 1.92 {
905 StatProviderTimeMeasurement providerTime(response);
|
906 marek 1.63
|
907 kumpf 1.92 rc = pr.miVector.instMI->ft->createInstance(
908 pr.miVector.instMI,&eCtx,&eRes,&eRef,&eInst);
909 }
|
910 marek 1.63
|
911 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
912 // Do this before checking rc from provider to throw exception in case
913 // rc.msg is also localized.
914 CMPIStatus tmprc={CMPI_RC_OK,NULL};
915 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
916 if (tmprc.rc == CMPI_RC_OK)
917 {
918 response->operationContext.set(
919 ContentLanguageListContainer(
920 ContentLanguageList(
|
921 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
922 CMGetCharPtr(cldata.value.string)))));
923 handler.setContext(response->operationContext);
|
924 dave.sudlik 1.99 }
925
|
926 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
927 dave.sudlik 1.102 {
928 CIMException cimException(
929 (CIMStatusCode)rc.rc,
|
930 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
931 dave.sudlik 1.102
932 if (eRes.resError)
933 {
934 for (CMPI_Error* currErr=eRes.resError;
935 currErr!=NULL;
936 currErr=currErr->nextError)
937 {
938 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
939 }
940 }
941 throw cimException;
942 }
|
943 marek 1.63 }
944 HandlerCatch(handler);
945
946 PEG_METHOD_EXIT();
947
948 return(response);
949 }
950
951 Message * CMPIProviderManager::handleModifyInstanceRequest(const Message * message)
952 {
953 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
954 "CMPIProviderManager::handleModifyInstanceRequest");
955
|
956 kumpf 1.92 HandlerIntro(ModifyInstance,message,request,response,handler);
|
957 marek 1.63 try {
958 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
959 "CMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
960 System::getHostName(),
961 request->nameSpace.getString(),
962 request->modifiedInstance.getPath().getClassName().getString());
963
964 // make target object path
965 CIMObjectPath objectPath(
966 System::getHostName(),
967 request->nameSpace,
968 request->modifiedInstance.getPath ().getClassName(),
969 request->modifiedInstance.getPath ().getKeyBindings());
970
971 Boolean remote=false;
972 CMPIProvider::OpProviderHolder ph;
973
974 // resolve provider name
975 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
976 ProviderName name = _resolveProviderName(pidc);
977
978 marek 1.63 if ((remote=pidc.isRemoteNameSpace())) {
979 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
980 }
981 else {
982 // get cached or load new provider module
983 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
984 }
985
986 // convert arguments
987 OperationContext context;
988
989 context.insert(request->operationContext.get(IdentityContainer::NAME));
990 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
991 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
992 // forward request
993 CMPIProvider & pr=ph.GetProvider();
994
995 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
996 "Calling provider.modifyInstance: " + pr.getName());
997
998 DDD(cerr<<"--- CMPIProviderManager::modifyInstance"<<endl);
999 marek 1.63
1000 CMPIStatus rc={CMPI_RC_OK,NULL};
1001 CMPI_ContextOnStack eCtx(context);
1002 CMPI_ObjectPathOnStack eRef(objectPath);
1003 CMPI_ResultOnStack eRes(handler,&pr.broker);
1004 CMPI_InstanceOnStack eInst(request->modifiedInstance);
1005 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1006
1007 CMPIPropertyList props(request->propertyList);
1008
1009 CMPIFlags flgs=0;
1010 if (request->includeQualifiers) flgs|=CMPI_FLAG_IncludeQualifiers;
1011 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1012
1013 const IdentityContainer container =
1014 request->operationContext.get(IdentityContainer::NAME);
1015 eCtx.ft->addEntry(&eCtx,
1016 CMPIPrincipal,
1017 (CMPIValue*)(const char*)container.getUserName().getCString(),
1018 CMPI_chars);
1019
|
1020 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1021 request->operationContext.get(AcceptLanguageListContainer::NAME);
|
1022 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1023 kumpf 1.79 eCtx.ft->addEntry(
1024 &eCtx,
|
1025 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1026 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1027 acceptLangs).getCString(),
1028 CMPI_chars);
|
1029 konrad.r 1.67
|
1030 marek 1.63 if (remote) {
1031 CString info=pidc.getRemoteInfo().getCString();
1032 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1033 }
1034
1035 CMPIProvider::pm_service_op_lock op_lock(&pr);
1036
|
1037 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1038 marek 1.63
|
1039 dave.sudlik 1.96 if (pr.miVector.instMI==0)
1040 {
1041 _throw_MINotInitializedException();
1042 }
1043
|
1044 kumpf 1.92 {
1045 StatProviderTimeMeasurement providerTime(response);
|
1046 marek 1.63
|
1047 kumpf 1.92 rc = pr.miVector.instMI->ft->modifyInstance(
1048 pr.miVector.instMI,&eCtx,&eRes,&eRef,&eInst,
1049 (const char **)props.getList());
1050 }
|
1051 marek 1.63
|
1052 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1053 // Do this before checking rc from provider to throw exception in case
1054 // rc.msg is also localized.
1055 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1056 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1057 if (tmprc.rc == CMPI_RC_OK)
1058 {
1059 response->operationContext.set(
1060 ContentLanguageListContainer(
1061 ContentLanguageList(
|
1062 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1063 CMGetCharPtr(cldata.value.string)))));
1064 handler.setContext(response->operationContext);
|
1065 dave.sudlik 1.99 }
1066
|
1067 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
1068 dave.sudlik 1.102 {
1069 CIMException cimException(
1070 (CIMStatusCode)rc.rc,
|
1071 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
1072 dave.sudlik 1.102
1073 if (eRes.resError)
1074 {
1075 for (CMPI_Error* currErr=eRes.resError;
1076 currErr!=NULL;
1077 currErr=currErr->nextError)
1078 {
1079 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
1080 }
1081 }
1082 throw cimException;
1083 }
|
1084 marek 1.63 }
1085 HandlerCatch(handler);
1086
1087 PEG_METHOD_EXIT();
1088
1089 return(response);
1090 }
1091
1092 Message * CMPIProviderManager::handleDeleteInstanceRequest(const Message * message)
1093 {
1094 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1095 "CMPIProviderManager::handleDeleteInstanceRequest");
1096
|
1097 kumpf 1.92 HandlerIntro(DeleteInstance,message,request,response,handler);
|
1098 marek 1.63 try {
1099 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1100 "CMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
1101 System::getHostName(),
1102 request->nameSpace.getString(),
1103 request->instanceName.getClassName().getString());
1104
1105 // make target object path
1106 CIMObjectPath objectPath(
1107 System::getHostName(),
1108 request->nameSpace,
1109 request->instanceName.getClassName(),
1110 request->instanceName.getKeyBindings());
1111
1112 Boolean remote=false;
1113 CMPIProvider::OpProviderHolder ph;
1114
1115 // resolve provider name
1116 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
1117 ProviderName name = _resolveProviderName(pidc);
1118
1119 marek 1.63 if ((remote=pidc.isRemoteNameSpace())) {
1120 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
1121 }
1122 else {
1123 // get cached or load new provider module
1124 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1125 }
1126
1127 // convert arguments
1128 OperationContext context;
1129
1130 context.insert(request->operationContext.get(IdentityContainer::NAME));
1131 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1132 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1133 // forward request
1134 CMPIProvider & pr=ph.GetProvider();
1135
1136 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1137 "Calling provider.deleteInstance: " + pr.getName());
1138
1139 CMPIStatus rc={CMPI_RC_OK,NULL};
1140 marek 1.63 CMPI_ContextOnStack eCtx(context);
1141 CMPI_ObjectPathOnStack eRef(objectPath);
1142 CMPI_ResultOnStack eRes(handler,&pr.broker);
1143 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1144
1145 CMPIFlags flgs=0;
1146 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1147
1148 const IdentityContainer container =
1149 request->operationContext.get(IdentityContainer::NAME);
1150 eCtx.ft->addEntry(&eCtx,
1151 CMPIPrincipal,
1152 (CMPIValue*)(const char*)container.getUserName().getCString(),
1153 CMPI_chars);
1154
|
1155 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1156 request->operationContext.get(AcceptLanguageListContainer::NAME);
1157
|
1158 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1159 kumpf 1.79 eCtx.ft->addEntry(
1160 &eCtx,
|
1161 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1162 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1163 acceptLangs).getCString(),
1164 CMPI_chars);
|
1165 marek 1.63 if (remote) {
1166 CString info=pidc.getRemoteInfo().getCString();
1167 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1168 }
1169
1170 CMPIProvider::pm_service_op_lock op_lock(&pr);
1171
|
1172 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1173 marek 1.63
|
1174 dave.sudlik 1.96 if (pr.miVector.instMI==0)
1175 {
1176 _throw_MINotInitializedException();
1177 }
1178
|
1179 kumpf 1.92 {
1180 StatProviderTimeMeasurement providerTime(response);
|
1181 marek 1.63
|
1182 kumpf 1.92 rc = pr.miVector.instMI->ft->deleteInstance(
1183 pr.miVector.instMI,&eCtx,&eRes,&eRef);
1184 }
|
1185 marek 1.63
|
1186 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1187 // Do this before checking rc from provider to throw exception in case
1188 // rc.msg is also localized.
1189 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1190 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1191 if (tmprc.rc == CMPI_RC_OK)
1192 {
1193 response->operationContext.set(
1194 ContentLanguageListContainer(
1195 ContentLanguageList(
|
1196 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1197 CMGetCharPtr(cldata.value.string)))));
1198 handler.setContext(response->operationContext);
|
1199 dave.sudlik 1.99 }
1200
|
1201 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
1202 dave.sudlik 1.102 {
1203 CIMException cimException(
1204 (CIMStatusCode)rc.rc,
|
1205 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
1206 dave.sudlik 1.102
1207 if (eRes.resError)
1208 {
1209 for (CMPI_Error* currErr=eRes.resError;
1210 currErr!=NULL;
1211 currErr=currErr->nextError)
1212 {
1213 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
1214 }
1215 }
1216 throw cimException;
1217 }
|
1218 marek 1.63 }
1219 HandlerCatch(handler);
1220
1221 PEG_METHOD_EXIT();
1222
1223 return(response);
1224 }
1225
1226 Message * CMPIProviderManager::handleExecQueryRequest(const Message * message)
1227 {
1228 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1229 "CMPIProviderManager::handleExecQueryRequest");
1230
|
1231 kumpf 1.92 HandlerIntro(ExecQuery,message,request,response,handler);
|
1232 marek 1.63
1233 try {
1234 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1235 "CMPIProviderManager::ExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",
1236 System::getHostName(),
1237 request->nameSpace.getString(),
1238 request->className.getString());
1239
1240 // make target object path
1241 CIMObjectPath objectPath(
1242 System::getHostName(),
1243 request->nameSpace,
1244 request->className);
1245
1246 Boolean remote=false;
1247
1248 CMPIProvider::OpProviderHolder ph;
1249
1250 // resolve provider name
1251 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
1252 ProviderName name = _resolveProviderName(pidc);
1253 marek 1.63
1254 if ((remote=pidc.isRemoteNameSpace())) {
1255 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
1256 }
1257 else {
1258 // get cached or load new provider module
1259 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1260 }
1261
1262 // convert arguments
1263 OperationContext context;
1264
1265 context.insert(request->operationContext.get(IdentityContainer::NAME));
1266 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1267 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1268
1269 // forward request
1270 CMPIProvider & pr=ph.GetProvider();
1271
1272 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1273 "Calling provider.execQuery: " + pr.getName());
1274 marek 1.63
1275 DDD(cerr<<"--- CMPIProviderManager::execQuery"<<endl);
1276
1277 const char **props=NULL;
1278
1279 CMPIStatus rc={CMPI_RC_OK,NULL};
1280 CMPI_ContextOnStack eCtx(context);
1281 CMPI_ObjectPathOnStack eRef(objectPath);
1282 CMPI_ResultOnStack eRes(handler,&pr.broker);
1283 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1284
1285 const CString queryLan=request->queryLanguage.getCString();
1286 const CString query=request->query.getCString();
1287
1288 CMPIFlags flgs=0;
1289 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1290
1291 const IdentityContainer container =
1292 request->operationContext.get(IdentityContainer::NAME);
1293 eCtx.ft->addEntry(&eCtx,
1294 CMPIPrincipal,
1295 marek 1.63 (CMPIValue*)(const char*)container.getUserName().getCString(),
1296 CMPI_chars);
1297 eCtx.ft->addEntry(&eCtx,
|
1298 konrad.r 1.66 CMPIInitNameSpace,
|
1299 marek 1.63 (CMPIValue*)(const char*)request->nameSpace.getString().getCString(),
1300 CMPI_chars);
|
1301 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1302 request->operationContext.get(AcceptLanguageListContainer::NAME);
1303
|
1304 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1305 kumpf 1.79 eCtx.ft->addEntry(
1306 &eCtx,
|
1307 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1308 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1309 acceptLangs).getCString(),
1310 CMPI_chars);
|
1311 marek 1.63 if (remote) {
1312 CString info=pidc.getRemoteInfo().getCString();
1313 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1314 }
1315
1316 CMPIProvider::pm_service_op_lock op_lock(&pr);
1317
|
1318 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1319 marek 1.63
|
1320 dave.sudlik 1.96 if (pr.miVector.instMI==0)
1321 {
1322 _throw_MINotInitializedException();
1323 }
1324
|
1325 kumpf 1.92 {
1326 StatProviderTimeMeasurement providerTime(response);
|
1327 marek 1.63
|
1328 kumpf 1.92 rc = pr.miVector.instMI->ft->execQuery(
1329 pr.miVector.instMI,&eCtx,&eRes,&eRef,
1330 CHARS(queryLan),CHARS(query));
1331 }
|
1332 marek 1.63
|
1333 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1334 // Do this before checking rc from provider to throw exception in case
1335 // rc.msg is also localized.
1336 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1337 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1338 if (tmprc.rc == CMPI_RC_OK)
1339 {
1340 response->operationContext.set(
1341 ContentLanguageListContainer(
1342 ContentLanguageList(
|
1343 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1344 CMGetCharPtr(cldata.value.string)))));
1345 handler.setContext(response->operationContext);
|
1346 dave.sudlik 1.99 }
1347
|
1348 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
1349 dave.sudlik 1.102 {
1350 CIMException cimException(
1351 (CIMStatusCode)rc.rc,
|
1352 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
1353
|
1354 dave.sudlik 1.102 if (eRes.resError)
1355 {
1356 for (CMPI_Error* currErr=eRes.resError;
1357 currErr!=NULL;
1358 currErr=currErr->nextError)
1359 {
1360 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
1361 }
1362 }
1363 throw cimException;
1364 }
1365
|
1366 marek 1.63 }
1367 HandlerCatch(handler);
1368
1369 PEG_METHOD_EXIT();
1370
1371 return(response);
1372 }
1373
1374 Message * CMPIProviderManager::handleAssociatorsRequest(const Message * message)
1375 {
1376 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1377 "CMPIProviderManager::handleAssociatorsRequest");
1378
|
1379 kumpf 1.92 HandlerIntro(Associators,message,request,response,handler);
|
1380 marek 1.63 try {
1381 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1382 "CMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
1383 System::getHostName(),
1384 request->nameSpace.getString(),
1385 request->objectName.getClassName().getString());
1386
1387 // make target object path
1388 CIMObjectPath objectPath(
1389 System::getHostName(),
1390 request->nameSpace,
1391 request->objectName.getClassName());
1392
1393 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1394
1395 CIMObjectPath assocPath(
1396 System::getHostName(),
1397 request->nameSpace,
1398 request->assocClass.getString());
1399
1400 Boolean remote=false;
1401 marek 1.63
1402 CMPIProvider::OpProviderHolder ph;
1403
1404 // resolve provider name
1405 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
1406 ProviderName name = _resolveProviderName(pidc);
1407
1408 if ((remote=pidc.isRemoteNameSpace())) {
1409 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
1410 }
1411 else {
1412 // get cached or load new provider module
1413 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1414 }
1415
1416 // convert arguments
1417 OperationContext context;
1418
1419 context.insert(request->operationContext.get(IdentityContainer::NAME));
1420 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1421 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1422 marek 1.63
1423 // forward request
1424 CMPIProvider & pr=ph.GetProvider();
1425
|
1426 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1427 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
1428 // If normalization is enabled, then the normalizer will take care of
1429 // any EmbeddedInstance / EmbeddedObject mismatches, and we don't need
1430 // to add a NormalizerContextContainer. The presence of an
1431 // ObjectNormalizer is determined by the presence of the
1432 // CachedClassDefinitionContainer
|
1433 a.dunfey 1.88 if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
1434 {
|
1435 a.dunfey 1.85 request->operationContext.get(CachedClassDefinitionContainer::NAME);
1436 }
|
1437 a.dunfey 1.88 else
|
1438 a.dunfey 1.85 #endif // PEGASUS_ENABLE_OBJECT_NORMALIZATION
1439 {
1440 // If a mechanism is needed to correct mismatches between the
1441 // EmbeddedInstance and EmbeddedObject types, then insert
1442 // containers for the class definition and a NormalizerContext.
1443 AutoPtr<NormalizerContext> tmpNormalizerContext(
1444 new CIMOMHandleContext(*pr._cimom_handle));
1445 CIMClass classDef(tmpNormalizerContext->getClass(
1446 request->nameSpace, request->className));
1447 request->operationContext.insert(CachedClassDefinitionContainer(classDef));
1448 request->operationContext.insert(
1449 NormalizerContextContainer(tmpNormalizerContext));
1450 }
1451 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1452
|
1453 marek 1.63 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1454 "Calling provider.associators: " + pr.getName());
1455
1456 DDD(cerr<<"--- CMPIProviderManager::associators"<<" role: >"<<request->role<<"< aCls "<<
1457 request->assocClass<<endl);
1458
1459 CMPIStatus rc={CMPI_RC_OK,NULL};
1460 CMPI_ContextOnStack eCtx(context);
1461 CMPI_ObjectPathOnStack eRef(objectPath);
1462 CMPI_ResultOnStack eRes(handler,&pr.broker);
1463 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1464 const CString aClass=request->assocClass.getString().getCString();
1465 const CString rClass=request->resultClass.getString().getCString();
1466 const CString rRole=request->role.getCString();
1467 const CString resRole=request->resultRole.getCString();
1468
1469 CMPIPropertyList props(request->propertyList);
1470
1471 CMPIFlags flgs=0;
1472 if (request->includeQualifiers) flgs|=CMPI_FLAG_IncludeQualifiers;
1473 if (request->includeClassOrigin) flgs|=CMPI_FLAG_IncludeClassOrigin;
1474 marek 1.63 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1475
1476 const IdentityContainer container =
1477 request->operationContext.get(IdentityContainer::NAME);
1478 eCtx.ft->addEntry(&eCtx,
1479 CMPIPrincipal,
1480 (CMPIValue*)(const char*)container.getUserName().getCString(),
1481 CMPI_chars);
1482
|
1483 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1484 request->operationContext.get(AcceptLanguageListContainer::NAME);
|
1485 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1486 kumpf 1.79 eCtx.ft->addEntry(
1487 &eCtx,
|
1488 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1489 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1490 acceptLangs).getCString(),
1491 CMPI_chars);
|
1492 konrad.r 1.67
|
1493 marek 1.63 if (remote) {
1494 CString info=pidc.getRemoteInfo().getCString();
1495 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1496 }
1497
1498 CMPIProvider::pm_service_op_lock op_lock(&pr);
1499
|
1500 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1501 marek 1.63
|
1502 dave.sudlik 1.96 if (pr.miVector.assocMI==0)
1503 {
1504 _throw_MINotInitializedException();
1505 }
1506
|
1507 kumpf 1.92 {
1508 StatProviderTimeMeasurement providerTime(response);
|
1509 marek 1.63
|
1510 kumpf 1.92 rc = pr.miVector.assocMI->ft->associators(
1511 pr.miVector.assocMI,&eCtx,&eRes,&eRef,
1512 CHARS(aClass),CHARS(rClass),CHARS(rRole),CHARS(resRole),
1513 (const char **)props.getList());
1514 }
|
1515 marek 1.63
|
1516 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1517 // Do this before checking rc from provider to throw exception in case
1518 // rc.msg is also localized.
1519 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1520 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1521 if (tmprc.rc == CMPI_RC_OK)
1522 {
1523 response->operationContext.set(
1524 ContentLanguageListContainer(
1525 ContentLanguageList(
|
1526 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1527 CMGetCharPtr(cldata.value.string)))));
1528 handler.setContext(response->operationContext);
|
1529 dave.sudlik 1.99 }
1530
|
1531 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
1532 dave.sudlik 1.102 {
1533 CIMException cimException(
1534 (CIMStatusCode)rc.rc,
|
1535 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
1536 dave.sudlik 1.102
1537 if (eRes.resError)
1538 {
1539 for (CMPI_Error* currErr=eRes.resError;
1540 currErr!=NULL;
1541 currErr=currErr->nextError)
1542 {
1543 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
1544 }
1545 }
1546 throw cimException;
1547 }
|
1548 marek 1.63 }
1549 HandlerCatch(handler);
1550
1551 PEG_METHOD_EXIT();
1552
1553 return(response);
1554 }
1555
1556 Message * CMPIProviderManager::handleAssociatorNamesRequest(const Message * message)
1557 {
1558 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1559 "CMPIProviderManager::handleAssociatorNamesRequest");
1560
|
1561 kumpf 1.92 HandlerIntro(AssociatorNames,message,request,response,handler);
|
1562 marek 1.63 try {
1563 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1564 "CMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1565 System::getHostName(),
1566 request->nameSpace.getString(),
1567 request->objectName.getClassName().getString());
1568
1569 // make target object path
1570 CIMObjectPath objectPath(
1571 System::getHostName(),
1572 request->nameSpace,
1573 request->objectName.getClassName());
1574
1575 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1576
1577 CIMObjectPath assocPath(
1578 System::getHostName(),
1579 request->nameSpace,
1580 request->assocClass.getString());
1581
1582 Boolean remote=false;
1583 marek 1.63 CMPIProvider::OpProviderHolder ph;
1584
1585 // resolve provider name
1586 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
1587 ProviderName name = _resolveProviderName(pidc);
1588
1589 if ((remote=pidc.isRemoteNameSpace())) {
1590 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
1591 }
1592 else {
1593 // get cached or load new provider module
1594 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1595 }
1596
1597 // convert arguments
1598 OperationContext context;
1599
1600 context.insert(request->operationContext.get(IdentityContainer::NAME));
1601 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1602 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1603
1604 marek 1.63 // forward request
1605 CMPIProvider & pr=ph.GetProvider();
1606
1607 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1608 "Calling provider.associatorNames: " + pr.getName());
1609
1610 DDD(cerr<<"--- CMPIProviderManager::associatorNames"<<" role: >"<<request->role<<"< aCls "<<
1611 request->assocClass<<endl);
1612
1613 CMPIStatus rc={CMPI_RC_OK,NULL};
1614 CMPI_ContextOnStack eCtx(context);
1615 CMPI_ObjectPathOnStack eRef(objectPath);
1616 CMPI_ResultOnStack eRes(handler,&pr.broker);
1617 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1618 const CString aClass=request->assocClass.getString().getCString();
1619 const CString rClass=request->resultClass.getString().getCString();
1620 const CString rRole=request->role.getCString();
1621 const CString resRole=request->resultRole.getCString();
1622
1623 CMPIFlags flgs=0;
1624 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1625 marek 1.63
1626 const IdentityContainer container =
1627 request->operationContext.get(IdentityContainer::NAME);
1628 eCtx.ft->addEntry(&eCtx,
1629 CMPIPrincipal,
1630 (CMPIValue*)(const char*)container.getUserName().getCString(),
1631 CMPI_chars);
1632
|
1633 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1634 request->operationContext.get(AcceptLanguageListContainer::NAME);
|
1635 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1636 kumpf 1.79 eCtx.ft->addEntry(
1637 &eCtx,
|
1638 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1639 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1640 acceptLangs).getCString(),
1641 CMPI_chars);
|
1642 konrad.r 1.67
|
1643 marek 1.63 if (remote) {
1644 CString info=pidc.getRemoteInfo().getCString();
1645 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1646 }
1647
1648 CMPIProvider::pm_service_op_lock op_lock(&pr);
1649
|
1650 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1651 marek 1.63
|
1652 dave.sudlik 1.96 if (pr.miVector.assocMI==0)
1653 {
1654 _throw_MINotInitializedException();
1655 }
1656
|
1657 kumpf 1.92 {
1658 StatProviderTimeMeasurement providerTime(response);
|
1659 marek 1.63
|
1660 kumpf 1.92 rc = pr.miVector.assocMI->ft->associatorNames(
1661 pr.miVector.assocMI,&eCtx,&eRes,&eRef,CHARS(aClass),
1662 CHARS(rClass),CHARS(rRole),CHARS(resRole));
1663 }
|
1664 marek 1.63
|
1665 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1666 // Do this before checking rc from provider to throw exception in case
1667 // rc.msg is also localized.
1668 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1669 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1670 if (tmprc.rc == CMPI_RC_OK)
1671 {
1672 response->operationContext.set(
1673 ContentLanguageListContainer(
1674 ContentLanguageList(
|
1675 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1676 CMGetCharPtr(cldata.value.string)))));
1677 handler.setContext(response->operationContext);
|
1678 dave.sudlik 1.99 }
1679
|
1680 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
1681 dave.sudlik 1.102 {
1682 CIMException cimException(
1683 (CIMStatusCode)rc.rc,
|
1684 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
1685 dave.sudlik 1.102
1686 if (eRes.resError)
1687 {
1688 for (CMPI_Error* currErr=eRes.resError;
1689 currErr!=NULL;
1690 currErr=currErr->nextError)
1691 {
1692 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
1693 }
1694 }
1695 throw cimException;
1696 }
|
1697 marek 1.63 }
1698 HandlerCatch(handler);
1699
1700 PEG_METHOD_EXIT();
1701
1702 return(response);
1703 }
1704
1705 Message * CMPIProviderManager::handleReferencesRequest(const Message * message)
1706 {
1707 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1708 "CMPIProviderManager::handleReferencesRequest");
1709
|
1710 kumpf 1.92 HandlerIntro(References,message,request,response,handler);
|
1711 marek 1.63 try {
1712 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1713 "CMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
1714 System::getHostName(),
1715 request->nameSpace.getString(),
1716 request->objectName.getClassName().getString());
1717
1718 // make target object path
1719 CIMObjectPath objectPath(
1720 System::getHostName(),
1721 request->nameSpace,
1722 request->objectName.getClassName());
1723
1724 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1725
1726 CIMObjectPath resultPath(
1727 System::getHostName(),
1728 request->nameSpace,
1729 request->resultClass.getString());
1730
1731 Boolean remote=false;
1732 marek 1.63 CMPIProvider::OpProviderHolder ph;
1733
1734 // resolve provider name
1735 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
1736 ProviderName name = _resolveProviderName(pidc);
1737
1738 if ((remote=pidc.isRemoteNameSpace())) {
1739 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
1740 }
1741 else {
1742 // get cached or load new provider module
1743 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1744 }
1745
1746 // convert arguments
1747 OperationContext context;
1748
1749 context.insert(request->operationContext.get(IdentityContainer::NAME));
1750 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1751 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1752 // forward request
1753 marek 1.63 CMPIProvider & pr=ph.GetProvider();
1754
|
1755 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1756 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
1757 // If normalization is enabled, then the normalizer will take care of
1758 // any EmbeddedInstance / EmbeddedObject mismatches, and we don't need
1759 // to add a NormalizerContextContainer. The presence of an
1760 // ObjectNormalizer is determined by the presence of the
1761 // CachedClassDefinitionContainer
|
1762 a.dunfey 1.88 if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
1763 {
|
1764 a.dunfey 1.85 request->operationContext.get(CachedClassDefinitionContainer::NAME);
1765 }
|
1766 a.dunfey 1.88 else
|
1767 a.dunfey 1.85 #endif // PEGASUS_ENABLE_OBJECT_NORMALIZATION
1768 {
1769 // If a mechanism is needed to correct mismatches between the
1770 // EmbeddedInstance and EmbeddedObject types, then insert
1771 // containers for the class definition and a NormalizerContext.
1772 AutoPtr<NormalizerContext> tmpNormalizerContext(
1773 new CIMOMHandleContext(*pr._cimom_handle));
1774 CIMClass classDef(tmpNormalizerContext->getClass(
1775 request->nameSpace, request->className));
1776 request->operationContext.insert(CachedClassDefinitionContainer(classDef));
1777 request->operationContext.insert(
1778 NormalizerContextContainer(tmpNormalizerContext));
1779 }
1780 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1781
|
1782 marek 1.63 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1783 "Calling provider.references: " + pr.getName());
1784
1785 DDD(cerr<<"--- CMPIProviderManager::references"<<" role: >"<<request->role<<"< aCls "<<
1786 request->resultClass<<endl);
1787
1788 CMPIStatus rc={CMPI_RC_OK,NULL};
1789 CMPI_ContextOnStack eCtx(context);
1790 CMPI_ObjectPathOnStack eRef(objectPath);
1791 CMPI_ResultOnStack eRes(handler,&pr.broker);
1792 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1793 const CString rClass=request->resultClass.getString().getCString();
1794 const CString rRole=request->role.getCString();
1795
1796 CMPIPropertyList props(request->propertyList);
1797
1798 CMPIFlags flgs=0;
1799 if (request->includeQualifiers) flgs|=CMPI_FLAG_IncludeQualifiers;
1800 if (request->includeClassOrigin) flgs|=CMPI_FLAG_IncludeClassOrigin;
1801 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1802
1803 marek 1.63 const IdentityContainer container =
1804 request->operationContext.get(IdentityContainer::NAME);
1805 eCtx.ft->addEntry(&eCtx,
1806 CMPIPrincipal,
1807 (CMPIValue*)(const char*)container.getUserName().getCString(),
1808 CMPI_chars);
1809
|
1810 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1811 request->operationContext.get(AcceptLanguageListContainer::NAME);
|
1812 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1813 kumpf 1.79 eCtx.ft->addEntry(
1814 &eCtx,
|
1815 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1816 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1817 acceptLangs).getCString(),
1818 CMPI_chars);
|
1819 konrad.r 1.67
|
1820 marek 1.63 if (remote) {
1821 CString info=pidc.getRemoteInfo().getCString();
1822 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1823 }
1824
1825 CMPIProvider::pm_service_op_lock op_lock(&pr);
1826
|
1827 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1828 marek 1.63
|
1829 dave.sudlik 1.96 if (pr.miVector.assocMI==0)
1830 {
1831 _throw_MINotInitializedException();
1832 }
1833
|
1834 kumpf 1.92 {
1835 StatProviderTimeMeasurement providerTime(response);
|
1836 marek 1.63
|
1837 kumpf 1.92 rc = pr.miVector.assocMI->ft->references(
1838 pr.miVector.assocMI,&eCtx,&eRes,&eRef,
1839 CHARS(rClass),CHARS(rRole),(const char **)props.getList());
1840 }
|
1841 marek 1.63
|
1842 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1843 // Do this before checking rc from provider to throw exception in case
1844 // rc.msg is also localized.
1845 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1846 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1847 if (tmprc.rc == CMPI_RC_OK)
1848 {
1849 response->operationContext.set(
1850 ContentLanguageListContainer(
1851 ContentLanguageList(
|
1852 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1853 CMGetCharPtr(cldata.value.string)))));
1854 handler.setContext(response->operationContext);
|
1855 dave.sudlik 1.99 }
1856
|
1857 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
1858 dave.sudlik 1.102 {
1859 CIMException cimException(
1860 (CIMStatusCode)rc.rc,
|
1861 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
1862 dave.sudlik 1.102
1863 if (eRes.resError)
1864 {
1865 for (CMPI_Error* currErr=eRes.resError;
1866 currErr!=NULL;
1867 currErr=currErr->nextError)
1868 {
1869 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
1870 }
1871 }
1872 throw cimException;
1873 }
|
1874 marek 1.63 }
1875 HandlerCatch(handler);
1876
1877 PEG_METHOD_EXIT();
1878
1879 return(response);
1880 }
1881
1882 Message * CMPIProviderManager::handleReferenceNamesRequest(const Message * message)
1883 {
1884 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1885 "CMPIProviderManager::handleReferenceNamesRequest");
1886
|
1887 kumpf 1.92 HandlerIntro(ReferenceNames,message,request,response,handler);
|
1888 marek 1.63 try {
1889 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1890 "CMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1891 System::getHostName(),
1892 request->nameSpace.getString(),
1893 request->objectName.getClassName().getString());
1894
1895 // make target object path
1896 CIMObjectPath objectPath(
1897 System::getHostName(),
1898 request->nameSpace,
1899 request->objectName.getClassName());
1900
1901 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1902
1903 CIMObjectPath resultPath(
1904 System::getHostName(),
1905 request->nameSpace,
1906 request->resultClass.getString());
1907
1908 Boolean remote=false;
1909 marek 1.63 CMPIProvider::OpProviderHolder ph;
1910
1911 // resolve provider name
1912 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
1913 ProviderName name = _resolveProviderName(pidc);
1914
1915 if ((remote=pidc.isRemoteNameSpace())) {
1916 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
1917 }
1918 else {
1919 // get cached or load new provider module
1920 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1921 }
1922
1923 // convert arguments
1924 OperationContext context;
1925
1926 context.insert(request->operationContext.get(IdentityContainer::NAME));
1927 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1928 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1929 CMPIProvider & pr=ph.GetProvider();
1930 marek 1.63
1931 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1932 "Calling provider.referenceNames: " + pr.getName());
1933
1934 DDD(cerr<<"--- CMPIProviderManager::referenceNames"<<" role: >"<<request->role<<"< aCls "<<
1935 request->resultClass<<endl);
1936
1937 CMPIStatus rc={CMPI_RC_OK,NULL};
1938 CMPI_ContextOnStack eCtx(context);
1939 CMPI_ObjectPathOnStack eRef(objectPath);
1940 CMPI_ResultOnStack eRes(handler,&pr.broker);
1941 CMPI_ThreadContext thr(&pr.broker,&eCtx);
1942 const CString rClass=request->resultClass.getString().getCString();
1943 const CString rRole=request->role.getCString();
1944
1945 CMPIFlags flgs=0;
1946 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
1947
1948 const IdentityContainer container =
1949 request->operationContext.get(IdentityContainer::NAME);
1950 eCtx.ft->addEntry(&eCtx,
1951 marek 1.63 CMPIPrincipal,
1952 (CMPIValue*)(const char*)container.getUserName().getCString(),
1953 CMPI_chars);
1954
|
1955 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1956 request->operationContext.get(AcceptLanguageListContainer::NAME);
1957
|
1958 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
1959 kumpf 1.79 eCtx.ft->addEntry(
1960 &eCtx,
|
1961 dave.sudlik 1.99 CMPIAcceptLanguage,
|
1962 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
1963 acceptLangs).getCString(),
1964 CMPI_chars);
|
1965 marek 1.63 if (remote) {
1966 CString info=pidc.getRemoteInfo().getCString();
1967 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
1968 }
1969
1970 CMPIProvider::pm_service_op_lock op_lock(&pr);
1971
|
1972 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
1973 marek 1.63
|
1974 dave.sudlik 1.96 if (pr.miVector.assocMI==0)
1975 {
1976 _throw_MINotInitializedException();
1977 }
1978
|
1979 kumpf 1.92 {
1980 StatProviderTimeMeasurement providerTime(response);
|
1981 marek 1.63
|
1982 kumpf 1.92 rc = pr.miVector.assocMI->ft->referenceNames(
1983 pr.miVector.assocMI,&eCtx,&eRes,&eRef,
1984 CHARS(rClass),CHARS(rRole));
1985 }
|
1986 marek 1.63
|
1987 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
1988 // Do this before checking rc from provider to throw exception in case
1989 // rc.msg is also localized.
1990 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1991 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1992 if (tmprc.rc == CMPI_RC_OK)
1993 {
1994 response->operationContext.set(
1995 ContentLanguageListContainer(
1996 ContentLanguageList(
|
1997 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
1998 CMGetCharPtr(cldata.value.string)))));
1999 handler.setContext(response->operationContext);
|
2000 dave.sudlik 1.99 }
2001
|
2002 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
2003 dave.sudlik 1.102 {
2004 CIMException cimException(
2005 (CIMStatusCode)rc.rc,
|
2006 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
2007 dave.sudlik 1.102
2008 if (eRes.resError)
2009 {
2010 for (CMPI_Error* currErr=eRes.resError;
2011 currErr!=NULL;
2012 currErr=currErr->nextError)
2013 {
2014 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
2015 }
2016 }
2017 throw cimException;
2018 }
|
2019 marek 1.63 }
2020 HandlerCatch(handler);
2021
2022 PEG_METHOD_EXIT();
2023
2024 return(response);
2025 }
2026
2027 Message * CMPIProviderManager::handleInvokeMethodRequest(const Message * message)
2028 {
2029 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
2030 "CMPIProviderManager::handleInvokeMethodRequest");
2031
|
2032 kumpf 1.92 HandlerIntro(InvokeMethod,message,request,response,handler);
|
2033 marek 1.63 try {
2034 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2035 "CMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
2036 System::getHostName(),
2037 request->nameSpace.getString(),
2038 request->instanceName.getClassName().getString());
2039
2040 // make target object path
2041 CIMObjectPath objectPath(
2042 System::getHostName(),
2043 request->nameSpace,
2044 request->instanceName.getClassName(),
2045 request->instanceName.getKeyBindings());
2046
2047 Boolean remote=false;
2048 CMPIProvider::OpProviderHolder ph;
2049
2050 // resolve provider name
2051 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
2052 ProviderName name = _resolveProviderName(pidc);
2053
2054 marek 1.63 if ((remote=pidc.isRemoteNameSpace())) {
2055 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
2056 }
2057 else {
2058 // get cached or load new provider module
2059 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
2060 }
2061
2062 // convert arguments
2063 OperationContext context;
2064
2065 context.insert(request->operationContext.get(IdentityContainer::NAME));
2066 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2067 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2068
2069 CIMObjectPath instanceReference(request->instanceName);
2070
2071 // ATTN: propagate namespace
2072 instanceReference.setNameSpace(request->nameSpace);
2073
2074 // forward request
2075 marek 1.63 CMPIProvider & pr=ph.GetProvider();
2076
|
2077 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2078 bool externalNormalizationEnabled = false;
2079 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
2080 // If normalization is enabled, then the normalizer will take care of
2081 // any EmbeddedInstance / EmbeddedObject mismatches, and we don't need
2082 // to add a NormalizerContextContainer. The presence of an
2083 // ObjectNormalizer is determined by the presence of the
2084 // CachedClassDefinitionContainer
|
2085 a.dunfey 1.88 if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
2086 {
|
2087 a.dunfey 1.85 request->operationContext.get(CachedClassDefinitionContainer::NAME);
2088 externalNormalizationEnabled = true;
2089 }
|
2090 a.dunfey 1.88 else
|
2091 a.dunfey 1.85 #endif // PEGASUS_ENABLE_OBJECT_NORMALIZATION
2092 {
2093 // If a mechanism is needed to correct mismatches between the
2094 // EmbeddedInstance and EmbeddedObject types, then insert
2095 // containers for the class definition and a NormalizerContext.
2096 AutoPtr<NormalizerContext> tmpNormalizerContext(
2097 new CIMOMHandleContext(*pr._cimom_handle));
2098 CIMClass classDef(tmpNormalizerContext->getClass(
2099 request->nameSpace, request->className));
2100 request->operationContext.insert(CachedClassDefinitionContainer(classDef));
2101 request->operationContext.insert(
2102 NormalizerContextContainer(tmpNormalizerContext));
2103 }
2104 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2105
|
2106 marek 1.63 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2107 "Calling provider.invokeMethod: " + pr.getName());
2108
2109 CMPIStatus rc={CMPI_RC_OK,NULL};
2110 CMPI_ContextOnStack eCtx(context);
2111 CMPI_ObjectPathOnStack eRef(objectPath);
2112 CMPI_ResultOnStack eRes(handler,&pr.broker);
2113 CMPI_ThreadContext thr(&pr.broker,&eCtx);
2114 CMPI_ArgsOnStack eArgsIn(request->inParameters);
2115 Array<CIMParamValue> outArgs;
2116 CMPI_ArgsOnStack eArgsOut(outArgs);
2117 CString mName=request->methodName.getString().getCString();
2118
2119 CMPIFlags flgs=0;
2120 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
2121
2122 const IdentityContainer container =
2123 request->operationContext.get(IdentityContainer::NAME);
2124 eCtx.ft->addEntry(&eCtx,
2125 CMPIPrincipal,
2126 (CMPIValue*)(const char*)container.getUserName().getCString(),
2127 marek 1.63 CMPI_chars);
2128
|
2129 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
2130 request->operationContext.get(AcceptLanguageListContainer::NAME);
2131
|
2132 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
2133 kumpf 1.79 eCtx.ft->addEntry(
2134 &eCtx,
|
2135 dave.sudlik 1.99 CMPIAcceptLanguage,
|
2136 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
2137 acceptLangs).getCString(),
2138 CMPI_chars);
|
2139 marek 1.63 if (remote) {
2140 CString info=pidc.getRemoteInfo().getCString();
2141 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
2142 }
2143
2144 CMPIProvider::pm_service_op_lock op_lock(&pr);
2145
|
2146 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
2147 marek 1.90
|
2148 dave.sudlik 1.96 if (pr.miVector.methMI==0)
2149 {
2150 _throw_MINotInitializedException();
2151 }
2152
|
2153 kumpf 1.92 {
2154 StatProviderTimeMeasurement providerTime(response);
|
2155 marek 1.63
|
2156 kumpf 1.92 rc = pr.miVector.methMI->ft->invokeMethod(
2157 pr.miVector.methMI,&eCtx,&eRes,&eRef,
2158 CHARS(mName),&eArgsIn,&eArgsOut);
2159 }
|
2160 marek 1.63
|
2161 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
2162 // Do this before checking rc from provider to throw exception in case
2163 // rc.msg is also localized.
2164 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2165 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2166 if (tmprc.rc == CMPI_RC_OK)
2167 {
2168 response->operationContext.set(
2169 ContentLanguageListContainer(
2170 ContentLanguageList(
|
2171 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
2172 CMGetCharPtr(cldata.value.string)))));
2173 handler.setContext(response->operationContext);
|
2174 dave.sudlik 1.99 }
2175
|
2176 marek 1.63 if (rc.rc!=CMPI_RC_OK)
|
2177 dave.sudlik 1.102 {
2178 CIMException cimException(
2179 (CIMStatusCode)rc.rc,
|
2180 marek 1.63 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
2181
|
2182 dave.sudlik 1.102 if (eRes.resError)
2183 {
2184 for (CMPI_Error* currErr=eRes.resError;
2185 currErr!=NULL;
2186 currErr=currErr->nextError)
2187 {
2188 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
2189 }
2190 }
2191 throw cimException;
2192 }
2193
|
2194 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2195 if(!externalNormalizationEnabled)
2196 {
2197 // There is no try catch here because if there is no external
2198 // normalization, then these containers were added by this method.
2199 const CachedClassDefinitionContainer * classCont =
2200 dynamic_cast<const CachedClassDefinitionContainer *>(
2201 &request->operationContext.get(
2202 CachedClassDefinitionContainer::NAME));
2203 const NormalizerContextContainer * contextCont =
2204 dynamic_cast<const NormalizerContextContainer*>(
2205 &request->operationContext.get(
2206 NormalizerContextContainer::NAME));
2207 CIMClass classDef(classCont->getClass());
2208 Uint32 methodIndex = classDef.findMethod(request->methodName);
2209 PEGASUS_ASSERT(methodIndex != PEG_NOT_FOUND);
2210 CIMMethod methodDef(classDef.getMethod(methodIndex));
2211 for(unsigned int i = 0, n = outArgs.size(); i < n; ++i)
2212 {
2213 CIMParamValue currentParam(outArgs[i]);
2214 CIMValue paramValue(currentParam.getValue());
2215 a.dunfey 1.85 // If the parameter value is an EmbeddedObject type, we have
2216 // to check against the type of the parameter definition.
2217 // CMPI does not distinguish between EmbeddedObjects and
2218 // EmbeddedInstances, so if the parameter definition has a type
2219 // of EmbeddedInstance, the type of the output parameter must
2220 // be changed.
2221 if(paramValue.getType() == CIMTYPE_OBJECT)
2222 {
2223 CIMObject paramObject;
2224 paramValue.get(paramObject);
2225 CIMInstance paramInst(paramObject);
2226 resolveEmbeddedInstanceTypes(&handler, paramInst);
2227 String currentParamName(currentParam.getParameterName());
2228 Uint32 paramIndex = methodDef.findParameter(
2229 CIMName(currentParamName));
2230 if(paramIndex == PEG_NOT_FOUND)
2231 {
2232 MessageLoaderParms msg("ProviderManager.CMPI."
2233 "CMPIProviderManager.PARAMETER_NOT_FOUND",
2234 "Parameter {0} not found in definition for "
2235 "method {1}.", currentParamName,
2236 a.dunfey 1.85 request->methodName.getString());
2237 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2238 msg.toString());
2239 handler.setStatus(CIM_ERR_FAILED,
2240 msg.toString());
2241 }
2242 else
2243 {
2244 CIMConstParameter paramDef(
2245 methodDef.getParameter(paramIndex));
2246 if(paramDef.findQualifier(CIMName("EmbeddedInstance"))
2247 != PEG_NOT_FOUND)
2248 {
2249 currentParam = CIMParamValue(currentParamName,
2250 CIMValue(paramInst));
2251 }
2252 else
2253 {
2254 currentParam = CIMParamValue(currentParamName,
2255 CIMValue(paramObject));
2256 }
2257 a.dunfey 1.85
2258 handler.deliverParamValue(currentParam);
2259 }
2260 }
2261 else
2262 {
2263 handler.deliverParamValue(currentParam);
2264 }
2265 }
2266 }
2267 #else
2268 for (int i=0,s=outArgs.size(); i<s; i++)
2269 {
2270 handler.deliverParamValue(outArgs[i]);
2271 }
2272 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
2273 marek 1.63 handler.complete();
2274 }
2275 HandlerCatch(handler);
2276
2277 PEG_METHOD_EXIT();
2278
2279 return(response);
2280 }
2281
2282 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
2283 String& providerName, String& location)
2284 {
2285 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
2286 pInstance.getProperty(pos).getValue().get(providerName);
2287
2288 pos = pmInstance.findProperty(CIMName ("Location"));
2289 pmInstance.getProperty(pos).getValue().get(location);
2290 return 0;
2291 }
2292
2293 Message * CMPIProviderManager::handleCreateSubscriptionRequest(const Message * message)
2294 marek 1.63 {
2295 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleCreateSubscriptionRequest");
2296
2297 HandlerIntroInd(CreateSubscription,message,request,response,
2298 handler);
2299 try {
2300 const CIMObjectPath &x=request->subscriptionInstance.getPath();
2301 CIMInstance req_provider, req_providerModule;
2302 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
2303 req_provider = pidc.getProvider();
2304 req_providerModule = pidc.getModule();
2305
2306 String providerName,providerLocation;
2307 LocateIndicationProviderNames(req_provider, req_providerModule,
2308 providerName,providerLocation);
2309
2310 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2311 "CMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
2312 System::getHostName(),
2313 request->nameSpace.getString(),
2314 providerName);
2315 marek 1.63
2316 Boolean remote=false;
2317 CMPIProvider::OpProviderHolder ph;
2318
2319 if ((remote=pidc.isRemoteNameSpace())) {
|
2320 marek 1.68 ph = providerManager.getRemoteProvider(providerLocation, providerName);
|
2321 marek 1.63 }
2322 else {
2323 // get cached or load new provider module
|
2324 marek 1.68 ph = providerManager.getProvider(providerLocation, providerName);
|
2325 marek 1.63 }
2326
2327 indProvRecord *prec=NULL;
|
2328 marek 1.95 {
2329 WriteLock writeLock(rwSemProvTab);
|
2330 marek 1.68 provTab.lookup(ph.GetProvider().getName(),prec);
|
2331 marek 1.63 if (prec) prec->count++;
2332 else {
2333 prec=new indProvRecord();
|
2334 marek 1.68 provTab.insert(ph.GetProvider().getName(),prec);
|
2335 marek 1.63 }
|
2336 marek 1.95 }
|
2337 marek 1.63
2338 //
2339 // Save the provider instance from the request
2340 //
2341 ph.GetProvider ().setProviderInstance (req_provider);
2342
2343 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
2344
|
2345 marek 1.95 indSelectRecord *srec=NULL;
2346
2347 {
2348 WriteLock writeLock(rwSemSelxTab);
2349 selxTab.lookup(sPath,srec);
2350 if (srec) srec->count++;
2351 else {
2352 srec=new indSelectRecord();
|
2353 r.kieninger 1.81 selxTab.insert(sPath,srec);
|
2354 marek 1.95 }
2355 }
|
2356 marek 1.63
2357 // convert arguments
2358 OperationContext context;
2359 context.insert(request->operationContext.get(IdentityContainer::NAME));
2360 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2361 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2362 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
2363 context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
2364
2365 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
2366
2367 CMPIProvider & pr=ph.GetProvider();
2368
2369 CMPIStatus rc={CMPI_RC_OK,NULL};
2370 CMPI_ContextOnStack eCtx(context);
2371 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get
2372 (SubscriptionFilterConditionContainer::NAME);
2373
2374 CIMOMHandleQueryContext *_context= new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),
2375 *pr._cimom_handle);
2376
2377 marek 1.63 CMPI_SelectExp *eSelx=new CMPI_SelectExp(context,
2378 _context,
2379 request->query,
2380 sub_cntr.getQueryLanguage());
2381
2382 srec->eSelx=eSelx;
2383 srec->qContext=_context;
2384
2385 CMPI_ThreadContext thr(&pr.broker,&eCtx);
2386
2387 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2388 "Calling provider.createSubscriptionRequest: " + pr.getName());
2389
2390 DDD(cerr<<"--- CMPIProviderManager::createSubscriptionRequest"<<endl);
2391
2392 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {
2393 CIMObjectPath className(
2394 System::getHostName(),
2395 request->nameSpace,
2396 request->classNames[i]);
2397 eSelx->classNames.append(className);
2398 marek 1.63 }
2399 CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]);
2400
2401 CIMPropertyList propertyList = request->propertyList;
2402 if (!propertyList.isNull()) {
2403 Array<CIMName> p=propertyList.getPropertyNameArray();
2404 int pCount=p.size();
|
2405 aruran.ms 1.71 eSelx->props = new const char*[1+pCount];
|
2406 marek 1.63 for (int i=0; i<pCount; i++) {
2407 eSelx->props[i]=strdup(p[i].getString().getCString());
2408 }
2409 eSelx->props[pCount]=NULL;
2410 }
2411
2412 Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy;
2413
2414 const IdentityContainer container =
2415 request->operationContext.get(IdentityContainer::NAME);
2416 eCtx.ft->addEntry(&eCtx,
2417 CMPIPrincipal,
2418 (CMPIValue*)(const char*)container.getUserName().getCString(),
2419 CMPI_chars);
2420
2421 eCtx.ft->addEntry(&eCtx,
|
2422 konrad.r 1.66 CMPIInitNameSpace,
|
2423 marek 1.63 (CMPIValue*)(const char*)request->nameSpace.getString().getCString(),
2424 CMPI_chars);
2425
|
2426 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
2427 request->operationContext.get(AcceptLanguageListContainer::NAME);
2428
|
2429 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
2430 kumpf 1.79 eCtx.ft->addEntry(
2431 &eCtx,
|
2432 dave.sudlik 1.99 CMPIAcceptLanguage,
|
2433 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
2434 acceptLangs).getCString(),
2435 CMPI_chars);
|
2436 dave.sudlik 1.100 CString info;
|
2437 marek 1.63 if (remote) {
|
2438 dave.sudlik 1.100 info=pidc.getRemoteInfo().getCString();
|
2439 marek 1.63 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
2440 }
2441
2442 CMPIProvider::pm_service_op_lock op_lock(&pr);
2443
|
2444 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
2445 marek 1.90
|
2446 dave.sudlik 1.96 if (pr.miVector.indMI==0)
2447 {
2448 _throw_MINotInitializedException();
2449 }
2450
|
2451 kumpf 1.92 {
2452 StatProviderTimeMeasurement providerTime(response);
2453
2454 if (pr.miVector.indMI->ft->ftVersion >= 100)
2455 {
2456 rc = pr.miVector.indMI->ft->activateFilter(
2457 pr.miVector.indMI,&eCtx,eSelx,
2458 CHARS(eSelx->classNames[0].getClassName().getString().
|
2459 dave.sudlik 1.96 getCString()),&eRef,false);
|
2460 kumpf 1.92 }
2461 else
2462 {
2463 // Older version of (pre 1.00) also pass in a CMPIResult
|
2464 marek 1.63
|
2465 kumpf 1.92 rc = ((CMPIStatus (*)(CMPIIndicationMI*, CMPIContext*,
2466 CMPIResult*, CMPISelectExp*,
2467 const char *, CMPIObjectPath*, CMPIBoolean))
|
2468 dave.sudlik 1.96 pr.miVector.indMI->ft->activateFilter)
2469 (pr.miVector.indMI,&eCtx,NULL,eSelx,
|
2470 kumpf 1.92 CHARS(eSelx->classNames[0].getClassName().getString().
|
2471 dave.sudlik 1.96 getCString()),&eRef,false);
|
2472 kumpf 1.92 }
2473 }
|
2474 marek 1.63
|
2475 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
2476 // Do this before checking rc from provider to throw exception in case
2477 // rc.msg is also localized.
2478 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2479 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2480 if (tmprc.rc == CMPI_RC_OK)
2481 {
2482 response->operationContext.set(
2483 ContentLanguageListContainer(
2484 ContentLanguageList(
|
2485 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
2486 CMGetCharPtr(cldata.value.string)))));
|
2487 dave.sudlik 1.99 }
2488
|
2489 marek 1.63 if (rc.rc!=CMPI_RC_OK)
2490 {
|
2491 marek 1.95 // Removed the select expression from the cache
2492 WriteLock lock(rwSemSelxTab);
2493 if (--srec->count<=0)
2494 {
2495 selxTab.remove(sPath);
2496 delete _context;
2497 delete eSelx;
2498 delete srec;
2499 }
|
2500 marek 1.63 throw CIMException((CIMStatusCode)rc.rc,
2501 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
2502 }
2503 else
2504 {
2505 //
2506 // Increment count of current subscriptions for this provider
2507 //
2508 if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())
2509 {
2510 //
2511 // If there were no current subscriptions before the increment,
2512 // the first subscription has been created
2513 // Call the provider's enableIndications method
2514 //
2515 if (_subscriptionInitComplete)
2516 {
2517 _callEnableIndications (req_provider, _indicationCallback,
|
2518 dave.sudlik 1.100 ph, (const char*)info);
|
2519 marek 1.63 }
2520 }
2521 }
2522 }
2523 HandlerCatch(handler);
2524
2525 PEG_METHOD_EXIT();
2526
2527 return(response);
2528 }
2529
2530 Message * CMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message)
2531 {
2532 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleDeleteSubscriptionRequest");
2533
2534 HandlerIntroInd(DeleteSubscription,message,request,response,
2535 handler);
2536 try {
2537 String providerName,providerLocation;
2538
2539 CIMInstance req_provider, req_providerModule;
2540 marek 1.63 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
2541 req_provider = pidc.getProvider();
2542 req_providerModule = pidc.getModule();
2543
2544 LocateIndicationProviderNames(req_provider, req_providerModule,
2545 providerName,providerLocation);
2546
2547 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2548 "CMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
2549 System::getHostName(),
2550 request->nameSpace.getString(),
2551 providerName);
2552
2553 Boolean remote=false;
2554 CMPIProvider::OpProviderHolder ph;
2555
2556 if ((remote=pidc.isRemoteNameSpace())) {
|
2557 marek 1.68 ph = providerManager.getRemoteProvider(providerLocation, providerName);
|
2558 marek 1.63 }
2559 else {
2560 // get cached or load new provider module
|
2561 marek 1.68 ph = providerManager.getProvider(providerLocation, providerName);
|
2562 marek 1.63 }
2563
2564
2565 indProvRecord *prec=NULL;
|
2566 marek 1.95 {
2567 WriteLock writeLock(rwSemProvTab);
|
2568 marek 1.68 provTab.lookup(ph.GetProvider().getName(),prec);
|
2569 marek 1.63 if (--prec->count<=0) {
2570 if (prec->handler)
2571 delete prec->handler;
2572 delete prec;
|
2573 marek 1.68 provTab.remove(ph.GetProvider().getName());
|
2574 marek 1.63 prec=NULL;
2575 }
|
2576 marek 1.95 }
|
2577 marek 1.63
2578 indSelectRecord *srec=NULL;
2579 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
2580 r.kieninger 1.81
|
2581 marek 1.95 WriteLock writeLock(rwSemSelxTab);
|
2582 r.kieninger 1.81 if (!selxTab.lookup(sPath,srec)) {
2583 // failed to get select expression from hash table
|
2584 marek 1.95 throw CIMException(CIM_ERR_FAILED,
2585 "CMPI Provider Manager Failed to locate subscription filter.");
|
2586 r.kieninger 1.81 };
|
2587 marek 1.63
2588 CMPI_SelectExp *eSelx=srec->eSelx;
|
2589 r.kieninger 1.81 CIMOMHandleQueryContext *qContext=srec->qContext;
|
2590 marek 1.63
2591 CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]);
|
2592 marek 1.95 if (--srec->count<=0)
2593 {
|
2594 r.kieninger 1.81 selxTab.remove(sPath);
|
2595 marek 1.95 }
|
2596 marek 1.63
2597 // convert arguments
2598 OperationContext context;
2599 context.insert(request->operationContext.get(IdentityContainer::NAME));
2600 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2601 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2602 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
2603
2604 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
2605
2606 CMPIProvider & pr=ph.GetProvider();
2607
2608 CMPIStatus rc={CMPI_RC_OK,NULL};
2609 CMPI_ContextOnStack eCtx(context);
2610 CMPI_ThreadContext thr(&pr.broker,&eCtx);
2611
2612 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2613 "Calling provider.deleteSubscriptionRequest: " + pr.getName());
2614
2615 DDD(cerr<<"--- CMPIProviderManager::deleteSubscriptionRequest"<<endl);
2616
2617 marek 1.63 const IdentityContainer container =
2618 request->operationContext.get(IdentityContainer::NAME);
2619 eCtx.ft->addEntry(&eCtx,
2620 CMPIPrincipal,
2621 (CMPIValue*)(const char*)container.getUserName().getCString(),
2622 CMPI_chars);
2623
2624 eCtx.ft->addEntry(&eCtx,
|
2625 konrad.r 1.66 CMPIInitNameSpace,
|
2626 marek 1.63 (CMPIValue*)(const char*)request->nameSpace.getString().getCString(),
2627 CMPI_chars);
|
2628 konrad.r 1.65
2629 const AcceptLanguageListContainer accept_language=
2630 request->operationContext.get(AcceptLanguageListContainer::NAME);
|
2631 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
|
2632 kumpf 1.79 eCtx.ft->addEntry(
2633 &eCtx,
|
2634 dave.sudlik 1.99 CMPIAcceptLanguage,
|
2635 kumpf 1.79 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
2636 acceptLangs).getCString(),
2637 CMPI_chars);
|
2638 dave.sudlik 1.100 CString info;
|
2639 marek 1.63 if (remote) {
|
2640 dave.sudlik 1.100 info=pidc.getRemoteInfo().getCString();
|
2641 marek 1.63 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
2642 }
2643
2644 CMPIProvider::pm_service_op_lock op_lock(&pr);
2645
|
2646 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
2647 marek 1.90
|
2648 dave.sudlik 1.96 if (pr.miVector.indMI==0)
2649 {
2650 _throw_MINotInitializedException();
2651 }
2652
|
2653 kumpf 1.92 {
2654 StatProviderTimeMeasurement providerTime(response);
2655
2656 if (pr.miVector.indMI->ft->ftVersion >= 100)
2657 {
2658 rc = pr.miVector.indMI->ft->deActivateFilter(
2659 pr.miVector.indMI,&eCtx,eSelx,
2660 CHARS(eSelx->classNames[0].getClassName().getString().
|
2661 dave.sudlik 1.96 getCString()),&eRef,prec==NULL);
|
2662 kumpf 1.92 }
2663 else
2664 {
2665 // Older version of (pre 1.00) also pass in a CMPIResult
|
2666 marek 1.63
|
2667 kumpf 1.92 rc = ((CMPIStatus (*)(CMPIIndicationMI*, CMPIContext*,
2668 CMPIResult*, CMPISelectExp*,
2669 const char *, CMPIObjectPath*, CMPIBoolean))
|
2670 dave.sudlik 1.96 pr.miVector.indMI->ft->deActivateFilter)
2671 (pr.miVector.indMI,&eCtx,NULL,eSelx,
|
2672 kumpf 1.92 CHARS(eSelx->classNames[0].getClassName().getString().
|
2673 dave.sudlik 1.96 getCString()),&eRef,prec==NULL);
|
2674 kumpf 1.92 }
2675 }
|
2676 marek 1.63
|
2677 marek 1.95 if (srec->count<=0)
2678 {
|
2679 kumpf 1.92 delete qContext;
2680 delete eSelx;
2681 delete srec;
|
2682 marek 1.95 }
|
2683 marek 1.63
|
2684 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
2685 // Do this before checking rc from provider to throw exception in case
2686 // rc.msg is also localized.
2687 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2688 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2689 if (tmprc.rc == CMPI_RC_OK)
2690 {
2691 response->operationContext.set(
2692 ContentLanguageListContainer(
2693 ContentLanguageList(
|
2694 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
2695 CMGetCharPtr(cldata.value.string)))));
|
2696 dave.sudlik 1.99 }
2697
|
2698 marek 1.63 if (rc.rc!=CMPI_RC_OK)
2699 {
2700 throw CIMException((CIMStatusCode)rc.rc,
2701 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
2702 }
2703 else
2704 {
2705 //
2706 // Decrement count of current subscriptions for this provider
2707 //
2708 if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())
2709 {
2710 //
2711 // If there are no current subscriptions after the decrement,
2712 // the last subscription has been deleted
2713 // Call the provider's disableIndications method
2714 //
2715 if (_subscriptionInitComplete)
2716 {
|
2717 dave.sudlik 1.100 _callDisableIndications (ph, (const char*)info);
|
2718 marek 1.63 }
2719 }
2720 }
2721 }
2722 HandlerCatch(handler);
2723
2724 PEG_METHOD_EXIT();
2725
2726 return(response);
2727 }
2728
2729 Message * CMPIProviderManager::handleDisableModuleRequest(const Message * message)
2730 {
2731 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleDisableModuleRequest");
2732
2733 CIMDisableModuleRequestMessage * request =
2734 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
2735
2736 PEGASUS_ASSERT(request != 0);
2737
2738 // get provider module name
2739 marek 1.63 Boolean disableProviderOnly = request->disableProviderOnly;
2740
2741 Array<Uint16> operationalStatus;
2742 // Assume success.
2743 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
2744
2745 //
2746 // Unload providers
2747 //
2748 Array<CIMInstance> _pInstances = request->providers;
2749 Array <Boolean> _indicationProviders = request->indicationProviders;
2750 /* The CIMInstances on request->providers array is completly _different_ than
2751 the request->providerModule CIMInstance. Hence */
2752
|
2753 konrad.r 1.69 String physicalName=(request->providerModule.getProperty(
|
2754 marek 1.63 request->providerModule.findProperty("Location")).getValue().toString());
2755
2756 for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)
2757 {
2758 String providerName;
2759 _pInstances [i].getProperty (_pInstances [i].findProperty
2760 (CIMName ("Name"))).getValue ().get (providerName);
2761
2762 Uint32 pos = _pInstances[i].findProperty("Name");
2763
2764 //
2765 // Reset the indication provider's count of current
2766 // subscriptions since it has been disabled
2767 //
2768 if (_indicationProviders [i])
2769 {
2770 if (physicalName.size () > 0)
2771 {
|
2772 konrad.r 1.70 try {
|
2773 marek 1.63 CMPIProvider::OpProviderHolder ph = providerManager.getProvider
2774 (physicalName, providerName);
2775 ph.GetProvider ().resetSubscriptions ();
|
2776 konrad.r 1.70 } catch (const Exception &e) {
2777 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2778 e.getMessage());
2779 }
|
2780 marek 1.63 }
2781 }
|
2782 konrad.r 1.70 providerManager.unloadProvider(physicalName, _pInstances[i].getProperty(
2783 _pInstances[i].findProperty("Name")
2784 ).getValue ().toString ());
|
2785 marek 1.63 }
2786
2787 CIMDisableModuleResponseMessage * response =
2788 new CIMDisableModuleResponseMessage(
2789 request->messageId,
2790 CIMException(),
2791 request->queueIds.copyAndPop(),
2792 operationalStatus);
2793
2794 PEGASUS_ASSERT(response != 0);
2795
2796 //
2797 // Set HTTP method in response from request
2798 //
2799 response->setHttpMethod (request->getHttpMethod ());
2800
2801 PEG_METHOD_EXIT();
2802
2803 return(response);
2804 }
2805
2806 marek 1.63 Message * CMPIProviderManager::handleEnableModuleRequest(const Message * message)
2807 {
2808 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleEnableModuleRequest");
2809
2810 CIMEnableModuleRequestMessage * request =
2811 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
2812
2813 PEGASUS_ASSERT(request != 0);
2814
2815 Array<Uint16> operationalStatus;
2816 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
2817
2818 CIMEnableModuleResponseMessage * response =
2819 new CIMEnableModuleResponseMessage(
2820 request->messageId,
2821 CIMException(),
2822 request->queueIds.copyAndPop(),
2823 operationalStatus);
2824
2825 PEGASUS_ASSERT(response != 0);
2826
2827 marek 1.63 // Set HTTP method in response from request
2828 response->setHttpMethod (request->getHttpMethod ());
2829
2830 PEG_METHOD_EXIT();
2831
2832 return(response);
2833 }
2834
2835 Message * CMPIProviderManager::handleStopAllProvidersRequest(const Message * message)
2836 {
2837 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleStopAllProvidersRequest");
2838
2839 CIMStopAllProvidersRequestMessage * request =
2840 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
2841
2842 PEGASUS_ASSERT(request != 0);
2843
2844 CIMStopAllProvidersResponseMessage * response =
2845 new CIMStopAllProvidersResponseMessage(
2846 request->messageId,
2847 CIMException(),
2848 marek 1.63 request->queueIds.copyAndPop());
2849
2850 PEGASUS_ASSERT(response != 0);
2851
2852 // Set HTTP method in response from request
2853 response->setHttpMethod (request->getHttpMethod ());
2854
2855 // tell the provider manager to shutdown all the providers
2856 providerManager.shutdownAllProviders();
2857
2858 PEG_METHOD_EXIT();
2859
2860 return(response);
2861 }
2862
2863 Message * CMPIProviderManager::handleInitializeProviderRequest(const Message * message)
2864 {
2865 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "CMPIProviderManager::handleInitializeProviderRequest");
2866
2867 HandlerIntroInit(InitializeProvider,message,request,response,handler);
2868
2869 marek 1.63 try
2870 {
2871 // resolve provider name
2872 ProviderName name = _resolveProviderName(
2873 request->operationContext.get(ProviderIdContainer::NAME));
2874
2875 // get cached or load new provider module
2876 CMPIProvider::OpProviderHolder ph =
2877 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
2878
2879 }
2880 HandlerCatch(handler);
2881
2882 PEG_METHOD_EXIT();
2883
2884 return(response);
2885 }
2886
2887 Message * CMPIProviderManager::handleSubscriptionInitCompleteRequest
2888 (const Message * message)
2889 {
2890 marek 1.63 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
2891 "CMPIProviderManager::handleSubscriptionInitCompleteRequest");
2892
2893 CIMSubscriptionInitCompleteRequestMessage * request =
2894 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
2895 (const_cast <Message *> (message));
2896
2897 PEGASUS_ASSERT (request != 0);
2898
2899 CIMSubscriptionInitCompleteResponseMessage * response =
2900 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
2901 (request->buildResponse ());
2902
2903 PEGASUS_ASSERT (response != 0);
2904
2905 //
2906 // Set indicator
2907 //
2908 _subscriptionInitComplete = true;
2909
2910 //
2911 marek 1.63 // For each provider that has at least one subscription, call
2912 // provider's enableIndications method
2913 //
2914 Array <CMPIProvider *> enableProviders;
2915 enableProviders = providerManager.getIndicationProvidersToEnable ();
2916
2917 Uint32 numProviders = enableProviders.size ();
2918 for (Uint32 i = 0; i < numProviders; i++)
2919 {
2920 try
2921 {
2922 CIMInstance provider;
2923 provider = enableProviders [i]->getProviderInstance ();
2924
2925 //
2926 // Get cached or load new provider module
2927 //
2928 CMPIProvider::OpProviderHolder ph = providerManager.getProvider
2929 (enableProviders [i]->getModule ()->getFileName (),
2930 enableProviders [i]->getName ());
|
2931 dave.sudlik 1.100 // Add remote info
|
2932 dave.sudlik 1.104 // ATTN: bug 5951
|
2933 dave.sudlik 1.100 CString info;
|
2934 dave.sudlik 1.104 // {
2935 // ProviderIdContainer pidc = (ProviderIdContainer)
2936 // request->operationContext.get(ProviderIdContainer::NAME);
2937 // if (pidc.isRemoteNameSpace() )
2938 // {
2939 // info = pidc.getRemoteInfo().getCString();
2940 // }
2941 // }
|
2942 dave.sudlik 1.100 _callEnableIndications (provider, _indicationCallback, ph, (const char*)info);
|
2943 marek 1.63 }
|
2944 konrad.r 1.64 catch (const CIMException & e)
|
2945 marek 1.63 {
2946 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2947 "CIMException: " + e.getMessage ());
2948 }
|
2949 konrad.r 1.64 catch (const Exception & e)
|
2950 marek 1.63 {
2951 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2952 "Exception: " + e.getMessage ());
2953 }
2954 catch(...)
2955 {
|
2956 marek 1.104.4.1 PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
|
2957 marek 1.63 "Unknown error in handleSubscriptionInitCompleteRequest");
2958 }
2959 }
2960
2961 PEG_METHOD_EXIT ();
2962 return (response);
2963 }
2964
|
2965 dave.sudlik 1.98 Message * CMPIProviderManager::handleGetPropertyRequest(const Message * message)
2966 {
2967 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
2968 "CMPIProviderManager::handleGetPropertyRequest");
2969
2970 HandlerIntro(GetProperty,message,request,response,handler);
2971
2972 // We're only going to be interested in the specific property from this
2973 // instance.
2974 Array<CIMName> localPropertyListArray;
2975 localPropertyListArray.append(request->propertyName);
2976 CIMPropertyList localPropertyList(localPropertyListArray);
2977
2978 // NOTE: GetProperty will use the CIMInstanceProvider interface, so we
2979 // must manually define a request, response, and handler (emulate
2980 // HandlerIntro macro)
2981 CIMGetInstanceRequestMessage * GI_request =
2982 new CIMGetInstanceRequestMessage(
2983 request->messageId,
2984 request->nameSpace,
2985 request->instanceName,
2986 dave.sudlik 1.98 false,
2987 false,
2988 false,
2989 localPropertyList,
2990 request->queueIds,
2991 request->authType,
2992 request->userName
2993 );
2994
2995 PEGASUS_ASSERT(GI_request != 0);
2996
2997 CIMGetInstanceResponseMessage * GI_response =
2998 dynamic_cast<CIMGetInstanceResponseMessage*>(GI_request->buildResponse());
2999
3000 PEGASUS_ASSERT(GI_response != 0);
3001
3002 GetInstanceResponseHandler GI_handler(GI_request, GI_response, _responseChunkCallback);
3003
3004 try
3005 {
3006 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3007 dave.sudlik 1.98 "CmpiProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2 Property name: $3",
3008 System::getHostName(),
3009 request->nameSpace.getString(),
3010 request->instanceName.getClassName().getString(),
3011 request->propertyName.getString());
3012
3013 // make target object path
3014 CIMObjectPath objectPath(
3015 System::getHostName(),
3016 request->nameSpace,
3017 request->instanceName.getClassName(),
3018 request->instanceName.getKeyBindings());
3019
3020 Boolean remote=false;
3021 CMPIProvider::OpProviderHolder ph;
3022
3023 // resolve provider name
3024 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
3025 ProviderName name = _resolveProviderName(pidc);
3026
3027 if ((remote=pidc.isRemoteNameSpace())) {
3028 dave.sudlik 1.98 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
3029 }
3030 else {
3031 // get cached or load new provider module
3032 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
3033 }
3034
3035 // convert arguments
3036 OperationContext context;
3037
3038 context.insert(request->operationContext.get(IdentityContainer::NAME));
3039 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3040 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3041 // forward request
3042 CMPIProvider & pr=ph.GetProvider();
3043
3044 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
3045 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
3046 // If normalization is enabled, then the normalizer will take care of
3047 // any EmbeddedInstance / EmbeddedObject mismatches, and we don't need
3048 // to add a NormalizerContextContainer. The presence of an
3049 dave.sudlik 1.98 // ObjectNormalizer is determined by the presence of the
3050 // CachedClassDefinitionContainer
3051 if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
3052 {
3053 request->operationContext.get(CachedClassDefinitionContainer::NAME);
3054 }
3055 else
3056 #endif // PEGASUS_ENABLE_OBJECT_NORMALIZATION
3057 {
3058 // If a mechanism is needed to correct mismatches between the
3059 // EmbeddedInstance and EmbeddedObject types, then insert
3060 // containers for the class definition and a NormalizerContext.
3061 AutoPtr<NormalizerContext> tmpNormalizerContext(
3062 new CIMOMHandleContext(*pr._cimom_handle));
3063 CIMClass classDef(tmpNormalizerContext->getClass(
3064 request->nameSpace, request->className));
3065 request->operationContext.insert(CachedClassDefinitionContainer(classDef));
3066 request->operationContext.insert(
3067 NormalizerContextContainer(tmpNormalizerContext));
3068 }
3069 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
3070 dave.sudlik 1.98
3071 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3072 "Calling provider.getInstance via getProperty: " + pr.getName());
3073
3074 DDD(cerr<<"--- CMPIProviderManager::getInstance via getProperty"<<endl);
3075
3076 CMPIStatus rc={CMPI_RC_OK,NULL};
3077 CMPI_ContextOnStack eCtx(context);
3078 CMPI_ObjectPathOnStack eRef(objectPath);
3079 CMPI_ResultOnStack eRes(GI_handler,&pr.broker);
3080 CMPI_ThreadContext thr(&pr.broker,&eCtx);
3081
3082 // For the getInstance provider call, use the property list that we
3083 // created containing the single property from the getProperty call.
3084 CMPIPropertyList props(localPropertyList);
3085
3086 CMPIFlags flgs=0;
3087 // Leave includeQualifiers and includeClassOrigin as false for this call to getInstance
3088 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
3089
3090 const IdentityContainer container =
3091 dave.sudlik 1.98 request->operationContext.get(IdentityContainer::NAME);
3092 eCtx.ft->addEntry(&eCtx,
3093 CMPIPrincipal,
3094 (CMPIValue*)(const char*)container.getUserName().getCString(),
3095 CMPI_chars);
3096
3097 const AcceptLanguageListContainer accept_language=
3098 request->operationContext.get(AcceptLanguageListContainer::NAME);
3099 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
3100
3101 eCtx.ft->addEntry(
3102 &eCtx,
|
3103 dave.sudlik 1.99 CMPIAcceptLanguage,
|
3104 dave.sudlik 1.98 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
3105 acceptLangs).getCString(),
3106 CMPI_chars);
3107
3108 if (remote) {
3109 CString info=pidc.getRemoteInfo().getCString();
3110 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
3111 }
3112
3113 CMPIProvider::pm_service_op_lock op_lock(&pr);
3114
|
3115 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
3116 dave.sudlik 1.98
3117 if (pr.miVector.instMI==0)
3118 {
3119 _throw_MINotInitializedException();
3120 }
3121
3122 {
3123 StatProviderTimeMeasurement providerTime(response);
3124
3125 rc = pr.miVector.instMI->ft->getInstance(
3126 pr.miVector.instMI,&eCtx,&eRes,&eRef,
3127 (const char **)props.getList());
3128 }
3129
|
3130 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
3131 // Do this before checking rc from provider to throw exception in case
3132 // rc.msg is also localized.
3133 CMPIStatus tmprc={CMPI_RC_OK,NULL};
3134 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
3135 if (tmprc.rc == CMPI_RC_OK)
3136 {
3137 response->operationContext.set(
3138 ContentLanguageListContainer(
3139 ContentLanguageList(
|
3140 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
3141 CMGetCharPtr(cldata.value.string)))));
3142 handler.setContext(response->operationContext);
|
3143 dave.sudlik 1.99 }
3144
|
3145 dave.sudlik 1.98 if (rc.rc!=CMPI_RC_OK)
|
3146 dave.sudlik 1.102 {
3147 CIMException cimException(
3148 (CIMStatusCode)rc.rc,
3149 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
3150
3151 if (eRes.resError)
3152 {
3153 for (CMPI_Error* currErr=eRes.resError;
3154 currErr!=NULL;
3155 currErr=currErr->nextError)
3156 {
3157 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
3158 }
3159 }
3160 throw cimException;
3161 }
|
3162 dave.sudlik 1.98
3163 // Copy property value from instance to getProperty response
3164 if(!(GI_response->cimInstance.isUninitialized()))
3165 {
3166 Uint32 pos = GI_response->cimInstance.findProperty(request->propertyName);
3167
3168 if(pos != PEG_NOT_FOUND)
3169 {
3170 response->value = GI_response->cimInstance.getProperty(pos).getValue();
3171 }
3172 // Else property not found. Return CIM_ERR_NO_SUCH_PROPERTY.
3173 else
3174 {
3175 throw PEGASUS_CIM_EXCEPTION(
3176 CIM_ERR_NO_SUCH_PROPERTY,
3177 request->propertyName.getString()
3178 );
3179 }
3180 }
3181 }
3182 HandlerCatch(handler);
3183 dave.sudlik 1.98
3184 delete GI_request;
3185 delete GI_response;
3186
3187 PEG_METHOD_EXIT();
3188
3189 return(response);
3190 }
3191
3192 Message * CMPIProviderManager::handleSetPropertyRequest(const Message * message)
3193 {
3194 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
3195 "CMPIProviderManager::handleSetPropertyRequest");
3196
3197 HandlerIntro(SetProperty,message,request,response,handler);
3198
3199 // We're only going to be interested in the specific property from this instance.
3200 Array<CIMName> localPropertyListArray;
3201 localPropertyListArray.append(request->propertyName);
3202 CIMPropertyList localPropertyList(localPropertyListArray);
3203
3204 dave.sudlik 1.98 // Build a modified instance with just the specific property and its new value.
3205 CIMInstance localModifiedInstance(request->instanceName.getClassName());
3206 localModifiedInstance.setPath(request->instanceName);
3207 localModifiedInstance.addProperty(CIMProperty(request->propertyName, request->newValue));
3208
3209 // NOTE: SetProperty will use the CIMInstanceProvider interface, so we must manually
3210 // define a request, response, and handler.
3211 CIMModifyInstanceRequestMessage * MI_request =
3212 new CIMModifyInstanceRequestMessage(
3213 request->messageId,
3214 request->nameSpace,
3215 localModifiedInstance,
3216 false,
3217 localPropertyList,
3218 request->queueIds,
3219 request->authType,
3220 request->userName
3221 );
3222
3223 PEGASUS_ASSERT(MI_request != 0);
3224
3225 dave.sudlik 1.98 CIMModifyInstanceResponseMessage * MI_response =
3226 dynamic_cast<CIMModifyInstanceResponseMessage*>(MI_request->buildResponse());
3227
3228 PEGASUS_ASSERT(MI_response != 0);
3229
3230 ModifyInstanceResponseHandler MI_handler(MI_request, MI_response, _responseChunkCallback);
3231
3232 try
3233 {
3234 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3235 "CmpiProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2 Property name: $3",
3236 System::getHostName(),
3237 request->nameSpace.getString(),
3238 request->instanceName.getClassName().getString(),
3239 request->propertyName.getString());
3240
3241 // make target object path
3242 CIMObjectPath objectPath(
3243 System::getHostName(),
3244 request->nameSpace,
3245 request->instanceName.getClassName(),
3246 dave.sudlik 1.98 request->instanceName.getKeyBindings());
3247
3248 Boolean remote=false;
3249 CMPIProvider::OpProviderHolder ph;
3250
3251 // resolve provider name
3252 ProviderIdContainer pidc = request->operationContext.get(ProviderIdContainer::NAME);
3253 ProviderName name = _resolveProviderName(pidc);
3254
3255 if ((remote=pidc.isRemoteNameSpace())) {
3256 ph = providerManager.getRemoteProvider(name.getLocation(), name.getLogicalName());
3257 }
3258 else {
3259 // get cached or load new provider module
3260 ph = providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
3261 }
3262
3263 // convert arguments
3264 OperationContext context;
3265
3266 context.insert(request->operationContext.get(IdentityContainer::NAME));
3267 dave.sudlik 1.98 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3268 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3269 // forward request
3270 CMPIProvider & pr=ph.GetProvider();
3271
3272 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3273 "Calling provider.modifyInstance via setProperty: " + pr.getName());
3274
3275 DDD(cerr<<"--- CMPIProviderManager::modifyInstance via setProperty"<<endl);
3276
3277 CMPIStatus rc={CMPI_RC_OK,NULL};
3278 CMPI_ContextOnStack eCtx(context);
3279 CMPI_ObjectPathOnStack eRef(objectPath);
3280 CMPI_ResultOnStack eRes(MI_handler,&pr.broker);
3281 CMPI_InstanceOnStack eInst(localModifiedInstance);
3282 CMPI_ThreadContext thr(&pr.broker,&eCtx);
3283
3284 CMPIPropertyList props(localPropertyList);
3285
3286 CMPIFlags flgs=0;
3287 // Leave includeQualifiers as false for this call to modifyInstance
3288 dave.sudlik 1.98 eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
3289
3290 const IdentityContainer container =
3291 request->operationContext.get(IdentityContainer::NAME);
3292 eCtx.ft->addEntry(&eCtx,
3293 CMPIPrincipal,
3294 (CMPIValue*)(const char*)container.getUserName().getCString(),
3295 CMPI_chars);
3296
3297 const AcceptLanguageListContainer accept_language=
3298 request->operationContext.get(AcceptLanguageListContainer::NAME);
3299 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
3300 eCtx.ft->addEntry(
3301 &eCtx,
|
3302 dave.sudlik 1.99 CMPIAcceptLanguage,
|
3303 dave.sudlik 1.98 (CMPIValue*)(const char*)LanguageParser::buildAcceptLanguageHeader(
3304 acceptLangs).getCString(),
3305 CMPI_chars);
3306
3307 if (remote) {
3308 CString info=pidc.getRemoteInfo().getCString();
3309 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",(CMPIValue*)(const char*)info,CMPI_chars);
3310 }
3311
3312 CMPIProvider::pm_service_op_lock op_lock(&pr);
3313
|
3314 r.kieninger 1.104.4.2 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
|
3315 dave.sudlik 1.98
3316 if (pr.miVector.instMI==0)
3317 {
3318 _throw_MINotInitializedException();
3319 }
3320
3321 {
3322 StatProviderTimeMeasurement providerTime(response);
3323
3324 rc = pr.miVector.instMI->ft->modifyInstance(
3325 pr.miVector.instMI,&eCtx,&eRes,&eRef,&eInst,
3326 (const char **)props.getList());
3327 }
3328
|
3329 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response
3330 // Do this before checking rc from provider to throw exception in case
3331 // rc.msg is also localized.
3332 CMPIStatus tmprc={CMPI_RC_OK,NULL};
3333 CMPIData cldata = eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
3334 if (tmprc.rc == CMPI_RC_OK)
3335 {
3336 response->operationContext.set(
3337 ContentLanguageListContainer(
3338 ContentLanguageList(
|
3339 dave.sudlik 1.103 LanguageParser::parseContentLanguageHeader(
3340 CMGetCharPtr(cldata.value.string)))));
3341 handler.setContext(response->operationContext);
|
3342 dave.sudlik 1.99 }
3343
|
3344 dave.sudlik 1.98 if (rc.rc!=CMPI_RC_OK)
|
3345 dave.sudlik 1.102 {
3346 CIMException cimException(
3347 (CIMStatusCode)rc.rc,
|
3348 dave.sudlik 1.98 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
|
3349 dave.sudlik 1.102
3350 if (eRes.resError)
3351 {
3352 for (CMPI_Error* currErr=eRes.resError;
3353 currErr!=NULL;
3354 currErr=currErr->nextError)
3355 {
3356 cimException.addError(((CIMError*)currErr->hdl)->getInstance());
3357 }
3358 }
3359 throw cimException;
3360 }
|
3361 dave.sudlik 1.98 }
3362 HandlerCatch(handler);
3363
3364 delete MI_request;
3365 delete MI_response;
3366
3367 PEG_METHOD_EXIT();
3368
3369 return(response);
3370 }
3371
|
3372 marek 1.63 Message * CMPIProviderManager::handleUnsupportedRequest(const Message * message)
3373 {
3374 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
3375 "CMPIProviderManager::handleUnsupportedRequest");
3376 CIMRequestMessage* request =
3377 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
3378 PEGASUS_ASSERT(request != 0 );
3379
3380 CIMResponseMessage* response = request->buildResponse();
3381 response->cimException =
3382 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
3383
3384 PEG_METHOD_EXIT();
3385 return response;
3386 }
3387
3388 ProviderName CMPIProviderManager::_resolveProviderName(
3389 const ProviderIdContainer & providerId)
3390 {
3391 String providerName;
3392 String fileName;
3393 marek 1.63 String location;
3394 CIMValue genericValue;
3395
3396 genericValue = providerId.getProvider().getProperty(
3397 providerId.getProvider().findProperty("Name")).getValue();
3398 genericValue.get(providerName);
3399
3400 genericValue = providerId.getModule().getProperty(
3401 providerId.getModule().findProperty("Location")).getValue();
3402 genericValue.get(location);
3403 fileName = _resolvePhysicalName(location);
3404
|
3405 thilo.boehm 1.89 // An empty file name is only for interest if we are in the
3406 // local name space. So the message is only issued if not
3407 // in the remote Name Space.
3408 if (fileName == String::EMPTY && (!providerId.isRemoteNameSpace()))
3409 {
3410 genericValue.get(location);
3411 String fullName = FileSystem::buildLibraryFileName(location);
|
3412 yi.zhou 1.97 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
|
3413 thilo.boehm 1.89 "ProviderManager.CMPI.CMPIProviderManager.CANNOT_FIND_LIBRARY",
3414 "For provider $0 library $1 was not found.", providerName, fullName);
3415
3416 }
|
3417 marek 1.63 ProviderName name(providerName, fileName, String::EMPTY, 0);
3418 name.setLocation(location);
3419 return name;
3420 // return ProviderName(providerName, fileName, interfaceName, 0);
3421 }
3422
3423 void CMPIProviderManager::_callEnableIndications
3424 (CIMInstance & req_provider,
|
3425 kumpf 1.84 PEGASUS_INDICATION_CALLBACK_T _indicationCallback,
|
3426 dave.sudlik 1.100 CMPIProvider::OpProviderHolder & ph,
3427 const char* remoteInfo)
|
3428 marek 1.63 {
3429 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
3430 "CMPIProviderManager::_callEnableIndications");
3431
3432 try
3433 {
|
3434 w.otsuka 1.86 indProvRecord *provRec =0;
|
3435 marek 1.95 {
3436 WriteLock lock(rwSemProvTab);
3437
|
3438 marek 1.63 if (provTab.lookup (ph.GetProvider ().getName (), provRec))
3439 {
3440 provRec->enabled = true;
3441 CIMRequestMessage * request = 0;
3442 CIMResponseMessage * response = 0;
|
3443 kumpf 1.84 provRec->handler=new EnableIndicationsResponseHandler(
3444 request,
3445 response,
3446 req_provider,
3447 _indicationCallback,
3448 _responseChunkCallback);
|
3449 marek 1.63 }
|
3450 marek 1.95 }
|
3451 marek 1.63
3452 CMPIProvider & pr=ph.GetProvider();
3453
|
3454 dave.sudlik 1.96 if (pr.miVector.indMI==0)
3455 {
3456 _throw_MINotInitializedException();
3457 }
3458
|
3459 marek 1.63 //
3460 // Versions prior to 86 did not include enableIndications routine
3461 //
3462 if (pr.miVector.indMI->ft->ftVersion >= 86)
3463 {
3464 OperationContext context;
|
3465 marek 1.90 #ifdef PEGASUS_ZOS_THREADLEVEL_SECURITY
3466 // For the z/OS security model we always need an Identity container in
3467 // the operation context. Since we don't have a client request ID here
3468 // we have to use the cim servers identity for the time being.
3469 IdentityContainer idContainer(System::getEffectiveUserName());
3470 context.insert(idContainer);
3471 #endif
3472
|
3473 marek 1.63 CMPIStatus rc={CMPI_RC_OK,NULL};
3474 CMPI_ContextOnStack eCtx(context);
3475 CMPI_ThreadContext thr(&pr.broker,&eCtx);
3476
|
3477 dave.sudlik 1.100 // Add RemoteInformation -V 5245
3478 if (remoteInfo)
3479 {
3480 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",
3481 (CMPIValue*)(const char*)remoteInfo,CMPI_chars);
3482 }
3483
|
3484 marek 1.63 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3485 "Calling provider.enableIndications: " + pr.getName());
3486
3487 DDD(cerr<<"--- provider.enableIndications"<<endl);
3488
3489 CMPIProvider::pm_service_op_lock op_lock(&pr);
3490 ph.GetProvider().protect();
3491
|
3492 dave.sudlik 1.101 // enableIndications() is defined by the CMPI standard as
3493 // returning a CMPIStatus return value. Unfortunately, Pegasus
3494 // originally implemented enableIndications() with a void
3495 // return type, and this incompatibility was not detected for
3496 // some time. Since exceptions thrown from enableIndications()
3497 // are not reported (other than via logging), it was decided to
3498 // discard the returned CMPIStatus here. This will prevent us from
3499 // breaking existing CMPI Indication providers. This is ok since
3500 // there really isn't a user to which the problem should be
3501 // reported.
|
3502 konrad.r 1.64 pr.miVector.indMI->ft->enableIndications(pr.miVector.indMI,&eCtx);
|
3503 marek 1.63 }
3504 else
3505 {
3506 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3507 "Not calling provider.enableIndications: " + pr.getName() +
3508 " routine as it is an earlier version that does not support this function");
3509
3510 DDD(cerr<<"--- provider.enableIndications " \
3511 "cannot be called as the provider uses an earlier version " \
3512 "that does not support this function"<<endl);
3513 }
3514 }
|
3515 konrad.r 1.64 catch (const Exception & e)
|
3516 marek 1.63 {
3517 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
|
3518 dave.sudlik 1.101 "Exception in _callEnableIndications: " + e.getMessage ());
|
3519 marek 1.63
3520 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
3521 "ProviderManager.CMPI.CMPIProviderManager."
3522 "ENABLE_INDICATIONS_FAILED",
3523 "Failed to enable indications for provider $0: $1.",
3524 ph.GetProvider ().getName (), e.getMessage ());
3525 }
3526 catch(...)
3527 {
|
3528 marek 1.104.4.1 PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
|
3529 marek 1.63 "Unexpected error in _callEnableIndications");
3530
3531 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
3532 "ProviderManager.CMPI.CMPIProviderManager."
3533 "ENABLE_INDICATIONS_FAILED_UNKNOWN",
3534 "Failed to enable indications for provider $0.",
3535 ph.GetProvider ().getName ());
3536 }
3537
3538 PEG_METHOD_EXIT ();
3539 }
3540
3541 void CMPIProviderManager::_callDisableIndications
|
3542 dave.sudlik 1.100 (CMPIProvider::OpProviderHolder & ph, const char *remoteInfo)
|
3543 marek 1.63 {
3544 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
3545 "CMPIProviderManager::_callDisableIndications");
3546
|
3547 dave.sudlik 1.101 try
|
3548 marek 1.95 {
|
3549 dave.sudlik 1.101 indProvRecord * provRec = 0;
3550 {
3551 WriteLock writeLock(rwSemProvTab);
3552 if (provTab.lookup (ph.GetProvider ().getName (), provRec))
3553 {
3554 provRec->enabled = false;
3555 if (provRec->handler) delete provRec->handler;
3556 provRec->handler = NULL;
3557 }
3558 }
3559
3560 CMPIProvider & pr=ph.GetProvider();
|
3561 marek 1.63
|
3562 dave.sudlik 1.101 if (pr.miVector.indMI==0)
3563 {
3564 _throw_MINotInitializedException();
3565 }
|
3566 marek 1.63
|
3567 dave.sudlik 1.101 //
3568 // Versions prior to 86 did not include disableIndications routine
3569 //
3570 if (pr.miVector.indMI->ft->ftVersion >= 86)
3571 {
3572 OperationContext context;
3573 CMPIStatus rc={CMPI_RC_OK,NULL};
3574 CMPI_ContextOnStack eCtx(context);
3575
3576 if (remoteInfo)
3577 {
3578 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",
3579 (CMPIValue*)(const char*)remoteInfo,CMPI_chars);
3580 }
3581 CMPI_ThreadContext thr(&pr.broker,&eCtx);
|
3582 dave.sudlik 1.96
|
3583 dave.sudlik 1.101 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3584 "Calling provider.disableIndications: " + pr.getName());
|
3585 dave.sudlik 1.100
|
3586 dave.sudlik 1.101 DDD(cerr<<"--- provider.disableIndications"<<endl);
|
3587 marek 1.63
|
3588 dave.sudlik 1.101 CMPIProvider::pm_service_op_lock op_lock(&pr);
|
3589 marek 1.63
|
3590 dave.sudlik 1.101 // disableIndications() is defined by the CMPI standard as
3591 // returning a CMPIStatus return value. Unfortunately, Pegasus
3592 // originally implemented disableIndications() with a void
3593 // return type, and this incompatibility was not detected for
3594 // some time. For consistency with the enableIndications()
3595 // interface, it was decided to discard the returned CMPIStatus
3596 // here. This will prevent us from breaking existing CMPI
3597 // Indication providers. This is ok since there really isn't a
3598 // user to which the problem should be reported.
3599 pr.miVector.indMI->ft->disableIndications(pr.miVector.indMI, &eCtx);
|
3600 marek 1.63
|
3601 dave.sudlik 1.101 ph.GetProvider().unprotect();
3602 }
3603 else
3604 {
3605 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3606 "Not calling provider.disableIndications: "
3607 + pr.getName() +
3608 " routine as it is an earlier version that does not support this function");
|
3609 marek 1.63
|
3610 dave.sudlik 1.101 DDD(cerr<<"--- provider.disableIndications " \
3611 "cannot be called as the provider uses an earlier version " \
3612 "that does not support this function"<<endl);
3613 }
3614 }
3615 catch (const Exception & e)
3616 {
3617 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3618 "Exception in _callDisableIndications: " + e.getMessage ());
|
3619 marek 1.63
|
3620 dave.sudlik 1.101 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
3621 "ProviderManager.CMPI.CMPIProviderManager."
3622 "DISABLE_INDICATIONS_FAILED",
3623 "Failed to disable indications for provider $0: $1.",
3624 ph.GetProvider ().getName (), e.getMessage ());
|
3625 marek 1.63 }
|
3626 dave.sudlik 1.101 catch(...)
|
3627 marek 1.63 {
|
3628 marek 1.104.4.1 PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
|
3629 dave.sudlik 1.101 "Unexpected error in _callDisableIndications");
3630
3631 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
3632 "ProviderManager.CMPI.CMPIProviderManager."
3633 "DISABLE_INDICATIONS_FAILED_UNKNOWN",
3634 "Failed to disable indications for provider $0.",
3635 ph.GetProvider ().getName ());
|
3636 marek 1.63 }
3637
3638 PEG_METHOD_EXIT ();
3639 }
3640
3641 PEGASUS_NAMESPACE_END
|
Return to
CMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI