pegasus/src/Pegasus/ProviderManager2/CMPI/CMPIProviderManager.cpp - annotate

Return to CMPIProviderManager.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI

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

No CVS admin address has been configured