src/http/modules/xxslt/ngx_http_xxslt_selector.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:
 * Przemyslaw Gajda, email: quermit(malpa)gmail.com
 * Piotr Janik, email: janik.piotrek(malpa)gmail.com
 *                                                                       malpa = @
 */

#include "ngx_http_xxslt_selector.h"

static ngx_int_t
ngx_http_xxslt_selector_unknown_match(ngx_http_xxslt_selector_data_t *ctx,
                ngx_chain_t *ch_beg, ngx_chain_t *ch_end,
                u_char *beg, u_char *end, ngx_int_t last_in_chain);
static ngx_int_t
ngx_http_xxslt_selector_parse_match(ngx_http_xxslt_selector_data_t *ctx,
                ngx_chain_t *ch_beg, ngx_chain_t *ch_end,
                u_char *beg, u_char *end, ngx_int_t last_in_chain);
static ngx_int_t
ngx_http_xxslt_selector_add_unknown(ngx_http_request_t *r, ngx_chain_t *in, ngx_http_xxslt_out_data_t *out);
static ngx_int_t
ngx_http_xxslt_selector_add_parse(ngx_http_request_t *r, ngx_chain_t *in, ngx_http_xxslt_out_data_t *out, 
ngx_http_xxslt_selector_data_t *sel_ctx);
static ngx_chain_t*
ngx_http_xxslt_selector_prepare_in(ngx_http_request_t *r, ngx_chain_t *ch_beg, ngx_chain_t *ch_end,
                        u_char *buf_beg, u_char *buf_end, ngx_int_t last_in_chain);
static void
ngx_http_xxslt_selector_set_pos(ngx_http_request_t *r, ngx_chain_t *in);

//==========

ngx_http_xxslt_selector_data_t *
ngx_http_xxslt_selector_init(ngx_http_request_t *r)
{
        ngx_http_xxslt_selector_data_t                  *ctx;


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

        
        ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_xxslt_selector_data_t));
        if( ctx == NULL ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_init] alloc fail.");
                return NULL;
        }

        ctx->id_data                             = 1;
        ctx->act_out_data_unknown       = NULL;
        ctx->act_out_data_parse         = NULL;
        ctx->r = r;

        // structure required to parse data (state matcher)
        ctx->match_data                         = ngx_pcalloc(r->pool, sizeof(ngx_http_xxslt_selector_match_t));
        if( ctx->match_data == NULL ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_init] alloc fail");
                return NULL;
        }

        ctx->match_data->state = NGX_HTTP_XXSLT_MATCH_OPEN;
        ctx->select_mode = NGX_HTTP_XXSLT_SELECTOR_UNKNOWN;
        ctx->match_data->open = (u_char*)"<xxslt>";
        ctx->match_data->o_len = strlen((char*)ctx->match_data->open);
        ctx->match_data->close = (u_char*)"</xxslt>";
        ctx->match_data->c_len = strlen((char*)ctx->match_data->close);

        ctx->backup_in = NULL;

        ctx->includes = xmlNewDoc((xmlChar *)"1.0");
        ctx->includes->children = xmlNewDocNode(ctx->includes, NULL, (xmlChar *)"inc", NULL);

        return ctx;
}

ngx_int_t
ngx_http_xxslt_selector_add_data_chunk(ngx_http_xxslt_selector_data_t *ctx, ngx_chain_t *in)
{
        ngx_http_xxslt_selector_match_t         *match;
        ngx_http_request_t                                      *r;
        ngx_int_t                                                       rc;
        ngx_chain_t                                                     *ch, *cl_end;
        ngx_buf_t                                                       *b;
        u_char                                                          *c;

        u_char                                                          *buf_last;
        ngx_chain_t                                                     *ch_last;

        ngx_int_t                                                       is_last_buf;


        r = ctx->r;
        match = ctx->match_data;

        if( in == NULL ) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                "[selector_add_data_chunk] in is null.");
                return NGX_ERROR;
        }

        // sometimes parser can't process all data and store it here to next call
        if( ctx->backup_in ) {
                ctx->backup_in->next = in;
                in = ctx->backup_in;
                ctx->backup_in = NULL;
        }

        ch = ch_last = in;
        if( ch->buf && ch->buf->last - ch->buf->pos > 0 ) {
                buf_last = ch->buf->pos;
        }
        else {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_add_data_chunk] null or empty buf");
                return NGX_ERROR;
        }

        is_last_buf = 0;
        while( ch ) { // search for a specific tag, distribution of data / xslt
                cl_end = ch;
                b = ch->buf;
                if( b == NULL || b->last - b->pos == 0 ) {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_add_data_chunk] null or empty buf");
                        return NGX_ERROR;
                }

                is_last_buf = is_last_buf || b->last_buf;

                // for each buffer
                for(c=b->pos; c<b->last; c++) {
                        if( match->state == NGX_HTTP_XXSLT_MATCH_OPEN && ctx->select_mode == NGX_HTTP_XXSLT_SELECTOR_UNKNOWN ) {
                                if( match->open[match->o_pos] == *c ) {
                                        match->o_pos++;
                                }
                                else {
                                        if( match->open[0] == *c ) {
                                                match->o_pos = 1;
                                        }
                                        else {
                                                match->o_pos = 0;
                                        }
                                }
                                if( match->o_pos == 0 ) {
                                        match->cl_before = ch;
                                        match->buf_before = c;
                                }

                                if( match->o_pos == match->o_len ) { // found the opening tag
                                        match->o_pos = 0;
                                        match->state = NGX_HTTP_XXSLT_MATCH_CLOSE;
                                        ctx->select_mode = NGX_HTTP_XXSLT_SELECTOR_PARSE;

                                        if( match->cl_before && match->buf_before ) {
                                                rc = ngx_http_xxslt_selector_unknown_match(ctx, ch_last, match->cl_before, buf_last, match->buf_before, 1/*last_in_chane*/);
                                                if(rc == NGX_ERROR)
                                                {
                                                        return NGX_ERROR;
                                                }
                                                match->cl_before = NULL;
                                                match->buf_before = NULL;
                                        }
                                        ch_last = ch;
                                        buf_last = c+1;
                                        if( ch_last->buf->last <= buf_last ) {
                                                ch_last = ch_last->next;
                                                if( ch_last ) {
                                                        buf_last = ch_last->buf->pos;
                                                }
                                        }
                                }
                        }
                        else if( match->state == NGX_HTTP_XXSLT_MATCH_CLOSE && ctx->select_mode == NGX_HTTP_XXSLT_SELECTOR_PARSE ) {
                                if( match->close[match->c_pos] == *c ) {
                                        match->c_pos++;
                                }
                                else {
                                        if( match->close[0] == *c ) {
                                                match->c_pos = 1;
                                        }
                                        else {
                                                match->c_pos = 0;
                                        }
                                }
                                if( match->c_pos == 0 ) {
                                        match->cl_before = ch;
                                        match->buf_before = c;
                                }

                                if( match->c_pos == match->c_len ) { // found the closing tag
                                        match->c_pos = 0;
                                        match->state = NGX_HTTP_XXSLT_MATCH_OPEN;
                                        ctx->select_mode = NGX_HTTP_XXSLT_SELECTOR_UNKNOWN;

                                        if( match->cl_before && match->buf_before ) {
                                                rc = ngx_http_xxslt_selector_parse_match(ctx, ch_last, match->cl_before, buf_last, match->buf_before, 1/*last_in_chane*/);
                                                if(rc == NGX_ERROR)
                                                {
                                                        return NGX_ERROR;
                                                }
                                                match->cl_before = NULL;
                                                match->buf_before = NULL;
                                        }
                                        ch_last = ch;
                                        buf_last = c+1;
                                        if( ch_last->buf->last <= buf_last ) {
                                                ch_last = ch_last->next;
                                                if( ch_last ) {
                                                        buf_last = ch_last->buf->pos;
                                                }
                                        }
                                }

                        }
                        else {
                                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                        "[selector_add_data_chunk] bad matcher state or mode :: %d %d ", match->state, ctx->select_mode );
                                return NGX_ERROR;
                        }
                }

                ch = ch->next;
        }

        // all data processed
        if( ch_last == NULL ) {
                if( is_last_buf ) {
                        if( ctx->act_out_data_parse ) {
                                ctx->act_out_data_parse->last = 1;
                        }
                        if( ctx->act_out_data_unknown ) {
                                ctx->act_out_data_unknown->last = 1;
                        }
                }

                if( is_last_buf ) {
                        ngx_http_xxslt_process_data(r);
                }

                ngx_http_xxslt_selector_set_pos(r, in);
                return NGX_OK;
        }

        if( match->state == NGX_HTTP_XXSLT_MATCH_OPEN && ctx->select_mode == NGX_HTTP_XXSLT_SELECTOR_UNKNOWN ) {

                // storing data chunk from last buffer, ex. <par...
                c = cl_end->buf->last - 1;
                if( match->o_pos > 0 && !is_last_buf ) {
                        c = c - match->o_pos;
                        ctx->backup_in = ngx_http_xxslt_selector_prepare_in(r, cl_end, cl_end, c+1, cl_end->buf->last-1, 0);
                        if( ctx->backup_in == NULL ) {
                                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                                "[selector_add_data_chunk] ngx_http_xxslt_selector_prepare_in error.");
                                return NGX_ERROR;
                        }
                }
                match->o_pos = 0;

                match->cl_before = NULL;
                match->buf_before = NULL;
                rc = ngx_http_xxslt_selector_unknown_match(ctx, ch_last, cl_end, buf_last, c, is_last_buf);
                
                if( ctx->act_out_data_unknown ) {
                        ctx->act_out_data_unknown->last = is_last_buf;
                }
        }
        else if( match->state == NGX_HTTP_XXSLT_MATCH_CLOSE && ctx->select_mode == NGX_HTTP_XXSLT_SELECTOR_PARSE ) { //NGX_HTTP_XXSLT_MATCH_CLOSE

                // storing data chunk from last buffer, ex. <par...
                c = cl_end->buf->last - 1;
                if( match->c_pos > 0 && !is_last_buf ) {
                        c = c - match->c_pos;
                        ctx->backup_in = ngx_http_xxslt_selector_prepare_in(r, cl_end, cl_end, c+1, cl_end->buf->last-1, 0);
                        if( ctx->backup_in == NULL ) {
                                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                                "[selector_add_data_chunk] ngx_http_xxslt_selector_prepare_in error.");
                                return NGX_ERROR;
                        }
                }
                match->c_pos = 0;

                match->cl_before = NULL;
                match->buf_before = NULL;
                rc = ngx_http_xxslt_selector_parse_match(ctx, ch_last, cl_end, buf_last, c, is_last_buf);

                if( ctx->act_out_data_parse ) {
                        ctx->act_out_data_parse->last = is_last_buf;
                }
        }
        else {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_add_data_chunk] bad matcher state or mode.");

                rc = NGX_ERROR;
        }

        if( is_last_buf ) {
                ngx_http_xxslt_process_data(r);
        }

        ngx_http_xxslt_selector_set_pos(r, in);
        return rc;
}

void
ngx_http_xxslt_selector_log_chain(ngx_http_request_t *r, ngx_chain_t *cl, u_char *label)
{
        u_char                          *c;
        ngx_int_t                       len;

        while( cl ) {
                len = cl->buf->last - cl->buf->pos;
                c = ngx_pcalloc(r->pool, len+1);

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

                ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                "%s: %s", label, c);

                cl = cl->next;
        }
}

static ngx_int_t
ngx_http_xxslt_selector_unknown_match(ngx_http_xxslt_selector_data_t *ctx,
                ngx_chain_t *ch_beg, ngx_chain_t *ch_end,
                u_char *beg, u_char *end, ngx_int_t last_in_chain)
{
        ngx_chain_t                                             *cl;
        ngx_http_xxslt_out_data_t               *out;
        ngx_int_t                                               rc;
        ngx_http_request_t                              *r;

        r = ctx->r;

        // copy buffers
        cl = ngx_http_xxslt_selector_prepare_in(r, ch_beg, ch_end, beg, end, last_in_chain);
        if( cl == NULL ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_unknown_match] ngx_http_xxslt_selector_prepare_in error.");
                return NGX_ERROR;
        }

        // get actual module structure
        ctx->act_out_data_parse = NULL;
        out = ctx->act_out_data_unknown;
        if( out == NULL ) {
                out = ngx_pcalloc(r->pool, sizeof(ngx_http_xxslt_out_data_t));
                if( out == NULL ) {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                        "[selector_unknown_match] ngx_http_xxslt_out_data_t allocation fail.");
                        return NGX_ERROR;
                }

                out->id = ctx->id_data++;
                out->r = ctx->r;
                out->data_type = NGX_HTTP_XXSLT_SELECTOR_UNKNOWN;

                ngx_http_xxslt_enqueue_data(out);
        }
        ctx->act_out_data_unknown = out;

        // forward data
        rc = ngx_http_xxslt_selector_add_unknown(r, cl, out);

        if( rc == NGX_ERROR ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_unknown_match] ngx_http_xxslt_selector_add_unknown error.");
                return NGX_ERROR;
        }

        return NGX_OK;
}

static ngx_int_t
ngx_http_xxslt_selector_parse_match(ngx_http_xxslt_selector_data_t *ctx,
                ngx_chain_t *ch_beg, ngx_chain_t *ch_end,
                u_char *beg, u_char *end, ngx_int_t last_in_chain)
{
        ngx_chain_t                                             *cl;
        ngx_http_xxslt_out_data_t               *out;
        ngx_int_t                                               rc;
        ngx_http_request_t                              *r;

        r = ctx->r;

        // copy buffers
        cl = ngx_http_xxslt_selector_prepare_in(r, ch_beg, ch_end, beg, end, last_in_chain);
        if( cl == NULL ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_parse_match] ngx_http_xxslt_selector_prepare_in error.");
                return NGX_ERROR;
        }

        // get actual module data
        ctx->act_out_data_unknown = NULL;
        out = ctx->act_out_data_parse;
        if( out == NULL ) {
                out = ngx_pcalloc(r->pool, sizeof(ngx_http_xxslt_out_data_t));
                if( out == NULL ) {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                        "[selector_parse_match] alloc fail.");
                        return NGX_ERROR;
                }

                out->id = ctx->id_data++;
                out->r = ctx->r;
                out->data_type = NGX_HTTP_XXSLT_SELECTOR_PARSE;

                ngx_http_xxslt_enqueue_data(out);
        }
        ctx->act_out_data_parse = out;

        // forward data
        rc = ngx_http_xxslt_selector_add_parse(r, cl, out, ctx);
        if( rc == NGX_ERROR ) {

                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_parse_match] ngx_http_xxslt_selector_add_parse error.");
                return NGX_ERROR;
        }

        if( rc == NGX_DONE ) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                                "selector async mode on");
                ctx->async = 1;
        }

        return NGX_OK;
}

static ngx_chain_t*
ngx_http_xxslt_selector_prepare_in(ngx_http_request_t *r, ngx_chain_t *ch_beg, ngx_chain_t *ch_end,
                        u_char *buf_beg, u_char *buf_end, ngx_int_t last_in_chain)
{
        if( !ch_beg || !ch_end || !buf_beg || !buf_end ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_prepare_in] null pointer.");
                return NULL;
        }

        if( ch_beg == ch_end && buf_beg > buf_end ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_prepare_in] no data.");
                return NULL;
        }

        ngx_chain_t      *cl, *cl_aloc, *res, *res_tail;
        ngx_int_t                len;
        u_char                  *beg;

        res = res_tail = NULL;
        cl = ch_beg;
        while( 1 ) {
                cl_aloc = ngx_pcalloc(r->pool, sizeof(ngx_chain_t));
                if( cl_aloc == NULL ) {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                        "[selector_prepare_in] chain allocation fail.");
                        return NULL;
                }
                cl_aloc->next = NULL;

                if( ch_beg == ch_end ) {
                        len = buf_end - buf_beg + 1;
                        beg = buf_beg;
                }
                else if( cl == ch_beg ) {
                        len = cl->buf->last - buf_beg + 1;
                        beg = buf_beg;
                }
                else if( cl == ch_end ) {
                        len = buf_end - cl->buf->pos + 1;
                        beg = cl->buf->pos;
                }
                else {
                        len = cl->buf->last - cl->buf->pos + 1;
                        beg = cl->buf->pos;
                }

                cl_aloc->buf = ngx_create_temp_buf(r->pool, len);
                if( cl_aloc->buf == NULL ) {
                        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                        "[selector_prepare_in] buffer allocation fail.");
                        return NULL;
                }
                ngx_memcpy(cl_aloc->buf->start, beg, len);
                cl_aloc->buf->last = cl_aloc->buf->pos + len;

                if( res == NULL ) {
                        res = res_tail = cl_aloc;
                }
                else {
                        res_tail->next = cl_aloc;
                        res_tail = cl_aloc;
                }

                if( cl == ch_end )
                        break;
                cl = cl->next;
        }

        res_tail->buf->last_in_chain = last_in_chain;

        return res;
}

static ngx_int_t
ngx_http_xxslt_selector_add_unknown(ngx_http_request_t *r, ngx_chain_t *in,
                ngx_http_xxslt_out_data_t *out)
{
        if( out->unknown == NULL ) {
                out->unknown = ngx_http_xxslt_unknown_create_new(r);
           out->unknown->id = out->id;
                out->unknown->r = r;
        }

        if( out->unknown == NULL ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_add_unknown] ngx_http_xxslt_unknown_create_new fail.");
                return NGX_ERROR;
        }

        return ngx_http_xxslt_unknown_add_data_chunk(out->unknown, in);
}

static ngx_int_t
ngx_http_xxslt_selector_add_parse(ngx_http_request_t *r, ngx_chain_t *in,
                ngx_http_xxslt_out_data_t *out, ngx_http_xxslt_selector_data_t *sel_ctx)
{
        if( out->parse == NULL ) {
                out->parse = ngx_http_xxslt_parse_create_new(r);
                out->parse->id = out->id;
                out->parse->r = r;
        
                out->parse->includes = sel_ctx->includes;
        }

        if( out->parse == NULL ) {
                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                                "[selector_add_parse] ngx_http_xxslt_parse_create_new fail.");
                return NGX_ERROR;
        }


        return ngx_http_xxslt_parse_add_data_chunk(out->parse, in);
}

static void
ngx_http_xxslt_selector_set_pos(ngx_http_request_t *r, ngx_chain_t *in) 
{
        while(in)
        {
                in->buf->pos = in->buf->last;
                in = in->next;
        }
}

void
ngx_http_xxslt_selector_cleanup(ngx_http_xxslt_selector_data_t *sel_ctx)
{
        if(sel_ctx->includes != NULL)
        {
                xmlFreeDoc(sel_ctx->includes);
                sel_ctx->includes = NULL;
        }
}

---