#include <yaz/zgdu.h>
#include <yaz/log.h>
+#include <stack>
#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
namespace filter {
class HttpRewrite::Replace {
public:
- std::string regex;
+ boost::regex re;
+ boost::smatch what;
std::string recipe;
std::map<int, std::string> group_index;
- 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();
+ void parse_groups(std::string pattern);
};
class HttpRewrite::Rule {
std::list<Replace> replace_list;
const std::string test_patterns(
std::map<std::string, std::string> & vars,
- const std::string & txt) const;
+ const std::string & txt);
};
class HttpRewrite::Within {
public:
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 *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, std::map<std::string, std::string> &vars);
else
{
//TODO what about proto
+ const char *host = z_HTTP_header_lookup(hreq->headers, "Host");
+ if (!host)
+ return;
+
path += "http://";
- path += z_HTTP_header_lookup(hreq->headers, "Host");
+ path += host;
path += hreq->path;
}
) : m_phase(p), m_vars(vars)
{
m_w = wrbuf_alloc();
- enabled_within = m_phase->within_list.end();
}
yf::HttpRewrite::Event::~Event()
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::string t(tag, tag_len);
- 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 && yaz_strcasecmp(it->tag.c_str(),
- t.c_str()) == 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++)
{
- 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)
{
- if (attr[i].compare("#text") == 0)
- {
- enabled_within = it;
- break;
- }
+ s_within.push(it);
+ return;
}
}
}
}
- wrbuf_putc(m_w, '<');
- wrbuf_write(m_w, tag, tag_len);
}
void yf::HttpRewrite::Event::anyTagEnd(const char *tag, int tag_len,
{
if (close_it)
{
- std::list<Within>::const_iterator it = enabled_within;
- if (it != m_phase->within_list.end())
+ if (!s_within.empty())
{
+ 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)
- {
- enabled_within = m_phase->within_list.end();
- }
+ s_within.pop();
}
}
if (close_it)
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 *value, int val_len,
+ const char *sep)
{
std::list<Within>::const_iterator it = m_phase->within_list.begin();
bool subst = false;
wrbuf_putc(m_w, ' ');
wrbuf_write(m_w, attr, attr_len);
- wrbuf_puts(m_w, "=\"");
-
- std::string output;
- if (subst)
+ if (value)
{
- std::string input(value, val_len);
- output = it->rule->test_patterns(m_vars, input);
+ 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);
}
- if (output.empty())
- wrbuf_write(m_w, value, val_len);
- else
- wrbuf_puts(m_w, output.c_str());
- wrbuf_puts(m_w, "\"");
}
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())
{
+ 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)
- {
- enabled_within = m_phase->within_list.end();
- }
+ s_within.pop();
}
wrbuf_puts(m_w, "</");
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;
-
- 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::list<Within>::const_iterator it = m_phase->within_list.end();
+ if (!s_within.empty())
+ it = s_within.top();
std::string output;
- if (subst)
+ if (it != m_phase->within_list.end())
{
std::string input(value, len);
output = it->rule->test_patterns(m_vars, input);
wrbuf_puts(m_w, output.c_str());
}
-
-/**
- * Tests pattern from the vector in order and executes recipe on
- the first match.
- */
const std::string yf::HttpRewrite::Rule::test_patterns(
std::map<std::string, std::string> & vars,
- const std::string & txt) const
-{
- std::list<Replace>::const_iterator it = replace_list.begin();
-
- for (; it != replace_list.end(); it++)
- {
- std::string out = it->search_replace(vars, txt);
- if (!out.empty()) return out;
- }
- return "";
-}
-
-const std::string yf::HttpRewrite::Replace::search_replace(
- std::map<std::string, std::string> & vars,
- const std::string & txt) const
+ const std::string & txt)
{
- //exec regex against value
- boost::regex re(regex);
- boost::smatch what;
+ std::string out;
std::string::const_iterator start, end;
start = txt.begin();
end = txt.end();
- std::string out;
- while (regex_search(start, end, what, re)) //find next full match
+ while (1)
{
+ std::list<Replace>::iterator bit = replace_list.end();
+ {
+ std::string::const_iterator best_pos = txt.end();
+ std::list<Replace>::iterator it = replace_list.begin();
+ for (; it != replace_list.end(); it++)
+ {
+ if (regex_search(start, end, it->what, it->re))
+ {
+ if (it->what[0].first < best_pos)
+ {
+ best_pos = it->what[0].first;
+ bit = it;
+ }
+ }
+ }
+ if (bit == replace_list.end())
+ break;
+ }
+
size_t i;
- for (i = 1; i < what.size(); ++i)
+ for (i = 1; i < bit->what.size(); ++i)
{
//check if the group is named
- std::map<int, std::string>::const_iterator it
- = group_index.find(i);
- if (it != group_index.end())
+ std::map<int, std::string>::const_iterator git
+ = bit->group_index.find(i);
+ if (git != bit->group_index.end())
{ //it is
- if (!what[i].str().empty())
- vars[it->second] = what[i];
+ vars[git->second] = bit->what[i];
}
}
//prepare replacement string
- std::string rvalue = sub_vars(vars);
+ std::string rvalue = bit->sub_vars(vars);
yaz_log(YLOG_LOG, "! Rewritten '%s' to '%s'",
- what.str(0).c_str(), rvalue.c_str());
- out.append(start, what[0].first);
+ bit->what.str(0).c_str(), rvalue.c_str());
+ out.append(start, bit->what[0].first);
out.append(rvalue);
- start = what[0].second; //move search forward
+ start = bit->what[0].second; //move search forward
}
- //if we had a match cat the last part
if (start != txt.begin())
out.append(start, end);
return out;
}
-void yf::HttpRewrite::Replace::parse_groups()
+void yf::HttpRewrite::Replace::parse_groups(std::string pattern)
{
int gnum = 0;
bool esc = false;
- const std::string & str = regex;
+ const std::string &str = pattern;
std::string res;
yaz_log(YLOG_LOG, "Parsing groups from '%s'", str.c_str());
for (size_t i = 0; i < str.size(); ++i)
}
esc = false;
}
- regex = res;
+ re = 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;
if (!strcmp((const char *) p->name, "rewrite"))
{
Replace replace;
+ std::string from;
const struct _xmlAttr *attr;
for (attr = p->properties; attr; attr = attr->next)
{
if (!strcmp((const char *) attr->name, "from"))
- replace.regex = mp::xml::get_text(attr->children);
+ from = mp::xml::get_text(attr->children);
else if (!strcmp((const char *) attr->name, "to"))
replace.recipe = mp::xml::get_text(attr->children);
else
+ " in rewrite section of http_rewrite");
}
yaz_log(YLOG_LOG, "Found rewrite rule from '%s' to '%s'",
- replace.regex.c_str(), replace.recipe.c_str());
- replace.parse_groups();
- if (!replace.regex.empty())
+ from.c_str(), replace.recipe.c_str());
+ if (!from.empty())
+ {
+ replace.parse_groups(from);
rule->replace_list.push_back(replace);
+ }
}
else
throw mp::filter::FilterException
projects / metaproxy-moved-to-github.git / blobdiff