(file) Return to DefaultProviderManager.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Default

Diff for /pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp between version 1.11.4.4 and 1.12

version 1.11.4.4, 2004/03/18 20:38:36 version 1.12, 2004/01/27 13:48:11
Line 43 
Line 43 
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/MessageLoader.h> //l10n #include <Pegasus/Common/MessageLoader.h> //l10n
  
 //#include <Pegasus/Common/QueryExpression.h>  #include <Pegasus/Common/QueryExpression.h>
 //#include <Pegasus/ProviderManager2/QueryExpressionFactory.h>  #include <Pegasus/ProviderManager2/QueryExpressionFactory.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
 #include <Pegasus/ProviderManager2/Default/Provider.h> #include <Pegasus/ProviderManager2/Default/Provider.h>
 #include <Pegasus/ProviderManager2/OperationResponseHandler.h>  #include <Pegasus/ProviderManager2/Default/OperationResponseHandler.h>
  
 #include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h> #include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h>
 #include <Pegasus/ProviderManager2/ProviderManagerService.h>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 94 
Line 93 
 { {
 } }
  
 Message * DefaultProviderManager::processMessage(Message * request)  Message * DefaultProviderManager::processMessage(Message * request) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "DefaultProviderManager::processMessage()");         "DefaultProviderManager::processMessage()");
Line 128 
Line 127 
         response = handleDeleteInstanceRequest(request);         response = handleDeleteInstanceRequest(request);
  
         break;         break;
  //   case CIM_EXEC_QUERY_REQUEST_MESSAGE:      case CIM_EXEC_QUERY_REQUEST_MESSAGE:
  //       response = handleExecQueryRequest(request);          response = handleExecQueryRequest(request);
  
  //       break;          break;
     case CIM_ASSOCIATORS_REQUEST_MESSAGE:     case CIM_ASSOCIATORS_REQUEST_MESSAGE:
         response = handleAssociatorsRequest(request);         response = handleAssociatorsRequest(request);
  
Line 184 
Line 183 
         response = handleConsumeIndicationRequest(request);         response = handleConsumeIndicationRequest(request);
         break;         break;
  
     case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:  
         response = handleExportIndicationRequest(request);  
         break;  
   
     case CIM_DISABLE_MODULE_REQUEST_MESSAGE:     case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
         response = handleDisableModuleRequest(request);         response = handleDisableModuleRequest(request);
  
Line 211 
Line 206 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message)  Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");
  
Line 221 
Line 216 
     return(0);     return(0);
 } }
  
 Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message)  Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");
  
Line 264 
Line 259 
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::INSTANCE);             ProviderType::INSTANCE);
  
         // resolve provider name         // resolve provider name
Line 329 
Line 327 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message)  Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");
  
Line 371 
Line 369 
             request->className);             request->className);
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::INSTANCE);             ProviderType::INSTANCE);
  
         // resolve provider name         // resolve provider name
Line 436 
Line 437 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message)  Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");
  
Line 480 
Line 481 
  
         // build an internal provider name from the request arguments         // build an internal provider name from the request arguments
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::INSTANCE);             ProviderType::INSTANCE);
  
         // resolve provider name         // resolve provider name
Line 540 
Line 544 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message)  Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");
  
Line 584 
Line 588 
             request->newInstance.getPath().getKeyBindings());             request->newInstance.getPath().getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::INSTANCE);             ProviderType::INSTANCE);
  
         // resolve provider name         // resolve provider name
Line 645 
Line 652 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message)  Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");
  
Line 688 
Line 695 
             request->modifiedInstance.getPath ().getKeyBindings());             request->modifiedInstance.getPath ().getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::INSTANCE);             ProviderType::INSTANCE);
  
         // resolve provider name         // resolve provider name
Line 753 
Line 763 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message)  Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");
  
Line 796 
Line 806 
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::INSTANCE);             ProviderType::INSTANCE);
  
         // resolve provider name         // resolve provider name
Line 855 
Line 868 
  
     return(response);     return(response);
 } }
 /*  
 Message * DefaultProviderManager::handleExecQueryRequest(const Message * message)  Message * DefaultProviderManager::handleExecQueryRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");
  
Line 898 
Line 911 
             request->className);             request->className);
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::QUERY);             ProviderType::QUERY);
  
         // resolve provider name         // resolve provider name
Line 970 
Line 986 
  
     return(response);     return(response);
 } }
 */  
 Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message)  Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");
  
Line 1012 
Line 1028 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         CIMObjectPath assocPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->assocClass.getString());  
   
         ProviderName name(         ProviderName name(
             assocPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::ASSOCIATION);             ProviderType::ASSOCIATION);
  
         // resolve provider name         // resolve provider name
Line 1079 
Line 1093 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message)  Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest");
  
Line 1123 
Line 1137 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         CIMObjectPath assocPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->assocClass.getString());  
   
         ProviderName name(         ProviderName name(
             assocPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::ASSOCIATION);             ProviderType::ASSOCIATION);
  
         // resolve provider name         // resolve provider name
Line 1186 
Line 1198 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleReferencesRequest(const Message * message)  Message * DefaultProviderManager::handleReferencesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");
  
Line 1230 
Line 1242 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         CIMObjectPath resultPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->resultClass.getString());  
   
         ProviderName name(         ProviderName name(
             resultPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::ASSOCIATION);             ProviderType::ASSOCIATION);
  
         // resolve provider name         // resolve provider name
Line 1300 
Line 1310 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message)  Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");
  
Line 1342 
Line 1352 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         CIMObjectPath resultPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->resultClass.getString());  
   
         ProviderName name(         ProviderName name(
             resultPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             ProviderType::ASSOCIATION);             ProviderType::ASSOCIATION);
  
         // resolve provider name         // resolve provider name
Line 1409 
Line 1417 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message)  Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");
  
Line 1452 
Line 1460 
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             0);             0);
  
         // resolve provider name         // resolve provider name
Line 1515 
Line 1526 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message)  Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");
  
Line 1560 
Line 1571 
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
               String::EMPTY,
               String::EMPTY,
               String::EMPTY,
             0);             0);
  
         // resolve provider name         // resolve provider name
Line 1625 
Line 1639 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message)  Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");
  
Line 1671 
Line 1685 
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(         ProviderName name(
             objectPath,              objectPath.toString(),
             ProviderType::METHOD,              String::EMPTY,
             request->methodName);              String::EMPTY,
               String::EMPTY,
               0);
  
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);         name = _resolveProviderName(name);
Line 1739 
Line 1755 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message)  Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");
  
Line 1784 
Line 1800 
             request->nameSpace.getString(),             request->nameSpace.getString(),
             temp);             temp);
  
         String physicalName=_resolvePhysicalName(          // NOTE: the provider and provider module name are embedded in the request, presumably to reduce
            request->providerModule.getProperty(          // the number of provider lookups (but this should be trivial if the data is cached and accessed
            request->providerModule.findProperty("Location")).getValue().toString());          // from the same source). to keep the lookups consistent, use the first class name, combined
           // with the other information in the request, and create an object path that can be used to
           // resolve the provider using the ProviderRegistrar.
   
           // make target object path
           CIMObjectPath objectPath(
               System::getHostName(),
               request->nameSpace,
               request->classNames[0].getString());
  
         ProviderName name(         ProviderName name(
            request->provider.getProperty(request->provider.findProperty              objectPath.toString(),
               ("Name")).getValue ().toString (),              String::EMPTY,
            physicalName,              String::EMPTY,
            request->providerModule.getProperty(request->providerModule.findProperty              String::EMPTY,
               ("InterfaceType")).getValue().toString(),  
             0);             0);
  
           // resolve provider name
           name = _resolveProviderName(name);
   
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =         OpProviderHolder ph =
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
Line 1871 
Line 1897 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message)  Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");
  
Line 1911 
Line 1937 
         }         }
  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
             "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",              "DefaultProviderManager::handleModifySubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             temp);             temp);
  
         String physicalName=_resolvePhysicalName(          // NOTE: the provider and provider module name are embedded in the request, presumably to reduce
            request->providerModule.getProperty(          // the number of provider lookups (but this should be trivial if the data is cached and accessed
            request->providerModule.findProperty("Location")).getValue().toString());          // from the same source). to keep the lookups consistent, use the first class name, combined
           // with the other information in the request, and create an object path that can be used to
           // resolve the provider using the ProviderRegistrar.
   
           // make target object path
           CIMObjectPath objectPath(
               System::getHostName(),
               request->nameSpace,
               request->classNames[0].getString());
  
         ProviderName name(         ProviderName name(
            request->provider.getProperty(request->provider.findProperty              objectPath.toString(),
               ("Name")).getValue ().toString (),              String::EMPTY,
            physicalName,              String::EMPTY,
            request->providerModule.getProperty(request->providerModule.findProperty              String::EMPTY,
               ("InterfaceType")).getValue().toString(),  
             0);             0);
  
           // resolve provider name
           name = _resolveProviderName(name);
   
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =         OpProviderHolder ph =
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
Line 2003 
Line 2039 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message)  Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");
  
Line 2048 
Line 2084 
             request->nameSpace.getString(),             request->nameSpace.getString(),
             temp);             temp);
  
         String physicalName=_resolvePhysicalName(          // NOTE: the provider and provider module name are embedded in the request, presumably to reduce
            request->providerModule.getProperty(          // the number of provider lookups (but this should be trivial if the data is cached and accessed
            request->providerModule.findProperty("Location")).getValue().toString());          // from the same source). to keep the lookups consistent, use the first class name, combined
           // with the other information in the request, and create an object path that can be used to
           // resolve the provider using the ProviderRegistrar.
   
           // make target object path
           CIMObjectPath objectPath(
               System::getHostName(),
               request->nameSpace,
               request->classNames[0].getString());
  
         ProviderName name(         ProviderName name(
            request->provider.getProperty(request->provider.findProperty              objectPath.toString(),
               ("Name")).getValue ().toString (),              String::EMPTY,
            physicalName,              String::EMPTY,
            request->providerModule.getProperty(request->providerModule.findProperty              String::EMPTY,
               ("InterfaceType")).getValue().toString(),  
             0);             0);
  
           // resolve provider name
           name = _resolveProviderName(name);
   
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =         OpProviderHolder ph =
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
Line 2127 
Line 2173 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message)  Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest");
  
Line 2158 
Line 2204 
  
     response->dest = request->queueIds.top();     response->dest = request->queueIds.top();
  
       /*
     // ATTN: need pointer to Provider Manager Server!     // ATTN: need pointer to Provider Manager Server!
      EnableIndicationsResponseHandler *handler =      //EnableIndicationsResponseHandler *handler =
         new EnableIndicationsResponseHandler(request, response,      //    new EnableIndicationsResponseHandler(request, response, this);
               request->provider, ProviderManagerService::providerManagerService);  
  
     try     try
     {     {
        String physicalName=_resolvePhysicalName(          // get the provider file name and logical name
           request->providerModule.getProperty(          Triad<String, String, String> triad =
               request->providerModule.findProperty("Location")).getValue().toString());              _getProviderRegPair(request->provider, request->providerModule);
   
        ProviderName name(  
                request->provider.getProperty(request->provider.findProperty  
                    ("Name")).getValue ().toString (),  
                physicalName,  
                request->providerModule.getProperty(request->providerModule.findProperty  
                     ("InterfaceType")).getValue().toString(),  
                0);  
  
         // get cached or load new provider module         // get cached or load new provider module
           //Provider provider =
         OpProviderHolder ph =         OpProviderHolder ph =
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              providerManager.getProvider(triad.first, triad.second, triad.third);
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Calling provider.enableIndications: " +             "Calling provider.enableIndications: " +
             ph.GetProvider().getName());             ph.GetProvider().getName());
           ph.GetProvider().protect();
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().enableIndications(*handler);         ph.GetProvider().enableIndications(*handler);
  
  
Line 2201 
Line 2238 
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
   
         response->cimException = CIMException(e);         response->cimException = CIMException(e);
     }     }
     catch(Exception & e)     catch(Exception & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
           //l10n
           //response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",
             "Internal Error"));             "Internal Error"));
Line 2216 
Line 2254 
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: Unknown");             "Exception: Unknown");
           //l10n
           //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",
             "Unknown Error"));             "Unknown Error"));
     }     }
       */
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
  
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message)  Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest");
  
Line 2241 
Line 2282 
         CIMException(),         CIMException(),
         request->queueIds.copyAndPop());         request->queueIds.copyAndPop());
  
       PEGASUS_ASSERT(response != 0);
   
     // preserve message key     // preserve message key
     response->setKey(request->getKey());     response->setKey(request->getKey());
  
Line 2251 
Line 2294 
  
     try     try
     {     {
        String physicalName=_resolvePhysicalName(  
               request->providerModule.getProperty(  
                  request->providerModule.findProperty("Location")).getValue().toString());  
   
        ProviderName name(        ProviderName name(
                request->provider.getProperty(request->provider.findProperty              String::EMPTY,
                    ("Name")).getValue ().toString (),              String::EMPTY,
                physicalName,              String::EMPTY,
                request->providerModule.getProperty(request->providerModule.findProperty              String::EMPTY,
                     ("InterfaceType")).getValue().toString(),  
             0);             0);
           /*
           ProviderName name(
               String::EMPTY,
               String::EMPTY,
               objectPath.toString());
   
           // resolve provider name
           name = _resolveProviderName(name);
           */
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =         OpProviderHolder ph =
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
  
           /*
           // get the provider file name and logical name
           Triad<String, String, String> triad =
               getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule);
   
           // get cached or load new provider module
           //Provider provider =
           OpProviderHolder ph =
               providerManager.getProvider(triad.first, triad.second, triad.third);
           */
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Calling provider.disableIndications: " +             "Calling provider.disableIndications: " +
             ph.GetProvider().getName());             ph.GetProvider().getName());
Line 2311 
Line 2369 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message *message)  Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message *message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest");
  
Line 2342 
Line 2400 
             String::EMPTY,             String::EMPTY,
             String::EMPTY,             String::EMPTY,
             String::EMPTY,             String::EMPTY,
               String::EMPTY,
             0);             0);
  
         /*         /*
Line 2413 
Line 2472 
     return(response);     return(response);
 } }
  
   
 Message *DefaultProviderManager::handleExportIndicationRequest(const Message *message)  
 {  
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManagerService::handlExportIndicationRequest");  
   
     CIMExportIndicationRequestMessage * request =  
         dynamic_cast<CIMExportIndicationRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMExportIndicationResponseMessage * response =  
         new CIMExportIndicationResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
        ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
        // resolve provider name  
        name = _resolveProviderName(request->destinationPath);  
   
        // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                        "Calling provider.: " +  
                        ph.GetProvider().getName());  
   
         OperationContext context;  
   
 //L10N_TODO  
 //l10n  
 // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent.  This  
 // does not appear to be hooked-up.  When it is added, need to  
 // make sure that Content-Language is set in the consume msg.  
 // NOTE: A-L is not needed to be set in the consume msg.  
       // add the langs to the context  
       context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
       CIMInstance indication_copy = request->indicationInstance;  
       pm_service_op_lock op_lock(&ph.GetProvider());  
   
       ph.GetProvider().consumeIndication(context,  
                                 request->destinationPath,  
                                 indication_copy);  
   
     }  
   
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown Error");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
   
   
   
 // //
 // This function disables a provider module if disableProviderOnly is not true, // This function disables a provider module if disableProviderOnly is not true,
 // otherwise, disables a provider. Disable provider module means that // otherwise, disables a provider. Disable provider module means that
Line 2517 
Line 2481 
 // //
 // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider. // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider.
 // //
 Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message)  Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message) throw()
 { {
       // HACK
       ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();
   
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");
  
     CIMDisableModuleRequestMessage * request =     CIMDisableModuleRequestMessage * request =
Line 2526 
Line 2493 
  
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
     Array<Uint16> operationalStatus;  
     Boolean disableProviderOnly = request->disableProviderOnly;  
     CIMException cimException;  
   
     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();  
   
     try {  
       // get provider module name       // get provider module name
       String moduleName;       String moduleName;
       CIMInstance mInstance = request->providerModule;       CIMInstance mInstance = request->providerModule;
       Uint32 pos = mInstance.findProperty(CIMName ("Name"));       Uint32 pos = mInstance.findProperty(CIMName ("Name"));
  
       if(pos != PEG_NOT_FOUND) {      if(pos != PEG_NOT_FOUND)
       {
          mInstance.getProperty(pos).getValue().get(moduleName);          mInstance.getProperty(pos).getValue().get(moduleName);
       }       }
  
Line 2547 
Line 2508 
       //       //
       // get operational status       // get operational status
       //       //
       if (!disableProviderOnly) {      Array<Uint16> operationalStatus;
   
       if(!disableProviderOnly)
       {
          Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus"));          Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus"));
                if (pos2 != PEG_NOT_FOUND) {  
           if(pos2 != PEG_NOT_FOUND)
           {
                //                //
                //  ATTN-CAKG-P2-20020821: Check for null status?                //  ATTN-CAKG-P2-20020821: Check for null status?
                //                //
Line 2559 
Line 2525 
          //          //
          // update module status from OK to Stopping          // update module status from OK to Stopping
          //          //
          for (Uint32 i=0, n = operationalStatus.size(); i < n; i++) {          for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)
                   if (operationalStatus[i] == _MODULE_OK) {          {
               if(operationalStatus[i] == _MODULE_OK)
               {
                   operationalStatus.remove(i);                   operationalStatus.remove(i);
                }                }
          }          }
   
          operationalStatus.append(_MODULE_STOPPING);          operationalStatus.append(_MODULE_STOPPING);
  
          if(_providerRegistrationManager->setProviderModuleStatus          if(_providerRegistrationManager->setProviderModuleStatus
                (moduleName, operationalStatus) == false) {              (moduleName, operationalStatus) == false)
           {
                //l10n                //l10n
                //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");                //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");
                   throw PEGASUS_CIM_EXCEPTION_L(              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
                      CIM_ERR_FAILED,                  "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",
                      MessageLoaderParms("ProviderManager.ProviderManagerService."                  "set module status failed."));
                               "SET_MODULE_STATUS_FAILED","set module status failed."));  
          }          }
       }       }
  
       // Unload providers       // Unload providers
       Array<CIMInstance> _pInstances = request->providers;       Array<CIMInstance> _pInstances = request->providers;
          Array<Boolean> _indicationProviders = request->indicationProviders;  
  
          String physicalName=_resolvePhysicalName(      for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)
             mInstance.getProperty(      {
                mInstance.findProperty("Location")).getValue().toString());          /* temp disabled by Chip
           // get the provider file name and logical name
       for (Uint32 i = 0, n = _pInstances.size(); i < n; i++) {          Triad<String, String, String> triad =
          String pName(_pInstances[i].getProperty(              getProviderRegistrar()->_getProviderRegPair(_pInstances[i], mInstance);
                   _pInstances[i].findProperty("Name")).getValue().toString());  
   
          Sint16 ret_value = providerManager.disableProvider(physicalName,pName);  
   
          if (ret_value == 0) {  
             // disable failed since there are pending requests,  
             // update module status from Stopping to OK if  
             // disableProviderOnly is not true  
             if (!disableProviderOnly) {  
                for(Uint32 j=0, m = operationalStatus.size(); j < m; j++) {  
                   if (operationalStatus[j] == _MODULE_STOPPING) {  
                      operationalStatus.remove(j);  
                   }  
                }  
   
                operationalStatus.append(_MODULE_OK);  
   
                if (_providerRegistrationManager->setProviderModuleStatus  
                      (moduleName, operationalStatus) == false) {  
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,  
                      MessageLoaderParms("ProviderManager.ProviderManagerService."  
                         "SET_MODULE_STATUS_FAILED","set module status failed."));  
                }  
             }  
          }  
  
          else if (ret_value == 1) {          providerManager.unloadProvider(triad.first, triad.second);
             // if It is an indication provider          */
             // remove the entry from the table since the  
             // provider has been disabled  
             if (_indicationProviders[i]) {  
                _removeEntry(_generateKey(pName,physicalName));  
             }  
          }  
          else {  
             // disable failed for other reason, throw exception  
             // update module status from Stopping to OK if  
             // disableProviderOnly is not true  
             if (!disableProviderOnly) {  
                for (Uint32 j=0, m = operationalStatus.size(); j < m; j++) {  
                   if (operationalStatus[j] == _MODULE_STOPPING) {  
                      operationalStatus.remove(j);  
                   }  
                }                }
  
                operationalStatus.append(_MODULE_OK);      if(!disableProviderOnly)
       {
                if (_providerRegistrationManager->setProviderModuleStatus          // update module status from Stopping to Stopped
                            (moduleName, operationalStatus) == false) {          for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,          {
                      MessageLoaderParms("ProviderManager.ProviderManagerService."              if(operationalStatus[i] == _MODULE_STOPPING)
                         "SET_MODULE_STATUS_FAILED","set module status failed."));              {
                   operationalStatus.remove(i);
                }                }
             }             }
  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,  
                MessageLoaderParms("ProviderManager.ProviderManagerService."  
                   "DISABLE_PROVIDER_FAILED","Failed to disable the provider."));  
          }  
       }  
       // disable succeed  
       // update module status from Stopping to Stopped if  
       // disableProviderOnly is not true  
       if (!disableProviderOnly) {  
          // update module status from Stopping to Stopped  
          for (Uint32 j=0, m = operationalStatus.size(); j < m; j++) {  
             if (operationalStatus[j] == _MODULE_STOPPING) {  
                operationalStatus.remove(j);  
                operationalStatus.append(_MODULE_STOPPED);                operationalStatus.append(_MODULE_STOPPED);
             }  
          }  
  
          if (_providerRegistrationManager->setProviderModuleStatus          if (_providerRegistrationManager->setProviderModuleStatus
                (moduleName, operationalStatus) == false) {              (moduleName, operationalStatus) == false)
           {
             //l10n             //l10n
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
             //"set module status failed.");             //"set module status failed.");
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
                MessageLoaderParms("ProviderManager.ProviderManagerService."                  "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",
                   "SET_MODULE_STATUS_FAILED","set module status failed."));                  "set module status failed."));
          }  
       }  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                          "Exception: " + e.getMessage());  
         cimException = e;  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                          "Exception: " + e.getMessage());  
         cimException = CIMException(CIM_ERR_FAILED, e.getMessage());  
     }     }
     catch(...) {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                          "Exception: Unknown");  
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");  
         cimException = PEGASUS_CIM_EXCEPTION_L(  
             CIM_ERR_FAILED,  
             MessageLoaderParms(  
                 "ProviderManager.ProviderManagerService.UNKNOWN_ERROR",  
                 "Unknown Error"));  
     }     }
  
     CIMDisableModuleResponseMessage * response =     CIMDisableModuleResponseMessage * response =
Line 2702 
Line 2591 
         request->queueIds.copyAndPop(),         request->queueIds.copyAndPop(),
         operationalStatus);         operationalStatus);
  
       PEGASUS_ASSERT(response != 0);
   
     // preserve message key     // preserve message key
     response->setKey(request->getKey());     response->setKey(request->getKey());
  
       //
     //  Set HTTP method in response from request     //  Set HTTP method in response from request
       //
     response->setHttpMethod (request->getHttpMethod ());     response->setHttpMethod (request->getHttpMethod ());
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 2713 
Line 2606 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message)  Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) throw()
 { {
     // HACK     // HACK
     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();
Line 2793 
Line 2686 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message)  Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");
  
Line 2847 
Line 2740 
     EnableIndicationsResponseHandler *ret = 0;     EnableIndicationsResponseHandler *ret = 0;
  
     _responseTable.lookup(key, ret);     _responseTable.lookup(key, ret);
     _responseTable.remove(key);         // why is this needed ? - we get killed when removed...  
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
  
Line 2875 
Line 2767 
     return(tableKey);     return(tableKey);
 } }
  
 String DefaultProviderManager::_generateKey (  
     const String & providerName,  
     const String & providerFileName)  
 {  
     String tableKey;  
   
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,  
                       "DefaultProviderManagerService::_generateKey");  
   
     //  
     //  Append providerName and providerFileName to key  
     //  
     tableKey.append (providerName);  
     tableKey.append (providerFileName);  
   
     PEG_METHOD_EXIT ();  
     return tableKey;  
 }  
   
 ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName) ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName)
 { {
     ProviderName temp = findProvider(providerName);     ProviderName temp = findProvider(providerName);
     String physicalName = _resolvePhysicalName(temp.getPhysicalName());  
     temp.setPhysicalName(physicalName);  
  
     return(temp);      String physicalName = temp.getPhysicalName();
 }  
  
 ProviderName DefaultProviderManager::_resolveProviderName(String & destinationPath)      // fully qualify physical provider name (module), if not already done so.
 {      #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
     ProviderName temp = findProvider(destinationPath);      physicalName = physicalName + String(".dll");
       #elif defined(PEGASUS_PLATFORM_LINUX_IX86_GNU) || defined(PEGASUS_PLATFORM_LINUX_IA86_GNU)
       String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
       physicalName = root + String("/lib") + physicalName + String(".so");
       #elif defined(PEGASUS_OS_HPUX)
       String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
       physicalName = root + String("/lib") + moduleLocation + String(".sl");
       #elif defined(PEGASUS_OS_OS400)
       // do nothing
       #else
       String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
       physicalName = root + String("/lib") + physicalName + String(".so");
  
     String physicalName = _resolvePhysicalName(temp.getPhysicalName());      #endif
  
     temp.setPhysicalName(physicalName);     temp.setPhysicalName(physicalName);
  

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