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

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

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

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

מטרה

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

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

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

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

מטרה

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

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

אבחון

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

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