Docs/ModUserOnline: mod_useronline.c

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

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

#include "plugin.h"
#include "inet_ntop_cache.h"

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

typedef struct {
        size_t  online_age;
        size_t  active_age;

        size_t  max_ips;
        size_t  id;
        int     enable;
        buffer **status_keynames;
} plugin_config;

typedef struct {
        unsigned int ipl;
        int hits;
        time_t last;
} user_data;

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


INIT_FUNC(mod_useronline_init) {
        plugin_data *p;
        
        p = calloc(1, sizeof(*p));
        return p;
}

#define NUM_STATUS_NAMES 6
FREE_FUNC(mod_useronline_free) {
        plugin_data *p = p_d;
        
        UNUSED(srv);

        if (!p) return HANDLER_GO_ON;
        
        if (p->config_storage) {
                size_t i, j;
                for (i = 0; i < srv->config_context->used; i++) {
                        plugin_config *s = p->config_storage[i];
                
                        free(p->ip_data[i]);
                        if (s->status_keynames) {
                                for (j=0; j<NUM_STATUS_NAMES; j++) {
                                        buffer_free(s->status_keynames[j]);
                                }
                        }
                        free(s);
                }
                free(p->config_storage);
                free(p->ip_data);
        }
        
        free(p);
        
        return HANDLER_GO_ON;
}

void status_counter_set_counter(server *srv, const char *s, int value) {
        data_integer *di;

        if (NULL == (di = (data_integer *)array_get_element(srv->status, s))) {
                /* not found, create it */

                if (NULL == (di = (data_integer *)array_get_unused_element(srv->status, TYPE_INTEGER))) {
                        di = data_integer_init();
                }
                buffer_copy_string(di->key, s);
                di->value = value;

                array_insert_unique(srv->status, (data_unset *)di);
        }
        di->value = value;
}

SETDEFAULTS_FUNC(mod_useronline_set_defaults) {
        plugin_data *p = p_d;
        size_t i = 0, j=0;
        
        config_values_t cv[] = { 
                { "useronline.online-age",      NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
                { "useronline.active-age",      NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
                { "useronline.max-ips",         NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
                { "useronline.enable",          NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 3 */
                { "useronline.status-name",     NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 4 */
                
                { NULL,                        NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
        };
        
        if (!p) return HANDLER_ERROR;
        
        /* 0 */
        p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
        p->ip_data = calloc(1, srv->config_context->used * sizeof(user_data *));
        
        for (i = 0; i < srv->config_context->used; i++) {
                plugin_config *s;
                buffer *status_name;

                s = calloc(1, sizeof(plugin_config));
                s->online_age   = 300;
                s->active_age   = 0;
                s->max_ips      = 1024;
                s->id           = i;
                s->enable       = 0;
                status_name=buffer_init();              
                
                cv[0].destination = &(s->online_age);
                cv[1].destination = &(s->active_age);
                cv[2].destination = &(s->max_ips);
                cv[3].destination = &(s->enable);
                cv[4].destination = status_name;
                
                p->config_storage[i] = s;
        
                if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
                        return HANDLER_ERROR;
                }

                if (s->enable) {
                        if (s->active_age==0) s->active_age = s->online_age/3;
                                
                        p->ip_data[i] = calloc(s->max_ips, sizeof(user_data));
                        p->ip_data[i][0].hits=-1;
                }
                /*not used? free the memory*/
                if (status_name->used==0 || !s->enable) {
                        buffer_free(status_name);
                } else {
                        s->status_keynames = calloc(NUM_STATUS_NAMES, sizeof(buffer*));
                        for (j=0; j<NUM_STATUS_NAMES; j++) {
                                s->status_keynames[j]=buffer_init_string("useronline.");
                                buffer_append_string    (s->status_keynames[j], status_name->ptr);
                                buffer_append_string    (s->status_keynames[j], ".");
                        }
                        buffer_free(status_name);
                        
                        buffer_append_string    (s->status_keynames[0], "id");
                        buffer_append_string    (s->status_keynames[1], "users-online");
                        buffer_append_string    (s->status_keynames[2], "users-active");
                        buffer_append_string    (s->status_keynames[3], "online-age");
                        buffer_append_string    (s->status_keynames[4], "active-age");
                        buffer_append_string    (s->status_keynames[5], "max-ips");
                        status_counter_set_counter(srv, s->status_keynames[0]->ptr, i);
                        status_counter_set_counter(srv, s->status_keynames[3]->ptr, s->online_age);
                        status_counter_set_counter(srv, s->status_keynames[4]->ptr, s->active_age);
                        status_counter_set_counter(srv, s->status_keynames[5]->ptr, s->max_ips);
                }
        }
        
        return HANDLER_GO_ON;
}
#undef NUM_STATUS_NAMES

#define PATCH() \
        p->conf = s;
static int mod_useronline_patch_connection(server *srv, connection *con, plugin_data *p) {
        size_t i;
        plugin_config *s = p->config_storage[0];

        PATCH();
        
        /* 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;
                
                PATCH();
        }
        
        return 0;
}
#undef PATCH

static void mod_useronline_add_env_int(array  *env, const char *key, int value) {
        data_string *ds;
        if (NULL == (ds = (data_string *)array_get_unused_element(env, TYPE_STRING))) {
                ds = data_string_init();
        }
        buffer_copy_string(ds->key, key);
        buffer_copy_long(ds->value, value);
        array_insert_unique(env, (data_unset *)ds);
}

URIHANDLER_FUNC(mod_useronline_uri_handler) {
        plugin_data *p = p_d;
        size_t j;
        plugin_config *s;
        user_data *ipd;
        unsigned int ipl;
        time_t time_threshold;
        time_t active_threshold;
        
        size_t user_count       = 0;
        size_t user_active      = 0;
        int free_slot           = -1;
        size_t last_item        = 0;
        int foundat             = -1;
        time_t current_time     = srv->cur_ts;

        mod_useronline_patch_connection(srv, con, p);
        
        if (!p->conf->enable) return HANDLER_GO_ON;

        s               = p->conf;
        ipd             = p->ip_data[s->id];
        ipl             = inet_addr(inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
        time_threshold  = current_time - (s->online_age);
        active_threshold= current_time - (s->active_age);
                
        for (j=0; j<s->max_ips; j++) {
                if (ipd[j].ipl==0) {
                        /*empty entry, mark it if first free slot*/
                        if (free_slot==-1) free_slot=j;
                        if (ipd[j].hits==-1) {
                                /* end found */
                                j=s->max_ips;
                        } 
                } else if (ipd[j].ipl==ipl) {
                        /*found a previous entry...*/
                        foundat=j;
                        ipd[j].hits++;
                        ipd[j].last=current_time;
                } else if (ipd[j].last < time_threshold) {
                        /*expired ip, mark it if first free slot*/
                        ipd[j].ipl=0;
                        if (free_slot==-1) free_slot=j;
                } 
                if (ipd[j].ipl>0) {
                        /*count user/ip*/
                        if (ipd[j].last >= active_threshold) user_active++;
                        user_count++;
                        last_item=j;
                }
        }
                                
        if (foundat==-1) {
                /*not found, add new*/
                if (free_slot!=-1) {
                        ipd[free_slot].ipl=ipl;
                        ipd[free_slot].last=current_time;
                        ipd[free_slot].hits=1;
                        foundat=free_slot;
                        if (free_slot>(int)last_item) last_item=free_slot;
                        
                        user_active++;
                        user_count++;
                }
        }
                                
        /*reduce amount of elements to scan through (mark as end, hits=-1)*/
        if (last_item+1 < s->max_ips) {
                ipd[last_item+1].ipl=0;
                ipd[last_item+1].hits=-1;
        }

        /*set environment variables*/

        /*users online currently*/
        mod_useronline_add_env_int(con->environment, "users_online", user_count);
        /*users active currently*/
        mod_useronline_add_env_int(con->environment, "users_active", user_active);
        /*hits made by current user*/
        mod_useronline_add_env_int(con->environment, "user_hits", ipd[foundat].hits);
        /*max age setting for current*/
        mod_useronline_add_env_int(con->environment, "users_online_age", s->online_age);
        /*max active age setting for current*/
        mod_useronline_add_env_int(con->environment, "users_active_age", s->active_age);
        /*max ips setting for current*/
        mod_useronline_add_env_int(con->environment, "users_online_max_ips", s->max_ips);
        /*current id for current*/
        mod_useronline_add_env_int(con->environment, "users_online_id", s->id);
        
        if (s->status_keynames) {
                /*users online currently*/
                status_counter_set_counter(srv, s->status_keynames[1]->ptr, user_count);
                /*users active currently*/
                status_counter_set_counter(srv, s->status_keynames[2]->ptr, user_active);
        }
        return HANDLER_GO_ON;
}

int mod_useronline_plugin_init(plugin *p) {
        p->version     = LIGHTTPD_VERSION_ID;
        p->name        = buffer_init_string("useronline");
        
        p->init        = mod_useronline_init;
        p->handle_uri_clean = mod_useronline_uri_handler;
        p->set_defaults   = mod_useronline_set_defaults;
        p->cleanup        = mod_useronline_free;
        
        p->data        = NULL;
        
        return 0;
}