Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

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

Apigee Edge का दस्तावेज़ देखा जा रहा है.
Apigee X के दस्तावेज़ पर जाएं. info

पर क्लिक करें.

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

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

XMLThreatProtection नीति, ExecutionFailed से जुड़ी कई तरह की गड़बड़ियां दिखा सकती है. यहां दी गई टेबल में, अलग-अलग तरह की गड़बड़ियों और उनकी संभावित वजहों के बारे में बताया गया है:

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

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

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

गड़बड़ी के मैसेज की जांच करें. इससे आपको 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)
```

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

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

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

गड़बड़ी के मैसेज की जांच करें. इससे आपको 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)"
```

नीति के उल्लंघन की वजह से अस्वीकार किए गए प्रॉडक्ट (पहले चरण में पहचाना गया) की जांच करें. साथ ही, <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>
```
ऊपर दिखाए गए एक्सएमएल पेलोड में, पांचवीं लाइन में रूट एलिमेंट <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)
```

रिज़ॉल्यूशन

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

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

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

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

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

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

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

वजह

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

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

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

गड़बड़ी के मैसेज की जांच करें. इससे आपको 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)
```

नीति के उल्लंघन की वजह से अस्वीकार किए गए प्रॉडक्ट (पहले चरण में पहचाना गया) की जांच करें. साथ ही, <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>
```
ऊपर दिखाई गई एक्सएमएल पेलोड की तीसरी लाइन में, तीन एट्रिब्यूट वाला एक एलिमेंट है. एट्रिब्यूट की संख्या 2 से ज़्यादा है. यह संख्या, <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"
        }
    }
}

वजह

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

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

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

गड़बड़ी के मैसेज की जांच करें. इससे आपको 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)
```

नीति के उल्लंघन की वजह से अस्वीकार किए गए प्रॉडक्ट (पहले चरण में पहचाना गया) की जांच करें. साथ ही, <Attribute> एलिमेंट में दी गई वैल्यू नोट करें

नीचे दिए गए XMLThreatProtection नीति के उदाहरण में, <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>
```
ऊपर दिखाई गई एक्सएमएल पेलोड की तीसरी लाइन में, 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)
```

रिज़ॉल्यूशन

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

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

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

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

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

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

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

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

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

गड़बड़ी के मैसेज की जांच करें. इससे आपको 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)
```

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

यहां XMLThreatProtection नीति का एक उदाहरण दिया गया है. इसमें <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>
```
ऊपर दिखाई गई XML पेलोड की चौथी लाइन में, 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"
        }
    }
}

वजह

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

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

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

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

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

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

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

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

यहां XMLThreatProtection नीति का एक उदाहरण दिया गया है. इसमें <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>
```
ऊपर दिखाई गई एक्सएमएल पेलोड की पहली लाइन में, प्रोसेसिंग का निर्देश देने वाला डेटा एलिमेंट (type="text/xsl" href="mobilephones.xsl"?)40 वर्णों वाला.) मौजूद है. इसकी लंबाई 30 से ज़्यादा है. 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)
```

रिज़ॉल्यूशन

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

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

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

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

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

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

रिज़ॉल्यूशन

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

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

वजह

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

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

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

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

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

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

गड़बड़ी के मैसेज की जांच करके, 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)
```

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

यहां XMLThreatProtection नीति का एक उदाहरण दिया गया है. इसमें <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>
```
ऊपर दिखाई गई XML पेलोड की दूसरी लाइन में, नेमस्पेस प्रीफ़िक्स 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)
```

रिज़ॉल्यूशन

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

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

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

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

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

रिज़ॉल्यूशन

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

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

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

रिज़ॉल्यूशन

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

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

<?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> एलिमेंट को ऐसे वैरिएबल पर सेट किया जाता है जो उस फ़्लो में मौजूद नहीं है जहां नीति लागू की जाती है.

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

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

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

यहां दिए गए XMLThreatProtection नीति के उदाहरण में, <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

रिज़ॉल्यूशन

पक्का करें कि XMLThreatProtection की उल्लंघन करने वाली नीति के <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"
        }
    }
}

वजह

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

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

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

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

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

यहां XMLThreatProtection नीति का एक उदाहरण दिया गया है. इसमें <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

रिज़ॉल्यूशन

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

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