‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

אתם צופים במסמכי התיעוד של Apigee Edge.
כדאי לעיין במסמכי התיעוד של Apigee X. מידע

ExecutionFailed

קוד השגיאה

steps.xmlthreatprotection.ExecutionFailed

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

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition policy_name:
        Execution failed. Reason: error_description at line line_num
        (possibly around char char_num)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

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

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: Premature end of document while parsing at line 5(possibly  around char 0)",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

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

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

סיבה

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

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

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר הרשומות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי הוא 5:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Children
count exceeded 3 at line 5(possibly around char 89)"
```

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

סיבה

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

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

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי הוא 4:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Text length
exceeded 15 at line 4(possibly around char 66)
```

בודקים את המדיניות שנכשלה (שזוהתה בשלב 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) של מטען הייעודי (payload) של הקלט, ומבררים אם אורך ערך המאפיין שצוין שם כולל יותר תווים מהמספר שצוין באלמנט <Text> (שזוהה בשלב 2). אם מספר התווים חורג מערך המאפיין, זו הסיבה לשגיאה.
```
<food>
  <name>Veg Sandwich</name>
  <price>$5.95</price>
  <description>Vegetarian Sandwich with onions, tomatoes and lettuce</description>
  <calories>650</calories>
</food>
```
ה-Payload של ה-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>
```
בשורת 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 ומספר השורה במטען הייעודי הוא 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>
```
במטען הייעודי (payload) של ה-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>
```
בשורת 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.google.com/profile">
  <profile:name>Rama Krishna</profile:name>
  <profile:company>Google</profile:company>
  <profile:phone>(91) 9876543210</profile:phone>
</profile:user>
```
מטען ה-XML שמוצג למעלה בשורה 2 כולל URI של מרחב שמות, www.google.com/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> לערך מתאים בהתאם לדרישות.

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

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

NSPrefixExceeded

קוד השגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

השגיאה הזו מתרחשת אם מטען הייעודי (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.googlecom/profile">
  <userprofile:name>Rama Krishna</userprofile:name>
  <userprofile:company>Google</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 במדיניות, אבל מטען הייעוד של הקלט מכיל רכיב עם יותר מ-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 Payload שמוצגת למעלה, בשורה 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 Edge‏ 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>