דף זה תורגם על ידי Cloud Translation API.

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

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

ElementNameExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

תעבורת נתונים בזמן ריצה מחזירה קוד תגובה 500 עם השגיאה הבאה:

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

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

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

סיבה

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

לדוגמה, אם הרכיב <Element> מצוין בתור 5 במדיניות XMLThreatProtection, אבל המטען הייעודי (Payload) של הקלט מכיל רכיב שמכיל יותר מ-5 תווים, השגיאה הזו תוחלף.

אבחון

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

לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1,, מספר השורה בתוכן המועמס הוא 1 ומספר התו האפשרי הוא 9.
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Element name
length exceeded 5 at line 1(possibly around char 9)
```

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

לדוגמה, במדיניות XMLThreatProtection הבאה, <Element> מוגדר כ-5:

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

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

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

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

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

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

לדוגמה, אם לדעתכם אתם יכולים לאפשר עד 10 רכיבי צאצא, עליכם לשנות את המדיניות XMLThreatProtection באופן הבא:

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

NodeDepthExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

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

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

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

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

AttributeCountExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

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

סיבה

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

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

רזולוציה

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

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

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

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

TextExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

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

סיבה

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

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

אבחון

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

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

בדוגמה הבאה של מדיניות XMLThreatProtection, הערך של <Comment> מוגדר כ-10:

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

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

אבחון

בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה חרגתם מאורך ההוראה לעיבוד. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (Payload) הוא 2:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction data length exceeded 30 at line 2(possibly around char 109)
```

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

בדוגמה הבאה של מדיניות XMLThreatProtection, הערך של <ProcessingInstructionData> מוגדר כ-30:

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

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

דוגמה למטען ייעודי (payload) של קלט:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<?xml-stylesheet type="text/xsl" href="mobilephones.xsl"?>
<mobilephones>
  <mobilephone>
      <name>iPhone</name>
      <price>$600</price>
  </mobilephone>
  <mobilephone>
      <name>Samsung</name>
      <price>$500</price>
  </mobilephone>
</mobilephones>
```
לעומס העבודה ב-XML שמוצג למעלה בשורה 1 יש אלמנט נתונים של הוראות עיבוד (type="text/xsl" href="mobilephones.xsl"?) באורך 40 תווים.. מכיוון שהאורך הזה גדול מ-30 (הערך שצוין לאלמנט <ProcessingInstructionData>), מופיעה השגיאה הבאה:
```
XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
Instruction data length exceeded 30 at line 2(possibly around char 109)
```

רזולוציה

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

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

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

סיבה

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

סיבה

השגיאה הזו מתרחשת אם עומס העבודה של הודעת הקלט שצוין על ידי הרכיב <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>
```
למטען הייעודי (Payload) של ה-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"
        }
    }
}

סיבה

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

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

סיבה

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

אבחון

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

רזולוציה

מוודאים שעומס עבודה תקין של קלט XML מועבר לכל שרת proxy של API שכולל את המדיניות XMLThreatProtection.

כדי לתקן את השגיאה לדוגמה המתוארת למעלה, משנים את המטען הייעודי (payload) של הקלט ב-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 ואת השם של משתנה Source בהודעת השגיאה. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות XMLThreatProtection הוא XML-Threat-Protection-1 והמשתנה Source הוא 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 ותגובות HTTP שלמות. משתני התהליך המובנים של Apigee Edge,‏ request,‏ response ו-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>