Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

פתרון בעיות של שגיאות זמן ריצה במדיניות XMLThreatProtection

הדף הזה רלוונטי ל-Apigee ול-Apigee Hybrid.

לעיון במסמכי התיעוד של Apigee Edge

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 יכולה להקפיץ הודעת שגיאה (throw) סוגים רבים של שגיאות ExecutionFailed. בטבלה הבאה מפורטים סוגי השגיאות השונים והסיבות האפשריות להן:

שגיאה	מטרה
ElementNameExceeded	המחרוזת ארוכה יותר מהאורך המקסימלי המותר בתג XML.
ChildCountExceeded	חריגה ממספר רכיבי הצאצא המקסימלי שמותר במטען ייעודי (payload) של XML.
NodeDepthExceeded	חריגה מהעומק המקסימלי של רכיבי XML שמותרים במטען ייעודי (payload) של XML.
AttributeCountExceeded	חלה חריגה מהמספר המקסימלי של מאפיינים ברכיב יחיד.
AttributeNameExceeded	חריגה מהאורך המקסימלי המותר של שם מאפיין.
AttributeValueExceeded	האורך המקסימלי המותר עבור ערך מאפיין חורג.
TextExceeded	הטקסט חורג מהאורך המקסימלי המותר.
CommentExceeded	ההערה חורגת מהאורך המקסימלי המותר.
PIDataExceeded	אורך הנתונים של הוראות העיבוד חורג מהמגבלה המותרת.
PITargetExceeded	השם של הוראת התהליך ארוך מדי.
NSURIExceeded	אורך כתובת ה-URL של מרחב השמות חורג מהמגבלה.
NSPrefixExceeded	האורך של קידומת מרחב השמות חורג מהמגבלה.
NSCountExceeded	מספר מרחבי השמות שנעשה בהם שימוש ברכיב יחיד חורג מהמותר.
מטען ייעודי (payload) לא תקין בפורמט XML	מטען ה-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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הקלט שצוין באלמנט <Source> של המדיניות מכיל אלמנטים ב-XML שחורגים מהאורך המקסימלי שצוין באלמנט <Element> מתחת לאלמנט <NameLimits>.

לדוגמה, אם האלמנט <Element> מוגדר כ-5 במדיניות XMLThreatProtection, אבל למטען הייעודי (payload) של הקלט יש אלמנט שמכיל יותר מ-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)
```

בודקים את המדיניות שנכשלה (שצוינה בשלב 1) ורושמים את הערך שצוין ברכיב <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>

בודקים את מספר השורה הספציפי (שזוהה בשלב 1) של מטען הייעודי (payload) של הקלט, ומוודאים שאורך הרכיב בשורה הזו גדול מהערך שצוין עבור רכיב <Element> (שזוהה בשלב 2). אם אורך הרכיב חורג מהערך הזה, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<company>
  <name>Example</name>
  <country>USA</country>
</company>
```
מטען ה-XML שמוצג למעלה מכיל רכיב בסיסי בשם company בשורה 1, שאורכו 7 תווים. מכיוון שאורך הרכיב גדול מ-5 (הערך שצוין לרכיב <Element>), מוצגת השגיאה הבאה:
```
XML-Threat-Protection-1: Execution failed. reason: XMLThreatProtection stepDefinition
XML-Threat-Protection-1: Element name length exceeded 5 at line 1(possibly around char 9)
```

רזולוציה

אם מדיניות XMLThreadProtection נועדה להגן מפני מטען ייעודי (payload) עם שמות רכיבים שחורגים מהערך המוגדר, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם תגיעו למסקנה שאפשר לציין רכיבים ארוכים יותר במטען הייעודי בלי שזה ישפיע על משהו, תוכלו לשנות את <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> מכיל רכיב XML שמכיל יותר רכיבי צאצא מהערך שצוין ברכיב <ChildCount> של המדיניות.

לדוגמה, אם הערך של הרכיב <ChildCount> הוא 3, אבל מטען ה-XML של הקלט מכיל רכיב עם יותר מ-3 רכיבי צאצא, השגיאה הזו תופיע.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר הערכים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)"
```

בודקים את המדיניות שנכשלה (שצוינה בשלב 1) ורושמים את הערך שצוין ברכיב <ChildCount>.

בדוגמה הבאה של מדיניות, הערך של <ChildCount> מוגדר ל-3(שימו לב שהערות, רכיבי include ואחרים נספרים במסגרת המגבלה הזו):

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

בודקים את מספר השורה הספציפי (שזוהה בשלב 1) של מטען הייעודי (payload) של הקלט, ומבררים אם מספר רכיבי הצאצא (כולל כל התגובות וכו') במטען הייעודי גדול מהערך שצוין לרכיב <ChildCount> (שזוהה בשלב 2). אם מספר רכיבי הצאצא חורג ממספר הצאצאים, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<movie>
  <title>Jurassic Park</title>
  <language>English</language>
  <country>USA</country>
  <director>Steven Spielberg</director>
</movie>
```
במטען הנתונים של ה-XML שמוצג למעלה, שורה 5 מכילה רכיב צאצא רביעי <director>של רכיב הבסיס <movie>. מכיוון שמספר רכיבי הצאצא במטען הנתונים של ה-XML שמוזן גדול מ-3 (הערך שצוין לרכיב <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 נועדה להגן מפני מטען ייעודי (payload) עם מספר רכיבי צאצא שחורג מסף מסוים, הודעת השגיאה צפויה. במקרה כזה, לא צריך לבצע פעולה נוספת.

עם זאת, אם תגיעו למסקנה שאפשר לכלול במטען הנתונים מספר גדול יותר של רכיבי צאצא (כולל תגובות וכו') בלי שום השלכות, תוכלו לשנות את <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> מכיל מסמך XML שבו היררכיית הצמתים חורגת מהמספר שצוין ברכיב <NodeDepth> של מדיניות XMLThreatProtection.

לדוגמה, אם הרכיב <NodeDepth> מוגדר כ-4 במדיניות, אבל לעומק הצומת במטען הייעודי (payload) של הקלט יש ערך שגדול מ-4, השגיאה הזו תופיע.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם מעומק הצומת. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה XMLThreatProtection (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב <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>

בודקים את מספר השורה הספציפי (שצוין בשלב 1) של מטען הייעודי (payload) של הקלט, ומוודאים שעומק הצומת שצוין שם גבוה יותר מהמספר שצוין ברכיב <NodeDepth> (שצוין בשלב 2). אם מספר רכיבי הצאצא של ה-XML חורג מהספירה, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<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>
```
עומק הצומת במטען הנתונים של ה-XML שמוצג למעלה בשורה 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 נועדה להגן מפני מטען ייעודי (payload) עם סף עומק צומת ספציפי, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם קובעים שאפשר להגדיל את עומק הצומת, משנים את הערך של <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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שבו מספר המאפיינים של רכיב יחיד חורג מהמספר שצוין ברכיב <AttributeCountPerElement> של המדיניות.

לדוגמה, אם הרכיב <AttributeCountPerElement> מוגדר כ-2 במדיניות XMLThreatProtection, אבל למטען הייעודי (payload) של הקלט יש רכיב עם יותר מ-2 מאפיינים, השגיאה הזו תופעל.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XMLThreat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב <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>

בודקים את מספר השורה הספציפי (שמצוין בשלב 1) של מטען הייעודי לקלט, ומוודאים שמספר המאפיינים שצוין לא חורג מהמספר שצוין ברכיב <AttributeCountPerElementh> (שמצוין בשלב 2). אם מספר המאפיינים חורג מהמספר שצוין, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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>
```
במטען הייעודי (payload) של ה-XML שמוצג למעלה בשורה 3 יש רכיב עם שלושה מאפיינים. מכיוון שמספר המאפיינים גדול מ-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 נועדה להגן מפני מטען ייעודי (payload) שחורג ממספר מסוים של מאפיינים, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם אתם קובעים שאפשר לאפשר מספר גדול יותר של מאפיינים, אתם יכולים לשנות את <AttributeCountPerElement> לערך מתאים בהתאם לדרישות שלכם.

לדוגמה, אם אתם חושבים שאפשר לאפשר עד 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>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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שבו שם מאפיין חורג ממספר התווים שצוין ברכיב הצאצא <Attribute> של הרכיב <NameLimits> של המדיניות.

לדוגמה, אם רכיב <Attribute> מוגדר כמדיניות 5, אבל מטען הייעודי (payload) של הקלט כולל שם מאפיין עם יותר מ-5 תווים, השגיאה הזו תופיע.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות של XMLThreatProtection ואת מספר השורה שבה חרגתם מהאורך המקסימלי של שם המאפיין. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב <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>

בודקים את מספר השורה הספציפי (שצוין בשלב 1) של מטען הייעודי (payload) של הקלט, ומבררים אם אורך המאפיין שצוין שם מכיל יותר תווים מהמספר שצוין באלמנט <Attribute> (שצוין בשלב 2). אם מספר התווים חורג מערך המאפיין, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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>
```
‫מטען ה-XML שמוצג למעלה בשורה 3 כולל שני מאפיינים, category ו-cuisine, שאורך השם שלהם הוא 8 ו-7 תווים בהתאמה.. מכיוון שאורך שם המאפיין גדול מ-5 (הערך שצוין לאלמנט <Attribute>), מוצגת השגיאה הבאה:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
name length exceeded 5 at line 3(possibly around char 105)
```

רזולוציה

אם מדיניות 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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין על ידי רכיב <Source> במדיניות מכיל מסמך XML שבו ערך מאפיין חורג ממספר התווים שצוין ברכיב הצאצא <Attribute> של רכיב <ValueLimits>.

לדוגמה, אם רכיב <Attribute> מוגדר כ-10 במדיניות XMLThreatProtection, אבל מטען הייעודי (payload) של הקלט כולל ערך מאפיין עם יותר מ-10 תווים, השגיאה הזו תופיע.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שצוינה בשלב 1) ורושמים את הערך שצוין ברכיב הבן <Attribute> של הרכיב <ValueLimits>.

בדוגמה הבאה למדיניות 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>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>

בודקים את מספר השורה הספציפי (שצוין בשלב 1) של מטען הנתונים של הקלט, ומבררים אם אורך ערך המאפיין שצוין שם מכיל יותר תווים מהמספר שצוין באלמנט <Attribute> (שצוין בשלב 2). אם מספר התווים חורג מערך המאפיין, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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>
```
מטען ה-XML שמוצג למעלה בשורה 3 כולל מאפיין (סוג המטבח) עם ערך באורך 12 תווים. אורך הערך של המאפיין גדול מ-10 (הערך שצוין לאלמנט <Attribute>), ולכן מוצגת השגיאה הבאה:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
value length exceeded 10 at line 3(possibly around char 111)
```

רזולוציה

אם מדיניות XMLThreatProtection נועדה להגן מפני מטען ייעודי (payload) שחורג מאורך ערך מאפיין ספציפי, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם לדעתכם אפשר לאפשר ערכים ארוכים יותר של מאפיינים, אתם יכולים לשנות את <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"
        }
    }

מטרה

השגיאה הזו מתרחשת אם מטען הייעוד של הודעת הקלט שצוין על ידי רכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שאורך הטקסט של רכיב בו חורג ממספר התווים שצוין ברכיב הצאצא <Text> של רכיב <ValueLimits> במדיניות.

לדוגמה, אם אלמנט <Text> מוגדר כמחרוזת 15 במדיניות, אבל מטען הייעודי (payload) של הקלט מכיל טקסט עם יותר מ-15 תווים, השגיאה הזו תוחזר.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות של XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שצוינה בשלב 1) ורושמים את הערך שצוין ברכיב הבן <Text> של הרכיב <ValueLimits>.

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שצוין בשלב 1) של מטען הנתונים של הקלט, ומבררים אם אורך ערך המאפיין שצוין שם מכיל יותר תווים מהמספר שצוין באלמנט <Text> (שצוין בשלב 2). אם מספר התווים חורג מערך המאפיין, זו הסיבה לשגיאה.
```
<food>
  <name>Veg Sandwich</name>
  <price>$5.95</price>
  <description>Vegetarian Sandwich with onions, tomatoes and lettuce</description>
  <calories>650</calories>
</food>
```
מטען ה-XML שמוצג למעלה בשורה 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 נועדה להגן מפני מטען ייעודי (payload) שעולה על אורך טקסט ספציפי, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם קובעים שאפשר לאפשר אורכי טקסט ארוכים יותר, צריך לשנות את <Text>רכיב הצאצא של רכיב <ValueLimits> לערך מתאים בהתאם לדרישות.

לדוגמה, אם אתם חושבים שערכי המאפיינים יכולים להגיע ל-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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שאורך ההערה בו חורג ממספר התווים שצוין ברכיב הצאצא <Comment> של הרכיב <ValueLimits> של המדיניות.

לדוגמה, אם רכיב <Comment> מוגדר כ-10 במדיניות, אבל מטען הייעודי (payload) של הקלט מכיל תגובה עם יותר מ-10 תווים, השגיאה הזו תוחזר.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חריגה מאורך ההערה. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שצוינה בשלב 1) ורושמים את הערך שצוין ברכיב הבן <Comment> של הרכיב <ValueLimits>.

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שמזוהה בשלב 1) של מטען הייעודי (payload) של הקלט, ובודקים אם אורך התגובה שצוין שם מכיל יותר תווים מהמספר שצוין ברכיב <Comment> (שמזוהה בשלב 2). אם מספר התווים חורג מערך המאפיין, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<food>
  
  <name>Veg Sandwich</name>
  <price>$5.95</price>
  <description>Vegetarian Sandwich with onions, tomatoes and lettuce</description>
  <calories>650</calories>
</food>
```
ב-XML Payload שמוצג למעלה, בשורה 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 נועדה להגן מפני מטען ייעודי (payload) שחורג מאורך תגובה ספציפי, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם לדעתכם אפשר לאפשר תגובה ארוכה יותר, אתם יכולים לשנות את <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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שבו הוראה לעיבוד נתונים חורגת ממספר התווים שצוין ברכיב הצאצא <ProcessingInstructionData> של הרכיב <ValueLimits> של המדיניות.

לדוגמה, אם האלמנט <ProcessingInstructionData> מוגדר כ-10 במדיניות XMLThreatProtection, אבל למטען הייעודי (payload) של הקלט יש הוראת עיבוד עם יותר מ-10 תווים, השגיאה הזו תופיע.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חריגה מאורך הוראת העיבוד. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שצוינה בשלב 1) ורושמים את הערך שצוין ברכיב הבן <ProcessingInstructionData> של הרכיב <ValueLimits> .

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שצוין בשלב 1) של מטען הנתונים של הקלט, ומבררים אם אורך נתוני הוראות העיבוד שצוין שם כולל יותר תווים מהמספר שצוין ברכיב <ProcessingInstructionData> (שצוין בשלב 2). אם מספר התווים גדול מנתוני הוראות העיבוד, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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 שמוצג למעלה בשורה 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)
```

רזולוציה

אם מדיניות XMLThreatProtection נועדה להגן מפני מטען ייעודי (payload) שחורג מאורך נתונים מסוים של הוראות עיבוד, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם אתם קובעים שאפשר לאפשר רכיבי נתונים ארוכים יותר של הוראות עיבוד, אתם יכולים לשנות את <ProcessingInstructionData> רכיב הצאצא של רכיב <ValueLimits> לערך מתאים בהתאם לדרישות שלכם.

לדוגמה, אם אתם חושבים שאפשר להגדיר הוראות לעיבוד נתונים באורך של עד 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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין על ידי רכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שבו יעד של הוראת תהליך חורג ממספר התווים שצוין ברכיב הצאצא <ProcessingInstructionTarget> של רכיב <NameLimits> של המדיניות.

לדוגמה, אם הרכיב <ProcessingInstructionTarget> מוגדר כ-10 במדיניות XMLThreatProtection, אבל למטען הייעודי (payload) של הקלט יש יעד של הוראת תהליך עם יותר מ-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)
```

בודקים את המדיניות XMLThreatProtection שנכשלה (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב הבן <ProcessingInstructionTarget> של הרכיב <NameLimits>.

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שצוין בשלב 1) של מטען הייעודי לקלט, ומבררים אם אורך היעד של הוראת העיבוד שצוין שם מכיל יותר תווים מהמספר שצוין ברכיב <ProcessingInstructionTarget> (שצוין בשלב 2). אם מספר התווים חורג ממגבלת גודל היעד, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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>
```
המטען הייעודי (payload) ב-XML שמוצג למעלה בשורה 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 נועדה להגן מפני מטען ייעודי (payload) שחורג מאורך יעד ספציפי של הוראות תהליך, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם קובעים שיעד של הוראות תהליך יכול להיות ארוך יותר, צריך לשנות את <ProcessingInstructionTarget>רכיב הצאצא של רכיב <NameLimits> לערך מתאים בהתאם לדרישות.

לדוגמה, אם אתם חושבים שאתם יכולים להגדיר יעדים של הוראות תהליך של עד 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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין על ידי רכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שבו URI של Namespace חורג ממספר התווים שצוין ברכיב הצאצא <NamespaceURI> של הרכיב <ValueLimits> של המדיניות.

לדוגמה, אם רכיב <NamespaceURI> מוגדר כ-10 במדיניות, אבל למטען הייעודי (payload) של הקלט יש מזהה URI של מרחב שמות עם יותר מ-10 תווים, השגיאה הזו תוצג.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות של XMLThreatProtection ואת מספר השורה שבה אורך ה-URI של מרחב השמות חורג מהמגבלה. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב הצאצא <NamespaceURI> של הרכיב <ValueLimits>.

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שמצוין בשלב 1) של מטען הייעודי (payload) של הקלט, ובודקים אם אורך ה-URI של מרחב השמות שצוין שם מכיל יותר תווים מהמספר שצוין ברכיב <NamespaceURI> (שמצוין בשלב 2). אם מספר התווים חורג מאורך ה-URI של מרחב השמות, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?xml version = "1.0" encoding = "UTF-8"?>
  <profile:user xmlns:profile = "www.example.com/profile">
  <profile:name>Rama Krishna</profile:name>
  <profile:company>Example</profile:company>
  <profile:phone>(91) 9876543210</profile:phone>
</profile:user>
```
מטען ה-XML שמוצג למעלה בשורה 2 כולל URI של מרחב שמות, http://www.example/profile, באורך של 22 תווים. מכיוון שאורך ה-URI של מרחב השמות גדול מ-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 נועדה להגן מפני מטענים שעברו את האורך הספציפי של URI של מרחב שמות, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם קובעים שאפשר להשתמש ב-URI ארוך יותר של מרחב שמות, צריך לשנות את רכיב הצאצא <NamespaceURI> של הרכיב <ValueLimits> לערך מתאים בהתאם לדרישות.

לדוגמה, אם אתם חושבים שאפשר להשתמש באורכים של עד 30 תווים בכתובות URI של מרחב שמות, אתם יכולים לשנות את המדיניות באופן הבא:

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

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> מכיל מסמך XML שבו קידומת של מרחב שמות חורגת ממספר התווים שצוין ברכיב הצאצא <NamespacePrefix> של הרכיב <NameLimits> במדיניות.

לדוגמה, אם הרכיב <NamespacePrefix> מוגדר כ-10 במדיניות XMLThreatProtection, אבל למטען הייעודי (payload) של הקלט יש תחילית של מרחב שמות עם יותר מ-10 תווים, השגיאה הזו תופעל.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות של XMLThreatProtection ואת מספר השורה שבה חרגתם מאורך הקידומת של URI של מרחב שמות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב הצאצא <NamespacePrefix> של הרכיב <NameLimits>.

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שמזוהה בשלב 1) של מטען הנתונים של הקלט, ואם אורך קידומת מרחב השמות שצוינה שם מכיל יותר תווים מהמספר שצוין ברכיב <NamespacePrefix> (שמזוהה בשלב 2). אם מספר התווים חורג מהמגבלה של קידומת מרחב השמות, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?xml version = "1.0" encoding = "UTF-8"?>
<userprofile:user xmlns:userprofile = "www.example/profile">
  <userprofile:name>Rama Krishna</userprofile:name>
  <userprofile:company>Example</userprofile:company>
  <userprofile:phone>(011) 123-4567</userprofile:phone>
</userprofile:user>
```
מטען ה-XML שמוצג למעלה בשורה 2 כולל קידומת של מרחב שמות userprofile באורך של 11 תווים. אורך הקידומת של מרחב השמות ב-URI גדול מ-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 נועדה להגן מפני מטענים שעולים על אורך קידומת URI של מרחב שמות ספציפי, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם קובעים שאפשר להשתמש בקידומת ארוכה יותר של URI של מרחב שמות, צריך לשנות את רכיב הצאצא <NamespacePrefix> של הרכיב <NameLimits> לערך מתאים בהתאם לדרישות.

לדוגמה, אם אתם חושבים שאפשר להשתמש בקידומות של כתובות URI של מרחב שמות באורך של עד 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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> של מדיניות XMLThreatProtection מכיל מסמך XML שבו מספר מרחבי השמות שמשמשים ברכיב יחיד חורג מהמספר שצוין ברכיב הצאצא <NamespaceCountPerElement> של הרכיב <StructureLimits> של המדיניות.

לדוגמה, אם הרכיב <NamespaceCountPerElement> מוגדר כ-3 במדיניות, אבל מטען הייעודי (payload) של הקלט מכיל רכיב עם יותר מ-3 מרחבי שמות, השגיאה הזו תופעל.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר מרחבי השמות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XMLThreat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 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)
```

בודקים את המדיניות שנכשלה (שזוהתה בשלב 1) ורושמים את הערך שצוין ברכיב הצאצא <NamespaceCountPerElement> של הרכיב <StructureLimits>.

בדוגמה הבאה של מדיניות 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>

בודקים את מספר השורה הספציפי (שמצוין בשלב 1) של מטען הנתונים של הקלט, ומבררים אם מספר מרחבי השמות שצוין שם עבור רכיב יחיד גבוה ממספר מרחבי השמות שצוין ברכיב <NamespaceCountPerElement> (שמצוין בשלב 2). אם מספר מרחבי השמות חורג מהמגבלה של מספר מרחבי השמות לכל רכיב, זו הסיבה לשגיאה.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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>
```
מטען ה-XML שמוצג למעלה בשורה 2 מכיל יותר מ-3 מרחבי שמות. מכיוון שמספר מרחבי השמות גדול מ-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 נועדה להגן מפני מטען ייעודי (payload) שחורג ממספר מסוים של מרחבי שמות ברכיב יחיד, הודעת השגיאה צפויה. במקרה כזה, לא נדרשת פעולה נוספת.

עם זאת, אם קובעים שאפשר לאפשר מספר גדול יותר של מרחבי שמות, צריך לשנות את רכיב הצאצא <NamespaceCountPerElement> של רכיב <StructureLimits> לערך מתאים בהתאם לדרישות.

לדוגמה, אם אתם חושבים שאפשר להשתמש בעד 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>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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם מטען הייעודי (payload) של הודעת הקלט שצוין ברכיב <Source> של המדיניות XMLProtectionPolicy הוא לא מסמך XML תקין.

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות שבה התרחשה השגיאה. בדוגמה הבאה, שם המדיניות הוא XML-Threat-Protection-1.
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: Syntax error while parsing XML prologue
```
בודקים את מטען הנתונים של הקלט כדי לראות אם מסמך ה-XML שהועבר במטען הנתונים הוא אכן מסמך XML תקין.

דוגמה למטען ייעודי (payload) של קלט:
```
<?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>
```
במטען הייעודי (payload) של ה-XML שמוצג למעלה, בשורה 9 לא נסגר רכיב הבסיס בצורה נכונה כי חסר /. מכיוון שזהו XML לא תקין, מוצגת השגיאה:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: Syntax error while parsing XML prologue
```

רזולוציה

חשוב לוודא שמטען ייעודי (payload) של XML תקין מועבר לכל proxy ל-API שכולל את מדיניות XMLThreatProtection.

כדי לתקן את השגיאה שמתוארת בדוגמה שלמעלה, משנים את מטען ה-XML של הקלט באופן הבא:

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

מטרה

השגיאה הזו מתרחשת אם המשתנה message שצוין ברכיב <Source> של מדיניות XMLThreatProtection הוא אחד מהבאים:

לא רלוונטי (לא זמין בתהליך הספציפי שבו המדיניות מופעלת)
הערך לא תואם לאחד מהערכים התקינים request,‏ response או message

לדוגמה, השגיאה הזו מתרחשת אם הרכיב <Source> במדיניות מוגדר למשתנה שלא קיים בתהליך שבו המדיניות מופעלת.

אבחון

מזהים את שם המדיניות XMLThreatProtection ואת שם משתנה המקור בהודעת השגיאה. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות XMLThreatProtection הוא XML-Threat-Protection-1 ומשתנה המקור הוא requests:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Source requests
is not available
```

בודקים את המדיניות של XMLThreatProtection שנכשלה ואת הערך שצוין לרכיב <Source> שזוהה בשלב 1.

בדוגמה הבאה של מדיניות 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

רזולוציה

מוודאים שהמשתנה שהוגדר ברכיב <Source> של מדיניות XMLThreatProtection שנכשלה מוגדר ל-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"
        }
    }
}

מטרה

השגיאה הזו מתרחשת אם הרכיב <Source> במדיניות XMLThreatProtection מוגדר כמשתנה שלא שייך לסוג message.

משתני סוג ההודעה מייצגים בקשות ותגובות מלאות של HTTP. המשתנים המובנים של Apigee flow‏ request, response ו-message הם מסוג Message. מידע נוסף על משתני הודעות זמין במאמר חומר עזר בנושא משתני זרימה.

אבחון

מזהים את שם המשתנה שמוגדר כמשתנה מסוג Message מתוך הודעת השגיאה. לדוגמה, בהודעת השגיאה הבאה, שם המשתנה הוא message.content
```
Variable message.content does not resolve to a Message
```

בודקים את כל פריטי המדיניות של XMLThreadProtection ב-proxy ל-API שבו אירעה השגיאה, ומזהים את פריט המדיניות הספציפי של XMLThreadProtection שבו צוין רכיב <Source> עם שם המשתנה שזוהה בשלב 1 שלמעלה.

בדוגמה הבאה של מדיניות 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 הוא לא מסוג Message, מוצגת השגיאה:

Variable message.content does not resolve to a Message

רזולוציה

מוודאים שהרכיב <Source> במדיניות XMLThreatProtection שנכשלה מוגדר למשתנה זרימה 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>

פתרון בעיות של שגיאות זמן ריצה במדיניות XMLThreatProtection קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

ExecutionFailed

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

סוגי שגיאות וסיבות אפשריות

ElementNameExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

ChildCountExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

NodeDepthExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

AttributeCountExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

AttributeNameExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

AttributeValueExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

TextExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

CommentExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

PIDataExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

PITargetExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

מטרה

אבחון

רזולוציה

NSURIExceeded

קוד שגיאה

גוף התגובה לשגיאה

דוגמה לתוכן של תגובת שגיאה

פתרון בעיות של שגיאות זמן ריצה במדיניות XMLThreatProtection