ngx_http_array_var_module.c

#define DDEBUG 1
#include "ddebug.h"

#include "ngx_http_array_var_util.h"

#include <ndk.h>


typedef struct {
    ngx_uint_t          nargs;

} ngx_http_array_split_data_t;

typedef struct {
    ngx_flag_t                       in_place;
    ngx_http_complex_value_t        *template;
    ngx_int_t                        array_it_index;

} ngx_http_array_map_data_t;

typedef struct {
    ngx_flag_t                       in_place;

} ngx_http_array_map_op_data_t;


static char * ngx_http_array_split(ngx_conf_t *cf, ngx_command_t *cmd,
        void *conf);

static char * ngx_http_array_map(ngx_conf_t *cf, ngx_command_t *cmd,
        void *conf);

static char * ngx_http_array_join_or_map_op(ngx_conf_t *cf, ngx_command_t *cmd,
        void *conf);

static ngx_int_t ngx_http_array_var_split(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v, void *data);

static ngx_int_t ngx_http_array_var_map(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v, void *data);

static ngx_int_t ngx_http_array_var_map_op(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v, void *data);

static ngx_int_t ngx_http_array_var_join(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v);


static ngx_command_t  ngx_http_array_var_commands[] = {
    {
        ngx_string ("array_split"),
        NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF
            |NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_2MORE,
        ngx_http_array_split,
        0,
        0,
        NULL
    },
    {
        ngx_string ("array_map"),
        NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF
            |NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE23,
        ngx_http_array_map,
        0,
        0,
        NULL
    },
    {
        ngx_string ("array_map_op"),
        NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF
            |NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE23,
        ngx_http_array_join_or_map_op,
        0,
        0,
        ngx_http_array_var_map_op
    },
    {
        ngx_string("array_join"),
        NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF
            |NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE23,
        ngx_http_array_join_or_map_op,
        0,
        0,
        ngx_http_array_var_join
    },

    ngx_null_command
};


static ngx_http_module_t  ngx_http_array_var_module_ctx = {
    NULL,                                  /* preconfiguration */
    NULL,                                  /* postconfiguration */

    NULL,                                  /* create main configuration */
    NULL,                                  /* init main configuration */

    NULL,                                  /* create server configuration */
    NULL,                                  /* merge server configuration */

    NULL,                                  /* create location configuration */
    NULL,                                  /* merge location configuration */
};


ngx_module_t  ngx_http_array_var_module = {
    NGX_MODULE_V1,
    &ngx_http_array_var_module_ctx,          // module context
    ngx_http_array_var_commands,             // module directives
    NGX_HTTP_MODULE,                         // module type
    NULL,                                    // init master
    NULL,                                    // init module
    NULL,                                    // init process
    NULL,                                    // init thread
    NULL,                                    // exit thread
    NULL,                                    // exit process
    NULL,                                    // exit master
    NGX_MODULE_V1_PADDING
};


static char *
ngx_http_array_split(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ndk_set_var_t                    filter;
    ngx_str_t                        target;
    ngx_str_t                       *value;
    ngx_str_t                       *bad_arg;
    ngx_http_array_split_data_t     *data = NULL;

    data = ngx_palloc(cf->pool, sizeof(ngx_http_array_split_data_t));
    if (data == NULL) {
        return NGX_CONF_ERROR;
    }

    filter.type = NDK_SET_VAR_MULTI_VALUE_DATA;
    filter.func = ngx_http_array_var_split;
    filter.data = data;

    value = cf->args->elts;

    if (cf->args->nelts == 2 + 1) {
        dd("array_split $sep $var");
        data->nargs = filter.size = 2;
        target = value[2];
        return ndk_set_var_multi_value_core(cf, &target, &value[1], &filter);
    }

    /* cf->args->nelts >= 3 + 1 */

    if (value[3].len >= sizeof("to=") - 1
            && ngx_str3cmp(value[3].data, 't', 'o', '='))
    {
        dd("array_split $sep $str to=$array");
        data->nargs = filter.size = 2;

        target.data = value[3].data + sizeof("to=") - 1;
        target.len = value[3].len - (sizeof("to=") - 1);
        dd("split target: %.*s", target.len, target.data);

        if (cf->args->nelts > 3 + 1) {
            bad_arg = &value[4];
            goto unexpected_arg;
        }

        return ndk_set_var_multi_value_core(cf, &target, &value[1], &filter);
    }

    /* the 3rd argument is max_items */

    if (cf->args->nelts > 4 + 1) {
        bad_arg = &value[5];
        goto unexpected_arg;
    }

    if (cf->args->nelts == 4 + 1) {
        /* array_split $sep $str $max to=$array */

        if (value[4].len < sizeof("to=") - 1
                || ! (ngx_str3cmp(value[4].data, 't', 'o', '=')))
        {
            ngx_conf_log_error(NGX_LOG_ERR, cf, 0,
                    "%V: expecting the \"to\" option at the "
                    "4th argument: \"%V\"",
                    &cmd->name, &value[4]);

            return NGX_CONF_ERROR;
        }

        data->nargs = filter.size = 3;

        target.data = value[4].data + sizeof("to=") - 1;
        target.len = value[4].len - (sizeof("to=") - 1);

        return ndk_set_var_multi_value_core(cf, &target, &value[1], &filter);
    }

    /* cf->args->nelts == 3 + 1 */

    /* array_split $sep $var $max */

    target = value[2];
    data->nargs = filter.size = 3;

    return ndk_set_var_multi_value_core(cf, &target, &value[1], &filter);

unexpected_arg:

    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
            "%V: unexpected argument \"%V\"",
            &cmd->name, bad_arg);

    return NGX_CONF_ERROR;
}


static char *
ngx_http_array_map(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ndk_set_var_t                       filter;
    ngx_str_t                           target;
    ngx_str_t                           *value;
    ngx_http_array_map_data_t           *data;
    ngx_http_compile_complex_value_t     ccv;

    data = ngx_palloc(cf->pool, sizeof(ngx_http_array_map_data_t));
    if (data == NULL) {
        return NGX_CONF_ERROR;
    }

    data->template = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
    if (data->template == NULL) {
        return NGX_CONF_ERROR;
    }

    value = cf->args->elts;

    if (value[1].len == 0) {
        ngx_memzero(data->template, sizeof(ngx_http_complex_value_t));

    } else {
        ccv.cf = cf;
        ccv.value = &value[1];
        ccv.complex_value = data->template;

        if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
            return NGX_CONF_ERROR;
        }
    }

    filter.type = NDK_SET_VAR_VALUE_DATA;
    filter.func = ngx_http_array_var_map;
    filter.data = data;
    filter.size = 1;

    if (cf->args->nelts == 2 + 1) {
        /* array_map $template $array */
        target = value[2];

    } else {
        /* cf->args->nelts == 3 + 1 */

        if (value[3].len < sizeof("to=") - 1
                || ! (ngx_str3cmp(value[3].data, 't', 'o', '=')))
        {
            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                    "%V: expecting the \"to\" option at "
                    "the 3rd argument: \"%V\"",
                    &cmd->name, &value[3]);
            return NGX_CONF_ERROR;
        }

        target.data = value[3].data + sizeof("to=") - 1;
        target.len = value[3].len - (sizeof("to=") - 1);
    }

    return ndk_set_var_value_core(cf, &target, &value[2], &filter);
}


static char *
ngx_http_array_join_or_map_op(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ndk_set_var_t                    filter;
    ngx_str_t                        target;
    ngx_str_t                       *value;
    ngx_str_t                       *bad_arg;

    filter.type = NDK_SET_VAR_MULTI_VALUE;
    filter.func = (ndk_set_var_value_pt) cmd->post;

    value = cf->args->elts;

    if (cf->args->nelts == 2 + 1) {
        dd("array_join $sep $var");

        filter.size = 2;
        target = value[2];

        dd("array join target: %.*s", target.len, target.data);

        return ndk_set_var_multi_value_core(cf, &target, &value[1], &filter);
    }

    /* cf->args->nelts == 3 + 1 */

    if (value[3].len >= sizeof("to=") - 1
            && ngx_str3cmp(value[3].data, 't', 'o', '='))
    {
        /* array_join $sep $str to=$array */
        filter.size = 2;

        target.data = value[3].data + sizeof("to=") - 1;
        target.len = value[3].len - (sizeof("to=") - 1);

        if (cf->args->nelts > 3 + 1) {
            bad_arg = &value[4];
        } else {
            return ndk_set_var_multi_value_core(cf, &target, &value[1],
                    &filter);
        }
    } else {
        bad_arg = &value[3];
    }

    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
            "%V: unexpected argument \"%V\"",
            &cmd->name, bad_arg);

    return NGX_CONF_ERROR;
}


static ngx_int_t
ngx_http_array_var_split(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v, void *data)
{
    ngx_http_array_split_data_t             *conf = data;
    ngx_http_variable_value_t               *sep, *str;
    ngx_str_t                               *s;
    u_char                                  *pos, *end, *last;
    ssize_t                                  max;
    ngx_array_t                             *array;

    if (conf->nargs == 3) {
        max = ngx_atosz(v[2].data, v[2].len);
        if (max == NGX_ERROR) {
            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                    "array_split: invalid max items: \"%V\"",
                    &v[2]);

            return NGX_ERROR;
        }
    } else {
        max = 0;
    }

    if (max) {
        array = ngx_array_create(r->pool, max,
                sizeof(ngx_str_t));
    } else {
        array = ngx_array_create(r->pool, 4,
                sizeof(ngx_str_t));
    }

    if (array == NULL) {
        return NGX_ERROR;
    }

    sep = &v[0];
    str = &v[1];

    pos = str->data;
    end = str->data + str->len;

    while ((last = ngx_http_array_var_strlstrn(pos, end, sep->data,
                    sep->len - 1)))
    {
        s = ngx_array_push(array);
        if (s == NULL) {
            return NGX_ERROR;
        }

        s->data = pos;
        s->len = last - pos;

        dd("split item %.*s", s->len, s->data);

        pos = last + sep->len;
    }

    dd("pos %p, last %p, end %p", pos, last, end);

    s = ngx_array_push(array);
    if (s == NULL) {
        return NGX_ERROR;
    }

    s->data = pos;
    s->len = end - pos;

    dd("split item %.*s", s->len, s->data);

    dd("split: array size: %d", array->nelts);
    dd("split array ptr: %p", array);

    res->data = (u_char *) array;
    res->len = sizeof(ngx_array_t);

    return NGX_OK;
}


static ngx_int_t
ngx_http_array_var_map(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v, void *data)
{
    ngx_http_array_map_data_t       *conf = data;
    ngx_http_variable_value_t       *array_it;
    ngx_uint_t                       i;
    ngx_str_t                       *value, *new_value;
    ngx_array_t                     *array, *new_array;

    if (conf->template == NULL) {
        return NGX_OK;
    }

    if (v[0].len != sizeof(ngx_array_t)) {
        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                "array_join: invalid array variable value in the 2nd "
                "argument: \"%.*s\"", &v[0]);

        return NGX_ERROR;
    }

    array = (ngx_array_t *) v[0].data;

    value = array->elts;

    array_it = ngx_http_get_indexed_variable(r, conf->array_it_index);

    if ( conf->in_place) {
        new_array = array;
    } else {
        new_array = ngx_array_create(r->pool, array->nelts,
                sizeof(ngx_str_t));
        if (new_array == NULL) {
            return NGX_ERROR;
        }
    }

    for (i = 0; i < array->nelts; i++) {
        array_it->data = value[i].data;
        array_it->len = value[i].len;

        if (conf->in_place) {
            new_value = &value[i];

        } else {
            new_value = ngx_array_push(new_array);
            if (new_value == NULL) {
                return NGX_ERROR;
            }
        }

        if (ngx_http_complex_value(r, conf->template, new_value) != NGX_OK) {
            return NGX_ERROR;
        }
    }

    res->data = (u_char *) new_array;
    res->len = sizeof(ngx_array_t);

    return NGX_OK;
}


static ngx_int_t
ngx_http_array_var_map_op(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v, void *data)
{
    ngx_http_variable_value_t            arg;
    ngx_http_array_map_op_data_t        *conf = data;
    ndk_set_var_value_pt                 func;
    ngx_int_t                            rc;
    ngx_uint_t                           i;
    ngx_str_t                           *value;
    ngx_str_t                           *new_value;
    ngx_array_t                         *array;
    ngx_array_t                         *new_array;

    func = ngx_http_array_var_get_func_from_cmd(v[0].data, v[0].len);

    if (func == NULL) {
        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                "array_map_op: directive \"%v\" not found "
                "or does not use ndk_set_var_value",
                &v[0]);

        return NGX_ERROR;
    }

    if (v[1].len != sizeof(ngx_array_t)) {
        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                "array_map_op: invalid array variable value in the 2nd "
                "argument: \"%.*s\"", &v[0]);

        return NGX_ERROR;
    }

    array = (ngx_array_t *) v[1].data;

    value = array->elts;

    if ( conf->in_place) {
        new_array = array;

    } else {
        new_array = ngx_array_create(r->pool, array->nelts,
                sizeof(ngx_str_t));
        if (new_array == NULL) {
            return NGX_ERROR;
        }
    }

    for (i = 0; i < array->nelts; i++) {
        arg.data = value[i].data;
        arg.len = value[i].len;

        if (conf->in_place) {
            new_value = &value[i];

        } else {
            new_value = ngx_array_push(new_array);
            if (new_value == NULL) {
                return NGX_ERROR;
            }
        }

        rc = func(r, new_value, &arg);
        if (rc != NGX_OK) {
            return NGX_ERROR;
        }
    }

    res->data = (u_char *) new_array;
    res->len = sizeof(ngx_array_t *);

    return NGX_OK;
}


static ngx_int_t
ngx_http_array_var_join(ngx_http_request_t *r,
        ngx_str_t *res, ngx_http_variable_value_t *v)
{
    ngx_http_variable_value_t           *sep;
    ngx_array_t                         *array;
    size_t                               len;
    ngx_str_t                           *value;
    ngx_uint_t                           i;
    u_char                              *p;

    sep = &v[0];

    dd("sep %.*s", sep->len, sep->data);

    if (v[1].len != sizeof(ngx_array_t)) {
        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                "array_join: invalid array variable value in the "
                "2nd argument: \"%V\"", &v[1]);

        return NGX_ERROR;
    }

    array = (ngx_array_t *) v[1].data;

    dd("join array ptr %p", array);
    dd("array->nelts: %d", array->nelts);

    if (array->nelts == 0) {
        res->data = NULL;
        res->len = 0;
        return NGX_OK;
    }

    value = array->elts;

    len = sep->len * (array->nelts - 1);

    for (i = 0; i < array->nelts; i++) {
        len += value[i].len;
    }

    dd("buf len %d", len);

    res->data = ngx_palloc(r->pool, len);
    if (res->data == NULL) {
        return NGX_ERROR;
    }

    res->len = len;

    p = res->data;

    for (i = 0; i < array->nelts; i++) {
        dd("copying elem of size %d", value[i].len);
        p = ngx_copy(p, value[i].data, value[i].len);
        if (i < array->nelts - 1) {
            p = ngx_copy(p, sep->data, sep->len);
        }
    }

    if (p != res->data + res->len) {
        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                "array_join: buffer error");

        return NGX_ERROR;
    }

    return NGX_OK;
}