Lighttpd

#include <unistd.h>

#include <stdio.h>

#include <errno.h>

#include <fcntl.h>

#include <strings.h>

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifdef HAVE_MYSQL

#include <mysql.h>

#endif

#include "plugin.h"

#include "log.h"

#include "stat_cache.h"

#ifdef DEBUG_MOD_MYSQL_VHOST

#define DEBUG

#endif

/*

 * Plugin for lighttpd to use MySQL

 *   for domain to directory lookups,

 *   i.e virtual hosts (vhosts).

 *

 * Optionally sets fcgi_offset and fcgi_arg

 *   in preparation for fcgi.c to handle

 *   per-user fcgi chroot jails.

 *

 * /ada@riksnet.se 2004-12-06

 */

#ifdef HAVE_MYSQL

typedef struct {

        MYSQL         *mysql;

        buffer  *mydb;

        buffer  *myuser;

        buffer  *mypass;

        buffer  *mysock;

        buffer  *hostname;

        unsigned short port;

        buffer  *mysql_pre;

        buffer  *mysql_mid;

        buffer  *mysql_post;

} plugin_config;

/* global plugin data */

typedef struct {

        PLUGIN_DATA;

        buffer         *tmp_buf;

        plugin_config **config_storage;

        plugin_config conf;

} plugin_data;

/* per connection plugin data */

typedef struct {

        buffer        *server_name;

        buffer        *document_root;

        buffer        *fcgi_arg;

        unsigned fcgi_offset;

} plugin_connection_data;

/* init the plugin data */

INIT_FUNC(mod_mysql_vhost_init) {

        plugin_data *p;

        p = calloc(1, sizeof(*p));

        p->tmp_buf = buffer_init();

        return p;

}

/* cleanup the plugin data */

SERVER_FUNC(mod_mysql_vhost_cleanup) {

        plugin_data *p = p_d;

        UNUSED(srv);

#ifdef DEBUG

        log_error_write(srv, __FILE__, __LINE__, "ss",

                "mod_mysql_vhost_cleanup", p ? "yes" : "NO");

#endif

        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;

                        mysql_close(s->mysql);

                        buffer_free(s->mydb);

                        buffer_free(s->myuser);

                        buffer_free(s->mypass);

                        buffer_free(s->mysock);

                        buffer_free(s->mysql_pre);

                        buffer_free(s->mysql_mid);

                        buffer_free(s->mysql_post);

                        buffer_free(s->hostname);

                        free(s);

                }

                free(p->config_storage);

        }

        buffer_free(p->tmp_buf);

        free(p);

        return HANDLER_GO_ON;

}

/* handle the plugin per connection data */

static void* mod_mysql_vhost_connection_data(server *srv, connection *con, void *p_d)

{

        plugin_data *p = p_d;

        plugin_connection_data *c = con->plugin_ctx[p->id];

        UNUSED(srv);

#ifdef DEBUG

        log_error_write(srv, __FILE__, __LINE__, "ss",

                "mod_mysql_connection_data", c ? "old" : "NEW");

#endif

        if (c) return c;

        c = calloc(1, sizeof(*c));

        c->server_name = buffer_init();

        c->document_root = buffer_init();

        c->fcgi_arg = buffer_init();

        c->fcgi_offset = 0;

        return con->plugin_ctx[p->id] = c;

}

/* destroy the plugin per connection data */

CONNECTION_FUNC(mod_mysql_vhost_handle_connection_close) {

        plugin_data *p = p_d;

        plugin_connection_data *c = con->plugin_ctx[p->id];

        UNUSED(srv);

#ifdef DEBUG

        log_error_write(srv, __FILE__, __LINE__, "ss",

                "mod_mysql_vhost_handle_connection_close", c ? "yes" : "NO");

#endif

        if (!c) return HANDLER_GO_ON;

        buffer_free(c->server_name);

        buffer_free(c->document_root);

        buffer_free(c->fcgi_arg);

        c->fcgi_offset = 0;

        free(c);

        con->plugin_ctx[p->id] = NULL;

        return HANDLER_GO_ON;

}

/* set configuration values */

SERVER_FUNC(mod_mysql_vhost_set_defaults) {

        plugin_data *p = p_d;

        char *qmarkA;

        char *qmarkB;

        size_t i = 0;

        config_values_t cv[] = {

                { "mysql-vhost.db",        NULL, T_CONFIG_STRING,         T_CONFIG_SCOPE_SERVER },

                { "mysql-vhost.user",        NULL, T_CONFIG_STRING,         T_CONFIG_SCOPE_SERVER },

                { "mysql-vhost.pass",        NULL, T_CONFIG_STRING,         T_CONFIG_SCOPE_SERVER },

                { "mysql-vhost.sock",        NULL, T_CONFIG_STRING,         T_CONFIG_SCOPE_SERVER },

                { "mysql-vhost.sql",        NULL, T_CONFIG_STRING,         T_CONFIG_SCOPE_SERVER },

                { "mysql-vhost.hostname", NULL, T_CONFIG_STRING,T_CONFIG_SCOPE_SERVER },

                { "mysql-vhost.port",   NULL, T_CONFIG_SHORT,   T_CONFIG_SCOPE_SERVER },

                { NULL,                        NULL, T_CONFIG_UNSET,        T_CONFIG_SCOPE_UNSET }

        };

        p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));

        for (i = 0; i < srv->config_context->used; i++) {

                plugin_config *s;

                buffer *sel;

                s = calloc(1, sizeof(plugin_config));

                s->mydb = buffer_init();

                s->myuser = buffer_init();

                s->mypass = buffer_init();

                s->mysock = buffer_init();

                s->hostname = buffer_init();

                s->port   = 0;               /* default port for mysql */

                sel = buffer_init();

                s->mysql = NULL;

                s->mysql_pre = buffer_init();

                s->mysql_mid = buffer_init();

                s->mysql_post = buffer_init();

                cv[0].destination = s->mydb;

                cv[1].destination = s->myuser;

                cv[2].destination = s->mypass;

                cv[3].destination = s->mysock;

                cv[4].destination = sel;

                cv[5].destination = s->hostname;

                cv[6].destination = &(s->port);

                p->config_storage[i] = s;

                if (config_insert_values_global(srv,

                        ((data_config *)srv->config_context->data[i])->value,

                        cv)) return HANDLER_ERROR;

                s->mysql_pre = buffer_init();

                s->mysql_mid = buffer_init();

                s->mysql_post = buffer_init();

                // quick dirty changed manually - parses 2 questionmarks:

                // the first - and the last. - hopefully

                if (sel->used && (qmarkA = strchr(sel->ptr, '?')) && (qmarkB = strrchr(sel->ptr, '?'))) {

                        *qmarkA = '\0';

                        *qmarkB = '\0';

                        buffer_copy_string(s->mysql_pre, sel->ptr);

                        buffer_copy_string(s->mysql_mid, qmarkA+1);

                        buffer_copy_string(s->mysql_post, qmarkB+1);

                } else {

                        buffer_copy_string_buffer(s->mysql_pre, sel);

                }

                /* Original-Code for Lines 231 to 239:

                        if (sel->used && (qmark = strchr(sel->ptr, '?'))) {

                                *qmark = '\0';

                                buffer_copy_string(s->mysql_pre, sel->ptr);

                                buffer_copy_string(s->mysql_post, qmark+1);

                        } else {

                                buffer_copy_string_buffer(s->mysql_pre, sel);

                        }

                */

                /* required:

                 * - username

                 * - database

                 *

                 * optional:

                 * - password, default: empty

                 * - socket, default: mysql default

                 * - hostname, if set overrides socket

                 * - port, default: 3306

                 */

                /* all have to be set */

                if (!(buffer_is_empty(s->myuser) ||

                      buffer_is_empty(s->mydb))) {

                        my_bool reconnect = 1;

                        int fd;

                        if (NULL == (s->mysql = mysql_init(NULL))) {

                                log_error_write(srv, __FILE__, __LINE__, "s", "mysql_init() failed, exiting...");

                                return HANDLER_ERROR;

                        }

#if MYSQL_VERSION_ID >= 50013

                        /* in mysql versions above 5.0.3 the reconnect flag is off by default */

                        mysql_options(s->mysql, MYSQL_OPT_RECONNECT, &reconnect);

#endif

#define FOO(x) (s->x->used ? s->x->ptr : NULL)

                        if (!mysql_real_connect(s->mysql, FOO(hostname), FOO(myuser), FOO(mypass),

                                                FOO(mydb), s->port, FOO(mysock), 0)) {

                                log_error_write(srv, __FILE__, __LINE__, "s", mysql_error(s->mysql));

                                return HANDLER_ERROR;

                        }

#undef FOO

                        /* set close_on_exec for mysql the hard way */

                        /* Note: this only works as it is done during startup, */

                        /* otherwise we cannot be sure that mysql is fd i-1 */

                        if (-1 == (fd = open("/dev/null", 0))) {

                                close(fd);

                                fcntl(fd-1, F_SETFD, FD_CLOEXEC);

                        }

                }

        }

        return HANDLER_GO_ON;

}

#define PATCH(x) \

        p->conf.x = s->x;

static int mod_mysql_vhost_patch_connection(server *srv, connection *con, plugin_data *p) {

        size_t i, j;

        plugin_config *s = p->config_storage[0];

        PATCH(mysql_pre);

        PATCH(mysql_mid);

        PATCH(mysql_post);

#ifdef HAVE_MYSQL

        PATCH(mysql);

#endif

        /* 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("mysql-vhost.sql"))) {

                                PATCH(mysql_pre);

                                PATCH(mysql_mid);

                                PATCH(mysql_post);

                        }

                }

                if (s->mysql) {

                        PATCH(mysql);

                }

        }

        return 0;

}

#undef PATCH

/* handle document root request */

CONNECTION_FUNC(mod_mysql_vhost_handle_docroot) {

        plugin_data *p = p_d;

        plugin_connection_data *c;

        stat_cache_entry *sce;

        unsigned  cols;

        MYSQL_ROW row;

        MYSQL_RES *result = NULL;

        /* no host specified? */

        if (!con->uri.authority->used) return HANDLER_GO_ON;

        mod_mysql_vhost_patch_connection(srv, con, p);

        if (!p->conf.mysql) return HANDLER_GO_ON;

        /* sets up connection data if not done yet */

        c = mod_mysql_vhost_connection_data(srv, con, p_d);

        /* check if cached this connection */

        if (c->server_name->used && /* con->uri.authority->used && */

             buffer_is_equal(c->server_name, con->uri.authority)) goto GO_ON;

        /* build and run SQL query */

        buffer_copy_string_buffer(p->tmp_buf, p->conf.mysql_pre);

        if (p->conf.mysql_mid->used) {

                buffer_append_string_buffer(p->tmp_buf, con->uri.authority);

                buffer_append_string_buffer(p->tmp_buf, p->conf.mysql_mid);

        }

        if (p->conf.mysql_post->used) {

                buffer_append_string_buffer(p->tmp_buf, con->uri.authority);

                buffer_append_string_buffer(p->tmp_buf, p->conf.mysql_post);

        }

  if (mysql_query(p->conf.mysql, p->tmp_buf->ptr)) {

                log_error_write(srv, __FILE__, __LINE__, "s", mysql_error(p->conf.mysql));

                goto ERR500;

        }

        result = mysql_store_result(p->conf.mysql);

        cols = mysql_num_fields(result);

        row = mysql_fetch_row(result);

        if (!row || cols < 1) {

                /* no such virtual host */

                mysql_free_result(result);

                return HANDLER_GO_ON;

        }

        /* sanity check that really is a directory */

        buffer_copy_string(p->tmp_buf, row[0]);

        BUFFER_APPEND_SLASH(p->tmp_buf);

        if (HANDLER_ERROR == stat_cache_get_entry(srv, con, p->tmp_buf, &sce)) {

                log_error_write(srv, __FILE__, __LINE__, "sb", strerror(errno), p->tmp_buf);

                goto ERR500;

        }

        if (!S_ISDIR(sce->st.st_mode)) {

                log_error_write(srv, __FILE__, __LINE__, "sb", "Not a directory", p->tmp_buf);

                goto ERR500;

        }

        /* cache the data */

        buffer_copy_string_buffer(c->server_name, con->uri.authority);

        buffer_copy_string_buffer(c->document_root, p->tmp_buf);

        /* fcgi_offset and fcgi_arg are optional */

        if (cols > 1 && row[1]) {

                c->fcgi_offset = atoi(row[1]);

                if (cols > 2 && row[2]) {

                        buffer_copy_string(c->fcgi_arg, row[2]);

                } else {

                        c->fcgi_arg->used = 0;

                }

        } else {

                c->fcgi_offset = c->fcgi_arg->used = 0;

        }

        mysql_free_result(result);

        /* fix virtual server and docroot */

GO_ON:        buffer_copy_string_buffer(con->server_name, c->server_name);

        buffer_copy_string_buffer(con->physical.doc_root, c->document_root);

#ifdef DEBUG

        log_error_write(srv, __FILE__, __LINE__, "sbbdb",

                result ? "NOT CACHED" : "cached",

                con->server_name, con->physical.doc_root,

                c->fcgi_offset, c->fcgi_arg);

#endif

        return HANDLER_GO_ON;

ERR500:        if (result) mysql_free_result(result);

        con->http_status = 500; /* Internal Error */

        return HANDLER_FINISHED;

}

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

int mod_mysql_vhost_plugin_init(plugin *p) {

        p->version     = LIGHTTPD_VERSION_ID;

        p->name                                = buffer_init_string("mysql_vhost");

        p->init                                = mod_mysql_vhost_init;

        p->cleanup                             = mod_mysql_vhost_cleanup;

        p->handle_request_done                 = mod_mysql_vhost_handle_connection_close;

        p->set_defaults                        = mod_mysql_vhost_set_defaults;

        p->handle_docroot                  = mod_mysql_vhost_handle_docroot;

        return 0;

}

#else

/* we don't have mysql support, this plugin does nothing */

int mod_mysql_vhost_plugin_init(plugin *p) {

        p->version     = LIGHTTPD_VERSION_ID;

        p->name                                = buffer_init_string("mysql_vhost");

        return 0;

}

#endif