2008-05-12 Sam Weinig <sam@webkit.org>
authorweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 13 May 2008 00:14:43 +0000 (00:14 +0000)
committerweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 13 May 2008 00:14:43 +0000 (00:14 +0000)
        Reviewed by Dan Bernstein.

        Add parsing of AccessControlHeader and AccessItemRule.

        * xml/AccessControlList.cpp:
        (WebCore::AccessControlList::parseAccessControlHeader): When multiple http headers are sent
        in the response, the engine will concatenate them with commas separating the rules.  This simply
        reverses that process by splitting on the commas.
        (WebCore::AccessControlList::show):
        * xml/AccessControlList.h:
        * xml/AccessItem.cpp:
        (WebCore::AccessItem::AccessItem):
        (WebCore::AccessItem::show):
        * xml/AccessItem.h:
        (WebCore::AccessItem::isValid):
        * xml/AccessItemRule.cpp:
        (WebCore::skipLWS):
        (WebCore::AccessItemRule::parseAccessItemRule): Parse the rule according to the BNF provided by
        the Access Control spec.
        (WebCore::AccessItemRule::parsePatternList):
        (WebCore::AccessItemRule::invalidate):
        (WebCore::AccessItemRule::show):
        * xml/AccessItemRule.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@33065 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebCore/ChangeLog
WebCore/xml/AccessControlList.cpp
WebCore/xml/AccessControlList.h
WebCore/xml/AccessItem.cpp
WebCore/xml/AccessItem.h
WebCore/xml/AccessItemRule.cpp
WebCore/xml/AccessItemRule.h

index 3152e9a..3a056f5 100644 (file)
@@ -1,3 +1,29 @@
+2008-05-12  Sam Weinig  <sam@webkit.org>
+
+        Reviewed by Dan Bernstein.
+
+        Add parsing of AccessControlHeader and AccessItemRule.
+
+        * xml/AccessControlList.cpp:
+        (WebCore::AccessControlList::parseAccessControlHeader): When multiple http headers are sent
+        in the response, the engine will concatenate them with commas separating the rules.  This simply
+        reverses that process by splitting on the commas.
+        (WebCore::AccessControlList::show):
+        * xml/AccessControlList.h:
+        * xml/AccessItem.cpp:
+        (WebCore::AccessItem::AccessItem):
+        (WebCore::AccessItem::show):
+        * xml/AccessItem.h:
+        (WebCore::AccessItem::isValid):
+        * xml/AccessItemRule.cpp:
+        (WebCore::skipLWS):
+        (WebCore::AccessItemRule::parseAccessItemRule): Parse the rule according to the BNF provided by
+        the Access Control spec.
+        (WebCore::AccessItemRule::parsePatternList):
+        (WebCore::AccessItemRule::invalidate):
+        (WebCore::AccessItemRule::show):
+        * xml/AccessItemRule.h:
+
 2008-05-12  David Kilzer  <ddkilzer@apple.com>
 
         Fix logic error in DocLoader::clearPreloads()
index a1b68b9..2714caa 100644 (file)
@@ -44,6 +44,10 @@ AccessControlList::~AccessControlList()
 
 void AccessControlList::parseAccessControlHeader(const String& accessControlHeader)
 {
+    Vector<String> rules;
+    accessControlHeader.split(',', rules);
+    for (size_t i = 0; i < rules.size(); ++i)
+        m_list.append(new AccessItemRule(rules[i]));
 }
 
 bool AccessControlList::checkOrigin(const SecurityOrigin* accessControlOrigin)
@@ -51,4 +55,14 @@ bool AccessControlList::checkOrigin(const SecurityOrigin* accessControlOrigin)
     return false;
 }
 
+#ifndef NDEBUG
+void AccessControlList::show()
+{
+    printf("AccessControlList::show count: %d\n", static_cast<int>(m_list.size()));
+    for (size_t i = 0; i < m_list.size(); ++i)
+        m_list[i]->show();
+    printf("\n\n");
+}
+#endif
+
 } // namespace WebCore
index fc5bc39..c7f206d 100644 (file)
@@ -42,6 +42,10 @@ namespace WebCore {
 
         bool checkOrigin(const SecurityOrigin* accessControlOrigin);
 
+#ifndef NDEBUG
+        void show();
+#endif
+
     private:
         void parseAccessControlHeader(const String&);
 
index a53ae2d..3fb35e2 100644 (file)
 #include "PlatformString.h"
 #include "SecurityOrigin.h"
 
+#ifndef NDEBUG
+#include "CString.h"
+#endif
+
 namespace WebCore {
 
 AccessItem::AccessItem(const String& accessItemString)
-    : m_wildcard(false)
+    : m_valid(false)
+    , m_wildcard(false)
     , m_domainWildcard(false)
     , m_portWildcard(false)
     , m_port(0)
+#ifndef NDEBUG
+    , m_string(accessItemString)
+#endif
 {
     parseAccessItem(accessItemString);
 }
@@ -58,4 +66,11 @@ bool AccessItem::matches(const SecurityOrigin* accessControlOrigin)
     return false;
 }
 
+#ifndef NDEBUG
+void AccessItem::show()
+{
+    printf("    AccessItem::show: %s\n", m_string.utf8().data());
+}
+#endif
+
 } // namespace WebCore
index 231ea98..609e645 100644 (file)
@@ -39,15 +39,26 @@ namespace WebCore {
 
         bool matches(const SecurityOrigin*);
 
+        bool isValid() const { return m_valid; }
+
+#ifndef NDEBUG
+        void show();
+#endif
+
     private:
         void parseAccessItem(const String&);
 
+        bool m_valid;
         bool m_wildcard;
         String m_scheme;
         bool m_domainWildcard;
         Vector<String, 4> m_subdomains;
         bool m_portWildcard;
         unsigned short m_port;
+
+#ifndef NDEBUG
+        String m_string;
+#endif
     };
 
 } // namespace WebCore
index e2973cd..186e9ad 100644 (file)
@@ -27,6 +27,7 @@
 #include "AccessItemRule.h"
 
 #include "PlatformString.h"
+#include "ParserUtilities.h"
 
 namespace WebCore {
 
@@ -35,6 +36,20 @@ AccessItemRule::AccessItemRule(const String& rule)
     parseAccessItemRule(rule);
 }
 
+static inline bool skipLWS(const UChar*& ptr, const UChar* end)
+{
+    // LWS as defined by RFC 2616:
+    // LWS = [CRLF] 1*( SP | HT )
+
+    if (ptr + 1 < end && *ptr == '\r' && *(ptr + 1) == '\n')
+        ptr += 2;
+
+    const UChar* start = ptr;
+    while (ptr < end && (*ptr == ' ' || *ptr == '\t'))
+        ptr++;
+    return ptr != start;
+}
+
 void AccessItemRule::parseAccessItemRule(const String& rule)
 {
     // Parse the rule according to Section 4.2 (Access-Control HTTP Response Header) of the 
@@ -45,7 +60,97 @@ void AccessItemRule::parseAccessItemRule(const String& rule)
     //   rule           = "allow" 1*(LWS pattern) [LWS "exclude" 1*(LWS pattern)]
     //   pattern        = "<" access item ">"
 
-    // FIXME: Parse the rule.
+    if (rule.isEmpty())
+        return;
+
+    const UChar* ptr = rule.characters();
+    const UChar* end = ptr + rule.length();
+
+    // Skip leading whitespace
+    skipLWS(ptr, end);
+    if (ptr == end)
+        return;
+
+    if (!skipString(ptr, end, "allow"))
+        return;
+
+    parsePatternList(ptr, end, m_allowList);
+    if (m_allowList.isEmpty())
+        return;
+
+    if (!skipString(ptr, end, "exclude")) {
+        if (ptr != end)
+            invalidate();
+        return;
+    }
+
+    parsePatternList(ptr, end, m_excludeList);
+    if (m_excludeList.isEmpty()) {
+        invalidate();
+        return;
+    }
+
+    if (ptr != end)
+        invalidate();
+}
+
+void AccessItemRule::parsePatternList(const UChar*& ptr, const UChar* end, Vector<AccessItem>& list)
+{
+    while (ptr < end) {
+        if (!skipLWS(ptr, end) || ptr == end) {
+            invalidate();
+            return;
+        }
+
+        if (*ptr != '<')
+            return;
+
+        ptr++;
+
+        bool sawEndTag = false;
+        const UChar* start = ptr;
+        while (ptr < end) {
+            if (*ptr == '>') {
+                sawEndTag = true;
+                break;
+            }
+            ptr++;
+        }
+        if (!sawEndTag) {
+            invalidate();
+            return;
+        }
+        
+        AccessItem accessItem(String(start, ptr - start));
+        if (!accessItem.isValid()) {
+            invalidate();
+            return;
+        }
+
+        list.append(accessItem);
+        ptr++;
+    }
+}
+
+void AccessItemRule::invalidate()
+{
+    m_allowList.clear();
+    m_excludeList.clear();
+}
+
+#ifndef NDEBUG
+void AccessItemRule::show()
+{
+    printf("  AccessItemRule::show\n");
+
+    printf("  AllowList count: %d\n", static_cast<int>(m_allowList.size()));
+    for (size_t i = 0; i < m_allowList.size(); ++i)
+        m_allowList[i].show();
+
+    printf("  ExludeList count: %d\n", static_cast<int>(m_excludeList.size()));
+    for (size_t i = 0; i < m_excludeList.size(); ++i)
+        m_excludeList[i].show();
 }
+#endif
 
 } // namespace WebCore
index 5b7d51a..bcdd232 100644 (file)
@@ -37,8 +37,14 @@ namespace WebCore {
     public:
         AccessItemRule(const String&);
 
+#ifndef NDEBUG
+        void show();
+#endif
+
     private:
         void parseAccessItemRule(const String&);
+        void parsePatternList(const UChar*& ptr, const UChar* end, Vector<AccessItem>& list);
+        void invalidate();
 
         Vector<AccessItem> m_allowList;
         Vector<AccessItem> m_excludeList;