xref: /dports/databases/sqlcached/sqlcached/sqlcached_client.c

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include "common.h"
#include "sqlcached_client.h"

struct sc_line {
    char *buf;
    unsigned int buf_len;
    unsigned int buf_size;
};

static void sc_line_init(struct sc_line *line);
static void sc_line_read(struct sc_line *line, FILE *f);
static void sc_line_done(struct sc_line *line);
static void sc_line_forget(struct sc_line *line);

#define BUF_SIZE 200


int sc_connect_unix(char *unix_socket_name, struct sc_client_conn *sc, char **errormsg) {
    struct sockaddr_un sun;
    char sig[20];

    bzero(sc, sizeof(*sc));

    sun.sun_family = AF_LOCAL;
#ifdef __BSD_VISIBLE
    sun.sun_len = strlen(unix_socket_name);
#endif
    strcpy(sun.sun_path, unix_socket_name);

    if ((sc->sock_server = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0) {
        asprintf(errormsg, "Cannot create socket: %s", strerror(errno));
        return SC_NET_ERROR;
    }

    if (connect(sc->sock_server, (struct sockaddr*)&sun, SUN_LEN(&sun)) < 0) {
        asprintf(errormsg, "Cannot connect to %s: %s", unix_socket_name, strerror(errno));
        return SC_NET_ERROR;
    }

    sc->server = fdopen(sc->sock_server, "r+");
    fprintf(sc->server, "VER %s\r\n", SC_VER_SIG);
    if (fscanf(sc->server, "+VER %15[^\r\n]%*2[\r\n]", sig) != 1) {
        asprintf(errormsg, "Handshake error");
        return SC_HANDSHAKE_ERROR;
    }
    if (strncmp(sig, SC_VER_SIG, 15) != 0) {
        asprintf(errormsg, "Expecting version signature %s, got %s\n", SC_VER_SIG, sig);
        return SC_SIG_ERROR;
    }

    return SC_OK;
}


int sc_get_ver(struct sc_client_conn *sc, char *ver) {
    fprintf(sc->server, "VER %s\r\n", SC_VER_SIG);
    if (fscanf(sc->server, "+VER %15[^\r\n]%*2[\r\n]", ver) != 1)
        return SC_HANDSHAKE_ERROR;
    return SC_OK;
}


int sc_exec_query(struct sc_client_conn *sc, char *sql, struct sc_result_set *rs, char **errormsg) {
    char resp[104], tmpmsg[104];;
    int n_rows = -1, n_cols = -1;
    fprintf(sc->server, "SQL %s\r\n", sql);
    if (fscanf(sc->server, "%100[^\r\n]%*2[\r\n]", resp) != 1) {
        if (errormsg != NULL)
            asprintf(errormsg, "Error reading response line\n");
        return SC_NET_ERROR;
    }

    /*fprintf(stderr, "resp: %s\n", resp);*/
    if (rs != NULL)
        bzero(rs, sizeof *rs);

    if (sscanf(resp, "+REC %d, %d", &n_rows, &n_cols) == 2) {
        int i, j;
        struct sc_line line;

        /*printf("n_rows: %d, n_cols: %d\n", n_rows, n_cols);*/
        if (rs != NULL) {
            rs->n_rows = n_rows;
            rs->n_cols = n_cols;
            rs->names = malloc(n_cols * sizeof(char*));
        }
        bzero(&line, sizeof line);

        for (i = 0; i < n_cols; i++) { /* read header line (column names) */
            sc_line_init(&line);
            sc_line_read(&line, sc->server);
            if (rs != NULL) {
                rs->names[i] = line.buf;
                sc_line_forget(&line);
            } else
                sc_line_done(&line);
        }
        if (rs != NULL)
            rs->rows = malloc(n_rows * sizeof(char**));
        for (i = 0; i < n_rows; i++) { /* read rows */
            if (rs != NULL)
                rs->rows[i] = malloc(n_cols * sizeof(char*));
            for (j = 0; j < n_cols; j++) {
                sc_line_init(&line);
                sc_line_read(&line, sc->server);
                if (rs != NULL) {
                    rs->rows[i][j] = line.buf;
                    sc_line_forget(&line);
                } else
                    sc_line_done(&line);
            }
        }
        if (errormsg != NULL)
            *errormsg = NULL;
        return SC_OK;
    } else if (sscanf(resp, "+NREC %100[^\r\n]", tmpmsg) == 1) {
        if (errormsg != NULL)
            *errormsg = NULL;
        if (rs != NULL)
            rs->n_rows = atoi(tmpmsg);
        return SC_OK;
    }
    if (errormsg != NULL)
        *errormsg = strdup(resp);
    return SC_SQL_ERROR;
}


void sc_free_result(struct sc_client_conn *sc, struct sc_result_set *rs) {
    int i, j;

    for (i = 0; i < rs->n_cols; i++)
        free(rs->names[i]);

    for (i = 0; i < rs->n_rows; i++)
        for (j = 0; j < rs->n_cols; j++)
            free(rs->rows[i][j]);
}


static void sc_line_init(struct sc_line *line) {
    if (line->buf == NULL) {
        line->buf = malloc(BUF_SIZE);
        line->buf_size = BUF_SIZE;
    }
    line->buf_len = 0;
    bzero(line->buf, line->buf_size);
}


/* TODO: replace bzero() calls with on-the-fly \0-s */
static void sc_line_read(struct sc_line *line, FILE *f) {
    int ch;
    while (1) {
        ch = getc_unlocked(f);
        if (ch < 0)
            return;
        if (ch == '\n')
            return;
        if (ch == '\r') {
            ch = getc_unlocked(f);
            if (ch != '\n')
                ungetc(ch, f);
            return;
        }
        if (line->buf_len >= line->buf_size) { /* resize buffer */
            line->buf = realloc(line->buf, line->buf_size + BUF_SIZE);
            if (line->buf == NULL) {
                line->buf_len = 0;
                return;
            }
            bzero(line->buf + line->buf_size, BUF_SIZE);
            line->buf_size += BUF_SIZE;
        }
        line->buf[line->buf_len++] = (char)ch;
    }
}


static void sc_line_done(struct sc_line *line) {
    free(line->buf);
    bzero(line, sizeof *line);
}


static void sc_line_forget(struct sc_line *line) {
    bzero(line, sizeof *line);
}