X-Git-Url: http://lists.indexdata.dk/cgi-bin?a=blobdiff_plain;f=src%2Ffilter_http_rewrite.cpp;h=bf01abae23a461ebbb71a5897b326f3c086b5951;hb=bb6b58cbec0e41a8ba2403e540185e77882e8741;hp=9d672fb8da54a733552036eeccd152b5238bcfa0;hpb=213d7bae1233185595186f881a150ee238dac64f;p=metaproxy-moved-to-github.git

diff --git a/src/filter_http_rewrite.cpp b/src/filter_http_rewrite.cpp
index 9d672fb..bf01aba 100644
--- a/src/filter_http_rewrite.cpp
+++ b/src/filter_http_rewrite.cpp
@@ -26,6 +26,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include <yaz/zgdu.h>
 #include <yaz/log.h>
 
+#include <stack>
 #include <boost/regex.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
@@ -45,7 +46,7 @@ namespace metaproxy_1 {
             const std::string search_replace(
                 std::map<std::string, std::string> & vars,
                 const std::string & txt) const;
-            std::string sub_vars (
+            std::string sub_vars(
                 const std::map<std::string, std::string> & vars) const;
             void parse_groups();
         };
@@ -62,12 +63,15 @@ namespace metaproxy_1 {
             std::string header;
             std::string attr;
             std::string tag;
+            bool reqline;
             RulePtr rule;
         };
 
         class HttpRewrite::Phase {
         public:
+            Phase();
             std::list<Within> within_list;
+            int m_verbose;
             void rewrite_reqline(mp::odr & o, Z_HTTP_Request *hreq,
                 std::map<std::string, std::string> & vars) const;
             void rewrite_headers(mp::odr & o, Z_HTTP_Header *headers,
@@ -77,19 +81,20 @@ namespace metaproxy_1 {
                 std::map<std::string, std::string> & vars) const;
         };
         class HttpRewrite::Event : public HTMLParserEvent {
-            void openTagStart(const char *name);
-            void anyTagEnd(const char *name);
-            void attribute(const char *tagName, 
-                           const char *name, 
-                           const char *value,
-                           int val_len);
-            void closeTag(const char *name);
+            void openTagStart(const char *tag, int tag_len);
+            void anyTagEnd(const char *tag, int tag_len, int close_it);
+            void attribute(const char *tag, int tag_len,
+                           const char *attr, int attr_len,
+                           const char *value, int val_len,
+                           const char *sep);
+            void closeTag(const char *tag, int tag_len);
             void text(const char *value, int len);
             const Phase *m_phase;
             WRBUF m_w;
-            std::list<Within>::const_iterator enabled_within;
+            std::stack<std::list<Within>::const_iterator> s_within;
+            std::map<std::string, std::string> &m_vars;
         public:
-            Event(const Phase *p);
+            Event(const Phase *p, std::map<std::string, std::string> &vars);
             ~Event();
             const char *result();
         };
@@ -158,51 +163,54 @@ void yf::HttpRewrite::Phase::rewrite_reqline (mp::odr & o,
         path += hreq->path;
     }
 
-    std::list<Within>::const_iterator it = within_list.begin();
-    if (it != within_list.end())
-    {
-        RulePtr rule = it->rule;
 
-        yaz_log(YLOG_LOG, "Proxy request URL is %s", path.c_str());
-        std::string npath = rule->test_patterns(vars, path);
-        if (!npath.empty())
+    std::list<Within>::const_iterator it = within_list.begin();
+    for (; it != within_list.end(); it++)
+        if (it->reqline)
         {
-            yaz_log(YLOG_LOG, "Rewritten request URL is %s", npath.c_str());
-            hreq->path = odr_strdup(o, npath.c_str());
+            RulePtr rule = it->rule;
+            yaz_log(YLOG_LOG, "Proxy request URL is %s", path.c_str());
+            std::string npath = rule->test_patterns(vars, path);
+            if (!npath.empty())
+            {
+                yaz_log(YLOG_LOG, "Rewritten request URL is %s", npath.c_str());
+                hreq->path = odr_strdup(o, npath.c_str());
+            }
         }
-    }
 }
 
 void yf::HttpRewrite::Phase::rewrite_headers(mp::odr & o,
         Z_HTTP_Header *headers,
         std::map<std::string, std::string> & vars) const
 {
-    for (Z_HTTP_Header *header = headers;
-            header != 0;
-            header = header->next)
+    for (Z_HTTP_Header *header = headers; header; header = header->next)
     {
-        std::string sheader(header->name);
-        sheader += ": ";
-        sheader += header->value;
-        yaz_log(YLOG_LOG, "%s: %s", header->name, header->value);
-
         std::list<Within>::const_iterator it = within_list.begin();
-        if (it == within_list.end())
-            continue;
-        RulePtr rule = it->rule;
-
-        std::string out = rule->test_patterns(vars, sheader);
-        if (!out.empty())
+        for (; it != within_list.end(); it++)
         {
-            size_t pos = out.find(": ");
-            if (pos == std::string::npos)
+            if (it->header.length() > 0 &&
+                yaz_strcasecmp(it->header.c_str(), header->name) == 0)
             {
-                yaz_log(YLOG_LOG, "Header malformed during rewrite, ignoring");
-                continue;
+                std::string sheader(header->name);
+                sheader += ": ";
+                sheader += header->value;
+
+                RulePtr rule = it->rule;
+                std::string out = rule->test_patterns(vars, sheader);
+                if (!out.empty())
+                {
+                    size_t pos = out.find(": ");
+                    if (pos == std::string::npos)
+                    {
+                        yaz_log(YLOG_LOG, "Header malformed during rewrite, ignoring");
+                        continue;
+                    }
+                    header->name = odr_strdup(o, out.substr(0, pos).c_str());
+                    header->value = odr_strdup(o,
+                                               out.substr(pos + 2,
+                                                          std::string::npos).c_str());
+                }
             }
-            header->name = odr_strdup(o, out.substr(0, pos).c_str());
-            header->value = odr_strdup(o, out.substr(pos+2,
-                                                     std::string::npos).c_str());
         }
     }
 }
@@ -214,35 +222,30 @@ void yf::HttpRewrite::Phase::rewrite_body(mp::odr & o,
 {
     if (*content_buf)
     {
-        HTMLParser parser;
-        Event ev(this);
-        std::string buf(*content_buf, *content_len);
+        int i;
+        for (i = 0; i < *content_len; i++)
+            if ((*content_buf)[i] == 0)
+                return;  // binary content. skip
 
-        parser.parse(ev, buf.c_str());
-        std::cout << "RES\n" << ev.result() << std::endl;
-        std::cout << "-----" << std::endl;
+        HTMLParser parser;
+        Event ev(this, vars);
 
+        parser.set_verbose(m_verbose);
 
-        std::list<Within>::const_iterator it = within_list.begin();
-        if (it != within_list.end())
-        {
-            RulePtr rule = it->rule;
+        std::string buf(*content_buf, *content_len);
 
-            std::string body(*content_buf);
-            std::string nbody = rule->test_patterns(vars, body);
-            if (!nbody.empty())
-            {
-                *content_buf = odr_strdup(o, nbody.c_str());
-                *content_len = nbody.size();
-            }
-        }
+        parser.parse(ev, buf.c_str());
+        const char *res = ev.result();
+        *content_buf = odr_strdup(o, res);
+        *content_len = strlen(res);
     }
 }
 
-yf::HttpRewrite::Event::Event(const Phase *p) : m_phase(p)
+yf::HttpRewrite::Event::Event(const Phase *p,
+                              std::map<std::string, std::string> & vars
+    ) : m_phase(p), m_vars(vars)
 {
     m_w = wrbuf_alloc();
-    enabled_within = m_phase->within_list.end();
 }
 
 yf::HttpRewrite::Event::~Event()
@@ -255,119 +258,129 @@ const char *yf::HttpRewrite::Event::result()
     return wrbuf_cstr(m_w);
 }
 
-void yf::HttpRewrite::Event::openTagStart(const char *name)
+void yf::HttpRewrite::Event::openTagStart(const char *tag, int tag_len)
 {
-    // check if there is <within tag="x" .. />
-    if (enabled_within == m_phase->within_list.end())
+    wrbuf_putc(m_w, '<');
+    wrbuf_write(m_w, tag, tag_len);
+
+    std::string t(tag, tag_len);
+    std::list<Within>::const_iterator it = m_phase->within_list.begin();
+    for (; it != m_phase->within_list.end(); it++)
     {
-        std::list<Within>::const_iterator it =
-            m_phase->within_list.begin();
-        for (; it != m_phase->within_list.end(); it++)
+        if (it->tag.length() > 0 && yaz_strcasecmp(it->tag.c_str(),
+                                                   t.c_str()) == 0)
         {
-            if (it->tag.length() > 0 && it->tag.compare(name) == 0)
+            std::vector<std::string> attr;
+            boost::split(attr, it->attr, boost::is_any_of(","));
+            size_t i;
+            for (i = 0; i < attr.size(); i++)
             {
-                enabled_within = it;
+                if (attr[i].compare("#text") == 0)
+                {
+                    s_within.push(it);
+                    return;
+                }
             }
         }
     }
-    wrbuf_putc(m_w, '<');
-    wrbuf_puts(m_w, name);
 }
 
-void yf::HttpRewrite::Event::anyTagEnd(const char *name)
+void yf::HttpRewrite::Event::anyTagEnd(const char *tag, int tag_len,
+                                       int close_it)
 {
-    std::list<Within>::const_iterator it = enabled_within;
-    if (it != m_phase->within_list.end())
+    if (close_it)
     {
-        if (it->tag.compare(name) == 0)
+        if (!s_within.empty())
         {
-            enabled_within = m_phase->within_list.end();
+            std::list<Within>::const_iterator it = s_within.top();
+            std::string t(tag, tag_len);
+            if (yaz_strcasecmp(it->tag.c_str(), t.c_str()) == 0)
+                s_within.pop();
         }
     }
+    if (close_it)
+        wrbuf_putc(m_w, '/');
     wrbuf_putc(m_w, '>');
 }
 
-void yf::HttpRewrite::Event::attribute(const char *tagName,
-                                         const char *name,
-                                         const char *value,
-                                         int val_len)
+void yf::HttpRewrite::Event::attribute(const char *tag, int tag_len,
+                                       const char *attr, int attr_len,
+                                       const char *value, int val_len,
+                                       const char *sep)
 {
-    std::list<Within>::const_iterator it = enabled_within;
+    std::list<Within>::const_iterator it = m_phase->within_list.begin();
     bool subst = false;
 
-    if (it == m_phase->within_list.end())
+    for (; it != m_phase->within_list.end(); it++)
     {
-        // no active within tag.. see if a attr rule without tag applies
-        it = m_phase->within_list.begin();
-        for (; it != m_phase->within_list.end(); it++)
+        std::string t(tag, tag_len);
+        if (it->tag.length() == 0 ||
+            yaz_strcasecmp(it->tag.c_str(), t.c_str()) == 0)
         {
-            if (it->attr.length() > 0 && it->tag.length() == 0)
-                break;
-        }
-    }
-    if (it != m_phase->within_list.end())
-    {
-        std::vector<std::string> attr;
-        boost::split(attr, it->attr, boost::is_any_of(","));
-        size_t i;
-        for (i = 0; i < attr.size(); i++)
-        {
-            if (attr[i].compare("#text") && attr[i].compare(tagName) == 0)
+            std::string a(attr, attr_len);
+            std::vector<std::string> attr;
+            boost::split(attr, it->attr, boost::is_any_of(","));
+            size_t i;
+            for (i = 0; i < attr.size(); i++)
             {
-                subst = true;
+                if (attr[i].compare("#text") &&
+                    yaz_strcasecmp(attr[i].c_str(), a.c_str()) == 0)
+                    subst = true;
             }
         }
+        if (subst)
+            break;
     }
 
     wrbuf_putc(m_w, ' ');
-    wrbuf_puts(m_w, name);
-    wrbuf_puts(m_w, "\"");
-    wrbuf_write(m_w, value, val_len);
-    if (subst)
-        wrbuf_puts(m_w, " SUBST");
-    wrbuf_puts(m_w, "\"");
+    wrbuf_write(m_w, attr, attr_len);
+    if (value)
+    {
+        wrbuf_puts(m_w, "=");
+        wrbuf_puts(m_w, sep);
+
+        std::string output;
+        if (subst)
+        {
+            std::string input(value, val_len);
+            output = it->rule->test_patterns(m_vars, input);
+        }
+        if (output.empty())
+            wrbuf_write(m_w, value, val_len);
+        else
+            wrbuf_puts(m_w, output.c_str());
+        wrbuf_puts(m_w, sep);
+    }
 }
 
-void yf::HttpRewrite::Event::closeTag(const char *name)
+void yf::HttpRewrite::Event::closeTag(const char *tag, int tag_len)
 {
-    std::list<Within>::const_iterator it = enabled_within;
-    if (it != m_phase->within_list.end())
+    if (!s_within.empty())
     {
-        if (it->tag.compare(name) == 0)
-        {
-            enabled_within = m_phase->within_list.end();
-        }
+        std::list<Within>::const_iterator it = s_within.top();
+        std::string t(tag, tag_len);
+        if (yaz_strcasecmp(it->tag.c_str(), t.c_str()) == 0)
+            s_within.pop();
     }
     wrbuf_puts(m_w, "</");
-    wrbuf_puts(m_w, name);
+    wrbuf_write(m_w, tag, tag_len);
 }
 
 void yf::HttpRewrite::Event::text(const char *value, int len)
 {
-    std::list<Within>::const_iterator it = enabled_within;
-    bool subst = false;
-
+    std::list<Within>::const_iterator it = m_phase->within_list.end();
+    if (!s_within.empty())
+        it = s_within.top();
+    std::string output;
     if (it != m_phase->within_list.end())
     {
-        subst = true;
-        if (it->attr.length() > 0)
-        {
-            subst = false;
-            std::vector<std::string> attr;
-            boost::split(attr, it->attr, boost::is_any_of(","));
-            size_t i;
-            for (i = 0; i < attr.size(); i++)
-            {
-                if (attr[i].compare("#text") == 0)
-                {
-                    subst = true;
-                }
-            }
-        }
+        std::string input(value, len);
+        output = it->rule->test_patterns(m_vars, input);
     }
-    wrbuf_write(m_w, value, len);
-    if (subst)
-        wrbuf_puts(m_w, "<!-- SUBST -->");
+    if (output.empty())
+        wrbuf_write(m_w, value, len);
+    else
+        wrbuf_puts(m_w, output.c_str());
 }
 
 
@@ -410,8 +423,7 @@ const std::string yf::HttpRewrite::Replace::search_replace(
                 = group_index.find(i);
             if (it != group_index.end())
             {   //it is
-                if (!what[i].str().empty())
-                    vars[it->second] = what[i];
+                vars[it->second] = what[i];
             }
 
         }
@@ -492,8 +504,8 @@ void yf::HttpRewrite::Replace::parse_groups()
     regex = res;
 }
 
-std::string yf::HttpRewrite::Replace::sub_vars (
-        const std::map<std::string, std::string> & vars) const
+std::string yf::HttpRewrite::Replace::sub_vars(
+    const std::map<std::string, std::string> & vars) const
 {
     std::string out;
     bool esc = false;
@@ -542,9 +554,19 @@ std::string yf::HttpRewrite::Replace::sub_vars (
     return out;
 }
 
+yf::HttpRewrite::Phase::Phase() : m_verbose(0)
+{
+}
 
 void yf::HttpRewrite::configure_phase(const xmlNode *ptr, Phase &phase)
 {
+    static const char *names[2] = { "verbose", 0 };
+    std::string values[1];
+    values[0] = "0";
+    mp::xml::parse_attr(ptr, names, values);
+
+    phase.m_verbose = atoi(values[0].c_str());
+
     std::map<std::string, RulePtr > rules;
     for (ptr = ptr->children; ptr; ptr = ptr->next)
     {
@@ -590,14 +612,13 @@ void yf::HttpRewrite::configure_phase(const xmlNode *ptr, Phase &phase)
                          + std::string((const char *) p->name)
                          + " in http_rewrite filter");
             }
-            if (!rule->replace_list.empty())
-                rules[values[0]] = rule;
+            rules[values[0]] = rule;
         }
         else if (!strcmp((const char *) ptr->name, "within"))
         {
-            static const char *names[5] =
-                { "header", "attr", "tag", "rule", 0 };
-            std::string values[4];
+            static const char *names[6] =
+                { "header", "attr", "tag", "rule", "reqline", 0 };
+            std::string values[5];
             mp::xml::parse_attr(ptr, names, values);
             Within w;
             w.header = values[0];
@@ -610,6 +631,7 @@ void yf::HttpRewrite::configure_phase(const xmlNode *ptr, Phase &phase)
                     ("Reference to non-existing rule '" + values[3] +
                      "' in http_rewrite filter");
             w.rule = it->second;
+            w.reqline = values[4] == "1";
             phase.within_list.push_back(w);
         }
         else