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

שגיאה סיבה
ElementNameExceeded חרגת מאורך המחרוזת המקסימלי המותר בתג XML.
ChildCountExceeded חרגת מהמספר המקסימלי של רכיבי צאצא המותר במטען ייעודי של XML.
NodeDepthExceeded חרגת מהעומק המקסימלי של רכיבי XML המותר במטען ייעודי של 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"
        }
    }
}

סיבה

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

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

אבחון

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

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

    דוגמה למטען ייעודי (payload) של קלט:

    <company>
      <name>Google</name>
      <country>USA</country>
    </company>
    

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

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה ממספר הרשומות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 5:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Children
    count exceeded 3 at line 5(possibly around char 89)"
    
  2. יש לבדוק את המדיניות שנכשלה (שמופיעה בשלב 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>
    
  3. בוחנים את מספר השורה הספציפי (שזוהה בשלב 1) של המטען הייעודי (payload) של הקלט, ובודקים אם מספר רכיבי הצאצא (כולל כל התגובות וכו') במטען הייעודי (payload) גדול מהערך שצוין עבור הרכיב <ChildCount> (שזוהה בשלב 2). אם מספר רכיבי הצאצא חורג ממספר הצאצאים, זו הסיבה לשגיאה.

    דוגמה למטען ייעודי (payload) של קלט:

    <movie>
      <title>Jurassic Park</title>
      <language>English</language>
      <country>USA</country>
      <director>Steven Spielberg</director>
    </movie>
    

    במטען הייעודי (payload) של XML שמוצג למעלה, שורה 5 מכילה רכיב צאצא רביעי <director> של רכיב הבסיס <movie>. מאחר שמספר רכיבי הצאצא במטען הייעודי (payload) של ה-XML גדול מ-3 (הערך שצוין עבור הרכיב <ChildCount>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Children
    count exceeded 3 at line 5(possibly around char 89)
    

רזולוציה

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

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

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

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

NodeDepthExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה מעומק הצומת. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 6:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Node depth
    exceeded 5 at line 6(possibly around char 109)
    
  2. יש לבדוק את מדיניות 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>
    
  3. בוחנים את מספר השורה הספציפי (שזוהה בשלב 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>
    

    המטען הייעודי (payload) של XML שמוצג למעלה בשורה 6 כולל עומק צומת של 6..מכיוון שעומק הצומת גדול מ-5 (הערך שצוין עבור הרכיב <NodeDepth>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Node depth
    exceeded 5 at line 6(possibly around char 109)
    

רזולוציה

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

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

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

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

AttributeCountExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XMLThreat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 3:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
    count exceeded 2 at line 3(possibly around char 105)
    
  2. יש לבדוק את המדיניות שנכשלה (שמופיעה בשלב 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>
    
  3. בוחנים את מספר השורה הספציפי (שזוהה בשלב 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>
    

    המטען הייעודי (payload) של XML שמוצג למעלה בשורה 3 כולל רכיב עם שלושה מאפיינים. מכיוון שמספר המאפיינים גדול מ-2 (הערך שצוין עבור הרכיב <AttributeCountPerElement>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
    count exceeded 2 at line 3(possibly around char 105)
    

רזולוציה

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

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה מהאורך של שם המאפיין. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 3:

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

    דוגמה למטען ייעודי (payload) של קלט:

    <?xml version="1.0" encoding="UTF-8"?>
    <bookstore>
      <book category="cooking" cuisine="Indian" lang="en">
        <title>Easy Indian Cooking</title>
        <author>Suneeta</author>
        <year>2004</year>
        <price>300.00</price>
      </book>
    </bookstore>
    

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 3:

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

    המטען הייעודי (payload) של XML שמוצג למעלה בשורה 3 כולל מאפיין (מטבח) באורך של 12 תווים. מכיוון שהאורך של ערך המאפיין גדול מ-10 (הערך שצוין עבור הרכיב <Attribute>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Attribute
    value length exceeded 10 at line 3(possibly around char 111)
    

רזולוציה

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

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

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

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

TextExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה ממספר המאפיינים. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 4:

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

אבחון

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

    דוגמה למטען ייעודי (payload) של קלט:

    <food>
      <!--This is somewhat a long comment-->
      <name>Veg Sandwich</name>
      <price>$5.95</price>
      <description>Vegetarian Sandwich with onions, tomatoes and lettuce</description>
      <calories>650</calories>
    </food>
    

    המטען הייעודי (payload) של XML שמוצג למעלה בשורה 2 מכיל הערה עם ערך באורך של 31 תווים. מכיוון שאורך התגובה גדול מ-10 (הערך שצוין עבור הרכיב <Comment>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Comment length
    exceeded 10 at line 2(possibly around char 48)
    

רזולוציה

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

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

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

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

PIDataExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

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

אבחון

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

    דוגמה למטען ייעודי (payload) של קלט:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <?xml-stylesheet type="text/xsl" href="mobilephones.xsl"?>
    <mobilephones>
      <mobilephone>
          <name>iPhone</name>
          <price>$600</price>
      </mobilephone>
      <mobilephone>
          <name>Samsung</name>
          <price>$500</price>
      </mobilephone>
    </mobilephones>
    

    למטען הייעודי (payload) של XML שמוצג למעלה בשורה 2 יש שם יעד של הוראת עיבוד "xml-stylesheet"באורך של 14 תווים. מכיוון ששם היעד של הוראת העיבוד ארוך מ-10 (הערך שצוין עבור רכיב <ProcessingInstructionTarget>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Processing
    Instruction target length exceeded 10 at line 2(possibly around char 114)
    

רזולוציה

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

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

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

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

NSURIExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

  1. בוחנים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה מאורך ה-URI של מרחב השמות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 2:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
    uri length exceeded 10 at line 2(possibly around char 97)
    
  2. יש לבדוק את המדיניות שנכשלה (שמופיעה בשלב 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>
    
  3. בוחנים את מספר השורה הספציפי (שזוהה בשלב 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>
    

    המטען הייעודי (payload) של 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 תווים, השגיאה הזו מוצגת.

אבחון

  1. בוחנים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה מאורך הקידומת של ה-URI של מרחב השמות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XML-Threat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 2:

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

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

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

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

NSCountExceeded

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

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

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

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

סיבה

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

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

אבחון

  1. בודקים את הודעת השגיאה כדי לזהות את שם המדיניות XMLThreatProtection ואת מספר השורה שבה יש חריגה ממספר מרחבי השמות. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות הוא XMLThreat-Protection-1 ומספר השורה במטען הייעודי (payload) הוא 2:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace count
    exceeded 3 at line 2(possibly around char 234)
    
  2. יש לבדוק את המדיניות שנכשלה (שמופיעה בשלב 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>
    
  3. בוחנים את מספר השורה הספציפי (שזוהה בשלב 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>
    

    המטען הייעודי (payload) של XML שמוצג למעלה בשורה 2 כולל יותר מ-3 מרחבי שמות. מכיוון שמספר מרחבי השמות גדול מ-3 (הערך שצוין עבור רכיב <NamespaceCountPerElement>), מתקבלת השגיאה הבאה:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Execution failed.
    reason: XMLThreatProtection stepDefinition XML-Threat-Protection-1: Namespace
    count exceeded 3 at line 2(possibly around char 234)
    

רזולוציה

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

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

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

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

InvalidXMLPayload

קוד שגיאה

steps.xmlthreatprotection.ExecutionFailed

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

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition [policy_name]:
        Execution failed. Reason: [error_description]",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

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

{
    "fault": {
        "faultstring": "XMLThreatProtection stepDefinition XML-Threat-Protection-1:
        Execution failed. reason: Syntax error while parsing XML prologue",
        "detail": {
            "errorcode": "steps.xmlthreatprotection.ExecutionFailed"
        }
    }
}

סיבה

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

אבחון

  1. יש לבדוק את הודעת השגיאה כדי לזהות את שם המדיניות שבה אירעה השגיאה. בדוגמה הבאה שם המדיניות הוא XML-Threat-Protection-1.

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

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

אבחון

  1. מציינים את שם המדיניות XMLThreatProtection ואת שם המשתנה Source בהודעת השגיאה. לדוגמה, בהודעת השגיאה הבאה, שם המדיניות XMLThreatProtection הוא XML-Threat-Protection-1 והמשתנה Source הוא requests:

    XMLThreatProtection stepDefinition XML-Threat-Protection-1: Source requests
    is not available
    
  2. יש לבדוק את מדיניות 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. מידע נוסף על משתני הודעות אפשר למצוא במאמר מידע על משתנים.

אבחון

  1. בהודעת השגיאה צריך לזהות את שם המשתנה שתואם למשתנה מסוג 'הודעה'. לדוגמה, בהודעת השגיאה הבאה שם המשתנה הוא message.content

    Variable message.content does not resolve to a Message
    
  2. יש לבדוק את כל כללי המדיניות של XMLThreadProtection בשרת ה-API של שרת ה-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>