Release-1.4.10-patches: lighttpd-1.4.10-mod_extforward.c

#include <ctype.h>
#include <stdlib.h>
#include <string.h>

#include "base.h"
#include "log.h"
#include "buffer.h"

#include "plugin.h"

#include "inet_ntop_cache.h"
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

/**
 * mod_extforward.c for lighttpd, by comman.kang <at> gmail <dot> com
 * FIXME: only support ipv4 
 *
 * Config example:
 *
 *       Trust proxy 10.0.0.232 and 10.0.0.232 
 *       extforward.forwarder = ( "10.0.0.232" => "trust",
 *                                "10.0.0.233" => "trust" )
 * 
 *       Trust all proxies  (NOT RECOMMENDED!)
 *       extforward.forwarder = ( "all" => "trust")
 *
 * Note: In order to see the "real" ip address in access log , 
 *       you'll have to load mod_extforward after mod_accesslog. 
 *       like this: 
 *
 *       server.modules  = (
 *              .....
 *              mod_accesslog,
 *              mod_extforward
 *       )          
 * 
 * Known issues:
 *      seems causing segfault with mod_ssl and $HTTP{"socket"} directives
 *
 * ChangeLog: 
 *     2005.12.19   Initial Version
 *     2005.12.19   fixed conflict with conditional directives 
 */


/* plugin config for all request/connections */

typedef struct {
        array *forwarder;
} plugin_config;

typedef struct {
        PLUGIN_DATA;
        
        plugin_config **config_storage;
        
        plugin_config conf; 
} plugin_data;


/* context , used for restore remote ip */

typedef struct {
        sock_addr saved_remote_addr;
} handler_ctx;


static handler_ctx * handler_ctx_init(sock_addr oldaddr) {
        handler_ctx * hctx;
        hctx = calloc(1, sizeof(*hctx));
        hctx->saved_remote_addr = oldaddr;
        return hctx;
}

static void handler_ctx_free(handler_ctx *hctx) {
        free(hctx);
}

/* init the plugin data */
INIT_FUNC(mod_extforward_init) {
        plugin_data *p;
        p = calloc(1, sizeof(*p));
        return p;
}

/* detroy the plugin data */
FREE_FUNC(mod_extforward_free) {
        plugin_data *p = p_d;
        
        UNUSED(srv);

        if (!p) return HANDLER_GO_ON;
        
        if (p->config_storage) {
                size_t i;

                for (i = 0; i < srv->config_context->used; i++) {
                        plugin_config *s = p->config_storage[i];

                        if (!s) continue;
                        
                        array_free(s->forwarder);
                        
                        free(s);
                }
                free(p->config_storage);
        }
        
        
        free(p);
        
        return HANDLER_GO_ON;
}

/* handle plugin config and check values */

SETDEFAULTS_FUNC(mod_extforward_set_defaults) {
        plugin_data *p = p_d;
        size_t i = 0;
        
        config_values_t cv[] = { 
                { "extforward.forwarder",             NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
                { NULL,                         NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
        };
        
        if (!p) return HANDLER_ERROR;
        
        p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
        
        for (i = 0; i < srv->config_context->used; i++) {
                plugin_config *s;
                
                s = calloc(1, sizeof(plugin_config));
                s->forwarder    = array_init();
                
                cv[0].destination = s->forwarder;
                
                p->config_storage[i] = s;
        
                if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
                        return HANDLER_ERROR;
                }
        }
        
        return HANDLER_GO_ON;
}

#define PATCH(x) \
        p->conf.x = s->x;
static int mod_extforward_patch_connection(server *srv, connection *con, plugin_data *p) {
        size_t i, j;
        plugin_config *s = p->config_storage[0];
        
        PATCH(forwarder);
        
        /* skip the first, the global context */
        for (i = 1; i < srv->config_context->used; i++) {
                data_config *dc = (data_config *)srv->config_context->data[i];
                s = p->config_storage[i];
                
                /* condition didn't match */
                if (!config_check_cond(srv, con, dc)) continue;
                
                /* merge config */
                for (j = 0; j < dc->value->used; j++) {
                        data_unset *du = dc->value->data[j];
                        
                        if (buffer_is_equal_string(du->key, CONST_STR_LEN("extforward.forwarder"))) {
                                PATCH(forwarder);
                        }
                }
        }
        
        return 0;
}
#undef PATCH


static void put_string_into_array_len(array *ary, const char *str, int len)
{
        data_string *tempdata;
        if (len == 0)
                return;
        tempdata = data_string_init();
        buffer_copy_string_len(tempdata->value,str,len);
        array_insert_unique(ary,(data_unset *)tempdata);
}
/* 
   extract an forward array from the environment
*/
static array *extract_forward_array(buffer *pbuffer)
{
        array *result = array_init();
        if (pbuffer->used > 0) {
                char *base, *curr;
                /* state variable, 0 means not in string, 1 means in string */
                int in_str = 0;
                for (base = pbuffer->ptr, curr = pbuffer->ptr; *curr; curr++)
                {
                        if (in_str) {
                                if (*curr > '9' || ( *curr < '0'  && *curr != '.' ) ) {
                                        /* found an separator , insert value into result array */
                                        put_string_into_array_len(result, base, curr-base);
                                        /* change state to not in string */                                     
                                        in_str = 0;
                                }
                        } else {
                                if (*curr >= '0' && *curr <= '9')
                                {
                                        /* found leading char of an IP address, move base pointer change states */
                                        base = curr;
                                        in_str = 1;
                                }
                        }
                }
                /* if breaking out while in str, we get to the end of string, so add it */
                if (in_str) 
                {
                        put_string_into_array_len(result, base, curr-base);
                }
        }
        return result;
}

#define IP_TRUSTED 1
#define IP_UNTRUSTED 0
/*
   check whether ip is trusted, return 1 for trusted , 0 for untrusted
*/
static int is_proxy_trusted(const char *ipstr, plugin_data *p)
{
        data_string* allds = (data_string *) array_get_element(p->conf.forwarder,"all");
        if (allds) {
                if (strcasecmp(allds->value->ptr,"trust") == 0)
                        return IP_TRUSTED;
                else
                        return IP_UNTRUSTED;
        }
        return (data_string *)array_get_element(p->conf.forwarder,ipstr) ? IP_TRUSTED : IP_UNTRUSTED ;
}


URIHANDLER_FUNC(mod_extforward_uri_handler) {
        plugin_data *p = p_d;
        data_string *forwarded = NULL;
        UNUSED(srv);
        mod_extforward_patch_connection(srv, con, p);
        
        /* if the remote ip itself is not trusted , then do nothing */
        if (IP_UNTRUSTED == is_proxy_trusted (inet_ntoa(con->dst_addr.ipv4.sin_addr) ,p) )
                return HANDLER_GO_ON;
        
        /* log_error_write(srv, __FILE__, __LINE__,"s","remote address is trusted proxy, go on\n");*/
        if (con->request.headers && (
           (forwarded = (data_string *)array_get_element(con->request.headers,"X-Forwarded-For"))  ||
           (forwarded = (data_string *) array_get_element(con->request.headers,"Forwarded-For"))  ) 
           )
        {
                /* log_error_write(srv, __FILE__, __LINE__,"s","found forwarded header\n");*/
                /* found forwarded for header */
                int i;
                array *forward_array = extract_forward_array(forwarded->value);
                unsigned int real_remote_addr = 0xFFFFFFFF;
                for (i = forward_array->used -1 ;i>=0; i--)
                {
                        data_string *ds = (data_string *) forward_array->data[i];
                        if (ds) {
                                /* log_error_write(srv, __FILE__, __LINE__,"ss","forward",ds->value->ptr);*/
                                real_remote_addr = inet_addr(ds->value->ptr);
                                /* check whether it is trusted */
                                if (IP_UNTRUSTED == is_proxy_trusted(ds->value->ptr,p) )
                                        break;
                                /* log_error_write(srv, __FILE__, __LINE__,"ss",ds->value->ptr," is trusted");  */
                        }
                        else {
                                /* bug ?  bailing out here */
                                break;
                        }
                }
                if (real_remote_addr != 0xFFFFFFFF) /* parsed and inet_addr not returning -1 */
                {
                        /* log_error_write(srv, __FILE__, __LINE__,"ss","use forward",inet_ntoa(*((struct in_addr *)&real_remote_addr)));*/
                        /* we found the remote address, modify current connection and save the old address */
                        if (con->plugin_ctx[p->id]) {
                                log_error_write(srv, __FILE__, __LINE__,"patching an already patched connection!");
                                handler_ctx_free(con->plugin_ctx[p->id]);
                                con->plugin_ctx[p->id] = NULL;
                        }
                        /* save old address */
                        con->plugin_ctx[p->id] = handler_ctx_init(con->dst_addr);
                        /* patch connection address */
                        con->dst_addr.ipv4.sin_addr.s_addr = real_remote_addr;
                }
                array_free(forward_array);
        }
        
        /* not found */
        return HANDLER_GO_ON;
}

CONNECTION_FUNC(mod_extforward_restore) {
        plugin_data *p = p_d;
        UNUSED(srv);
        mod_extforward_patch_connection(srv, con, p);
        /* restore this connection 's remote ip */
        if (con->plugin_ctx[p->id]) {
                handler_ctx *hctx = con->plugin_ctx[p->id];
                con->dst_addr = hctx->saved_remote_addr;
                handler_ctx_free(hctx);
                con->plugin_ctx[p->id] = NULL;
        }
        return HANDLER_GO_ON;
}


/* this function is called at dlopen() time and inits the callbacks */

int mod_extforward_plugin_init(plugin *p) {
        p->version     = LIGHTTPD_VERSION_ID;
        p->name        = buffer_init_string("extforward");
        
        p->init        = mod_extforward_init;
        p->handle_uri_clean = mod_extforward_uri_handler;
        p->handle_request_done = mod_extforward_restore;
        p->connection_reset = mod_extforward_restore;
        p->set_defaults  = mod_extforward_set_defaults;
        p->cleanup     = mod_extforward_free;
        
        p->data        = NULL;
        
        return 0;
}