xmlreader.cpp

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

        throw XmlSemanticError(lineNumber, mlParms);
    }

    return name;
}

//------------------------------------------------------------------------------
//
// getClassOriginAttribute()
//
//     <!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED">
//
//------------------------------------------------------------------------------

CIMName XmlReader::getClassOriginAttribute(
    Uint32 lineNumber,
    const XmlEntry& entry,
    const char* tagName)
{
    String name;

    if (!entry.getAttributeValue("CLASSORIGIN", name))
        return CIMName();

    if (!CIMName::legal(name))
    {
        char buffer[MESSAGE_SIZE];
        sprintf(buffer, "%s.CLASSORIGIN", tagName);

        MessageLoaderParms mlParms(
            "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
            "Illegal value for $0 attribute",
            buffer);
        throw XmlSemanticError(lineNumber, mlParms);
    }

    return name;
}

//------------------------------------------------------------------------------
//
// getEmbeddedObjectAttribute()
//
//     <!ENTITY % EmbeddedObject "EMBEDDEDOBJECT (object | instance) #IMPLIED">
//
//------------------------------------------------------------------------------

String XmlReader::getEmbeddedObjectAttribute(
    Uint32 lineNumber,
    const XmlEntry& entry,
    const char* elementName)
{
    String embeddedObject;

    if (!entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))
        return String();

    // The embeddedObject attribute, if present, must have the string
    // value "object" or "instance".
    if (!(String::equal(embeddedObject, "object") ||
          String::equal(embeddedObject, "instance")))
    {
        char buffer[MESSAGE_SIZE];
        sprintf(buffer, "%s.EMBEDDEDOBJECT", elementName);

        MessageLoaderParms mlParms(
            "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
            "Illegal value for $0 attribute",
            buffer);
        throw XmlSemanticError(lineNumber, mlParms);
    }

    return embeddedObject;
}

//------------------------------------------------------------------------------
//
// getReferenceClassAttribute()
//
//     <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
//
//------------------------------------------------------------------------------

CIMName XmlReader::getReferenceClassAttribute(
    Uint32 lineNumber,
    const XmlEntry& entry,
    const char* elementName)
{
    String name;

    if (!entry.getAttributeValue("REFERENCECLASS", name))
        return CIMName();

    if (!CIMName::legal(name))
    {
#ifdef PEGASUS_SNIA_INTEROP_TEST
        name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";
        return name;
#endif

        char buffer[MESSAGE_SIZE];
        sprintf(buffer, "%s.REFERENCECLASS", elementName);

        MessageLoaderParms mlParms(
            "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
            "Illegal value for $0 attribute",
            buffer);
        throw XmlSemanticError(lineNumber, mlParms);
    }

    return name;
}

//------------------------------------------------------------------------------
//
// getSuperClassAttribute()
//
//     <!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED">
//
//------------------------------------------------------------------------------

CIMName XmlReader::getSuperClassAttribute(
    Uint32 lineNumber,
    const XmlEntry& entry,
    const char* tagName)
{
    String superClass;

    if (!entry.getAttributeValue("SUPERCLASS", superClass))
        return CIMName();

    if (!CIMName::legal(superClass))
    {
        char buffer[MESSAGE_SIZE];
        sprintf(buffer, "%s.SUPERCLASS", tagName);

        MessageLoaderParms mlParms(
            "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
            "Illegal value for $0 attribute",
            buffer);
        throw XmlSemanticError(lineNumber, mlParms);
    }

    return superClass;
}

//------------------------------------------------------------------------------
//
// getCimTypeAttribute()
//
// This method can be used to get a TYPE attribute or a PARAMTYPE attribute.
// The only significant difference is that PARAMTYPE may specify a value of
// "reference" type.  This method recognizes these attributes by name, and
// does not allow a "TYPE" attribute to be of "reference" type.
//
//     <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
//         |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
//
//     <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8
//         |uint16|sint16|uint32|sint32|uint64|sint64|datetime|real32|real64
//         |reference)">
//
//------------------------------------------------------------------------------

Boolean XmlReader::getCimTypeAttribute(
    Uint32 lineNumber,
    const XmlEntry& entry,
    CIMType& cimType,  // Output parameter
    const char* tagName,
    const char* attributeName,
    Boolean required)
{
    const char* typeName;

    if (!entry.getAttributeValue(attributeName, typeName))
    {
        if (required)
        {
            char message[MESSAGE_SIZE];
            sprintf(message, "%s.%s", tagName, attributeName);

            MessageLoaderParms mlParms(
                "Common.XmlReader.MISSING_ATTRIBUTE",
                "missing $0 attribute",
                message);
            throw XmlValidationError(lineNumber, mlParms);
        }
        else
        {
            return false;
        }
    }

    CIMType type = CIMTYPE_BOOLEAN;
    Boolean unrecognizedType = false;

    if (strcmp(typeName, "boolean") == 0)
        type = CIMTYPE_BOOLEAN;
    else if (strcmp(typeName, "string") == 0)
        type = CIMTYPE_STRING;
    else if (strcmp(typeName, "char16") == 0)
        type = CIMTYPE_CHAR16;
    else if (strcmp(typeName, "uint8") == 0)
        type = CIMTYPE_UINT8;
    else if (strcmp(typeName, "sint8") == 0)
        type = CIMTYPE_SINT8;
    else if (strcmp(typeName, "uint16") == 0)
        type = CIMTYPE_UINT16;
    else if (strcmp(typeName, "sint16") == 0)
        type = CIMTYPE_SINT16;
    else if (strcmp(typeName, "uint32") == 0)
        type = CIMTYPE_UINT32;
    else if (strcmp(typeName, "sint32") == 0)
        type = CIMTYPE_SINT32;
    else if (strcmp(typeName, "uint64") == 0)
        type = CIMTYPE_UINT64;
    else if (strcmp(typeName, "sint64") == 0)
        type = CIMTYPE_SINT64;
    else if (strcmp(typeName, "datetime") == 0)
        type = CIMTYPE_DATETIME;
    else if (strcmp(typeName, "real32") == 0)
        type = CIMTYPE_REAL32;
    else if (strcmp(typeName, "real64") == 0)
        type = CIMTYPE_REAL64;
    else if (strcmp(typeName, "reference") == 0)
        type = CIMTYPE_REFERENCE;
//  PEP 194:
//  Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
//  Pegasus internal representation of an embedded object, so it won't be
//  found here.
    else unrecognizedType = true;

    if (unrecognizedType ||
        ((type == CIMTYPE_REFERENCE) &&
         (strcmp(attributeName, "PARAMTYPE") != 0)))
    {
        char buffer[MESSAGE_SIZE];
        sprintf(buffer, "%s.%s", tagName, attributeName);

        MessageLoaderParms mlParms(
            "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
            "Illegal value for $0 attribute",
            buffer);

        throw XmlSemanticError(lineNumber, mlParms);
    }

    cimType = type;
    return true;
}

//------------------------------------------------------------------------------
//
// getCimBooleanAttribute()
//
//------------------------------------------------------------------------------

Boolean XmlReader::getCimBooleanAttribute(
    Uint32 lineNumber,
    const XmlEntry& entry,
    const char* tagName,
    const char* attributeName,
    Boolean defaultValue,
    Boolean required)
{
    const char* tmp;

    if (!entry.getAttributeValue(attributeName, tmp))
    {
        if (!required)
            return defaultValue;

        char buffer[62];
        sprintf(buffer, "%s.%s", attributeName, tagName);

        MessageLoaderParms mlParms(
            "Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
            "missing required $0 attribute",
            buffer);
        throw XmlValidationError(lineNumber, mlParms);
    }

    if (strcmp(tmp, "true") == 0)
        return true;
    else if (strcmp(tmp, "false") == 0)
        return false;

    char buffer[62];
    sprintf(buffer, "%s.%s", attributeName, tagName);

    MessageLoaderParms mlParms(
        "Common.XmlReader.INVALID_ATTRIBUTE",
        "Invalid $0 attribute value",
        buffer);

    throw XmlSemanticError(lineNumber, mlParms);

    return false;
}

//------------------------------------------------------------------------------
//
// SringToReal()
//
//      [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
//          [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
//
//------------------------------------------------------------------------------

Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)
{
    //
    // Check the string against the DMTF-defined grammar
    //
    const char* p = stringValue;

    if (!*p)
        return false;

    // Skip optional sign:

    if (*p == '+' || *p  == '-')
        p++;

    // Skip optional first set of digits:

    while (isdigit(*p))
        p++;

    // Test required dot:

    if (*p++ != '.')
        return false;

    // One or more digits required:

    if (!isdigit(*p++))
        return false;

    while (isdigit(*p))
        p++;

    // If there is an exponent now:

    if (*p)
    {
        // Test exponent:

        if (*p != 'e' && *p != 'E')
            return false;

        p++;

        // Skip optional sign:

        if (*p == '+' || *p  == '-')
            p++;

        // One or more digits required:

        if (!isdigit(*p++))
            return false;

        while (isdigit(*p))
            p++;
    }

    if (*p)
        return false;

    //
    // Do the conversion
    //
    char* end;
    errno = 0;
    x = strtod(stringValue, &end);
    if (*end || (errno == ERANGE))
    {
        return false;
    }

    return true;
}

inline Uint8 _xmlReader_hexCharToNumeric(const char c)
{
    Uint8 n;

    if (isdigit(c))
        n = (c - '0');
    else if (isupper(c))
        n = (c - 'A' + 10);
    else // if (islower(c))
        n = (c - 'a' + 10);

    return n;
}

// See http://www.ietf.org/rfc/rfc2396.txt section 2
//
// Also see the "CIM Operations over HTTP" spec, section 3.3.2 and
// 3.3.3, for the treatment of non US-ASCII chars (UTF-8)
String XmlReader::decodeURICharacters(String uriString)
{
    Uint32 i;

    Array<Uint8> utf8Chars;

    for (i=0; i<uriString.size(); i++)
    {
        if (uriString[i] == '%')
        {
            if (i+2 >= uriString.size())
            {
                MessageLoaderParms mlParms(
                    "Common.XmlReader.INVALID_URI_ENCODING",
                    "Invalid URI encoding");
                throw ParseError(MessageLoader::getMessage(mlParms));
            }

            Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
            Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
            if ( (digit1 > 15) || (digit2 > 15) )
            {
                MessageLoaderParms mlParms(
                    "Common.XmlReader.INVALID_URI_ENCODING",
                    "Invalid URI encoding");
                throw ParseError(MessageLoader::getMessage(mlParms));
            }

            Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
            utf8Chars.append((Uint8)decodedChar);
        }
        else
        {
            utf8Chars.append((Uint8)uriString[i]);
        }
    }

    // If there was a string to decode...
    if (uriString.size() > 0)
    {
        // Convert UTF-8 to UTF-16 and return the String
        utf8Chars.append('\0');
        return String((char *)utf8Chars.getData());
    }
    else
    {
        return String();
    }
}

//------------------------------------------------------------------------------
//