इस पेज का अनुवाद Cloud Translation API से किया गया है.

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"
        }
    }
}

अलग-अलग तरह की गड़बड़ियां और संभावित वजहें

XMLThreadProtection की नीति में, Execution रिज़ॉर्ट से जुड़ी कई तरह की गड़बड़ियां पाई जा सकती हैं. नीचे दी गई टेबल में अलग-अलग तरह की गड़बड़ियों और उनकी संभावित वजहों के बारे में बताया गया है:

गड़बड़ी	वजह
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> एलिमेंट में दी गई सीमा से ज़्यादा हों.

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

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

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

उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

फ़ेल हो चुकी नीति की जांच करें (पहले चरण में इसकी पहचान की गई है) और <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>

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

इनपुट पेलोड का एक उदाहरण यहां दिया गया है:
```
<company>
  <name>Google</name>
  <country>USA</country>
</company>
```
ऊपर दिखाए गए एक्सएमएल पेलोड में लाइन 1 पर company नाम का एक रूट एलिमेंट है, जिसमें 7 वर्ण हैं. एलिमेंट की लंबाई 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 तक की लंबाई वाले एलिमेंट को अनुमति दी जा सकती है, तो XMLThreadProtection की नीति में इस तरह से बदलाव करें:

<?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 है, लेकिन इनपुट एक्सएमएल पेलोड में किसी एलिमेंट में तीन से ज़्यादा चाइल्ड एलिमेंट हैं, तो यह गड़बड़ी दिखती है.

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

XMLThreadProtection नीति का नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें एंट्री की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)"
```

फ़ेल हो चुकी नीति की जांच करें (पहले चरण में इसकी पहचान की गई है) और <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>

इनपुट पेलोड की खास लाइन नंबर की जांच करें (जिसकी पहचान पहले चरण में की गई है). साथ ही, देखें कि क्या पेलोड में चाइल्ड एलिमेंट (सभी टिप्पणियां वगैरह शामिल हैं) की संख्या, <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)
```

रिज़ॉल्यूशन

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

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

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

<?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> एलिमेंट के साथ बताए गए इनपुट मैसेज पेलोड में कोई एक्सएमएल दस्तावेज़ मौजूद हो. इस दस्तावेज़ में मौजूद नोड हैरारकी, XMLThreadProtection नीति के <NodeDepth> एलिमेंट में दी गई संख्या से ज़्यादा होती है.

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

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

गड़बड़ी के मैसेज की जांच करके XML XMLProtection नीति के नाम और उस लाइन नंबर की जांच करें जहां नोड की गहराई पार हुई है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि क्या वहां बताई गई नोड डेप्थ की संख्या, <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 है.नोड डेप्थ 5 (<NodeDepth> एलिमेंट के लिए बताई गई वैल्यू) से ज़्यादा है. इसलिए, आपको यह गड़बड़ी दिखेगी:
```
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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि नोड की ज़्यादा गहराई की अनुमति हो सकती है, तो <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"
        }
    }
}

वजह

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

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

फ़ेल हो चुकी नीति की जांच करें (पहले चरण में इसकी पहचान की गई है) और <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि क्या बताए गए एट्रिब्यूट की संख्या, <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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि ज़्यादा संख्या में एट्रिब्यूट इस्तेमाल किए जा सकते हैं, तो <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"
        }
    }
}

वजह

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

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें एट्रिब्यूट के नाम की वैल्यू तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि एट्रिब्यूट की लंबाई में, <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)
```

रिज़ॉल्यूशन

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

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

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि एट्रिब्यूट की वैल्यू की लंबाई, <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>
```
ऊपर लाइन 3 में दिखाए गए एक्सएमएल पेलोड में 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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि लंबे एट्रिब्यूट वैल्यू का इस्तेमाल किया जा सकता है, तो <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"
        }
    }

वजह

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

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें एट्रिब्यूट की संख्या तय सीमा से ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि एट्रिब्यूट की वैल्यू की लंबाई, <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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि लंबे टेक्स्ट का इस्तेमाल किया जा सकता है, तो <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"
        }
    }
}

वजह

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

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

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

XMLThreadProtection नीति का नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जहां टिप्पणी की लंबाई ज़्यादा है. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

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

इनपुट पेलोड का एक उदाहरण यहां दिया गया है:
```
<food>
  
  <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)
```

रिज़ॉल्यूशन

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

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

उदाहरण के लिए, अगर आपको लगता है कि 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"
        }
    }
}

वजह

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

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें प्रोसेसिंग के निर्देश की लंबाई तय सीमा से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि प्रोसेसिंग के निर्देश डेटा की लंबाई में, <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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि निर्देश वाले डेटा एलिमेंट को लंबे समय तक प्रोसेस किया जा सकता है, तो <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"
        }
    }
}

वजह

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

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

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

गड़बड़ी के मैसेज की जांच करें, ताकि XMLThreadProtection नीति का नाम और उस लाइन नंबर की पहचान की जा सके जहां प्रोसेसिंग के निर्देश टारगेट की संख्या तय सीमा से ज़्यादा हो गई है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि प्रोसेसिंग के निर्देश टारगेट की लंबाई, <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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि प्रोसेस से जुड़े निर्देश का टारगेट लंबा हो सकता है, तो <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"
        }
    }
}

वजह

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

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें नेमस्पेस यूआरआई की लंबाई ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचाना गया) की जांच करें और देखें कि क्या बताए गए नेमस्पेस यूआरआई की लंबाई में, <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>
```
ऊपर लाइन 2 में दिखाए गए एक्सएमएल पेलोड में 22 वर्णों का एक नेमस्पेस यूआरआई, www.google.com/profile है. नेमस्पेस यूआरआई की लंबाई 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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि लंबे नेमस्पेस यूआरआई का इस्तेमाल किया जा सकता है, तो <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> चाइल्ड एलिमेंट में तय वर्णों की संख्या से ज़्यादा हो.

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

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

XMLThreadProtection नीति के नाम और उस लाइन नंबर की पहचान करने के लिए गड़बड़ी के मैसेज की जांच करें जिसमें नेमस्पेस यूआरआई प्रीफ़िक्स की लंबाई से ज़्यादा है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की खास लाइन नंबर (पहले चरण में पहचानी गई) की जांच करें और देखें कि क्या बताए गए नेमस्पेस प्रीफ़िक्स की लंबाई, <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 में दिखाया गया एक्सएमएल पेलोड में 11 वर्णों वाला नेमस्पेस प्रीफ़िक्स userprofile है. नेमस्पेस यूआरआई प्रीफ़िक्स की लंबाई 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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि लंबे नेमस्पेस यूआरआई प्रीफ़िक्स का इस्तेमाल किया जा सकता है, तो <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"
        }
    }
}

वजह

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

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

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

XML XMLProtection नीति के नाम और उस लाइन नंबर की जांच करें जिसमें नेमस्पेस की संख्या तय सीमा से ज़्यादा है. इसके लिए गड़बड़ी के मैसेज की जांच करें. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम 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)
```

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

इस XML XMLProtection नीति के उदाहरण में, <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>

इनपुट पेलोड की लाइन नंबर की जांच करें. इसे पहले चरण में पहचाना गया है. साथ ही, यह जांच करें कि क्या किसी एक एलिमेंट के लिए उसमें मौजूद नेमस्पेस की संख्या, <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 में दिखाए गए एक्सएमएल पेलोड में तीन से ज़्यादा नेमस्पेस हैं. नेमस्पेस की संख्या 3 (<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)
```

रिज़ॉल्यूशन

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

हालांकि, अगर आपको लगता है कि ज़्यादा संख्या में नेमस्पेस का इस्तेमाल किया जा सकता है, तो <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> एलिमेंट से बताया गया इनपुट मैसेज पेलोड एक मान्य एक्सएमएल दस्तावेज़ नहीं है.

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

गड़बड़ी के मैसेज की जांच करके नीति का नाम पता करें. यहां दिए गए उदाहरण में, नीति का नाम XML-Threat-Protection-1 है.
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: Syntax error while parsing XML prologue
```
इनपुट पेलोड की जांच करें और देखें कि पेलोड में पास किया गया एक्सएमएल दस्तावेज़, वाकई में अच्छी तरह से बनाया गया एक्सएमएल दस्तावेज़ है या नहीं.

इनपुट पेलोड का एक उदाहरण यहां दिया गया है:
```
<?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
```

रिज़ॉल्यूशन

पक्का करें कि मान्य इनपुट एक्सएमएल पेलोड ऐसे किसी भी एपीआई प्रॉक्सी को भेजा गया हो जिसमें XMLThreadProtection नीति शामिल हो.

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

<?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"
        }
    }
}

वजह

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

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

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

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

XMLThreadProtection नीति का नाम और गड़बड़ी के मैसेज से सोर्स वैरिएबल के नाम की पहचान करें. उदाहरण के लिए, इस गड़बड़ी के मैसेज में, XML XMLProtection नीति का नाम XML-Threat-Protection-1 और सोर्स वैरिएबल requests: है
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Source requests
is not available
```

एक्सएमएल के दौरान गड़बड़ी ठीक करने से जुड़ी नीति की जांच करें और पहले चरण में पहचाने गए <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

रिज़ॉल्यूशन

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

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

<?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"
        }
    }
}

वजह

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

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

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

गड़बड़ी के मैसेज से मैसेज टाइप के वैरिएबल का समाधान करने वाले वैरिएबल के नाम की पहचान करें. उदाहरण के लिए, नीचे दिए गए गड़बड़ी के मैसेज में वैरिएबल का नाम message.content है
```
Variable message.content does not resolve to a Message
```

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

इस XML XMLProtection नीति के उदाहरण में, <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 का टाइप 'मैसेज' नहीं है, इसलिए आपको गड़बड़ी का यह मैसेज मिला है:

Variable message.content does not resolve to a Message

रिज़ॉल्यूशन

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

इस नीति को ठीक करने के लिए, <Source> एलिमेंट में बदलाव किया जा सकता है, ताकि मैसेज टाइप के वैरिएबल के बारे में बताया जा सके. उदाहरण के लिए, काम न करने वाले XMLThreadProtection में, <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>