metaproxy_1::filter::HttpRewrite::Phase Class Reference

Collaboration diagram for metaproxy_1::filter::HttpRewrite::Phase:

Public Member Functions
	Phase ()
void	read_skip_headers (Z_HTTP_Request *hreq, std::list< boost::regex > &skip_list, std::string bind_addr)
void	rewrite_reqline (mp::odr &o, Z_HTTP_Request *hreq, std::map< std::string, std::string > &vars, std::string bind_addr) const
void	rewrite_headers (mp::odr &o, Z_HTTP_Header *headers, std::map< std::string, std::string > &vars) const
void	rewrite_body (mp::odr &o, const char *content_type, char **content_buf, int *content_len, std::map< std::string, std::string > &vars, std::list< boost::regex > &skip_list) const

Public Attributes
int	m_verbose
std::list< Content >	content_list

Detailed Description

Definition at line 87 of file filter_http_rewrite.cpp.

Constructor & Destructor Documentation

Phase()

mp::filter::HttpRewrite::Phase::Phase

(

)

Definition at line 759 of file filter_http_rewrite.cpp.

                          : m_verbose(0)
{
}

Member Function Documentation

read_skip_headers()

void mp::filter::HttpRewrite::Phase::read_skip_headers	(	Z_HTTP_Request *	hreq,
		std::list< boost::regex > &	skip_list,
		std::string	bind_addr
	)

Definition at line 182 of file filter_http_rewrite.cpp.

{
    std::string url(hreq->path);
    if ( url.substr(0,7) != "http://" &&  url.substr(0,8) != "https://")
    { // path was relative, as it often is
       // make absolute, so we can match the page regex against it
        const char *host =  z_HTTP_header_lookup(hreq->headers, "Host");
        std::string proto;
        if (bind_addr.find("ssl:") == 0) {
          proto = "https";
        } else {
          proto = "http";
        }
        if (host)
          url = proto + "://" + std::string(host) + hreq->path ;
    }
 
    while ( const char *hv = z_HTTP_header_remove( &(hreq->headers),
        "X-Metaproxy-SkipLink") )
    {
        yaz_log(YLOG_LOG,"Found SkipLink '%s'", hv );
        const char *p = strchr(hv,' ');
        if (!p)
            continue; // should not happen
        std::string page(hv,p);
        std::string link(p+1);
        boost::regex pagere(page);
        if ( boost::regex_search(url, pagere) )
        {
            yaz_log(YLOG_LOG,"SkipLink '%s' matches URL %s",
                    page.c_str(), url.c_str() );
            boost::regex linkre(link);
            skip_list.push_back(linkre);
        }
        else
        {
            yaz_log(YLOG_LOG,"SkipLink ignored, '%s' does not match '%s'",
                    url.c_str(), page.c_str() );
        }
    }
}

rewrite_body()

void mp::filter::HttpRewrite::Phase::rewrite_body	(	mp::odr &	o,
		const char *	content_type,
		char **	content_buf,
		int *	content_len,
		std::map< std::string, std::string > &	vars,
		std::list< boost::regex > &	skip_list
	)		const

Definition at line 313 of file filter_http_rewrite.cpp.

{
    if (*content_len == 0)
        return;
    if (!content_type) {
        yaz_log(YLOG_LOG, "rewrite_body: null content_type, can not rewrite");
        return;
    }
    std::list<Content>::const_iterator cit = content_list.begin();
    for (; cit != content_list.end(); cit++)
    {
        yaz_log(YLOG_LOG, "rewrite_body: content_type=%s type=%s",
                content_type, cit->type.c_str());
        if (cit->type != "headers"
            && regex_match(content_type, cit->content_re))
            break;
    }
    if (cit == content_list.end()) {
        yaz_log(YLOG_LOG,"rewrite_body: No content rule matched %s, not rewriting",
                content_type );  
        return;
    }
 
    int i;
    for (i = 0; i < *content_len; i++)
        if ((*content_buf)[i] == 0) {
            yaz_log(YLOG_LOG,"rewrite_body: Looks like binary stuff, not rewriting");
            return;  // binary content. skip
        }
 
    std::string content(*content_buf, *content_len);
    cit->parse(m_verbose, content, vars, skip_list);
    *content_buf = odr_strdup(o, content.c_str());
    *content_len = strlen(*content_buf);
}

rewrite_headers()

void mp::filter::HttpRewrite::Phase::rewrite_headers	(	mp::odr &	o,
		Z_HTTP_Header *	headers,
		std::map< std::string, std::string > &	vars
	)		const

Definition at line 281 of file filter_http_rewrite.cpp.

{
    std::list<Content>::const_iterator cit = content_list.begin();
    for (; cit != content_list.end(); cit++)
        if (cit->type == "headers")
            break;
 
    if (cit == content_list.end())
        return;
 
    for (Z_HTTP_Header *header = headers; header; header = header->next)
    {
        std::list<Within>::const_iterator it = cit->within_list.begin();
        for (; it != cit->within_list.end(); it++)
        {
            if (!it->header.empty() &&
                regex_match(header->name, it->header))
            {
                // Match and replace only the header value
                std::string hval(header->value);
                std::list<boost::regex> dummy_skip_list; // no skips here!
                if (it->exec(vars, hval, true, dummy_skip_list))
                {
                    header->value = odr_strdup(o, hval.c_str());
                }
            }
        }
    }
}

rewrite_reqline()

void mp::filter::HttpRewrite::Phase::rewrite_reqline	(	mp::odr &	o,
		Z_HTTP_Request *	hreq,
		std::map< std::string, std::string > &	vars,
		std::string	bind_addr
	)		const

Definition at line 227 of file filter_http_rewrite.cpp.

{
    std::string proto;
    if (bind_addr.find("ssl:") == 0) {
      proto = "https";
    } else {
      proto = "http";
    }
    yaz_log(YLOG_LOG,"rewrite_reqline: p='%s' ba='%s'",
            hreq->path, proto.c_str() );
    std::string path;
    if ((strstr(hreq->path, "http://") == hreq->path) ||
        (strstr(hreq->path, "https://") == hreq->path) )
    {
        yaz_log(YLOG_LOG, "Path in the method line is absolute, "
            "possibly a proxy request"); // the usual case with cf_proxy
        path = hreq->path;
    }
    else
    {
        const char *host = z_HTTP_header_lookup(hreq->headers, "Host");
        if (!host)
            return;
 
        path = proto + "://";
        path += host;
        path += hreq->path;
    }
 
    std::list<Content>::const_iterator cit = content_list.begin();
    for (; cit != content_list.end(); cit++)
        if (cit->type == "headers")
            break;
 
    if (cit == content_list.end())
        return;
 
    std::list<Within>::const_iterator it = cit->within_list.begin();
    for (; it != cit->within_list.end(); it++)
        if (it->reqline)
        {
            yaz_log(YLOG_LOG, "Proxy request URL is %s", path.c_str());
            std::list<boost::regex> dummy_skip_list; // no skips here!
            if (it->exec(vars, path, true, dummy_skip_list))
            {
                yaz_log(YLOG_LOG, "Rewritten request URL is %s", path.c_str());
                hreq->path = odr_strdup(o, path.c_str());
            }
        }
}

Member Data Documentation

content_list

std::list<Content> metaproxy_1::filter::HttpRewrite::Phase::content_list

Definition at line 91 of file filter_http_rewrite.cpp.

Referenced by metaproxy_1::filter::HttpRewrite::configure_phase().

m_verbose

int metaproxy_1::filter::HttpRewrite::Phase::m_verbose

Definition at line 90 of file filter_http_rewrite.cpp.

Referenced by metaproxy_1::filter::HttpRewrite::configure_phase().

---

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

• filter_http_rewrite.cpp