metaproxy_1::filter::HttpRewrite Class Reference

#include <filter_http_rewrite.hpp>

Inheritance diagram for metaproxy_1::filter::HttpRewrite:

Collaboration diagram for metaproxy_1::filter::HttpRewrite:

Classes
class	Content
class	Event
class	Phase
class	Replace
class	Rule
class	Within

Public Types
typedef boost::shared_ptr< Rule >	RulePtr

Public Member Functions
	HttpRewrite ()
	~HttpRewrite ()
void	process (metaproxy_1::Package &package) const
void	configure (const xmlNode *ptr, bool test_only, const char *path)

Private Member Functions
void	configure_phase (const xmlNode *ptr, Phase &phase)

Private Attributes
boost::scoped_ptr< Phase >	req_phase
boost::scoped_ptr< Phase >	res_phase

Detailed Description

Definition at line 30 of file filter_http_rewrite.hpp.

Member Typedef Documentation

RulePtr

typedef boost::shared_ptr<Rule> metaproxy_1::filter::HttpRewrite::RulePtr

Definition at line 41 of file filter_http_rewrite.hpp.

Constructor & Destructor Documentation

HttpRewrite()

mp::filter::HttpRewrite::HttpRewrite

(

)

Definition at line 128 of file filter_http_rewrite.cpp.

                           :
    req_phase(new Phase), res_phase(new Phase)
{
}

~HttpRewrite()

mp::filter::HttpRewrite::~HttpRewrite

(

)

Definition at line 133 of file filter_http_rewrite.cpp.

{
}

Member Function Documentation

configure()

void mp::filter::HttpRewrite::configure	(	const xmlNode *	ptr,
		bool	test_only,
		const char *	path
	)

Definition at line 958 of file filter_http_rewrite.cpp.

{
    for (ptr = ptr->children; ptr; ptr = ptr->next)
    {
        if (ptr->type != XML_ELEMENT_NODE)
            continue;
        else if (!strcmp((const char *) ptr->name, "request"))
        {
            configure_phase(ptr, *req_phase);
        }
        else if (!strcmp((const char *) ptr->name, "response"))
        {
            configure_phase(ptr, *res_phase);
        }
        else
        {
            throw mp::filter::FilterException
                ("Bad element "
                 + std::string((const char *) ptr->name)
                 + " in http_rewrite filter");
        }
    }
}

References configure_phase(), req_phase, and res_phase.

Here is the call graph for this function:

configure_phase()

void mp::filter::HttpRewrite::configure_phase ( const xmlNode *  ptr, Phase &  phase  )

private

Definition at line 868 of file filter_http_rewrite.cpp.

{
    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)
    {
        if (ptr->type != XML_ELEMENT_NODE)
            continue;
        else if (!strcmp((const char *) ptr->name, "rule"))
        {
            static const char *names[2] = { "name", 0 };
            std::string values[1];
            values[0] = "default";
            mp::xml::parse_attr(ptr, names, values);
 
            RulePtr rule(new Rule);
            for (xmlNode *p = ptr->children; p; p = p->next)
            {
                if (p->type != XML_ELEMENT_NODE)
                    continue;
                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"))
                            from = mp::xml::get_text(attr->children);
                        else if (!strcmp((const char *) attr->name,  "to"))
                            replace.recipe = mp::xml::get_text(attr->children);
                        else
                            throw mp::filter::FilterException
                                ("Bad attribute "
                                 + std::string((const char *) attr->name)
                                 + " in rewrite section of http_rewrite");
                    }
                    yaz_log(YLOG_LOG, "Found rewrite rule from '%s' to '%s'",
                            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
                        ("Bad element "
                         + std::string((const char *) p->name)
                         + " in http_rewrite filter");
            }
            rules[values[0]] = rule;
        }
        else if (!strcmp((const char *) ptr->name, "content"))
        {
            static const char *names[3] =
                { "type", "mime", 0 };
            std::string values[2];
            mp::xml::parse_attr(ptr, names, values);
            if (values[0].empty())
            {
                    throw mp::filter::FilterException
                        ("Missing attribute, type for for element "
                         + std::string((const char *) ptr->name)
                         + " in http_rewrite filter");
            }
            Content c;
 
            c.type = values[0];
            if (!values[1].empty())
                c.content_re.assign(values[1], boost::regex::icase);
            c.configure(ptr->children, rules);
            phase.content_list.push_back(c);
        }
        else
        {
            throw mp::filter::FilterException
                ("Bad element "
                 + std::string((const char *) ptr->name)
                 + " in http_rewrite filter");
        }
    }
}

References metaproxy_1::filter::HttpRewrite::Content::configure(), metaproxy_1::filter::HttpRewrite::Phase::content_list, metaproxy_1::filter::HttpRewrite::Content::content_re, metaproxy_1::filter::HttpRewrite::Phase::m_verbose, metaproxy_1::filter::HttpRewrite::Replace::parse_groups(), metaproxy_1::filter::HttpRewrite::Replace::recipe, and metaproxy_1::filter::HttpRewrite::Content::type.

Referenced by configure().

Here is the call graph for this function:

process()

void mp::filter::HttpRewrite::process

(

metaproxy_1::Package &

package

)

const

Definition at line 137 of file filter_http_rewrite.cpp.

{
    yaz_log(YLOG_LOG, "HttpRewrite begins....");
    Z_GDU *gdu = package.request().get();
    //map of request/response vars
    std::map<std::string, std::string> vars;
    //we have an http req
 
    std::list<boost::regex> skip_list;
    
    if (gdu && gdu->which == Z_GDU_HTTP_Request)
    {
        Z_HTTP_Request *hreq = gdu->u.HTTP_Request;
        mp::odr o;
        std::string bind_addr = package.origin(). get_bind_address();
        req_phase->rewrite_reqline(o, hreq, vars, bind_addr);
        res_phase->read_skip_headers(hreq, skip_list, bind_addr);
        yaz_log(YLOG_LOG, ">> Request headers");
        req_phase->rewrite_headers(o, hreq->headers, vars);
        req_phase->rewrite_body(o,
                                z_HTTP_header_lookup(hreq->headers,
                                                     "Content-Type"),
                                &hreq->content_buf, &hreq->content_len,
                                vars, skip_list);
        package.request() = gdu;
    }
    package.move();
    gdu = package.response().get();
    if (gdu && gdu->which == Z_GDU_HTTP_Response)
    {
        Z_HTTP_Response *hres = gdu->u.HTTP_Response;
        yaz_log(YLOG_LOG, "Response code %d", hres->code);
        mp::odr o;
        yaz_log(YLOG_LOG, "<< Respose headers");
        res_phase->rewrite_headers(o, hres->headers, vars);
        res_phase->rewrite_body(o,
                                z_HTTP_header_lookup(hres->headers,
                                                     "Content-Type"),
                                &hres->content_buf, &hres->content_len,
                                vars, skip_list);
        package.response() = gdu;
    }
}

Member Data Documentation

req_phase

boost::scoped_ptr<Phase> metaproxy_1::filter::HttpRewrite::req_phase

private

Definition at line 36 of file filter_http_rewrite.hpp.

Referenced by configure().

res_phase

boost::scoped_ptr<Phase> metaproxy_1::filter::HttpRewrite::res_phase

private

Definition at line 37 of file filter_http_rewrite.hpp.

Referenced by configure().

---

The documentation for this class was generated from the following files:

• filter_http_rewrite.hpp
• filter_http_rewrite.cpp