इस पेज का अनुवाद 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"
        }
    }
}

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

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

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

ElementNameExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

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

वजह

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

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

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

गड़बड़ी के मैसेज की जांच करके, 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 नाम का एक रूट एलिमेंट है, जिसमें सात वर्ण हैं. एलिमेंट की लंबाई 5 (<Element> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा होने पर, आपको यह गड़बड़ी दिखती है:
```
XML-Threat-Protection-1: Execution failed. reason: XMLThreatProtection stepDefinition
XML-Threat-Protection-1: Element name length exceeded 5 at line 1(possibly around char 9)
```

रिज़ॉल्यूशन

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

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

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

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

ChildCountExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

वजह

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

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

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

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

रिज़ॉल्यूशन

अगर 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> एलिमेंट में दी गई वैल्यू को नोट करें.

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

रिज़ॉल्यूशन

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

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

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

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

AttributeCountExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

वजह

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

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

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

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

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

उदाहरण के लिए, अगर XMLMajorProtection नीति में <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>
```
ऊपर दी गई तीसरी लाइन में मौजूद एक्सएमएल पेलोड में एक एट्रिब्यूट (cuisine) है, जिसकी वैल्यू 12 वर्णों की है. एट्रिब्यूट की वैल्यू की लंबाई 10 (<Attribute> एलिमेंट के लिए तय की गई वैल्यू) से ज़्यादा होने की वजह से, आपको यह गड़बड़ी दिखती है:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
value length exceeded 10 at line 3(possibly around char 111)
```

रिज़ॉल्यूशन

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

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

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

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

TextExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

वजह

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

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

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

रिज़ॉल्यूशन

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

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

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

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

CommentExceeded

गड़बड़ी कोड

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

वजह

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

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

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

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

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

रिज़ॉल्यूशन

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

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

वजह

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

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

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

रिज़ॉल्यूशन

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

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

वजह

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

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

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

गड़बड़ी के मैसेज की जांच करके, उस XMLसंरक्षित नीति के नाम और उस लाइन नंबर की पहचान करें जहां प्रोसेस करने के निर्देश की तय संख्या पार हो गई है. उदाहरण के लिए, गड़बड़ी के इस मैसेज में, नीति का नाम XML-Threat-Protection-1है और पेलोड में लाइन नंबर 1 है:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction target length exceeded 10 at line 2(possibly around char 114)
```

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

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

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

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

रिज़ॉल्यूशन

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

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

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

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

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

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

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

रिज़ॉल्यूशन

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

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

रिज़ॉल्यूशन

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

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

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

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

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

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

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

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

रिज़ॉल्यूशन

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

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

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

NonMessageVariable

गड़बड़ी कोड

steps.xmlthreatprotection.NonMessageVariable

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

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

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

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

वजह

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

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

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

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

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

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

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

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

Variable message.content does not resolve to a Message

रिज़ॉल्यूशन

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

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

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