src/http/modules/xslt2/ngx_http_xslt2_xml.c

Go to the documentation of this file.

/*
 *  Copyright 2009 DreamLab Onet.pl Sp. z o.o.
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *
 * Authors:
 * Piotr Janik, email: janik.piotrek(malpa)gmail.com
 * Przemyslaw Gajda, email: quermit(malpa)gmail.com
 *                                                                       malpa = @
 */

#include "ngx_http_xslt2_xml.h"
#include "ngx_http_xslt2_filter_module.h"

// =============================== DECLARATIONS ================================

static ngx_http_xslt2_sheet_t *
        ngx_http_xslt2_xml_create_new_stylesheet(ngx_http_xslt2_xml_data_t *xml_data);
static ngx_int_t
        ngx_http_xslt2_xml_return_original(ngx_http_xslt2_xml_data_t *xml_data);
static ngx_int_t 
        ngx_http_xslt2_xml_get_local_stylesheet(ngx_http_xslt2_sheet_t *sheet);
static ngx_int_t 
        ngx_http_xslt2_xml_get_external_stylesheet(ngx_http_xslt2_sheet_t *sheet);
static void 
        ngx_http_xslt2_xml_download_handler(ngx_http_download_conn_t *dl_ctx);
static ngx_int_t 
        ngx_http_xslt2_xml_parse_stylesheet(ngx_http_xslt2_sheet_t *sheet);
static ngx_int_t 
        ngx_http_xslt2_xml_apply_stylesheets(ngx_http_xslt2_xml_data_t *xml_data);
static ngx_int_t
        ngx_http_xslt2_xml_get_cached_stylesheet(ngx_http_request_t *r, ngx_http_xslt2_sheet_t *sheet);
static void
        ngx_http_xslt2_xml_mxcache_get_handler(ngx_http_mxcache_conn_t *conn);
static ngx_int_t
        ngx_http_xslt2_xml_set_cached_stylesheet(ngx_http_request_t *r, ngx_http_xslt2_sheet_t *sheet);
static void
        ngx_http_xslt2_xml_mxcache_set_handler(ngx_http_mxcache_conn_t *conn);
static void
        ngx_http_xslt2_xml_get_stylesheet(ngx_http_xslt2_sheet_t *sheet, ngx_flag_t use_cache);
static void
        ngx_http_xslt2_xml_stylesheet_node(ngx_http_xslt2_xml_data_t *xml_data, const xmlChar *pidata);
static void
        ngx_http_xslt2_xml_stylesheet_error(ngx_http_xslt2_xml_data_t *xml_data, char *msg, ...);

// ============================== sax handlers =================================
static void ngx_http_xslt2_xml_sax_start_document(void *data);
static void ngx_http_xslt2_xml_sax_end_document(void *data);
static void ngx_http_xslt2_xml_sax_internal_subset(void *data, const xmlChar *name,
        const xmlChar *externalId, const xmlChar *systemId);
static void ngx_http_xslt2_xml_sax_external_subset(void *data, const xmlChar *name,
        const xmlChar *externalId, const xmlChar *systemId);
static void ngx_http_xslt2_xml_sax_entity_decl(void *data, const xmlChar *name,
        int type, const xmlChar *publicId, const xmlChar *systemId,
        xmlChar *content);
static void ngx_http_xslt2_xml_sax_attribute_decl(void *data, const xmlChar *elem,
        const xmlChar *fullname, int type, int def, const xmlChar *defaultValue,
        xmlEnumerationPtr tree);
static void ngx_http_xslt2_xml_sax_element_decl(void *data, const xmlChar * name,
        int type, xmlElementContentPtr content);
static void ngx_http_xslt2_xml_sax_notation_decl(void *data, const xmlChar *name,
        const xmlChar *publicId, const xmlChar *systemId);
static void ngx_http_xslt2_xml_sax_unparsed_entity_decl(void *data,
        const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId,
        const xmlChar *notationName);
static void ngx_http_xslt2_xml_sax_start_element(void *data,
        const xmlChar *localname, const xmlChar *prefix, const xmlChar *URI,
        int nb_namespaces, const xmlChar **namespaces, int nb_attributes,
        int nb_defaulted, const xmlChar **attributes);
static void ngx_http_xslt2_xml_sax_end_element(void *data,
        const xmlChar * localname ATTRIBUTE_UNUSED,
        const xmlChar * prefix ATTRIBUTE_UNUSED,
        const xmlChar * URI ATTRIBUTE_UNUSED);
static void ngx_http_xslt2_xml_sax_characters(void *data, const xmlChar *p, int len);
static void ngx_http_xslt2_xml_sax_cdata_block(void *data, const xmlChar *p,
        int len);
static xmlEntityPtr ngx_http_xslt2_xml_sax_get_entity(void *data,
        const xmlChar *name);
static xmlEntityPtr ngx_http_xslt2_xml_sax_get_parameter_entity(void *data,
        const xmlChar *name);
static xmlParserInputPtr ngx_http_xslt2_xml_sax_resolve_entity(void *data,
        const xmlChar *publicId, const xmlChar *systemId);
static void ngx_http_xslt2_xml_sax_reference(void *data, const xmlChar *name);
static void ngx_http_xslt2_xml_sax_comment(void *data, const xmlChar *value);
static void ngx_http_xslt2_xml_sax_processing_instruction(void *data,
        const xmlChar *target, const xmlChar *pidata);
static int ngx_http_xslt2_xml_sax_is_standalone(void *data);
static int ngx_http_xslt2_xml_sax_has_internal_subset(void *data);
static int ngx_http_xslt2_xml_sax_has_external_subset(void *data);
static void ngx_cdecl ngx_http_xslt2_xml_sax_error(void *data, const char *msg, ...);
// =============================================================================
// =============================================================================

ngx_http_xslt2_xml_data_t* ngx_http_xslt2_xml_create_new(ngx_http_request_t *r) 
{
        ngx_http_xslt2_xml_data_t       *xml_data;
        xmlSAXHandler                           *sax;
        
        xml_data = ngx_pcalloc(r->pool, sizeof(ngx_http_xslt2_xml_data_t));

        xml_data->ctxt = xmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL);
        if(xml_data->ctxt == NULL) 
        {
                        return NULL;
        }

        xml_data->sax = ngx_palloc(r->pool, sizeof(xmlSAXHandler));
        if (xml_data->sax == NULL) {
                return NULL;
        }

        sax = xml_data->ctxt->sax;

        ngx_memcpy(xml_data->sax, sax, sizeof(xmlSAXHandler));

        sax->startDocument = ngx_http_xslt2_xml_sax_start_document;
        sax->endDocument = ngx_http_xslt2_xml_sax_end_document;

        sax->internalSubset = ngx_http_xslt2_xml_sax_internal_subset;
        sax->externalSubset = ngx_http_xslt2_xml_sax_external_subset;
        sax->entityDecl = ngx_http_xslt2_xml_sax_entity_decl;
        sax->attributeDecl = ngx_http_xslt2_xml_sax_attribute_decl;
        sax->elementDecl = ngx_http_xslt2_xml_sax_element_decl;
        sax->notationDecl = ngx_http_xslt2_xml_sax_notation_decl;
        sax->unparsedEntityDecl = ngx_http_xslt2_xml_sax_unparsed_entity_decl;
        sax->setDocumentLocator = NULL;

        sax->startElementNs = ngx_http_xslt2_xml_sax_start_element;
        sax->endElementNs = ngx_http_xslt2_xml_sax_end_element;

        sax->characters = ngx_http_xslt2_xml_sax_characters;
        sax->ignorableWhitespace  = ngx_http_xslt2_xml_sax_characters;
        sax->cdataBlock = ngx_http_xslt2_xml_sax_cdata_block;
        sax->getEntity = ngx_http_xslt2_xml_sax_get_entity;
        sax->resolveEntity = ngx_http_xslt2_xml_sax_resolve_entity;
        sax->getParameterEntity = ngx_http_xslt2_xml_sax_get_parameter_entity;
        sax->reference = ngx_http_xslt2_xml_sax_reference;
        sax->comment = ngx_http_xslt2_xml_sax_comment;
        sax->processingInstruction = ngx_http_xslt2_xml_sax_processing_instruction;

        sax->isStandalone = ngx_http_xslt2_xml_sax_is_standalone;
        sax->hasInternalSubset = ngx_http_xslt2_xml_sax_has_internal_subset;
        sax->hasExternalSubset = ngx_http_xslt2_xml_sax_has_external_subset;

        sax->warning = NULL;
        sax->error = ngx_http_xslt2_xml_sax_error;
        sax->fatalError = ngx_http_xslt2_xml_sax_error;

        xml_data->ctxt->userData = xml_data;

        xml_data->ctxt->replaceEntities = 1;
        xml_data->ctxt->loadsubset = 1;


        xml_data->r = r;

        return xml_data;
}

ngx_int_t 
ngx_http_xslt2_xml_add_data_chunk(ngx_http_xslt2_xml_data_t *xml_data, ngx_chain_t *in) 
{
        int                                     rc;
        ngx_buf_t                       *buf;
        xmlParserCtxtPtr        ctxt;
        ngx_http_request_t      *r;

        if(xml_data == NULL || in == NULL) 
        {
                return NGX_ERROR;
        }
        
        buf = in->buf;
        ctxt = xml_data->ctxt;
        r = xml_data->r;
        
        while(in != NULL) 
        {
                buf = in->buf;

                rc = xmlParseChunk(ctxt, (char *) buf->pos, (int) (buf->last - buf->pos), buf->last_buf);


                buf->pos = buf->last;

                if(rc != 0)
                {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                  "[xml_add_data_chunk] xmlParseChunk() failed, error:%d", rc);
                        return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                           "<b>Error during XML parsing</b> :: %s", xml_data->libxml_error);
                }

                if(xml_data->stylesheet_err != 0)
                {
                        return ngx_http_xslt2_finalize_with_error(r, xml_data->stylesheet_err,
                           (char *) xml_data->stylesheet_err_msg);
                }

                in = in->next;
        }

        if(buf->last_buf || buf->last_buf) 
        {
                xml_data->doc = ctxt->myDoc;

                if(xml_data->doc == NULL) 
                {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                  "[xml_add_data_chunk] xmlParseChunk() finalization failed");
                        return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                           "<b>Error during XML parsing</b> :: %s", xml_data->libxml_error);
                }
                if(!ctxt->wellFormed)
                {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                  "[xml_add_data_chunk] XML is not well formed");
                        return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                        "<b>XML is not well formed</b> :: libxml error: %s", xml_data->libxml_error);
                }
                xml_data->xml_ready = 1;


                if(xml_data->sheets == NULL) 
                {
                        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                  "[xml_add_data_chunk] No style sheets declared");

                        return ngx_http_xslt2_xml_return_original(xml_data);
                }                       

                return ngx_http_xslt2_xml_apply_stylesheets(xml_data);
        }
        return NGX_OK;
}

static ngx_int_t
ngx_http_xslt2_xml_return_original(ngx_http_xslt2_xml_data_t *xml_data)
{
        xmlChar                         *buf;
        int                                     len;

        ngx_http_request_t      *r;
        ngx_chain_t                     *cl;

        r = xml_data->r;

        xmlDocDumpMemory(xml_data->doc, &buf, &len);

        if(buf == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[ngx_http_xslt2_xml_return_original] xsltSaveResultToString failed");
                return ngx_http_xslt2_finalize_with_error(r,
                   NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        cl = ngx_pcalloc(xml_data->r->pool, sizeof(ngx_chain_t));
        if(cl == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[ngx_http_xslt2_xml_return_original] XML buffer chain allocation failed");
                return ngx_http_xslt2_finalize_with_error(r,
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        cl->buf = ngx_pcalloc(xml_data->r->pool, sizeof(ngx_buf_t));
        if(cl->buf == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                           "[ngx_http_xslt2_xml_return_original] XML buffer allocation failed");
                return ngx_http_xslt2_finalize_with_error(r,
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        cl->buf->pos = ngx_pcalloc(xml_data->r->pool, sizeof(u_char)*(len + 1));
        if(cl->buf->pos == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[ngx_http_xslt2_xml_return_original] XML buffer content allocation failed");
                return ngx_http_xslt2_finalize_with_error(r,
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        ngx_cpystrn(cl->buf->pos, (u_char *) buf, len+1);

        cl->buf->last = cl->buf->pos + len;
        cl->buf->memory = 1;

        xml_data->buffer_chain = cl;
        xml_data->res_len = len;

        xmlFree(buf);

        xml_data->done = 1;

        return ngx_http_xslt2_process_data(r);
}


void
ngx_http_xslt2_xml_cleanup(ngx_http_xslt2_xml_data_t *xml_data) 
{
        if(xml_data->doc != NULL)
        {
                xmlFreeDoc(xml_data->doc);
                xml_data->doc = NULL;
        }
        if(xml_data->ctxt != NULL)
        {
                xmlFreeParserCtxt(xml_data->ctxt);
                xml_data->ctxt = NULL;
        }

        // cleanup of stylesheets list
        while(xml_data->sheets)
        {
                if(xml_data->sheets->stylesheet != NULL)
                {
                        xsltFreeStylesheet(xml_data->sheets->stylesheet);
                        xml_data->sheets->stylesheet = NULL;
                }
                
                // terminate remaining downloads
                if(xml_data->sheets->download != NULL)
                {
                        ngx_http_download_cleanup(xml_data->sheets->download);
                }

                if(xml_data->sheets->xcache_get != NULL)
                {
                        ngx_http_mxcache_cleanup(xml_data->sheets->xcache_get);
                }

                xml_data->sheets = xml_data->sheets->next;
        }
}

static ngx_http_xslt2_sheet_t *
ngx_http_xslt2_xml_create_new_stylesheet(ngx_http_xslt2_xml_data_t *xml_data) 
{
        ngx_http_xslt2_sheet_t  *sheet;
        ngx_http_request_t              *r;

        r = xml_data->r;
        
        sheet = ngx_pcalloc(r->pool, sizeof(ngx_http_xslt2_sheet_t));
        if(sheet == NULL) {
                return NULL;
        }

        sheet->parent_xml = xml_data;
        sheet->id = xml_data->sheets_n++;

        // create new list of style sheets
        if (xml_data->sheets == NULL) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                        "[xml_create_new_stylesheet] new style sheet list created");
                
                xml_data->sheets = xml_data->sheets_tail = sheet;       
                xml_data->act_sheet = xml_data->sheets; 
        }
        // add to existing list
        else {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                        "[xml_create_new_stylesheet] new style sheet added to list");
                xml_data->sheets_tail->next = sheet;
                xml_data->sheets_tail = sheet;
        }

        return sheet;
}

static ngx_int_t 
ngx_http_xslt2_xml_get_cached_stylesheet(ngx_http_request_t *r, ngx_http_xslt2_sheet_t *sheet)
{
        ngx_http_mxcache_conn_t                 *xc_ctx;
        u_char                                                  *key;
        u_char                                                  *uri;
        ngx_int_t                                               rc;

        uri = sheet->res_uri;

        if( !ngx_http_mxcache_is_enabled(r) ) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                "[xml_get_cached_stylesheet] XCache disabled");
                return NGX_DONE;
        }

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                        "[xml_get_cached_stylesheet] XCache get %s request", uri);

        xc_ctx = ngx_http_mxcache_create_new(r);

        sheet->xcache_get = xc_ctx;

        //new key
        if( ngx_strncmp(uri, "http://", 7) == 0 ) {
                key = uri;
        }
        else {
                key = ngx_palloc(r->pool, r->uri.len + ngx_strlen(uri) + 1);
                ngx_cpystrn(key, r->uri.data, r->uri.len + 1);
                strcat((char*)key, (char*)uri);
        }
        //---
        xc_ctx->key = key;
        xc_ctx->data = sheet;
        xc_ctx->res_uri = uri;
        xc_ctx->rpool = r->pool;
        xc_ctx->done_handler = ngx_http_xslt2_xml_mxcache_get_handler;

        // send request to cache
        rc = ngx_http_mxcache_get(xc_ctx);

        if(rc == NGX_OK)
        {
                sheet->parent_xml->dl_in_progress++;
        }
        return rc;
}

static void
ngx_http_xslt2_xml_mxcache_get_handler(ngx_http_mxcache_conn_t *conn)
{
        ngx_http_xslt2_sheet_t          *sheet;
        ngx_http_xslt2_xml_data_t       *xml_data;
        ngx_http_request_t                      *r;
        ngx_int_t                                       rc;
        u_char                                          *uri;


        sheet = conn->data;
        uri = conn->res_uri;
        xml_data = sheet->parent_xml;
        r = xml_data->r;

        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, conn->log, 0,
                         "[xml_mxcache_get_handler] XCached get %s, rc: %d", conn->res_uri, conn->error);

        xml_data->dl_in_progress--;

        if( conn->error == NGX_OK && conn->out_bufs && conn->data_begin ) {

                ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                 "[xml_mxcache_get_handler] XCache get %s, OK!", conn->res_uri);

                sheet->ready = 1;

                sheet->buffer_chain = conn->out_bufs;

                rc = ngx_http_xslt2_xml_parse_stylesheet(sheet);
                if(rc != NGX_OK)
                {
                        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                        "[xml_mxcache_get_handler] Parse style sheet error");
                        ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                        "<b>Error during style sheet parsing</b> :: %s", sheet->res_uri);
                        return;
                }

                ngx_http_xslt2_xml_apply_stylesheets(sheet->parent_xml);
        }
        else {
                ngx_log_debug2(NGX_LOG_DEBUG_HTTP, conn->log, 0,
                                "[xml_mxcache_get_handler] XCached get %s failed (rc: %d), trying classic method", conn->res_uri, conn->error);
                ngx_http_xslt2_xml_get_stylesheet(sheet, XXSLT_NO_CACHE);
        }
}

static ngx_int_t
ngx_http_xslt2_xml_set_cached_stylesheet(ngx_http_request_t *r, ngx_http_xslt2_sheet_t *sheet)
{
        ngx_http_mxcache_conn_t         *xc_ctx;
        ngx_int_t                                       bytes;
        ngx_int_t                                       size;
        ngx_int_t                                       rc;
        u_char                                          *key;

        ngx_chain_t                                     *cl;
        u_char                                          *uri;

        if( !ngx_http_mxcache_is_enabled(r) ) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                "[xml_set_cached_stylesheet] mxcache disabled");
                return NGX_DONE;
        }

        cl = sheet->buffer_chain;
        uri = sheet->res_uri;

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                         "[xml_set_cached_stylesheet] mxcache set %s request", uri);

        xc_ctx = ngx_http_mxcache_create_new(r); // r - ngx_http_request_t

        //new key
        if( ngx_strncmp(uri, "http://", 7) == 0 ) {
                key = uri;
        }
        else {
                key = ngx_palloc(r->pool, r->uri.len + ngx_strlen(uri) + 1);
                ngx_cpystrn(key, r->uri.data, r->uri.len + 1);
                strcat((char*)key, (char*)uri);
        }
        //---

        xc_ctx->key = key;
        xc_ctx->res_uri = uri;

        bytes = 0;
        // copy buffer chain, because it's allocated on r->pool
        while( cl ) {
                bytes += ngx_buf_size(cl->buf);

                if( xc_ctx->out_bufs == NULL ) {
                        xc_ctx->out_bufs = xc_ctx->out_bufs_tail = ngx_alloc_chain_link(xc_ctx->pool);
                }
                else {
                        xc_ctx->out_bufs_tail->next = ngx_alloc_chain_link(xc_ctx->pool);
                        xc_ctx->out_bufs_tail = xc_ctx->out_bufs_tail->next;
                }
                size = cl->buf->last - cl->buf->pos;
                xc_ctx->out_bufs_tail->buf = ngx_create_temp_buf(xc_ctx->pool, size);
                ngx_memcpy(xc_ctx->out_bufs_tail->buf->pos, cl->buf->pos, size);
                xc_ctx->out_bufs_tail->buf->last = xc_ctx->out_bufs_tail->buf->pos + size;

                cl = cl->next;
        }
        xc_ctx->out_bufs_tail->next = NULL;

        xc_ctx->bytes = bytes;

        xc_ctx->done_handler = ngx_http_xslt2_xml_mxcache_set_handler;

        rc = ngx_http_mxcache_set(xc_ctx);

        if( rc != NGX_OK ) {
                // need to cleanup here, because handler won't be called
                ngx_http_mxcache_cleanup(xc_ctx);
        }
        return rc;
}

static void
ngx_http_xslt2_xml_mxcache_set_handler(ngx_http_mxcache_conn_t *conn)
{
        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, conn->log, 0,
                         "[xml_mxcache_set_handler] mxcached set %s, rc: %d", conn->res_uri, conn->error);

        ngx_http_mxcache_cleanup(conn);
}

static void
ngx_http_xslt2_xml_get_stylesheet(ngx_http_xslt2_sheet_t *sheet, ngx_flag_t use_cache)
{
        ngx_http_xslt2_xml_data_t       *xml_data;
        ngx_http_request_t                      *r;
        ngx_int_t                                       rc;

        xml_data = sheet->parent_xml;
        r = xml_data->r;

        if(use_cache == XXSLT_USE_CACHE)
        {
                rc = ngx_http_xslt2_xml_get_cached_stylesheet(r, sheet);
        }
        else
        {
                rc = NGX_ERROR;
        }
        // cache used, we finish here
        if(rc == NGX_OK)
                return;


        // external style sheet
        if(xmlStrncmp(sheet->res_uri, (xmlChar *) "http://", 7) == 0)
        {
                ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                         "[xml_get_stylesheet] style sheet URL: %s", sheet->res_uri);

                ngx_http_xslt2_xml_get_external_stylesheet(sheet);
        }
        else // local style sheet
        {
                ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                         "[xml_get_stylesheet] style sheet URI: %s", sheet->res_uri);

                ngx_http_xslt2_xml_get_local_stylesheet(sheet);
        }
}

static ngx_int_t
ngx_http_xslt2_xml_get_local_stylesheet(ngx_http_xslt2_sheet_t *sheet)
{
        ngx_int_t                       rc;
        ngx_http_request_t      *r;
        ngx_str_t                       *uri_str;
        ngx_chain_t                     *buffer_chain = NULL;
        u_char                          *uri;

        r = sheet->parent_xml->r;
        sheet->ready = 1;
        uri = sheet->res_uri;
        
        uri_str = ngx_pcalloc(r->pool, sizeof(ngx_str_t));

        if(uri_str == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_get_local_stylesheet] alloc failed");
                return ngx_http_xslt2_finalize_with_error(r, 
                        NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        uri_str->data = uri;
        uri_str->len = ngx_strlen(uri);


        rc = ngx_http_filesync_get(r, uri_str, &buffer_chain);

        if(rc != NGX_OK || buffer_chain == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_get_local_stylesheet] fileasync failed");
                return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR,
                        "<b>XSL style sheet is unavailable</b> :: %s", sheet->res_uri);
        }

        sheet->buffer_chain = buffer_chain;

        rc = ngx_http_xslt2_xml_set_cached_stylesheet(r, sheet);
        if( rc != NGX_OK ) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                 "[xml_get_local_stylesheet] mxcache set request error");
        }

        rc = ngx_http_xslt2_xml_parse_stylesheet(sheet);
        if(rc != NGX_OK)
        {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[xml_get_local_stylesheet] Parse style sheet error");
                        return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR,
                                "<b>Error during style sheet parsing</b> :: %s", sheet->res_uri);
        }

        return ngx_http_xslt2_xml_apply_stylesheets(sheet->parent_xml);
}

static ngx_int_t 
ngx_http_xslt2_xml_get_external_stylesheet(ngx_http_xslt2_sheet_t *sheet)
{
        ngx_http_download_conn_t        *dl_ctx;
        ngx_http_request_t                      *r;
        ngx_str_t                                       *url;
        ngx_int_t                                       rc;
        u_char                                          *uri;

        r = sheet->parent_xml->r;
        uri = sheet->res_uri;

        dl_ctx = ngx_http_download_create_new(r);

        dl_ctx->r = r;
        dl_ctx->data = sheet;
        dl_ctx->done_handler = ngx_http_xslt2_xml_download_handler;

        sheet->download = dl_ctx;
        
        url = ngx_pcalloc(r->pool, sizeof(ngx_str_t));

        if(url == NULL) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_get_external_stylesheet] external style sheet loading failed");
                return ngx_http_xslt2_finalize_with_error(r, 
                        NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }       

        url->data = uri;
        url->len = strlen((char *) uri);

        rc = ngx_http_download_parse_url(url, dl_ctx);

        if(rc != NGX_OK) 
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_get_external_stylesheet] external style sheet loading failed");
                return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                "<b>XSL Style sheet URL parsing failed</b> :: %s", sheet->res_uri);
        }
        
        rc = ngx_http_download_enqueue(dl_ctx);

        if(rc != NGX_OK && rc != NGX_AGAIN)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_get_external_stylesheet] external style sheet loading failed");
                return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                "<b>XSL Style sheet is unavailable</b> :: %s", sheet->res_uri);
        }

        sheet->parent_xml->dl_in_progress++;

        return rc;
}

static void
ngx_http_xslt2_xml_download_handler(ngx_http_download_conn_t *dl_ctx)
{
        ngx_http_xslt2_sheet_t          *sheet;
        ngx_http_xslt2_xml_data_t       *xml_data;
        ngx_http_request_t                      *r;

        ngx_int_t                                       headers_len;
        ngx_int_t                                       rc;

        sheet = dl_ctx->data;
        xml_data = sheet->parent_xml;
        r = xml_data->r;


        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                 "[xml_stylesheet_ready]");

        xml_data->dl_in_progress--;
        sheet->ready = 1;

        if(dl_ctx->error != NGX_OK || dl_ctx->status != 200) 
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_stylesheet_ready] error during style sheet download :: %d", dl_ctx->error);
                ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                "<b>XSL style sheet download failed</b> :: %s", sheet->res_uri);
                return;
        }

        if(dl_ctx->out_bufs == NULL ||
           dl_ctx->out_bufs->buf == NULL ||
           dl_ctx->out_bufs->buf->pos == NULL ||
           dl_ctx->body_start == NULL) 
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_stylesheet_ready] empty buffer");
                ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                "<b>XSL style sheet download failed</b> :: %s", sheet->res_uri);
                return;
        }

        headers_len = dl_ctx->body_start - dl_ctx->out_bufs->buf->pos;

        sheet->buffer_chain = dl_ctx->out_bufs;
        sheet->buffer_chain->buf->pos = dl_ctx->body_start;

        rc = ngx_http_xslt2_xml_set_cached_stylesheet(r, sheet);
        if( rc != NGX_OK ) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                 "[xml_stylesheet_ready] XCache set request error");
        }

        rc = ngx_http_xslt2_xml_parse_stylesheet(sheet);
        if(rc != NGX_OK)
        {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                 "[xml_stylesheet_ready] parse style sheet error");
                ngx_http_xslt2_finalize_with_error(r, NGX_ERROR,
                                "<b>Error during style sheet parsing</b> :: %s", sheet->res_uri);
                return;
        }

        ngx_http_xslt2_xml_apply_stylesheets(sheet->parent_xml);
}

static ngx_int_t 
ngx_http_xslt2_xml_parse_stylesheet(ngx_http_xslt2_sheet_t *sheet)
{
        ngx_chain_t                                     *bc;
        ngx_buf_t                                       *buf;

        xmlDocPtr                                       doc;
        xmlParserCtxtPtr                        ctxt;
        xsltStylesheetPtr                       xslt_sheet;

        ngx_int_t                                       rc;

        ngx_http_xslt2_xml_data_t       *xml_data;

        xml_data = sheet->parent_xml;

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0, 
           "[xml_parse_stylesheet]");

        bc = sheet->buffer_chain;

        ctxt = xmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL); 

        while(bc != NULL)
        {
                buf = bc->buf;

                rc = xmlParseChunk(ctxt, (char *) buf->pos, (int) (buf->last - buf->pos),
                                buf->last_buf || buf->last_in_chain);

                if(rc != 0)
                        return NGX_ERROR;

                if(buf->last_buf)
                        break;

                bc = bc->next;
        }

        doc = ctxt->myDoc;

        // it doesn't free ctx->myDoc
        xmlFreeParserCtxt(ctxt);

        if(doc == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                   "[xml_parse_stylesheet] error during XML style sheet parsing");
                return NGX_ERROR;
        }       

        xslt_sheet = xsltParseStylesheetDoc(doc);

        if(xslt_sheet == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                   "[xml_parse_stylesheet] error during XSLT style sheet parsing");
                return NGX_ERROR;
        }   

        sheet->stylesheet = xslt_sheet;

        return NGX_OK;
}

static ngx_int_t 
ngx_http_xslt2_xml_apply_stylesheets(ngx_http_xslt2_xml_data_t *xml_data)
{
        xmlDocPtr                               res;

        xmlChar                                 *buf;
        int                                             len;
        ngx_int_t                               rc;
        ngx_chain_t                             *cl;
        ngx_http_request_t              *r;

        r = xml_data->r;

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0, 
                        "[xml_apply_stylesheets]");

        if(xml_data->xml_ready == 0) 
        {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0, 
                                "[xml_apply_stylesheets] XML is not ready to apply style sheets");
                return NGX_OK;
        }

        if(xml_data->sheets == NULL)
        {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0, 
                                "[xml_apply_stylesheets] XML has no declared style sheets");
                return NGX_ERROR;
        }

        while(xml_data->act_sheet)
        {
                if(xml_data->act_sheet->ready == 0) 
                {
                        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0, 
                                        "[xml_apply_stylesheets] Style sheet [%d] is not ready yet", xml_data->act_sheet->id);
                        return NGX_DONE;
                }

                res = xsltApplyStylesheet(xml_data->act_sheet->stylesheet, xml_data->doc, NULL);
                
                if(res == NULL) 
                {
                        ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                                        "[xml_apply_stylesheets] Application of style sheet :: %d failed", xml_data->act_sheet->id);
                        return ngx_http_xslt2_finalize_with_error(r, NGX_ERROR, 
                                        "<b>Application of XSL style sheet failed</b> :: %s", xml_data->act_sheet->res_uri);
                }
                // replace doc with new one
                xmlFreeDoc(xml_data->doc);
                xml_data->doc = res;

                xml_data->act_sheet = xml_data->act_sheet->next;
        }


        // saving result to string and finalize
        rc = xsltSaveResultToString(&buf, &len, xml_data->doc, xml_data->sheets_tail->stylesheet);

        if(rc != 0) 
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                                "[xml_apply_stylesheets] xsltSaveResultToString failed");
                return ngx_http_xslt2_finalize_with_error(r, 
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        cl = ngx_pcalloc(xml_data->r->pool, sizeof(ngx_chain_t));
        if(cl == NULL)  
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                                "[xml_apply_stylesheets] XML buffer chain allocation failed");
                return ngx_http_xslt2_finalize_with_error(r, 
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        cl->buf = ngx_pcalloc(xml_data->r->pool, sizeof(ngx_buf_t));
        if(cl->buf == NULL)     
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                                "[xml_apply_stylesheets] XML buffer allocation failed");
                return ngx_http_xslt2_finalize_with_error(r, 
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        cl->buf->pos = ngx_pcalloc(xml_data->r->pool, sizeof(u_char)*(len + 1));
        if(cl->buf->pos == NULL)        
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0, 
                                "[xml_apply_stylesheets] XML buffer content allocation failed");
                return ngx_http_xslt2_finalize_with_error(r, 
                                NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
        }

        ngx_cpystrn(cl->buf->pos, (u_char *) buf, len+1);

        cl->buf->last = cl->buf->pos + len;
        cl->buf->memory = 1;
        cl->buf->last_buf = cl->buf->last_in_chain = 1;

        xml_data->buffer_chain = cl;
        xml_data->res_len = len;

        xmlFree(buf);

        xml_data->done = 1;

        return ngx_http_xslt2_process_data(r);
}

static void
ngx_http_xslt2_xml_stylesheet_node(ngx_http_xslt2_xml_data_t *xml_data, const xmlChar *pidata)
{
        ngx_http_xslt2_sheet_t          *sheet;
        ngx_http_request_t                      *r;

        const xmlChar                           *uri;
        const xmlChar                           *uri_end;
        u_char                                          *res;

        r = xml_data->r;

        // uri
        if((uri = xmlStrstr(pidata, (xmlChar *)"href=\"")) == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0,
                         "[xml_stylesheet_node] style sheet loading failed");
                ngx_http_xslt2_xml_stylesheet_error(xml_data, "No href attribute in style sheet declaration");
                return;
        };
        uri += 6; // without href="

        if((uri_end = xmlStrchr(uri, (xmlChar)'\"')) == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0,
                         "[xml_stylesheet_node] Style sheet loading failed");
                ngx_http_xslt2_xml_stylesheet_error(xml_data, "Broken href attribute in style sheet declaration");
                return;
        };

        sheet = ngx_http_xslt2_xml_create_new_stylesheet(xml_data);

        if(sheet == NULL)
        {
                ngx_log_error(NGX_LOG_ERR, xml_data->r->connection->log, 0,
                         "[xml_stylesheet_node] Style sheet loading failed");
                ngx_http_xslt2_xml_stylesheet_error(xml_data, NULL);
                return;
        }

        res = ngx_pcalloc(xml_data->r->pool, sizeof(u_char)*(uri_end - uri + 1));
        ngx_cpystrn(res, (u_char *) uri, uri_end - uri + 1);

        sheet->res_uri = res;

        ngx_http_xslt2_xml_get_stylesheet(sheet, XXSLT_USE_CACHE);
}

static void
ngx_http_xslt2_xml_stylesheet_error(ngx_http_xslt2_xml_data_t *xml_data, char *msg, ...)
{
        va_list                                         args;
        u_char                                          err_msg[NGX_MAX_ERROR_STR];
        ngx_int_t                                       n;

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0,
           "[xml_stylesheet_error] stylesheet error");

        xml_data->stylesheet_err = NGX_HTTP_INTERNAL_SERVER_ERROR;

        if(msg == NULL)
        {
                return;
        }

        err_msg[0] = '\0';
        va_start(args, msg);
        n = (size_t) vsnprintf((char *) err_msg, NGX_MAX_ERROR_STR, msg, args);
        va_end(args);
        err_msg[n] = '\0';

        xml_data->stylesheet_err_msg = ngx_pcalloc(xml_data->r->pool, sizeof(u_char)*(n+1));

        if(xml_data->stylesheet_err_msg == NULL)
        {
                return;
        }

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, xml_data->r->connection->log, 0,
           "[xml_stylesheet_error] finished");

        xml_data->stylesheet_err = NGX_ERROR;
        ngx_cpystrn(xml_data->stylesheet_err_msg, err_msg, n+1);
}
// ============================== SAX HANDLERS =================================

static void
ngx_http_xslt2_xml_sax_processing_instruction(void *data, const xmlChar *target,
        const xmlChar *pidata)
{
        ngx_http_xslt2_xml_data_t               *xml_data = data;

        if(xmlStrcmp(target, (xmlChar *) "xml-stylesheet") == 0) {
                ngx_http_xslt2_xml_stylesheet_node(xml_data, pidata);
                return;
        }

        xml_data->sax->processingInstruction(xml_data->ctxt, target, pidata);
}

static void
ngx_http_xslt2_xml_sax_start_document(void *data)
{
        ngx_http_xslt2_xml_data_t               *xml_data = data;

        xml_data->sax->startDocument(xml_data->ctxt);
}

static void
ngx_http_xslt2_xml_sax_end_document(void *data)
{
        ngx_http_xslt2_xml_data_t               *xml_data = data;

        xml_data->sax->endDocument(xml_data->ctxt);
}

static void
ngx_http_xslt2_xml_sax_internal_subset(void *data, const xmlChar *name,
        const xmlChar *externalId, const xmlChar *systemId)
{
        ngx_http_xslt2_xml_data_t               *xml_data = data;

        xml_data->sax->internalSubset(xml_data->ctxt, name, externalId, systemId);
}

static void
ngx_http_xslt2_xml_sax_external_subset(void *data, const xmlChar *name,
        const xmlChar *externalId, const xmlChar *systemId)
{
        //TODO: external subset handling
}

static void
ngx_http_xslt2_xml_sax_entity_decl(void *data, const xmlChar *name, int type,
        const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;


        xml_data->sax->entityDecl(xml_data->ctxt, name, type, publicId, systemId, content);
}

static void
ngx_http_xslt2_xml_sax_attribute_decl(void *data, const xmlChar *elem,
        const xmlChar *fullname, int type, int def, const xmlChar *defaultValue,
        xmlEnumerationPtr tree)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;


        xml_data->sax->attributeDecl(xml_data->ctxt, elem, fullname, type, def, defaultValue,
                                                        tree);
}

static void
ngx_http_xslt2_xml_sax_element_decl(void *data, const xmlChar * name, int type,
        xmlElementContentPtr content)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->elementDecl(xml_data->ctxt, name, type, content);
}

static void
ngx_http_xslt2_xml_sax_notation_decl(void *data, const xmlChar *name,
        const xmlChar *publicId, const xmlChar *systemId)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->notationDecl(xml_data->ctxt, name, publicId, systemId);
}

static void
ngx_http_xslt2_xml_sax_unparsed_entity_decl(void *data, const xmlChar *name,
        const xmlChar *publicId, const xmlChar *systemId,
        const xmlChar *notationName)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->unparsedEntityDecl(xml_data->ctxt, name, publicId, systemId,
                                                                 notationName);
}

static void
ngx_http_xslt2_xml_sax_start_element(void *data, const xmlChar *localname,
        const xmlChar *prefix, const xmlChar *URI, int nb_namespaces,
        const xmlChar **namespaces, int nb_attributes, int nb_defaulted,
        const xmlChar **attributes)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;


        xml_data->sax->startElementNs(xml_data->ctxt, localname, prefix, URI, nb_namespaces,
                namespaces, nb_attributes, nb_defaulted, attributes);
}

static void
ngx_http_xslt2_xml_sax_end_element(void *data,
        const xmlChar * localname ATTRIBUTE_UNUSED,
        const xmlChar * prefix ATTRIBUTE_UNUSED,
        const xmlChar * URI ATTRIBUTE_UNUSED)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->endElementNs(xml_data->ctxt, localname, prefix, URI);
}

static void
ngx_http_xslt2_xml_sax_characters(void *data, const xmlChar *p, int len)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->characters(xml_data->ctxt, p, len);
}

static void
ngx_http_xslt2_xml_sax_cdata_block(void *data, const xmlChar *p, int len)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->cdataBlock(xml_data->ctxt, p, len);
}

static xmlEntityPtr
ngx_http_xslt2_xml_sax_get_entity(void *data, const xmlChar *name)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;
        

        return xml_data->sax->getEntity(xml_data->ctxt, name);
}

static xmlEntityPtr
ngx_http_xslt2_xml_sax_get_parameter_entity(void *data, const xmlChar *name)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;


        return xml_data->sax->getParameterEntity(xml_data->ctxt, name);
}

static xmlParserInputPtr
ngx_http_xslt2_xml_sax_resolve_entity(void *data, const xmlChar *publicId,
        const xmlChar *systemId)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        return xml_data->sax->resolveEntity(xml_data->ctxt, publicId, systemId);
}

static void
ngx_http_xslt2_xml_sax_reference(void *data, const xmlChar *name)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->reference(xml_data->ctxt, name);
}

static void
ngx_http_xslt2_xml_sax_comment(void *data, const xmlChar *value)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        xml_data->sax->comment(xml_data->ctxt, value);
}

static int
ngx_http_xslt2_xml_sax_is_standalone(void *data)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        return xml_data->sax->isStandalone(xml_data->ctxt);
}

static int
ngx_http_xslt2_xml_sax_has_internal_subset(void *data)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        return xml_data->sax->hasInternalSubset(xml_data->ctxt);
}

static int
ngx_http_xslt2_xml_sax_has_external_subset(void *data)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        return xml_data->sax->hasExternalSubset(xml_data->ctxt);
}

static void ngx_cdecl
ngx_http_xslt2_xml_sax_error(void *data, const char *msg, ...)
{
        ngx_http_xslt2_xml_data_t *xml_data = data;

        size_t  n;
        va_list   args;
        u_char  buf[NGX_MAX_ERROR_STR];

        buf[0] = '\0';

        va_start(args, msg);
        n = (size_t) vsnprintf((char *) buf, NGX_MAX_ERROR_STR, msg, args);
        va_end(args);

        while (--n && (buf[n] == CR || buf[n] == LF)) { /* void */ }

        xml_data->libxml_error = (char *) buf;
}
// =============================================================================

---