src/sqlchild.c

Go to the documentation of this file.

/*
 * sqlchild.c
 *
 * Copyright (c) 2004,2005 Martin Murray <mmurray@monkey.org>
 * All rights reserved.
 *
 */

#include "copyright.h"
#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dbi/dbi.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <signal.h>
#include <errno.h>

#include "externs.h"

/* /TODO
 * String sanitization.
 *  - dbi_driver_quote_string_copy ?
 * 
 * Handle Timezones in DATETIME
 *
 * Handle final write() failing.
 * 
 * Correct handling of TEXT data type.
 */

#ifdef DEBUG_SQL
#ifndef DEBUG
#define DEBUG
#endif
#endif
#include "debug.h"

#ifdef SQL_SUPPORT
#define MAX_QUERIES 8

static int running_queries = 0;
dbi_conn conn = NULL;

#define DBIS_EFAIL -1
#define DBIS_READY 0
#define DBIS_RESOURCE 1

static int dbi_initialized = 0;
static int dbi_state;
static int query_counter = 0;
static int recent = 0;

static struct query_state_t {
        dbref thing;
        int attr;
        char *preserve;
        char *query;
        struct event ev;
        char *rdelim;
        char *cdelim;
        struct query_state_t *next;
        int serial;
        struct timeval start;
        char slot;
        int fd;
        int pid;
} *running = NULL, *pending = NULL, *pending_tail = NULL, *recent_head =
        NULL, *recent_tail = NULL;

static struct timeval query_timeout = { 10, 0 };

void sqlchild_init();
void sqlchild_destruct();
static void sqlchild_kill_all();
int sqlchild_kill(int requestId);
void sqlchild_list(dbref thing);
static void sqlchild_kill_query(struct query_state_t *aqt);
static void sqlchild_child_abort_query(struct query_state_t *aqt,
                                                                           char *error);
static void sqlchild_child_abort_query_dbi(struct query_state_t *aqt,
                                                                                   char *error);
static void sqlchild_child_execute_query(struct query_state_t *aqt);
static void sqlchild_finish_query(int fd, short events, void *arg);
static void sqlchild_check_queue();
int sqlchild_request(dbref thing, int attr, char slot, char *pres,
                                         char *query, char *rdelim, char *cdelim);

void sqlchild_init()
{
        dbi_driver *driver;

        if(dbi_initialized)
                return;

        dprintk("initializing sqlchild.");

        if(dbi_initialize(NULL) == -1) {
                dprintk("dbi_initialized() failed.");
                dbi_state = DBIS_EFAIL;
                return;
        }

        dprintk("libdbi started.");

        driver = dbi_driver_list(NULL);
        while (driver != NULL) {
                dprintk("libdbi driver '%s' ready.", dbi_driver_get_name(driver));
                driver = dbi_driver_list(driver);
        }

        dbi_state = DBIS_READY;
}

void sqlchild_destruct()
{
        dprintk("shutting down.");
        dbi_state = DBIS_EFAIL;
        sqlchild_kill_all();
        dbi_shutdown();
}

/* do_query entrypoint */
int sqlchild_request(dbref thing, int attr, char slot, char *pres,
                                         char *query, char *rdelim, char *cdelim)
{
        int fds[2];
        struct query_state_t *aqt;

        if(dbi_state < DBIS_READY)
                return -1;

        aqt = malloc(sizeof(struct query_state_t));
        aqt->thing = thing;
        aqt->attr = attr;
        aqt->preserve = strdup(pres);
        aqt->query = strdup(query);
        aqt->rdelim = strdup(rdelim);
        aqt->cdelim = strdup(cdelim);
        aqt->serial = query_counter++;
        aqt->slot = slot;

        if(pending == NULL) {
                aqt->next = NULL;
                pending = aqt;
                pending_tail = aqt;
        } else {
                pending_tail->next = aqt;
                aqt->next = NULL;
                pending_tail = aqt;
        }
        sqlchild_check_queue();
        return 1;
}

void sqlchild_kill_all()
{
        dprintk("shutting down.\n");
        if(!dbi_initialized)
                return;
        while (running) {
                sqlchild_kill_query(running);
        }
}

int sqlchild_kill(int requestId)
{
        int status;
        struct query_state_t *iter = NULL, *aqt = NULL;

        dprintk("received request to terminate %d", requestId);

        if(running)
                iter = running;
        while (iter)
                if(iter->serial == requestId) {
                        sqlchild_kill_query(iter);
                        return 1;
                } else
                        iter = iter->next;
        if(pending)
                iter = pending;
        while (iter)
                if(iter->serial == requestId) {
                        sqlchild_kill_query(iter);
                        return 1;
                } else
                        iter = iter->next;
        return 0;
}

static void sqlchild_kill_query(struct query_state_t *aqt)
{
        struct query_state_t *iter;

        dprintk("terminating query %d", aqt->serial);

        kill(aqt->pid, SIGTERM);
        waitpid(aqt->pid, NULL, 0);

        iter = running;
        if(running == aqt) {
                running = aqt->next;
        } else {
                while (iter) {
                        if(iter->next == aqt) {
                                iter->next = aqt->next;
                                break;
                        }
                        iter = iter->next;
                }
        }
        if(aqt->preserve)
                free(aqt->preserve);
        if(aqt->query)
                free(aqt->query);
        if(aqt->rdelim)
                free(aqt->rdelim);
        if(aqt->cdelim)
                free(aqt->cdelim);
        close(aqt->fd);
        free(aqt);
        running_queries--;
        sqlchild_check_queue();
};

void sqlchild_list(dbref thing)
{
        int nactive = 0, npending = 0;
        int nrecent = recent;
        struct query_state_t *aqt;
        notify(thing, "/--------------------------- Recent Queries");
        if(recent) {
                aqt = recent_head;
                while (aqt) {
                        notify_printf(thing, "%08d #%8d %40s", aqt->serial, aqt->thing,
                                                  aqt->query);
                        aqt = aqt->next;
                }
        }
        notify(thing, "/--------------------------- Running Queries");
        if(running) {
                aqt = running;
                while (aqt) {
                        notify_printf(thing, "%08d #%8d %40s", aqt->serial, aqt->thing,
                                                  aqt->query);
                        aqt = aqt->next;
                        nactive++;
                }
        } else {
                notify(thing, "- No active queries.");
        }
        notify(thing, "/--------------------------- Pending Queries");
        if(pending) {
                aqt = pending;
                while (aqt) {
                        notify_printf(thing, "%08d #%-8d %40s", aqt->serial, aqt->thing,
                                                  aqt->query);
                        aqt = aqt->next;
                        npending++;
                }
        } else {
                notify(thing, "- No pending queries.");
        }
        notify_printf(thing, "%d active and %d pending queries.", nactive,
                                  pending);
}

struct query_response {
        int status;
        int n_chars;
};

/* HOST FUNCTIONS */

static void sqlchild_finish_query(int fd, short events, void *arg)
{
        pid_t pchild;
        int status;
        char *argv[5];
        struct query_state_t *aqt = (struct query_state_t *) arg, *iter;
        struct query_response resp = { -1, 0 };
        char buffer[LBUF_SIZE];
        buffer[0] = '\0';

        /*dprintk("receiving response for query %d", aqt->serial); */

        if(read(aqt->fd, &resp, sizeof(struct query_response)) < 0) {
                log_perror("SQL", "FAIL", NULL, "sqlchild_finish_query");
                argv[0] = "-1";
                argv[1] = "";
                argv[3] = "serious braindamage";
                goto fail;

        }

        if(resp.n_chars >= LBUF_SIZE) {
                resp.n_chars = LBUF_SIZE - 1;
        }

        if(resp.n_chars) {
                if(read(aqt->fd, buffer, resp.n_chars) < 0) {
                        log_perror("SQL", "FAIL", NULL, "sqlchild_finish_query");
                        argv[0] = "-1";
                        argv[1] = "";
                        argv[3] = "serious braindamage";
                        goto fail;
                }
        }

        if(resp.status == 0) {
                argv[0] = "1";
                argv[1] = buffer;
                argv[3] = "Success";
        } else {
                argv[0] = "0";
                argv[1] = "";
                if(resp.n_chars) {
                        argv[3] = buffer;
                } else {
                        argv[3] = "minor braindamage, no error and no result reported.";
                }
        }

  fail:
        argv[2] = aqt->preserve;
        did_it(GOD, aqt->thing, 0, NULL, 0, NULL, aqt->attr, argv, 4);

  hardfail:
        if(running == aqt) {
                running = aqt->next;
        } else {
                iter = running;
                while (iter) {
                        if(iter->next == aqt) {
                                iter->next = aqt->next;
                                break;
                        }
                        iter = iter->next;
                }
        }

        close(aqt->fd);
        pchild = waitpid(aqt->pid, &status, WNOHANG);
        if(!pchild) {
        /*      dprintk("%d exited abnormally.", aqt->pid); */
        }
        recent++;
        if(recent_tail == NULL) {
                aqt->next = NULL;
                recent_head = recent_tail = aqt;
        } else {
                recent_tail->next = aqt;
                recent_tail = aqt;
        }

        if(recent > 20) {
                aqt = recent_head;
                recent_head = aqt->next;
                if(aqt->preserve) {
                        free(aqt->preserve);
                        aqt->preserve = NULL;
                }
                if(aqt->query) {
                        free(aqt->query);
                        aqt->query = NULL;
                }
                if(aqt->rdelim) {
                        free(aqt->rdelim);
                        aqt->rdelim = NULL;
                }
                if(aqt->cdelim) {
                        free(aqt->cdelim);
                        aqt->cdelim = NULL;
                }
                free(aqt);
                aqt = NULL;
                recent--;
        }
        running_queries--;
        sqlchild_check_queue();
        return;
}

static void sqlchild_check_queue()
{
        int fds[2];
        struct query_state_t *aqt;
        if(running_queries >= mudconf.sqlDB_max_queries)
                return;
        if(pending == NULL)
                return;
        if(dbi_state != DBIS_READY)
                return;

        aqt = pending;
        pending = aqt->next;
        if(pending == NULL)
                pending_tail = NULL;

        if(pipe(fds) < 0) {
                log_perror("SQL", "FAIL", NULL, "pipe");
                return;
        }
        if((aqt->pid = fork()) == 0) {
                aqt->fd = fds[1];
                close(fds[0]);
                unbind_signals();
                sqlchild_child_execute_query(aqt);
                exit(0);
        } else {
                running_queries++;
                aqt->fd = fds[0];
                close(fds[1]);
        }
        
/*      dprintk("waiting on sqlchild pid %d executing request %d", aqt->pid,
                        aqt->serial);
*/
        if(running)
                aqt->next = running;
        running = aqt;

        event_set(&aqt->ev, aqt->fd, EV_READ, sqlchild_finish_query, aqt);
        event_add(&aqt->ev, &query_timeout);
        return;
}

/* CHILD FUNCTIONS */

static void sqlchild_child_abort_query(struct query_state_t *aqt, char *error)
{
        struct query_response resp = { DBIS_EFAIL, 0 };
        if(error) {
                resp.n_chars = strlen(error) + 1;
                write(aqt->fd, &resp, sizeof(resp));
                write(aqt->fd, error, resp.n_chars);
        } else {
                write(aqt->fd, &resp, sizeof(resp));
        }
        close(aqt->fd);
        exit(0);
        return;
}

static void sqlchild_child_abort_query_dbi(struct query_state_t *aqt,
                                                                                   char *error)
{
        char *error_ptr;
        if(dbi_conn_error(conn, (const char **) &error_ptr) != -1)
                sqlchild_child_abort_query(aqt, error_ptr);
        else
                sqlchild_child_abort_query(aqt, error);
        return;
}

static void sqlchild_make_connection(char db_slot)
{
        char *db_type, *db_hostname, *db_username, *db_password, *db_database;
        switch (db_slot) {
        case 'A':
                db_type = mudconf.sqlDB_type_A;
                db_hostname = mudconf.sqlDB_hostname_A;
                db_username = mudconf.sqlDB_username_A;
                db_password = mudconf.sqlDB_password_A;
                db_database = mudconf.sqlDB_dbname_A;
                break;
        case 'B':
                db_type = mudconf.sqlDB_type_B;
                db_hostname = mudconf.sqlDB_hostname_B;
                db_username = mudconf.sqlDB_username_B;
                db_password = mudconf.sqlDB_password_B;
                db_database = mudconf.sqlDB_dbname_B;
                break;
        case 'C':
                db_type = mudconf.sqlDB_type_C;
                db_hostname = mudconf.sqlDB_hostname_C;
                db_username = mudconf.sqlDB_username_C;
                db_password = mudconf.sqlDB_password_C;
                db_database = mudconf.sqlDB_dbname_C;
                break;
        case 'D':
                db_type = mudconf.sqlDB_type_D;
                db_hostname = mudconf.sqlDB_hostname_D;
                db_username = mudconf.sqlDB_username_D;
                db_password = mudconf.sqlDB_password_D;
                db_database = mudconf.sqlDB_dbname_D;
                break;
        case 'E':
                db_type = mudconf.sqlDB_type_E;
                db_hostname = mudconf.sqlDB_hostname_E;
                db_username = mudconf.sqlDB_username_E;
                db_password = mudconf.sqlDB_password_E;
                db_database = mudconf.sqlDB_dbname_E;
                break;
        default:
                return;
        }
        conn = dbi_conn_new(db_type);
        if(!conn) {
                dprintk("dbi_conn_new() failed with db_type %s.", db_type);
                dbi_state = DBIS_EFAIL;
                return;
        }
        if(strncmp(db_type, "mysql", 128) == 0) {
                // dbi_conn_set_option(conn, "mysql_include_trailing_null", 1);
                if(strnlen(mudconf.sqlDB_mysql_socket, 128) > 0
                                && dbi_conn_set_option(conn, "mysql_unix_socket",
                                        mudconf.sqlDB_mysql_socket)) {
                        dprintk("failed to set mysql_unix_socket");
                        dbi_state = DBIS_EFAIL;
                        return;
                }
        }
        if(strncmp(db_type, "sqlite", 128) == 0
           && strnlen(mudconf.sqlDB_sqlite_dbdir, 128) > 0
           && dbi_conn_set_option(conn, "sqlite_dbdir",
                                                          mudconf.sqlDB_sqlite_dbdir)) {
                dprintk("failed to set sqlite dir.");
                dbi_state = DBIS_EFAIL;
                return;
        }
        if(db_hostname && dbi_conn_set_option(conn, "host", db_hostname)) {
                dprintk("failed to set hostname");
                dbi_state = DBIS_EFAIL;
                return;
        }
        if(db_username && dbi_conn_set_option(conn, "username", db_username)) {
                dprintk("failed to set username");
                dbi_state = DBIS_EFAIL;
                return;
        }
        if(db_password && dbi_conn_set_option(conn, "password", db_password)) {
                dprintk("failed to set password");
                dbi_state = DBIS_EFAIL;
                return;
        }
        if(db_database && dbi_conn_set_option(conn, "dbname", db_database)) {
                dprintk("failed to set database");
                dbi_state = DBIS_EFAIL;
                return;
        }
        dprintk("started.");
        return;
}

static char *sqlchild_sanitize_string(char *input, int length)
{
        char *retval = malloc(length + 1);
        int i = 0;
        memset(retval, 0, length + 1);
        for(i = 0; input[i] && i < length; i++) {
                if(isprint(input[i])) {
                        retval[i] = input[i];
                } else {
                        retval[i] = ' ';
                }
        }
        dprintk("length: %d, i is %d, terimnal character is 0x%02x.", length, i, input[i]);
        return retval;
}

static void sqlchild_child_execute_query(struct query_state_t *aqt)
{
        struct query_response resp = { DBIS_READY, -1 };
        dbi_result result;
        int rows, fields, i, ii, retval;
        char output_buffer[LBUF_SIZE], *ptr, *eptr, *delim;
        int binary_length;
        char time_buffer[64];
        int length = 0;
        struct tm tm;

        long long type_int;
        double type_fp;
        char *type_string, *binbuffer;
        time_t type_time;

        ptr = output_buffer;
        eptr = ptr + (LBUF_SIZE - 1);
        *ptr = '\0';

        /* dprintk("executing query %d.", aqt->serial); */

        sqlchild_make_connection(aqt->slot);
        if(!conn) {
                sqlchild_child_abort_query(aqt, "failed to create connection");
                return;
        }
        if(dbi_state != DBIS_READY) {
                sqlchild_child_abort_query_dbi(aqt,
                                "unknown error in sqlchild_make_connection");
                return;
        }

        if(!conn) {
                sqlchild_child_abort_query_dbi(aqt,
                                "unknown error in sqlchild_make_connection");
                return;
        }

        if(dbi_conn_connect(conn) != 0) {
                sqlchild_child_abort_query_dbi(aqt, "dbi_conn_connect failed");
                return;
        }

        result = dbi_conn_query(conn, aqt->query);
        if(result == NULL) {
                sqlchild_child_abort_query_dbi(aqt,
                                "unknown error in dbi_conn_query");
                return;
        }

        rows = dbi_result_get_numrows(result);
        fields = dbi_result_get_numfields(result);

        delim = NULL;

        while (dbi_result_next_row(result)) {
                if((eptr <= ptr) || ((eptr-ptr) < 10)) {
                        // XXX: quick hack. I should check my snprintf() return values.
                        sqlchild_child_abort_query(aqt, "result too long");
                        return;
                }

                if(delim != NULL) {
                        ptr += snprintf(ptr, eptr - ptr, aqt->rdelim);
                }

                for(i = 1; i <= fields; i++) {
                        if((eptr <= ptr) || ((eptr-ptr) < 10)) {
                                // XXX: quick hack. I should check my snprintf() return values.
                                sqlchild_child_abort_query(aqt, "result too long");
                                return;
                        }

                        if(fields == i)
                                delim = "";
                        else
                                delim = aqt->cdelim;

                        // XXX: handle error values form snprintf()
                        switch (dbi_result_get_field_type_idx(result, i)) {
                                case DBI_TYPE_INTEGER:
                                        type_int = dbi_result_get_longlong_idx(result, i);
                                        ptr += snprintf(ptr, eptr - ptr, "%lld%s", type_int, delim);
                                        break;

                                case DBI_TYPE_DECIMAL:
                                        type_fp = dbi_result_get_double_idx(result, i);
                                        ptr += snprintf(ptr, eptr - ptr, "%f%s", type_fp, delim);
                                        break;

                                case DBI_TYPE_STRING:
                                        type_string = dbi_result_get_string_copy_idx(result, i);
                                        ptr += snprintf(ptr, eptr - ptr, "%s%s", type_string, delim);
                                        free(type_string);
                                        break;

                                case DBI_TYPE_BINARY:
                                        binary_length = dbi_result_get_field_length_idx(result, i);
                                        if(binary_length) {
                                                type_string = (char *)dbi_result_get_binary_idx(result, i);
                                                if(strncmp(type_string, "ERROR", 5)==0) {
                                                        sqlchild_child_abort_query(aqt, "fucked.");
                                                        return;
                                                }
                                                binbuffer = sqlchild_sanitize_string(type_string, binary_length);
                                                ptr += snprintf(ptr, eptr - ptr, "%s%s", binbuffer, delim);
                                                free(binbuffer);
                                        } else {
                                                ptr += snprintf(ptr, eptr - ptr, "%s", delim);
                                        }

                                        break;

                                case DBI_TYPE_DATETIME:
                                        type_time = dbi_result_get_datetime_idx(result, i);
                                        localtime_r(&type_time, &tm);
                                        asctime_r(&tm, time_buffer);
                                        ptr += snprintf(ptr, eptr - ptr, "%s%s", time_buffer, delim);
                                        break;

                                default:
                                        sqlchild_child_abort_query(aqt, "unknown type");
                                        return;
                        }

                        if((eptr - ptr) < 10) {
                                sqlchild_child_abort_query(aqt, "result too large");
                                return;
                        }

                }
        }

        *ptr++ = '\0';
        resp.n_chars = eptr - output_buffer;
        eptr = ptr;
        
        // XXX: handle failure
        write(aqt->fd, &resp, sizeof(struct query_response));
        ptr = output_buffer;
        while (ptr < eptr) {
                retval = write(aqt->fd, ptr, eptr - ptr);
                ptr += retval;
        }
        close(aqt->fd);
        return;
}

#endif /* SQL_SUPPORT */

---