XMLThreadProtection की नीति के मुताबिक, रनटाइम के दौरान हुई गड़बड़ी को हल करना

आपको Apigee Edge दस्तावेज़ दिख रहा है.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है इस पेज पर जाएं Apigee X दस्तावेज़. जानकारी

ExecutionFailed

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition policy_name:
        Execution failed. Reason: error_description at line line_num
        (possibly around char char_num)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: Premature end of document while parsing at line 5(possibly  around char 0)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ियों के टाइप और उनकी संभावित वजहें

एक्सएमएलटीथ-प्रोटेक्ट नीति की वजह से, कई अलग-अलग तरह की एक्ज़िकयूशन-फ़ेल गड़बड़ियां हो सकती हैं. यहां दी गई टेबल में अलग-अलग तरह की गड़बड़ियों और उनके संभावित वजहों के बारे में बताया गया है:

गड़बड़ी वजह
ElementNameExceeded एक्सएमएल टैग में स्ट्रिंग की तय सीमा से ज़्यादा वर्णों का इस्तेमाल किया गया है.
ChildCountExceeded एक्सएमएल पेलोड में, चाइल्ड एलिमेंट की तय सीमा से ज़्यादा एलिमेंट मौजूद हैं.
NodeDepthExceeded एक्सएमएल पेलोड में, एक्सएमएल एलिमेंट की ज़्यादा से ज़्यादा गहराई सेट की गई है.
AttributeCountExceeded किसी एक एलिमेंट में ज़्यादा से ज़्यादा एट्रिब्यूट की संख्या पार हो गई है.
AttributeNameExceeded एट्रिब्यूट के नाम की तय सीमा से ज़्यादा वर्णों का इस्तेमाल किया गया है.
AttributeValueExceeded एट्रिब्यूट की वैल्यू की तय सीमा से ज़्यादा वर्णों का इस्तेमाल किया गया है.
TextExceeded टेक्स्ट के लिए अधिकतम सीमा पार हो गई है.
CommentExceeded टिप्पणी के लिए तय सीमा से ज़्यादा वर्ण हैं.
PIDataExceeded डेटा प्रोसेस करने के निर्देश वाला डेटा, तय सीमा से ज़्यादा है.
PITargetExceeded प्रोसेस निर्देश का नाम तय सीमा से ज़्यादा है.
NSURIExceeded नेमस्पेस के यूआरएल की लंबाई तय सीमा से ज़्यादा है.
NSPrefixExceeded नेमस्पेस प्रीफ़िक्स की लंबाई पार हो गई है.
NSCountExceeded एक एलिमेंट में इस्तेमाल किए गए नाम वाले स्पेस की संख्या, तय सीमा से ज़्यादा है.
अमान्य एक्सएमएल पेलोड डाला गया एक्सएमएल पेलोड अमान्य है.

ElementNameExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी का जवाब

रनटाइम ट्रैफ़िक नीचे दी गई गड़बड़ी के साथ 500 रिस्पॉन्स कोड दिखाता है:

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition policy_name:
        Execution failed. reason: XMLThreatProtection stepDefinition policy_name:
        Element name length exceeded num at line line_num(possibly
        around char char_num)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब के मुख्य हिस्से का उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Element name length exceeded 5 at line 1(possibly around char 9)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब नीति के <Source> एलिमेंट के बताए गए इनपुट पेलोड में ऐसे एक्सएमएल एलिमेंट होते हैं जिनकी लंबाई <NameLimits> एलिमेंट के नीचे मौजूद <Element> एलिमेंट में तय की गई सीमा से ज़्यादा होती है.

उदाहरण के लिए, अगर XMLThreatProtection नीति में <Element> एलिमेंट को 5 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में ऐसा एलिमेंट है जिसमें पांच से ज़्यादा वर्ण हैं, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, XMLThreatProtection की नीति का नाम, लाइन नंबर, और इनपुट पेलोड में उस वर्णों की संख्या का पता लगाएं जहां एलिमेंट की लंबाई तय सीमा से ज़्यादा है.

    उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1,पेलोड में लाइन नंबर 1 है और वर्णों की संभावित संख्या 9. है

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Element name
length exceeded 5 at line 1(possibly around char 9)

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <Element> एलिमेंट में दी गई वैल्यू नोट करें.

    उदाहरण के लिए, यहां दी गई एक्सएमएलटी-टीटी-प्रोटेक्ट नीति में, <Element> को 5 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>5</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
    <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>5</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की उस लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि उस लाइन पर मौजूद एलिमेंट की लंबाई, <Element> एलिमेंट (दूसरे चरण में पहचाने गए) के लिए तय की गई वैल्यू से ज़्यादा है या नहीं. अगर एलिमेंट की लंबाई इस वैल्यू से ज़्यादा है, तो यह गड़बड़ी की वजह है.

    इनपुट पेलोड का उदाहरण यहां दिया गया है:

    <company>
  <name>Google</name>
  <country>USA</country>
</company>

    ऊपर दिखाए गए एक्सएमएल पेलोड में, पहली लाइन में company नाम का एक रूट एलिमेंट है, जिसमें सात वर्ण हैं. एलिमेंट की लंबाई 5 (<Element> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा होने पर, आपको यह गड़बड़ी दिखती है:

    XML-Threat-Protection-1: Execution failed. reason: XMLThreatProtection stepDefinition
XML-Threat-Protection-1: Element name length exceeded 5 at line 1(possibly around char 9)

रिज़ॉल्यूशन

अगर XMLThreadProtection नीति का मकसद तय की गई वैल्यू से ज़्यादा एलिमेंट वाले पेलोड से बचना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि पेलोड में लंबे एलिमेंट को बिना किसी नतीजे के शामिल किया जा सकता है, तो अपनी ज़रूरतों के हिसाब से <Element> को सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि 10 तक के एलिमेंट की अनुमति दी जा सकती है, तो XMLThreatProtection नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>5</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

ChildCountExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition policy_name:
        Execution failed. reason: XMLThreatProtection stepDefinition policy_name:
        Children count exceeded num at line  num(possibly
        around char num)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Children count exceeded 3 at line 5(possibly around char 89)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब <Source> एलिमेंट के बताए गए इनपुट मैसेज पेलोड में कोई ऐसा एक्सएमएल एलिमेंट होता है जिसमें नीति के <ChildCount>एलिमेंट में बताई गई वैल्यू से ज़्यादा चाइल्ड एलिमेंट शामिल होते हैं.

उदाहरण के लिए, अगर <ChildCount>एलिमेंट 3 है, लेकिन इनपुट एक्सएमएल पेलोड में तीन से ज़्यादा चाइल्ड एलिमेंट वाला एलिमेंट है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, XMLThreatProtection की नीति का नाम और उस लाइन नंबर की पहचान करें जहां एंट्री की संख्या ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1है और पेलोड में लाइन नंबर 5 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Children
count exceeded 3 at line 5(possibly around char 89)"

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <ChildCount> एलिमेंट में दी गई वैल्यू नोट करें.

    नीति के इस उदाहरण में, <ChildCount> को 3 पर सेट किया गया है. ध्यान दें कि टिप्पणियों, शामिल किए गए एलिमेंट, और अन्य चीज़ों को इस सीमा में गिना जाता है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>5</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि पेलोड में चाइल्ड एलिमेंट (सभी टिप्पणियां वगैरह शामिल हैं) की संख्या, <ChildCount> एलिमेंट (दूसरे चरण में पहचाने गए) के लिए तय की गई वैल्यू से ज़्यादा है या नहीं. अगर चाइल्ड एलिमेंट की संख्या, चाइल्ड की संख्या से ज़्यादा है, तो गड़बड़ी की यह वजह है.

    इनपुट पेलोड का उदाहरण यहां दिया गया है:

    <movie>
  <title>Jurassic Park</title>
  <language>English</language>
  <country>USA</country>
  <director>Steven Spielberg</director>
</movie>

    ऊपर दिखाए गए एक्सएमएल पेलोड में, लाइन 5 में रूट एलिमेंट <movie> का चौथा चाइल्ड एलिमेंट <director> शामिल है. इनपुट एक्सएमएल पेलोड में चाइल्ड एलिमेंट की संख्या तीन से ज़्यादा (<ChildCount> एलिमेंट के लिए तय की गई वैल्यू) है, इसलिए आपको यह गड़बड़ी दिखेगी:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Children
count exceeded 3 at line 5(possibly around char 89)

रिज़ॉल्यूशन

अगर एक्सएमएल-टीचर-प्रोटेक्ट नीति का मकसद, तय थ्रेशोल्ड से ज़्यादा चाइल्ड एलिमेंट की संख्या वाले पेलोड से सुरक्षित रखना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कोई और कार्रवाई करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि बिना किसी असर के, पेलोड में बड़ी संख्या में चाइल्ड एलिमेंट (टिप्पणियां वगैरह) शामिल किए जा सकते हैं, तो अपनी ज़रूरतों के हिसाब से <ChildCount>की वैल्यू में बदलाव करें.

उदाहरण के लिए, अगर आपको ज़्यादा से ज़्यादा 10 चाइल्ड एलिमेंट की अनुमति देनी है, तो XMLThreatProtection नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>5</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">10</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

NodeDepthExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Node depth exceeded [num] at line [num](possibly around
        char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Node depth exceeded 5 at line 6(possibly around char 110)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब <Source> एलिमेंट के बताए गए इनपुट मैसेज पेलोड में कोई एक्सएमएल दस्तावेज़ होता है, जिसमें नोड की हैरारकी, XMLOptionsProtection नीति के <NodeDepth> एलिमेंट में दी गई संख्या से ज़्यादा होती है.

उदाहरण के लिए, अगर नीति में <NodeDepth> एलिमेंट को 4 के तौर पर बताया गया है, लेकिन इनपुट पेलोड की नोड डेप्थ 4 से ज़्यादा है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, उस XML पिकअप नीति के नाम और उस लाइन नंबर की पहचान करें जहां नोड की गहराई तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1है और पेलोड में लाइन नंबर 6 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Node depth
exceeded 5 at line 6(possibly around char 109)

  2. पहले चरण में पहचानी गई, एक्सएमएल-टीचर-प्रोटेक्ट से जुड़ी उस नीति की जांच करें जो सफल नहीं हुई है और <NodeDepth> एलिमेंट में दी गई वैल्यू को नोट करें.

    एक्सएमएल कोड के लिए सुरक्षा से जुड़ी नीति के इस उदाहरण में, <NodeDepth> को 5 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>5</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि क्या वहां बताई गई नोड की गहराई, <NodeDepth> एलिमेंट (दूसरे चरण में पहचानी गई) में बताई गई संख्या से ज़्यादा है. अगर एक्सएमएल चाइल्ड एलिमेंट का लेवल, तय संख्या से ज़्यादा है, तो गड़बड़ी की यही वजह है.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <hellos>
   <hello1>
       <wave1>
            <wave2>
                <wave3>
                    <wave4>
                       <wave5>wave</wave5>
                    </wave4>
                </wave3>
            </wave2>
       </wave1>
   </hello1>
   <hello2>world2</hello2>
   <hello3>world3</hello3>
   <hello4>world4</hello4>
   <hello5>world5</hello5>
   <hello6>world6</hello6>
</hellos>

    ऊपर दी गई लाइन 6 में दिखाए गए एक्सएमएल पेलोड की नोड डेप्थ 6 है.नोड डेप्थ, <NodeDepth> एलिमेंट के लिए तय की गई वैल्यू 5 से ज़्यादा होने की वजह से, आपको यह गड़बड़ी दिखती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Node depth
exceeded 5 at line 6(possibly around char 109)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, खास नोड डेप्थ थ्रेशोल्ड वाले पेलोड से सुरक्षा करना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि नोड की गहराई ज़्यादा हो सकती है, तो अपनी ज़रूरतों के हिसाब से <NodeDepth>की वैल्यू में बदलाव करें.

उदाहरण के लिए, अगर आपको लगता है कि नोड की डेप्थ 10 तक हो सकती है, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

AttributeCountExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Attribute count exceeded [num] at line [num](possibly around
        char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Attribute count exceeded 2 at line 3(possibly around char 105)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब एक्सएमएल खतरे वाली सुरक्षा नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज पेलोड में कोई एक्सएमएल दस्तावेज़ है. इसमें किसी एक एलिमेंट के एट्रिब्यूट की संख्या, नीति के <AttributeCountPerElement> एलिमेंट में दी गई संख्या से ज़्यादा होती है.

उदाहरण के लिए, अगर एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति में <AttributeCountPerElement> एलिमेंट को 2 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में दो से ज़्यादा एट्रिब्यूट वाला एलिमेंट है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, XMLThreatProtection नीति के नाम और उस लाइन नंबर की पहचान करें जहां एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम XMLThreat-Protection-1 है और पेलोड की लाइन नंबर 3 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
count exceeded 2 at line 3(possibly around char 105)

  2. जिस नीति की पुष्टि नहीं हुई है उसकी जांच करें (पहले चरण में बताया गया था) और <AttributeCountPerElement> एलिमेंट में दी गई वैल्यू नोट करें.

    नीति के इस उदाहरण में, <AttributeCountPerElement> को 2 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (जिसकी पहचान पहले चरण में बताई गई है) की जांच करें और देखें कि क्या एट्रिब्यूट की दी गई संख्या, <AttributeCountPerElementh> एलिमेंट (दूसरे चरण में बताई गई) में दी गई संख्या से ज़्यादा है. अगर एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है, तो गड़बड़ी की यही वजह है.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="cooking" cuisine="Indian" lang="en">
    <title>Easy Indian Cooking</title>
    <author>Suneeta</author>
    <year>2004</year>
    <price>300.00</price>
  </book>
</bookstore>

    ऊपर पंक्ति 3 में दिखाए गए एक्सएमएल पेलोड में तीन विशेषताओं वाला एक एलिमेंट है. एट्रिब्यूट की संख्या दो (<AttributeCountPerElement> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा है, इसलिए आपको यह गड़बड़ी मिलती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
count exceeded 2 at line 3(possibly around char 105)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, किसी तय संख्या से ज़्यादा एट्रिब्यूट वाले पेलोड से बचाना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि ज़्यादा एट्रिब्यूट की अनुमति दी जा सकती है, तो <AttributeCountPerElement>अपनी ज़रूरतों के हिसाब से सही वैल्यू में बदलाव करें.

उदाहरण के लिए, अगर आपको लगता है कि हर एलिमेंट के लिए ज़्यादा से ज़्यादा पांच एट्रिब्यूट की अनुमति दी जा सकती है, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

AttributeNameExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Attribute name length exceeded [num] at line [num](possibly around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Attribute name length exceeded 5 at line 3(possibly around char 105)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLMajorProtection नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज पेलोड में ऐसा एक्सएमएल दस्तावेज़ होता है जिसमें एट्रिब्यूट का नाम, नीति के <NameLimits> एलिमेंट के <Attribute> चाइल्ड एलिमेंट में तय किए गए वर्णों की संख्या से ज़्यादा होता है.

उदाहरण के लिए, अगर नीति में <Attribute> एलिमेंट को 5 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में पांच से ज़्यादा वर्णों वाला एट्रिब्यूट का नाम है, तो यह गड़बड़ी होती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, XMLThreatProtection नीति का नाम और उस लाइन नंबर की पहचान करें जहां एट्रिब्यूट के नाम की लंबाई तय सीमा से ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम XML-Threat-Protection-1 है और पेलोड की लाइन नंबर 3 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
name length exceeded 5 at line 3(possibly around char 105)

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <Attribute> एलिमेंट में दी गई वैल्यू नोट करें

    एक्सएमएल-टीचर-प्रोटेक्ट नीति के इस उदाहरण में, <Attribute> को 5 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि वहां दिए गए एट्रिब्यूट की लंबाई, <Attribute> एलिमेंट (दूसरे चरण में पहचाने गए) में बताई गई संख्या से ज़्यादा है या नहीं. अगर वर्णों की संख्या, एट्रिब्यूट की वैल्यू से ज़्यादा है, तो गड़बड़ी की यह वजह है.

    इनपुट पेलोड का उदाहरण यहां दिया गया है:

    <?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="cooking" cuisine="Indian" lang="en">
    <title>Easy Indian Cooking</title>
    <author>Suneeta</author>
    <year>2004</year>
    <price>300.00</price>
  </book>
</bookstore>

    ऊपर पंक्ति 3 में दिखाए गए एक्सएमएल पेलोड में दो एट्रिब्यूट category और cuisine हैं, जिनके नाम की लंबाई 8 और 7 वर्ण हैं. क्योंकि एट्रिब्यूट के नाम की लंबाई 5 (<Attribute> एलिमेंट के लिए दिया गया मान) से ज़्यादा है, इसलिए आपको यह गड़बड़ी दिखेगी:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
name length exceeded 5 at line 3(possibly around char 105)

रिज़ॉल्यूशन

अगर एक्सएमएल-टीचर-प्रोटेक्ट नीति का मकसद, एट्रिब्यूट के नाम की लंबाई से ज़्यादा साइज़ वाले पेलोड से सुरक्षा करना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि एट्रिब्यूट के नाम की लंबाई ज़्यादा हो सकती है, तो अपनी ज़रूरतों के हिसाब से <Attribute> को सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि 10 वर्णों तक एट्रिब्यूट के नाम डाले जा सकते हैं, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

AttributeValueExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]: Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:  Attribute value length exceeded [num] at line [num](possibly around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Attribute value length exceeded 10 at line 3(possibly around char 111)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज पेलोड में कोई एक्सएमएल दस्तावेज़ होता है, जिसमें एट्रिब्यूट की वैल्यू, <ValueLimits> एलिमेंट के <Attribute> चाइल्ड एलिमेंट में तय किए गए वर्णों की संख्या से ज़्यादा होती है.

उदाहरण के लिए, अगर XMLसिर्फ़ सुरक्षा की नीति में <Attribute> एलिमेंट को 10 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में 10 से ज़्यादा वर्णों वाली एट्रिब्यूट की वैल्यू है, तो यह गड़बड़ी होती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करें और एक्सएमएल-टीचर-प्रोटेक्ट पॉलिसी के नाम के साथ-साथ उस लाइन नंबर की भी पहचान करता है जिसमें एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम XML-Threat-Protection-1 है और पेलोड की लाइन नंबर 3 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
value length exceeded 10 at line 3(possibly around char 111)

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <ValueLimits> एलिमेंट के <Attribute> चाइल्ड एलिमेंट में दी गई वैल्यू नोट करें.

    एक्सएमएल कोड के लिए सुरक्षा से जुड़ी नीति के इस उदाहरण में, <Attribute> को 10 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि वहां दी गई एट्रिब्यूट वैल्यू की लंबाई, <Attribute> एलिमेंट (दूसरे चरण में पहचाने गए) में दी गई संख्या से ज़्यादा है या नहीं. अगर वर्णों की संख्या, एट्रिब्यूट की वैल्यू से ज़्यादा है, तो गड़बड़ी की यही वजह है.

    इनपुट पेलोड का उदाहरण यहां दिया गया है:

    <?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="cooking" cuisine="South Indian" lang="en">
    <title>Easy Indian Cooking</title>
    <author>Suneeta</author>
    <year>2004</year>
    <price>300.00</price>
  </book>
</bookstore>

    ऊपर दी गई तीसरी लाइन में मौजूद एक्सएमएल पेलोड में, एक एट्रिब्यूट (cuisine) है. इसकी वैल्यू 12 वर्णों की है. एट्रिब्यूट की वैल्यू की लंबाई 10 (<Attribute> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा होने की वजह से, आपको यह गड़बड़ी दिखती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
value length exceeded 10 at line 3(possibly around char 111)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, किसी एट्रिब्यूट की वैल्यू की तय सीमा से ज़्यादा के पेलोड से सुरक्षा करना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि लंबे एट्रिब्यूट वाली वैल्यू इस्तेमाल की जा सकती हैं, तो <ValueLimits> एलिमेंट के <Attribute>चाइल्ड एलिमेंट को अपनी शर्तों के हिसाब से सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि 15 वर्ण तक की वैल्यू एट्रिब्यूट की जा सकती हैं, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

TextExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]: Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:  Text length exceeded [num] at line [num](possibly around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Text length exceeded 15 at line 4(possibly around char 66)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }

वजह

यह गड़बड़ी तब होती है, जब XMLThreatProtection नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज के पेलोड में कोई ऐसा एक्सएमएल दस्तावेज़ शामिल होता है जिसमें किसी एलिमेंट का टेक्स्ट, नीति के <ValueLimits> एलिमेंट के <Text> चाइल्ड एलिमेंट में तय किए गए वर्णों की संख्या से ज़्यादा हो.

उदाहरण के लिए, अगर नीति में <Text> एलिमेंट को 15 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में 15 से ज़्यादा वर्ण वाला टेक्स्ट है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, XMLThreatProtection नीति के नाम और उस लाइन नंबर की पहचान करें जहां एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1 है और पेलोड में लाइन नंबर 4 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Text length
exceeded 15 at line 4(possibly around char 66)

  2. पहले चरण में बताई गई उस नीति की जांच करें जो लागू नहीं हुई. साथ ही, <ValueLimits> एलिमेंट के <Text> चाइल्ड एलिमेंट में बताई गई वैल्यू को नोट करें.

    यहां दिए गए एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति के उदाहरण में, <Text> को 15 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (जिसकी पहचान पहले चरण में बताई गई है) की जांच करें और देखें कि क्या उसमें दिए गए एट्रिब्यूट की वैल्यू में, <Text> एलिमेंट में दी गई संख्या (दूसरे चरण में बताई गई संख्या) से ज़्यादा वर्ण हैं. अगर वर्णों की संख्या, एट्रिब्यूट की वैल्यू से ज़्यादा है, तो गड़बड़ी की यही वजह है.

    <food>
  <name>Veg Sandwich</name>
  <price>$5.95</price>
  <description>Vegetarian Sandwich with onions, tomatoes and lettuce</description>
  <calories>650</calories>
</food>

    ऊपर पंक्ति 4 पर दिखाए गए एक्सएमएल पेलोड में 53 वर्णों की लंबाई वाला टेक्स्ट है. एट्रिब्यूट की वैल्यू 15 (<Text> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा है, इसलिए आपको यह गड़बड़ी मिलती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Text length
exceeded 15 at line 4(possibly around char 66)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, किसी खास टेक्स्ट की लंबाई से ज़्यादा के पेलोड से बचाना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि ज़्यादा शब्दों वाले टेक्स्ट का इस्तेमाल किया जा सकता है, तो <ValueLimits> एलिमेंट के <Text>चाइल्ड एलिमेंट को अपनी शर्तों के हिसाब से सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि आपके पास 60 वर्णों तक की एट्रिब्यूट वैल्यू हो सकती हैं, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>60</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

CommentExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Comment length exceeded [num] at line [num](possibly around char
        [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Comment length exceeded 10 at line 2(possibly around char 48)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLMajorProtection नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज पेलोड में कोई एक्सएमएल दस्तावेज़ शामिल होता है. इस दस्तावेज़ में टिप्पणी की लंबाई, नीति के <ValueLimits> एलिमेंट के <Comment> चाइल्ड एलिमेंट में तय किए गए वर्णों की संख्या से ज़्यादा होती है.

उदाहरण के लिए, अगर नीति में <Comment> एलिमेंट को 10 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में 10 से ज़्यादा वर्णों वाली कोई टिप्पणी है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करें, ताकि एक्सएमएल-टीचर-प्रोटेक्ट पॉलिसी के नाम और उस लाइन नंबर की पहचान की जा सके जहां टिप्पणी की लंबाई तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1है और पेलोड में लाइन नंबर 2 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Comment length exceeded 10 at line 2(possibly around char 48)

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <ValueLimits> एलिमेंट के <Comment> चाइल्ड एलिमेंट में दी गई वैल्यू नोट करें.

    यहां दिए गए एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति के उदाहरण में, <Comment> को 10 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि वहां दी गई टिप्पणी की लंबाई, <Comment> एलिमेंट (दूसरे चरण में पहचानी गई) में बताई गई संख्या से ज़्यादा है या नहीं. अगर वर्णों की संख्या एट्रिब्यूट की वैल्यू से ज़्यादा है, तो यह गड़बड़ी की वजह होगी.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <food>
  <!--This is somewhat a long comment-->
  <name>Veg Sandwich</name>
  <price>$5.95</price>
  <description>Vegetarian Sandwich with onions, tomatoes and lettuce</description>
  <calories>650</calories>
</food>

    ऊपर दी गई लाइन 2 में मौजूद एक्सएमएल पेलोड में, टिप्पणी की वैल्यू 31 वर्णों की है. टिप्पणी की वैल्यू 10 से ज़्यादा (<Comment> एलिमेंट के लिए तय की गई वैल्यू) होने की वजह से, आपको यह गड़बड़ी दिखती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Comment length
exceeded 10 at line 2(possibly around char 48)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, टिप्पणी की तय सीमा से ज़्यादा के पेलोड से बचाना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि लंबी टिप्पणी की अनुमति दी जा सकती है, तो अपनी शर्तों के हिसाब से, <Comment>चाइल्ड एलिमेंट<ValueLimits> में बदलाव करके, उसकी सही वैल्यू डालें.

उदाहरण के लिए, अगर आपको लगता है कि ज़्यादा से ज़्यादा 40 वर्णों की वैल्यू एट्रिब्यूट की जा सकती है, तो नीति में इस तरह से बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>40</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

PIDataExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Processing Instruction data length exceeded [num] at line
        [num](possibly around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Processing Instruction data length exceeded 30 at line 2(possibly around char 109)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLThreatProtection नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज के पेलोड में कोई ऐसा एक्सएमएल दस्तावेज़ शामिल होता है जिसमें डेटा प्रोसेस करने का निर्देश, नीति के <ValueLimits> एलिमेंट के <ProcessingInstructionData> चाइल्ड एलिमेंट में तय किए गए वर्ण से ज़्यादा हो.

उदाहरण के लिए, अगर XML पिकअप नीति में <ProcessingInstructionData> एलिमेंट को 10 के तौर पर दिखाया गया है, लेकिन इनपुट पेलोड में 10 से ज़्यादा वर्णों का प्रोसेसिंग निर्देश है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करें, ताकि XMLसंरक्षित नीति के नाम और उस लाइन नंबर की पहचान की जा सके जिसमें डेटा प्रोसेस करने के निर्देश की तय सीमा पार हो गई है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1है और पेलोड में लाइन नंबर 2 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction data length exceeded 30 at line 2(possibly around char 109)

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <ValueLimits> एलिमेंट के <ProcessingInstructionData> चाइल्ड एलिमेंट में दी गई वैल्यू नोट करें .

    यहां दिए गए एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति के उदाहरण में, <ProcessingInstructionData> को 30 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (जिसकी पहचान पहले चरण में बताई गई है) की जांच करें. साथ ही, देखें कि क्या प्रोसेस करने से जुड़े निर्देश के डेटा की लंबाई में, <ProcessingInstructionData> एलिमेंट में दी गई संख्या (दूसरे चरण में बताई गई संख्या) से ज़्यादा वर्ण हैं. अगर निर्देशों की जानकारी प्रोसेस करने से जुड़े डेटा में वर्णों की संख्या ज़्यादा हो जाती है, तो यह गड़बड़ी होने की वजह होगी.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<?xml-stylesheet type="text/xsl" href="mobilephones.xsl"?>
<mobilephones>
  <mobilephone>
      <name>iPhone</name>
      <price>$600</price>
  </mobilephone>
  <mobilephone>
      <name>Samsung</name>
      <price>$500</price>
  </mobilephone>
</mobilephones>

    ऊपर पंक्ति 1 पर दिखाए गए एक्सएमएल पेलोड में प्रोसेसिंग निर्देश डेटा एलिमेंट है (type="text/xsl" href="mobilephones.xsl"?)40 वर्णों की लंबाई वाला. क्योंकि यह लंबाई 30 (<ProcessingInstructionData> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा है, इसलिए आपको यह गड़बड़ी मिलती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction data length exceeded 30 at line 2(possibly around char 109)

रिज़ॉल्यूशन

अगर एक्सएमएल-टीचर-प्रोटेक्ट नीति का मकसद ऐसे पेलोड से बचाना है जिनकी लंबाई, प्रोसेसिंग के निर्देश के लिए तय की गई सीमा से ज़्यादा है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि प्रोसेसिंग निर्देश वाले लंबे डेटा एलिमेंट की अनुमति दी जा सकती है, तो अपनी ज़रूरतों के हिसाब से <ValueLimits> एलिमेंट के <ProcessingInstructionData> चाइल्ड एलिमेंट की वैल्यू में बदलाव करें.

उदाहरण के लिए, अगर आपको लगता है कि डेटा प्रोसेसिंग के निर्देशों की लंबाई 50 वर्ण तक हो सकती है, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>40</Comment>
        <ProcessingInstructionData>50</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

PITargetExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Processing Instruction target length exceeded [num] at line [num](possibly around
        char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Processing Instruction target length exceeded 10 at line 2(possibly around char 114)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLThreatProtection नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज के पेलोड में कोई ऐसा एक्सएमएल दस्तावेज़ शामिल होता है जिसमें प्रोसेस निर्देश का टारगेट, नीति के <NameLimits> एलिमेंट के <ProcessingInstructionTarget> चाइल्ड एलिमेंट में तय किए गए वर्ण से ज़्यादा हो.

उदाहरण के लिए, अगर XMLThreatProtection नीति में <ProcessingInstructionTarget> एलिमेंट को 10 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में 10 से ज़्यादा वर्ण वाला प्रोसेस निर्देश टारगेट है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, उस XMLसंरक्षित नीति के नाम और उस लाइन नंबर की पहचान करें जहां प्रोसेस करने के निर्देश की तय संख्या पार हो गई है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1है और पेलोड में लाइन नंबर 1 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction target length exceeded 10 at line 2(possibly around char 114)

  2. पहले चरण में बताई गई, लागू न हुई XMLThreatProtection नीति की जांच करें. साथ ही, <NameLimits> एलिमेंट के <ProcessingInstructionTarget> चाइल्ड एलिमेंट में बताई गई वैल्यू पर ध्यान दें.

    यहां दी गई एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति के उदाहरण में, <ProcessingInstructionTarget> को 10 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
    <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि वहां बताए गए प्रोसेसिंग निर्देश के टारगेट की लंबाई, <ProcessingInstructionTarget> एलिमेंट (दूसरे चरण में पहचाने गए) में बताई गई संख्या से ज़्यादा है या नहीं. अगर वर्णों की संख्या, टारगेट साइज़ की सीमा से ज़्यादा है, तो गड़बड़ी की यही वजह है.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<?xml-stylesheet type="text/xsl" href="mobilephones.xsl"?>
<mobilephones>
  <mobilephone>
      <name>iPhone</name>
      <price>$600</price>
  </mobilephone>
  <mobilephone>
      <name>Samsung</name>
      <price>$500</price>
  </mobilephone>
</mobilephones>

    ऊपर दी गई लाइन 2 में मौजूद एक्सएमएल पेलोड में, प्रोसेसिंग निर्देश का टारगेट नाम "xml-stylesheet" है, जिसकी लंबाई 14 वर्ण है. प्रोसेसिंग निर्देश के टारगेट का नाम 10 से ज़्यादा (<ProcessingInstructionTarget> एलिमेंट के लिए तय की गई वैल्यू) है, इसलिए आपको यह गड़बड़ी दिखती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction target length exceeded 10 at line 2(possibly around char 114)

रिज़ॉल्यूशन

अगर XMLImageProtection नीति को ऐसे पेलोड से बचाया जाता है जिनकी प्रोसेस से जुड़े निर्देश के लिए तय की गई सीमा से ज़्यादा समय लगता है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि प्रोसेस से जुड़े निर्देश का कोई टारगेट ज़्यादा हो सकता है, तो <NameLimits> एलिमेंट के <ProcessingInstructionTarget>चाइल्ड एलिमेंट को अपनी शर्तों के मुताबिक सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि ज़्यादा से ज़्यादा 25 वर्णों वाले निर्देश टारगेट प्रोसेस किए जा सकते हैं, तो नीति में इस तरह से बदलाव करें:

  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>15</NamespacePrefix>
    <ProcessingInstructionTarget>25</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
  </XMLThreatProtection>

NSURIExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]: Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:  Namespace uri length length exceeded [num] at line [num](possibly around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Namespace uri length exceeded 10 at line 2(possibly around char 97)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब एक्सएमएल खतरे को सुरक्षित रखने की नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज पेलोड में ऐसा एक्सएमएल दस्तावेज़ होता है जिसमें नेमस्पेस यूआरएल, नीति के <ValueLimits>एलिमेंट के <NamespaceURI> चाइल्ड एलिमेंट में तय किए गए वर्णों की संख्या से ज़्यादा होता है.

उदाहरण के लिए, अगर नीति में <NamespaceURI> एलिमेंट को 10 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में 10 से ज़्यादा वर्णों वाला नेमस्पेस यूआरआई है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करें, ताकि एक्सएमएल-टीचर-प्रोटेक्ट पॉलिसी के नाम और उस लाइन नंबर की पहचान की जा सके जहां नेमस्पेस यूआरआई की लंबाई तय सीमा से ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम XML-Threat-Protection-1 है और पेलोड की लाइन नंबर 2 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
uri length exceeded 10 at line 2(possibly around char 97)

  2. पहले चरण में बताई गई उस नीति की जांच करें जो लागू नहीं हुई. साथ ही, <ValueLimits> एलिमेंट के <NamespaceURI> चाइल्ड एलिमेंट में बताई गई वैल्यू को नोट करें.

    एक्सएमएल-टीचर-प्रोटेक्ट नीति के इस उदाहरण में, <NamespaceURI> को 10 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>10</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड के खास लाइन नंबर (जिसकी पहचान पहले चरण में की गई है) की जांच करें. साथ ही, देखें कि क्या नेमस्पेस यूआरआई की लंबाई में, <NamespaceURI> एलिमेंट में दी गई संख्या से ज़्यादा वर्ण हैं (जिसकी पहचान दूसरे चरण में की गई है). अगर वर्णों की संख्या नेमस्पेस यूआरआई की लंबाई से ज़्यादा है, तो यह गड़बड़ी की वजह है.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <?xml version = "1.0" encoding = "UTF-8"?>
  <profile:user xmlns:profile = "www.google.com/profile">
  <profile:name>Rama Krishna</profile:name>
  <profile:company>Google</profile:company>
  <profile:phone>(91) 9876543210</profile:phone>
</profile:user>

    ऊपर दी गई दूसरी लाइन में मौजूद एक्सएमएल पेलोड में नेमस्पेस यूआरआई, www.google.com/profile है, जिसकी लंबाई 22 वर्ण है. नेमस्पेस यूआरआई की लंबाई 10 (<NamespaceURI> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा है, इसलिए आपको यह गड़बड़ी मिलती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
uri length exceeded 10 at line 2(possibly around char 99)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, किसी खास नेमस्पेस यूआरआई की लंबाई से ज़्यादा के पेलोड से सुरक्षा करना है, तो गड़बड़ी का मैसेज दिखना चाहिए. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि लंबे नेमस्पेस यूआरआई की अनुमति दी जा सकती है, तो अपनी ज़रूरतों के मुताबिक <ValueLimits> एलिमेंट के <NamespaceURI> चाइल्ड एलिमेंट को सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि आपके पास 30 वर्णों तक का नेमस्पेस यूआरआई हो सकता है, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>30</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

NSPrefixExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Namespace prefix length exceeded [num] at line [num](possibly
        around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Namespace prefix length exceeded 10 at line 2(possibly around char 105)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब <Source> एलिमेंट से तय किए गए इनपुट मैसेज के पेलोड में कोई ऐसा एक्सएमएल दस्तावेज़ शामिल होता है जिसमें नेमस्पेस प्रीफ़िक्स, नीति के <NameLimits> एलिमेंट के <NamespacePrefix> चाइल्ड एलिमेंट में बताए गए वर्ण से ज़्यादा हो.

उदाहरण के लिए, अगर XMLThreatProtection नीति में <NamespacePrefix> एलिमेंट को 10 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में 10 से ज़्यादा वर्णों वाला नेमस्पेस प्रीफ़िक्स है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, XMLThreatProtection नीति का नाम और उस लाइन नंबर की पहचान करें जहां नेमस्पेस यूआरआई प्रीफ़िक्स की लंबाई तय सीमा से ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम XML-Threat-Protection-1 है और पेलोड की लाइन नंबर 2 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
prefix length exceeded 10 at line 2(possibly around char 105)

  2. फ़ेल हुई नीति की जांच करें (पहले चरण में बताया गया है) और <NameLimits के <NamespacePrefix> चाइल्ड एलिमेंट में दी गई वैल्यू नोट करें> एलिमेंट.

    एक्सएमएल-टीचर-प्रोटेक्ट नीति के इस उदाहरण में, <NamespacePrefix> को 10 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि वहां बताए गए नेमस्पेस प्रीफ़िक्स की लंबाई, <NamespacePrefix> एलिमेंट (दूसरे चरण में पहचाने गए) में बताई गई संख्या से ज़्यादा है या नहीं. अगर वर्णों की संख्या नेमस्पेस प्रीफ़िक्स सीमा से ज़्यादा है, तो यह गड़बड़ी की वजह है.

    इनपुट पेलोड का उदाहरण यहां दिया गया है:

    <?xml version = "1.0" encoding = "UTF-8"?>
<userprofile:user xmlns:userprofile = "www.googlecom/profile">
  <userprofile:name>Rama Krishna</userprofile:name>
  <userprofile:company>Google</userprofile:company>
  <userprofile:phone>(011) 123-4567</userprofile:phone>
</userprofile:user>

    ऊपर दी गई लाइन 2 में दिखाए गए एक्सएमएल पेलोड में, नेमस्पेस प्रीफ़िक्स userprofile है, जिसकी लंबाई 11 वर्ण है. नेमस्पेस यूआरआई प्रीफ़िक्स की लंबाई 10 (<NamespacePrefix> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा होने की वजह से, आपको यह गड़बड़ी दिखेगी:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
prefix length exceeded 10 at line 2(possibly around char 105)

रिज़ॉल्यूशन

अगर XMLMajorProtection नीति को ऐसे पेलोड से बचाने के लिए बनाया गया है जो किसी खास नेमस्पेस यूआरआई प्रीफ़िक्स की लंबाई से ज़्यादा के होते हैं, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, आपको कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि नेमस्पेस यूआरआई के लिए लंबे प्रीफ़िक्स की अनुमति दी जा सकती है, तो अपनी ज़रूरतों के हिसाब से <NameLimits> एलिमेंट के <NamespacePrefix> चाइल्ड एलिमेंट की वैल्यू में बदलाव करें.

उदाहरण के लिए, अगर आपको लगता है कि नेमस्पेस यूआरआई प्रीफ़िक्स की लंबाई 15 वर्णों तक हो सकती है, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>5</Attribute>
        <NamespacePrefix>15</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>2</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>15</Text>
        <Attribute>10</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>10</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

NSCountExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. reason: XMLThreatProtection stepDefinition [policy_name]:
        Namespace count exceeded [num] at line [num](possibly around char [num])",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed. reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace count exceeded 3 at line 2(possibly around char 234)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLThreatProtection नीति के <Source> एलिमेंट से तय किए गए इनपुट मैसेज के पेलोड में कोई ऐसा एक्सएमएल दस्तावेज़ शामिल हो जिसमें किसी एक एलिमेंट में इस्तेमाल किए गए नेमस्पेस की संख्या, नीति के <StructureLimits> एलिमेंट के <NamespaceCountPerElement> चाइल्ड एलिमेंट में बताई गई संख्या से ज़्यादा हो.

उदाहरण के लिए, अगर नीति में <NamespaceCountPerElement> एलिमेंट को 3 के तौर पर बताया गया है, लेकिन इनपुट पेलोड में तीन से ज़्यादा नेमस्पेस वाला एलिमेंट है, तो यह गड़बड़ी दिखती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करें, ताकि XMLMajorProtection नीति के नाम और उस लाइन नंबर की पहचान की जा सके जहां नेमस्पेस की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XMLThreat-Protection-1है और पेलोड में लाइन नंबर 2 है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace count
exceeded 3 at line 2(possibly around char 234)

  2. पहले चरण में बताई गई उस नीति की जांच करें जो लागू नहीं हुई. साथ ही, <StructureLimits> एलिमेंट के <NamespaceCountPerElement> चाइल्ड एलिमेंट में बताई गई वैल्यू को नोट करें.

    यहां दी गई एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति के उदाहरण में, <NamespaceCountPerElement> को 3 पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

  3. इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि किसी एक एलिमेंट के लिए वहां बताए गए नेमस्पेस की संख्या, <NamespaceCountPerElement> एलिमेंट (दूसरे चरण में पहचाने गए) में बताई गई संख्या से ज़्यादा है या नहीं. अगर नेमस्पेस की संख्या, हर एलिमेंट के लिए नेमस्पेस की संख्या से ज़्यादा है, तो यह गड़बड़ी की वजह है.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <?xml version = "1.0" encoding = "UTF-8"?>
<hellos xmlns:h="https://www.w3schools.com/greeting1" xmlns:a="https://www.w3schools.com/greeting2" xmlns:b="https://www.w3schols.com/greeting3" xmlns:c="https://www.w3schools.com/greeting4">
    <a:hello1>world1</a:hello1>
    <b:hello2>world2</b:hello2>
    <c:hello2>world2</c:hello2>
    <h:hello2>world2</h:hello2>
</hellos>

    ऊपर दी गई लाइन 2 में दिखाए गए एक्सएमएल पेलोड में तीन से ज़्यादा नेमस्पेस हैं. नेमस्पेस की संख्या तीन (<NamespaceCountPerElement> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा होती है, इसलिए आपको यह गड़बड़ी मिलती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
count exceeded 3 at line 2(possibly around char 234)

रिज़ॉल्यूशन

अगर XMLThreatProtection नीति का मकसद, किसी एक एलिमेंट में नेमस्पेस की तय संख्या से ज़्यादा वाले पेलोड से सुरक्षा करना है, तो गड़बड़ी का मैसेज दिख सकता है. इस मामले में, कुछ और करने की ज़रूरत नहीं है.

हालांकि, अगर आपको लगता है कि बड़ी संख्या में नेमस्पेस की अनुमति दी जा सकती है, तो <StructureLimits> एलिमेंट के <NamespaceCountPerElement> चाइल्ड एलिमेंट को अपनी ज़रूरत के हिसाब से सही वैल्यू में बदलें.

उदाहरण के लिए, अगर आपको लगता है कि एक एलिमेंट में ज़्यादा से ज़्यादा पांच नेमस्पेस हो सकते हैं, तो नीति में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>5</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

InvalidXMLPayload

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. Reason: [error_description]",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: Syntax error while parsing XML prologue",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLProtectionPolicy नीति के <Source> एलिमेंट से तय किया गया इनपुट मैसेज पेलोड मान्य एक्सएमएल दस्तावेज़ नहीं है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज की जांच करके, उस नीति का नाम पता लगाएं जिसमें गड़बड़ी हुई है. नीचे दिए गए उदाहरण में नीति का नाम XML-Threat-Protection-1 है.

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: Syntax error while parsing XML prologue

  2. इनपुट पेलोड की जांच करें और देखें कि पेलोड में पास किया गया एक्सएमएल दस्तावेज़, सही तरीके से बनाया गया एक्सएमएल दस्तावेज़ है या नहीं.

    इनपुट पेलोड का एक उदाहरण यहां दिया गया है:

    <?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="cooking">
    <title lang="en">Easy Indian Cooking</title>
    <author>Suneeta</author>
    <year>2004</year>
    <price>300.00</price>
  </book>
<bookstore>

    ऊपर दिखाए गए एक्सएमएल पेलोड में, लाइन 9 में रूट एलिमेंट को सही तरीके से बंद नहीं किया गया है, क्योंकि / मौजूद नहीं है. इसका एक्सएमएल फ़ॉर्मैट सही नहीं है, इसलिए आपको यह गड़बड़ी मिलती है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: Syntax error while parsing XML prologue

रिज़ॉल्यूशन

पक्का करें कि ऐसे किसी भी एपीआई प्रॉक्सी को मान्य इनपुट एक्सएमएल पेलोड पास किया जाए जिसमें XML TabProtection नीति मौजूद है.

ऊपर बताए गए उदाहरण में दी गई गड़बड़ी को ठीक करने के लिए, इनपुट एक्सएमएल पेलोड में इस तरह बदलाव करें:

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="cooking">
    <title lang="en">Easy Indian Cooking
    <author>Suneeta</author>
    <year>2004</year>
    <price>300.00</price>
  </book>
</bookstore>

SourceUnavailable

गड़बड़ी कोड

steps.xmlthreatprotection.SourceUnavailable

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition[policy_name]: Source[var_name] is not available"
        "detail": {
            "errorcode": "steps.xmlthreatprotection.SourceUnavailable"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Source requests is not available",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.SourceUnavailable"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLThreatProtection नीति के <Source> एलिमेंट में बताए गए message वैरिएबल में से कोई एक हो:

  • दायरे से बाहर है (जिस फ़्लो में नीति लागू की जा रही है उसमें उपलब्ध नहीं है)
  • यह request, response या message जैसी मान्य वैल्यू नहीं है

उदाहरण के लिए, यह गड़बड़ी तब होती है, जब नीति में <Source> एलिमेंट को किसी ऐसे वैरिएबल पर सेट किया जाता है जो उस फ़्लो में मौजूद नहीं होता जहां नीति लागू की जाती है.

संक्रमण की जांच

  1. गड़बड़ी के मैसेज से, XMLThreatProtection नीति का नाम और सोर्स वैरिएबल का नाम पहचानें. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, XMLMajorProtection नीति का नाम XML-Threat-Protection-1 है और सोर्स वैरिएबल requests: है

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Source requests
is not available

  2. XMLThreatProtection की उस नीति की जांच करें जो लागू नहीं हुई है. साथ ही, पहले चरण में पहचाने गए <Source> एलिमेंट के लिए बताई गई वैल्यू देखें.

    यहां दिए गए एक्सएमएल खतरे से सुरक्षा से जुड़ी नीति के उदाहरण में, <Source> एलिमेंट को requests पर सेट किया गया है.

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>requests</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

    <Source> एलिमेंट के लिए मान्य वैल्यू request, response या message. हैं. ऐसा इसलिए, क्योंकि requests एक मान्य वैल्यू नहीं है और नीति के लागू होने के दौरान, यह वैल्यू मौजूद नहीं होती. इसलिए, आपको गड़बड़ी का यह मैसेज मिलता है:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Source requests
is not available

रिज़ॉल्यूशन

पक्का करें कि सफल नहीं होने वाली एक्सएमएल-टीचर-प्रोटेक्ट नीति के <Source> एलिमेंट में सेट किया गया वैरिएबल, request, response या message पर सेट है. साथ ही, यह उस फ़्लो में मौजूद होता है जहां नीति लागू होती है.

ऊपर दी गई उदाहरण नीति को ठीक करने के लिए, request वैरिएबल का इस्तेमाल करने के लिए <Source> एलिमेंट में बदलाव किया जा सकता है, क्योंकि यह अनुरोध फ़्लो में मौजूद है:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>request</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

NonMessageVariable

गड़बड़ी कोड

steps.xmlthreatprotection.NonMessageVariable

गड़बड़ी के जवाब का मुख्य हिस्सा

{
    "fault": {
        "faultstring": "Variable var_name does not resolve to a Message"
        "detail": {
            "errorcode": "steps.xmlthreatprotection.NonMessageVariable"
        }
    }
}

गड़बड़ी के जवाब का मुख्य हिस्सा उदाहरण

{
    "fault": {
        "faultstring": "Variable message.content does not resolve to a Message",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.NonMessageVariable"
        }
    }
}

वजह

यह गड़बड़ी तब होती है, जब XMLMajorProtection नीति में <Source> एलिमेंट को किसी ऐसे वैरिएबल पर सेट किया गया हो जो Message टाइप का न हो.

मैसेज टाइप वैरिएबल, सभी एचटीटीपी अनुरोधों और जवाबों को दिखाते हैं. पहले से मौजूद Apigee Edge फ़्लो वैरिएबल, request, response, और message, मैसेज टाइप के होते हैं. मैसेज वैरिएबल के बारे में ज़्यादा जानने के लिए, वैरिएबल का रेफ़रंस देखें.

संक्रमण की जांच

  1. उस वैरिएबल के नाम की पहचान करें जो गड़बड़ी के मैसेज से, मैसेज टाइप वैरिएबल पर ले जाता है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में वैरिएबल का नाम message.content है

    Variable message.content does not resolve to a Message

  2. एपीआई प्रॉक्सी में मौजूद उन सभी XMLThreadProtection नीतियों की जांच करें जिनमें गड़बड़ी हुई है. इसके बाद, उस एक्सएमएलThreadProtection नीति की पहचान करें जिसमें <Source> एलिमेंट को ऊपर दिए गए पहले चरण में बताए गए वैरिएबल नाम से तय किया गया है.

    एक्सएमएल कोड के लिए सुरक्षा से जुड़ी नीति के इस उदाहरण में, <Source> को message.content पर सेट किया गया है:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>message.content</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>

    वैरिएबल message.content, Message टाइप का नहीं है. इसलिए, आपको गड़बड़ी का यह मैसेज मिलता है:

    Variable message.content does not resolve to a Message

रिज़ॉल्यूशन

पक्का करें कि काम न करने वाली एक्सएमएल-थीम के लिए सुरक्षा से जुड़ी नीति में मौजूद <Source> एलिमेंट को Message टाइप फ़्लो वैरिएबल पर सेट किया गया हो. यह वैरिएबल, उस फ़्लो में मौजूद होता है जहां नीति लागू होती है.

नीति को ठीक करने के लिए, <Source> एलिमेंट में बदलाव करके, मैसेज टाइप का वैरिएबल तय किया जा सकता है. उदाहरण के लिए, XMLThreatProtection में, <Source> एलिमेंट को message के तौर पर सेट किया जा सकता है:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<XMLThreatProtection async="false" continueOnError="false" enabled="true" name="XML-Threat-Protection-1">
    <DisplayName>XML Threat Protection-1</DisplayName>
    <Properties/>
    <NameLimits>
        <Element>10</Element>
        <Attribute>10</Attribute>
        <NamespacePrefix>10</NamespacePrefix>
        <ProcessingInstructionTarget>10</ProcessingInstructionTarget>
    </NameLimits>
    <Source>message</Source>
    <StructureLimits>
        <NodeDepth>10</NodeDepth>
        <AttributeCountPerElement>5</AttributeCountPerElement>
        <NamespaceCountPerElement>3</NamespaceCountPerElement>
        <ChildCount includeComment="true" includeElement="true" includeProcessingInstruction="true" includeText="true">3</ChildCount>
    </StructureLimits>
    <ValueLimits>
        <Text>20</Text>
        <Attribute>15</Attribute>
        <NamespaceURI>40</NamespaceURI>
        <Comment>10</Comment>
        <ProcessingInstructionData>30</ProcessingInstructionData>
    </ValueLimits>
</XMLThreatProtection>