cimmessagedeserializer.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

        case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE:
            message = _deserializeCIMExportIndicationResponseMessage(parser);
            break;
        case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE:
            message = _deserializeCIMProcessIndicationResponseMessage(parser);
            break;
        //case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE:
            // ATTN: No need to serialize this yet
            //message =
            //    _deserializeCIMNotifyProviderRegistrationResponseMessage(
            //        parser);
            //break;
        //case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE:
            // ATTN: No need to serialize this yet
            //message =
            //  _deserializeCIMNotifyProviderTerminationResponseMessage(parser);
            //break;
        //case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE:
            // ATTN: No need to serialize this yet
            //message = _deserializeCIMHandleIndicationResponseMessage(parser);
            //break;
        case CIM_DISABLE_MODULE_RESPONSE_MESSAGE:
            message = _deserializeCIMDisableModuleResponseMessage(parser);
            break;
        case CIM_ENABLE_MODULE_RESPONSE_MESSAGE:
            message = _deserializeCIMEnableModuleResponseMessage(parser);
            break;
        //case CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE:
            // ATTN: No need to serialize this yet
            //message =
            //    _deserializeCIMNotifyProviderEnableResponseMessage(parser);
            //break;
        //case CIM_NOTIFY_PROVIDER_FAIL_RESPONSE_MESSAGE:
            // ATTN: No need to deserialize this yet
            //message =
            //    _deserializeCIMNotifyProviderFailResponseMessage(parser);
            //break;
        case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE:
            message = _deserializeCIMStopAllProvidersResponseMessage(parser);
            break;
        case CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE:
            message = _deserializeCIMInitializeProviderResponseMessage(parser);
            break;
        case CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE:
            message =
                _deserializeCIMInitializeProviderAgentResponseMessage(parser);
            break;
        case CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE:
            message = _deserializeCIMNotifyConfigChangeResponseMessage(parser);
            break;
        case CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE:
            message =
                _deserializeCIMSubscriptionInitCompleteResponseMessage
                    (parser);
            break;
    }
    PEGASUS_ASSERT(message != 0);

    message->queueIds = queueIdStack;
    message->cimException = cimException;

    return message;
}


//
// Utility Methods
//

//
// _deserializeUserInfo consolidates decoding of these common message attributes
//
void CIMMessageDeserializer::_deserializeUserInfo(
    XmlParser& parser,
    String& authType,
    String& userName)
{
    CIMValue genericValue;

    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(authType);

    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(userName);
}

//
// _deserializeQueueIdStack
//
void CIMMessageDeserializer::_deserializeQueueIdStack(
    XmlParser& parser,
    QueueIdStack& queueIdStack)
{
    // ATTN: Incoming queueIdStack is presumed to be empty

    XmlEntry entry;
    CIMValue genericValue;
    Uint32 genericUint32;
    Array<Uint32> items;

    XmlReader::expectStartTag(parser, entry, "PGQIDSTACK");
    while (XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue))
    {
        genericValue.get(genericUint32);
        items.append(genericUint32);
    }
    XmlReader::expectEndTag(parser, "PGQIDSTACK");

    for (Uint32 i=items.size(); i>0; i--)
    {
        queueIdStack.push(items[i-1]);
    }
}

//
// _deserializeOperationContext
//
void CIMMessageDeserializer::_deserializeOperationContext(
    XmlParser& parser,
    OperationContext& operationContext)
{
    operationContext.clear();

    XmlEntry entry;
    CIMValue genericValue;
    String genericString;

    XmlReader::expectStartTag(parser, entry, "PGOC");

    if (XmlReader::testStartTag(parser, entry, "PGOCID"))
    {
        String userName;

        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(userName);
        operationContext.insert(IdentityContainer(userName));
        XmlReader::expectEndTag(parser, "PGOCID");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCSI"))
    {
        CIMInstance subscriptionInstance;
        _deserializeCIMInstance(parser, subscriptionInstance);
        operationContext.insert(
            SubscriptionInstanceContainer(subscriptionInstance));
        XmlReader::expectEndTag(parser, "PGOCSI");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCSFC"))
    {
        String filterCondition;
        String queryLanguage;

        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(filterCondition);
        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(queryLanguage);
        operationContext.insert(
            SubscriptionFilterConditionContainer(
                filterCondition, queryLanguage));
        XmlReader::expectEndTag(parser, "PGOCSFC");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCSFQ"))
    {
        String filterQuery;
        String queryLanguage;
        CIMNamespaceName nameSpace;

        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(filterQuery);
        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(queryLanguage);
        _deserializeCIMNamespaceName(parser, nameSpace);
        operationContext.insert(
            SubscriptionFilterQueryContainer(
                filterQuery, queryLanguage, nameSpace));
        XmlReader::expectEndTag(parser, "PGOCSFQ");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCSIN"))
    {
        Array<CIMObjectPath> subscriptionInstanceNames;
        CIMObjectPath genericObjectPath;

        while (_deserializeCIMObjectPath(parser, genericObjectPath))
        {
            subscriptionInstanceNames.append(genericObjectPath);
        }
        operationContext.insert(
            SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
        XmlReader::expectEndTag(parser, "PGOCSIN");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCTO"))
    {
        Uint32 timeout;

        XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
        genericValue.get(timeout);
        operationContext.insert(TimeoutContainer(timeout));
        XmlReader::expectEndTag(parser, "PGOCTO");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCALL"))
    {
        AcceptLanguageList acceptLanguages;

        _deserializeAcceptLanguageList(parser, acceptLanguages);
        operationContext.insert(AcceptLanguageListContainer(acceptLanguages));
        XmlReader::expectEndTag(parser, "PGOCALL");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCCLL"))
    {
        ContentLanguageList contentLanguages;

        _deserializeContentLanguageList(parser, contentLanguages);
        operationContext.insert(
            ContentLanguageListContainer(contentLanguages));
        XmlReader::expectEndTag(parser, "PGOCCLL");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCSTO"))
    {
        String snmpTrapOid;

        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(snmpTrapOid);
        operationContext.insert(SnmpTrapOidContainer(snmpTrapOid));
        XmlReader::expectEndTag(parser, "PGOCSTO");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCL"))
    {
        String languageId;

        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(languageId);
        operationContext.insert(LocaleContainer(languageId));
        XmlReader::expectEndTag(parser, "PGOCL");
    }

    if (XmlReader::testStartTag(parser, entry, "PGOCPI"))
    {
        CIMValue genericValue;
        CIMInstance module;
        CIMInstance provider;
        Boolean isRemoteNameSpace;
        String remoteInfo;

        _deserializeCIMInstance(parser, module);
        _deserializeCIMInstance(parser, provider);

        XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
        genericValue.get(isRemoteNameSpace);

        XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
        genericValue.get(remoteInfo);

        operationContext.insert(ProviderIdContainer(
            module, provider, isRemoteNameSpace, remoteInfo));
        XmlReader::expectEndTag(parser, "PGOCPI");
    }

    XmlReader::expectEndTag(parser, "PGOC");
}

//
// _deserializeContentLanguageList
//
void CIMMessageDeserializer::_deserializeContentLanguageList(
    XmlParser& parser,
    ContentLanguageList& contentLanguages)
{
    contentLanguages.clear();

    XmlEntry entry;
    CIMValue genericValue;
    String genericString;

    XmlReader::expectStartTag(parser, entry, "PGCONTLANGS");
    while (XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue))
    {
        genericValue.get(genericString);
        contentLanguages.append(LanguageTag(genericString));
    }
    XmlReader::expectEndTag(parser, "PGCONTLANGS");
}

//
// _deserializeAcceptLanguageList
//
void CIMMessageDeserializer::_deserializeAcceptLanguageList(
    XmlParser& parser,
    AcceptLanguageList& acceptLanguages)
{
    acceptLanguages.clear();

    XmlEntry entry;
    CIMValue genericValue;
    String genericString;
    Real32 genericReal32;

    XmlReader::expectStartTag(parser, entry, "PGACCLANGS");
    while (XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue))
    {
        genericValue.get(genericString);
        XmlReader::getValueElement(parser, CIMTYPE_REAL32, genericValue);
        genericValue.get(genericReal32);
        acceptLanguages.insert(LanguageTag(genericString), genericReal32);
    }
    XmlReader::expectEndTag(parser, "PGACCLANGS");
}

//
// _deserializeCIMException
//
void CIMMessageDeserializer::_deserializeCIMException(
    XmlParser& parser,
    CIMException& cimException)
{
    XmlEntry entry;
    CIMValue genericValue;
    Uint32 statusCode;
    String message;
    String cimMessage;
    String file;
    Uint32 line;
    ContentLanguageList contentLanguages;

    XmlReader::expectStartTag(parser, entry, "PGCIMEXC");

    XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
    genericValue.get(statusCode);
    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(message);
    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(cimMessage);
    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(file);
    XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
    genericValue.get(line);
    _deserializeContentLanguageList(parser, contentLanguages);

    XmlReader::expectEndTag(parser, "PGCIMEXC");

    TraceableCIMException e = TraceableCIMException(
        contentLanguages,
        CIMStatusCode(statusCode),
        message,
        file,
        line);
    e.setCIMMessage(cimMessage);
    cimException = e;
}

//
// _deserializeCIMPropertyList
//
void CIMMessageDeserializer::_deserializeCIMPropertyList(
    XmlParser& parser,
    CIMPropertyList& propertyList)
{
    const char* name;
    CIMValue genericValue;
    Boolean emptyTag;

    propertyList.clear();
    XmlReader::getIParamValueTag(parser, name, emptyTag);
    PEGASUS_ASSERT(!emptyTag);
    PEGASUS_ASSERT(System::strcasecmp(name, "PropertyList") == 0);
    if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, genericValue))
    {
        Array<String> propertyListArray;
        genericValue.get(propertyListArray);
        Array<CIMName> cimNameArray;
        for (Uint32 i = 0; i < propertyListArray.size(); i++)
        {
            cimNameArray.append(propertyListArray[i]);
        }
        propertyList.set(cimNameArray);
    }
    XmlReader::expectEndTag(parser, "IPARAMVALUE");
}

//
// _deserializeCIMObjectPath
//
Boolean CIMMessageDeserializer::_deserializeCIMObjectPath(
    XmlParser& parser,
    CIMObjectPath& cimObjectPath)
{
    XmlEntry entry;

    if (!XmlReader::testStartTag(parser, entry, "PGPATH"))
    {
        return false;
    }

    // VALUE.REFERENCE element is absent when the object is uninitialized.
    // In this case, XmlReader::getValueReferenceElement returns "false" and
    // leaves cimObjectPath untouched.
    if (!XmlReader::getValueReferenceElement(parser, cimObjectPath))
    {
        cimObjectPath = CIMObjectPath();
    }

    XmlReader::expectEndTag(parser, "PGPATH");

    return true;
}

//
// _deserializeCIMInstance
//
Boolean CIMMessageDeserializer::_deserializeCIMInstance(
    XmlParser& parser,
    CIMInstance& cimInstance)
{
    XmlEntry entry;

    if (!XmlReader::testStartTag(parser, entry, "PGINST"))
    {
        return false;
    }

    // INSTANCE element is absent when the object is uninitialized.
    // In this case, XmlReader::getInstanceElement returns "false" and
    // leaves cimInstance untouched.
    if (XmlReader::getInstanceElement(parser, cimInstance))
    {
        CIMObjectPath path;
        _deserializeCIMObjectPath(parser, path);
        cimInstance.setPath(path);
    }