2014-03-30 23:54:35 +02:00
|
|
|
/*
|
2016-01-04 12:58:51 +01:00
|
|
|
* Copyright (c) 2014-2016 Joris Vink <joris@coders.se>
|
2014-03-30 23:54:35 +02:00
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/queue.h>
|
|
|
|
|
|
|
|
#include <libpq-fe.h>
|
2014-07-18 15:59:07 +02:00
|
|
|
#include <pg_config.h>
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
#include "kore.h"
|
|
|
|
#include "http.h"
|
2014-07-03 22:14:46 +02:00
|
|
|
#include "pgsql.h"
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
struct pgsql_job {
|
2014-08-14 14:34:23 +02:00
|
|
|
struct http_request *req;
|
|
|
|
struct kore_pgsql *pgsql;
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
TAILQ_ENTRY(pgsql_job) list;
|
|
|
|
};
|
|
|
|
|
2014-08-21 16:36:12 +02:00
|
|
|
struct pgsql_wait {
|
|
|
|
struct http_request *req;
|
|
|
|
TAILQ_ENTRY(pgsql_wait) list;
|
|
|
|
};
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
#define PGSQL_CONN_MAX 2
|
|
|
|
#define PGSQL_CONN_FREE 0x01
|
2016-01-04 11:12:43 +01:00
|
|
|
#define PGSQL_LIST_INSERTED 0x0100
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
static void pgsql_queue_wakeup(void);
|
2017-02-06 20:01:16 +01:00
|
|
|
static void pgsql_cancel(struct kore_pgsql *);
|
2016-01-04 11:12:43 +01:00
|
|
|
static void pgsql_set_error(struct kore_pgsql *, const char *);
|
2014-09-28 21:39:16 +02:00
|
|
|
static void pgsql_queue_add(struct http_request *);
|
2014-08-14 14:46:21 +02:00
|
|
|
static void pgsql_conn_release(struct kore_pgsql *);
|
2014-03-31 01:04:22 +02:00
|
|
|
static void pgsql_conn_cleanup(struct pgsql_conn *);
|
2016-01-04 11:12:43 +01:00
|
|
|
static void pgsql_read_result(struct kore_pgsql *);
|
|
|
|
static void pgsql_schedule(struct kore_pgsql *);
|
|
|
|
|
|
|
|
static struct pgsql_conn *pgsql_conn_create(struct kore_pgsql *,
|
|
|
|
struct pgsql_db *);
|
|
|
|
static struct pgsql_conn *pgsql_conn_next(struct kore_pgsql *,
|
|
|
|
struct pgsql_db *,
|
|
|
|
struct http_request *);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-08-21 16:36:12 +02:00
|
|
|
static struct kore_pool pgsql_job_pool;
|
|
|
|
static struct kore_pool pgsql_wait_pool;
|
2014-03-30 23:54:35 +02:00
|
|
|
static TAILQ_HEAD(, pgsql_conn) pgsql_conn_free;
|
2014-08-21 16:36:12 +02:00
|
|
|
static TAILQ_HEAD(, pgsql_wait) pgsql_wait_queue;
|
2016-01-04 11:12:43 +01:00
|
|
|
static LIST_HEAD(, pgsql_db) pgsql_db_conn_strings;
|
2014-03-30 23:54:35 +02:00
|
|
|
static u_int16_t pgsql_conn_count;
|
2014-07-04 09:14:05 +02:00
|
|
|
u_int16_t pgsql_conn_max = PGSQL_CONN_MAX;
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
kore_pgsql_init(void)
|
|
|
|
{
|
|
|
|
pgsql_conn_count = 0;
|
|
|
|
TAILQ_INIT(&pgsql_conn_free);
|
2014-08-21 16:36:12 +02:00
|
|
|
TAILQ_INIT(&pgsql_wait_queue);
|
2016-01-04 11:12:43 +01:00
|
|
|
LIST_INIT(&pgsql_db_conn_strings);
|
2014-08-21 16:36:12 +02:00
|
|
|
|
|
|
|
kore_pool_init(&pgsql_job_pool, "pgsql_job_pool",
|
|
|
|
sizeof(struct pgsql_job), 100);
|
|
|
|
kore_pool_init(&pgsql_wait_pool, "pgsql_wait_pool",
|
|
|
|
sizeof(struct pgsql_wait), 100);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2017-02-06 11:40:33 +01:00
|
|
|
void
|
|
|
|
kore_pgsql_sys_cleanup(void)
|
|
|
|
{
|
|
|
|
struct pgsql_conn *conn, *next;
|
|
|
|
|
|
|
|
kore_pool_cleanup(&pgsql_job_pool);
|
|
|
|
kore_pool_cleanup(&pgsql_wait_pool);
|
|
|
|
|
2017-02-07 22:35:09 +01:00
|
|
|
TAILQ_FOREACH_SAFE(conn, &pgsql_conn_free, list, next) {
|
2017-02-06 11:40:33 +01:00
|
|
|
pgsql_conn_cleanup(conn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
int
|
2016-01-04 11:12:43 +01:00
|
|
|
kore_pgsql_query_init(struct kore_pgsql *pgsql, struct http_request *req,
|
|
|
|
const char *dbname, int flags)
|
2014-03-30 23:54:35 +02:00
|
|
|
{
|
2016-01-04 11:12:43 +01:00
|
|
|
struct pgsql_db *db;
|
|
|
|
|
|
|
|
memset(pgsql, 0, sizeof(*pgsql));
|
|
|
|
pgsql->flags = flags;
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_INIT;
|
|
|
|
|
|
|
|
if ((req == NULL && (flags & KORE_PGSQL_ASYNC)) ||
|
|
|
|
((flags & KORE_PGSQL_ASYNC) && (flags & KORE_PGSQL_SYNC))) {
|
|
|
|
pgsql_set_error(pgsql, "invalid query init parameters");
|
2014-09-28 21:39:16 +02:00
|
|
|
return (KORE_RESULT_ERROR);
|
2016-01-04 11:12:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
db = NULL;
|
|
|
|
LIST_FOREACH(db, &pgsql_db_conn_strings, rlist) {
|
|
|
|
if (!strcmp(db->name, dbname))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (db == NULL) {
|
|
|
|
pgsql_set_error(pgsql, "no database found");
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
if ((pgsql->conn = pgsql_conn_next(pgsql, db, req)) == NULL)
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
|
|
|
|
if (pgsql->flags & KORE_PGSQL_ASYNC) {
|
|
|
|
pgsql->conn->job = kore_pool_get(&pgsql_job_pool);
|
|
|
|
pgsql->conn->job->req = req;
|
|
|
|
pgsql->conn->job->pgsql = pgsql;
|
|
|
|
|
|
|
|
http_request_sleep(req);
|
|
|
|
pgsql->flags |= PGSQL_LIST_INSERTED;
|
|
|
|
LIST_INSERT_HEAD(&(req->pgsqls), pgsql, rlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (KORE_RESULT_OK);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kore_pgsql_query(struct kore_pgsql *pgsql, const char *query)
|
|
|
|
{
|
|
|
|
if (pgsql->conn == NULL) {
|
|
|
|
pgsql_set_error(pgsql, "no connection was set before query");
|
2014-09-28 21:39:16 +02:00
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
if (pgsql->flags & KORE_PGSQL_SYNC) {
|
|
|
|
pgsql->result = PQexec(pgsql->conn->db, query);
|
|
|
|
|
|
|
|
if ((PQresultStatus(pgsql->result) != PGRES_TUPLES_OK) &&
|
|
|
|
(PQresultStatus(pgsql->result) != PGRES_COMMAND_OK)) {
|
|
|
|
pgsql_set_error(pgsql, PQerrorMessage(pgsql->conn->db));
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_DONE;
|
|
|
|
} else {
|
|
|
|
if (!PQsendQuery(pgsql->conn->db, query)) {
|
|
|
|
pgsql_set_error(pgsql, PQerrorMessage(pgsql->conn->db));
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
pgsql_schedule(pgsql);
|
|
|
|
}
|
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
return (KORE_RESULT_OK);
|
|
|
|
}
|
2014-08-21 16:36:12 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
int
|
2016-06-07 13:12:31 +02:00
|
|
|
kore_pgsql_v_query_params(struct kore_pgsql *pgsql,
|
2016-11-19 12:56:51 +01:00
|
|
|
const char *query, int result, int count, va_list args)
|
2014-09-28 21:39:16 +02:00
|
|
|
{
|
|
|
|
u_int8_t i;
|
|
|
|
char **values;
|
2016-01-04 11:12:43 +01:00
|
|
|
int *lengths, *formats, ret;
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
if (pgsql->conn == NULL) {
|
|
|
|
pgsql_set_error(pgsql, "no connection was set before query");
|
2014-09-28 21:39:16 +02:00
|
|
|
return (KORE_RESULT_ERROR);
|
2016-01-04 11:12:43 +01:00
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-10-12 01:17:35 +02:00
|
|
|
if (count > 0) {
|
|
|
|
lengths = kore_calloc(count, sizeof(int));
|
|
|
|
formats = kore_calloc(count, sizeof(int));
|
|
|
|
values = kore_calloc(count, sizeof(char *));
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
values[i] = va_arg(args, void *);
|
2016-12-27 07:42:42 +01:00
|
|
|
lengths[i] = va_arg(args, int);
|
2014-10-12 01:17:35 +02:00
|
|
|
formats[i] = va_arg(args, int);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
lengths = NULL;
|
|
|
|
formats = NULL;
|
|
|
|
values = NULL;
|
2014-09-28 21:39:16 +02:00
|
|
|
}
|
2014-08-14 22:05:34 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
ret = KORE_RESULT_ERROR;
|
|
|
|
|
|
|
|
if (pgsql->flags & KORE_PGSQL_SYNC) {
|
|
|
|
pgsql->result = PQexecParams(pgsql->conn->db, query, count,
|
|
|
|
NULL, (const char * const *)values, lengths, formats,
|
|
|
|
result);
|
|
|
|
|
|
|
|
if ((PQresultStatus(pgsql->result) != PGRES_TUPLES_OK) &&
|
|
|
|
(PQresultStatus(pgsql->result) != PGRES_COMMAND_OK)) {
|
|
|
|
pgsql_set_error(pgsql, PQerrorMessage(pgsql->conn->db));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_DONE;
|
|
|
|
} else {
|
|
|
|
if (!PQsendQueryParams(pgsql->conn->db, query, count, NULL,
|
|
|
|
(const char * const *)values, lengths, formats, result)) {
|
|
|
|
pgsql_set_error(pgsql, PQerrorMessage(pgsql->conn->db));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
pgsql_schedule(pgsql);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
ret = KORE_RESULT_OK;
|
|
|
|
|
|
|
|
cleanup:
|
2016-07-12 13:54:14 +02:00
|
|
|
kore_free(values);
|
|
|
|
kore_free(lengths);
|
|
|
|
kore_free(formats);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
2016-06-07 13:12:31 +02:00
|
|
|
int
|
|
|
|
kore_pgsql_query_params(struct kore_pgsql *pgsql,
|
2016-11-19 12:56:51 +01:00
|
|
|
const char *query, int result, int count, ...)
|
2016-06-07 13:12:31 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list args;
|
|
|
|
|
2016-09-05 16:22:46 +02:00
|
|
|
va_start(args, count);
|
2016-06-07 13:12:31 +02:00
|
|
|
|
|
|
|
ret = kore_pgsql_v_query_params(pgsql, query, result, count, args);
|
|
|
|
|
2016-09-05 16:22:46 +02:00
|
|
|
va_end(args);
|
2016-06-07 13:12:31 +02:00
|
|
|
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
int
|
|
|
|
kore_pgsql_register(const char *dbname, const char *connstring)
|
|
|
|
{
|
|
|
|
struct pgsql_db *pgsqldb;
|
|
|
|
|
|
|
|
LIST_FOREACH(pgsqldb, &pgsql_db_conn_strings, rlist) {
|
|
|
|
if (!strcmp(pgsqldb->name, dbname))
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
pgsqldb = kore_malloc(sizeof(*pgsqldb));
|
|
|
|
pgsqldb->name = kore_strdup(dbname);
|
|
|
|
pgsqldb->conn_string = kore_strdup(connstring);
|
|
|
|
LIST_INSERT_HEAD(&pgsql_db_conn_strings, pgsqldb, rlist);
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
return (KORE_RESULT_OK);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
kore_pgsql_handle(void *c, int err)
|
|
|
|
{
|
|
|
|
struct http_request *req;
|
2014-08-14 14:34:23 +02:00
|
|
|
struct kore_pgsql *pgsql;
|
2014-03-30 23:54:35 +02:00
|
|
|
struct pgsql_conn *conn = (struct pgsql_conn *)c;
|
2014-03-31 00:57:00 +02:00
|
|
|
|
|
|
|
if (err) {
|
|
|
|
pgsql_conn_cleanup(conn);
|
|
|
|
return;
|
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
req = conn->job->req;
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql = conn->job->pgsql;
|
|
|
|
kore_debug("kore_pgsql_handle: %p (%d)", req, pgsql->state);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
if (!PQconsumeInput(conn->db)) {
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->state = KORE_PGSQL_STATE_ERROR;
|
|
|
|
pgsql->error = kore_strdup(PQerrorMessage(conn->db));
|
2014-03-30 23:54:35 +02:00
|
|
|
} else {
|
2016-01-04 11:12:43 +01:00
|
|
|
pgsql_read_result(pgsql);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
if (pgsql->state == KORE_PGSQL_STATE_WAIT) {
|
2014-07-04 16:51:19 +02:00
|
|
|
http_request_sleep(req);
|
2014-04-17 10:49:48 +02:00
|
|
|
} else {
|
2014-07-04 16:51:19 +02:00
|
|
|
http_request_wakeup(req);
|
2014-04-17 10:49:48 +02:00
|
|
|
}
|
2014-03-31 00:57:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-08-14 14:34:23 +02:00
|
|
|
kore_pgsql_continue(struct http_request *req, struct kore_pgsql *pgsql)
|
2014-03-31 00:57:00 +02:00
|
|
|
{
|
2014-08-14 14:34:23 +02:00
|
|
|
kore_debug("kore_pgsql_continue: %p->%p (%d)",
|
|
|
|
req->owner, req, pgsql->state);
|
2014-04-17 10:49:48 +02:00
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
if (pgsql->error) {
|
2016-07-12 13:54:14 +02:00
|
|
|
kore_free(pgsql->error);
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->error = NULL;
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2014-08-14 16:43:40 +02:00
|
|
|
if (pgsql->result) {
|
2014-08-14 14:34:23 +02:00
|
|
|
PQclear(pgsql->result);
|
2014-08-14 16:43:40 +02:00
|
|
|
pgsql->result = NULL;
|
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
switch (pgsql->state) {
|
2014-03-30 23:54:35 +02:00
|
|
|
case KORE_PGSQL_STATE_INIT:
|
|
|
|
case KORE_PGSQL_STATE_WAIT:
|
|
|
|
break;
|
|
|
|
case KORE_PGSQL_STATE_DONE:
|
2014-07-04 16:51:19 +02:00
|
|
|
http_request_wakeup(req);
|
2014-08-14 14:46:21 +02:00
|
|
|
pgsql_conn_release(pgsql);
|
2014-03-30 23:54:35 +02:00
|
|
|
break;
|
|
|
|
case KORE_PGSQL_STATE_ERROR:
|
|
|
|
case KORE_PGSQL_STATE_RESULT:
|
2014-08-14 14:46:21 +02:00
|
|
|
kore_pgsql_handle(pgsql->conn, 0);
|
2014-03-30 23:54:35 +02:00
|
|
|
break;
|
|
|
|
default:
|
2014-08-14 14:34:23 +02:00
|
|
|
fatal("unknown pgsql state %d", pgsql->state);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-08-14 14:34:23 +02:00
|
|
|
kore_pgsql_cleanup(struct kore_pgsql *pgsql)
|
2014-03-30 23:54:35 +02:00
|
|
|
{
|
2014-08-14 22:05:34 +02:00
|
|
|
kore_debug("kore_pgsql_cleanup(%p)", pgsql);
|
|
|
|
|
2014-08-14 14:46:21 +02:00
|
|
|
if (pgsql->result != NULL)
|
2014-08-14 14:34:23 +02:00
|
|
|
PQclear(pgsql->result);
|
2014-03-31 00:57:00 +02:00
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
if (pgsql->error != NULL)
|
2016-07-12 13:54:14 +02:00
|
|
|
kore_free(pgsql->error);
|
2014-03-31 01:09:08 +02:00
|
|
|
|
2014-08-21 16:36:12 +02:00
|
|
|
if (pgsql->conn != NULL)
|
2014-08-14 14:46:21 +02:00
|
|
|
pgsql_conn_release(pgsql);
|
2014-08-14 14:34:23 +02:00
|
|
|
|
|
|
|
pgsql->result = NULL;
|
|
|
|
pgsql->error = NULL;
|
|
|
|
pgsql->conn = NULL;
|
2014-08-14 22:05:34 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
if (pgsql->flags & PGSQL_LIST_INSERTED) {
|
|
|
|
LIST_REMOVE(pgsql, rlist);
|
|
|
|
pgsql->flags &= ~PGSQL_LIST_INSERTED;
|
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2014-04-02 23:01:47 +02:00
|
|
|
void
|
|
|
|
kore_pgsql_logerror(struct kore_pgsql *pgsql)
|
|
|
|
{
|
|
|
|
kore_log(LOG_NOTICE, "pgsql error: %s",
|
|
|
|
(pgsql->error) ? pgsql->error : "unknown");
|
|
|
|
}
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
int
|
2014-04-01 21:43:32 +02:00
|
|
|
kore_pgsql_ntuples(struct kore_pgsql *pgsql)
|
2014-03-30 23:54:35 +02:00
|
|
|
{
|
2014-04-01 21:43:32 +02:00
|
|
|
return (PQntuples(pgsql->result));
|
|
|
|
}
|
|
|
|
|
2017-02-06 11:40:33 +01:00
|
|
|
int
|
|
|
|
kore_pgsql_nfields(struct kore_pgsql *pgsql)
|
|
|
|
{
|
|
|
|
return (PQnfields(pgsql->result));
|
|
|
|
}
|
|
|
|
|
2014-09-28 23:03:49 +02:00
|
|
|
int
|
|
|
|
kore_pgsql_getlength(struct kore_pgsql *pgsql, int row, int col)
|
|
|
|
{
|
|
|
|
return (PQgetlength(pgsql->result, row, col));
|
|
|
|
}
|
|
|
|
|
2017-02-06 11:40:33 +01:00
|
|
|
char *
|
|
|
|
kore_pgsql_fieldname(struct kore_pgsql *pgsql, int field)
|
|
|
|
{
|
|
|
|
return (PQfname(pgsql->result, field));
|
|
|
|
}
|
|
|
|
|
2014-04-01 21:43:32 +02:00
|
|
|
char *
|
|
|
|
kore_pgsql_getvalue(struct kore_pgsql *pgsql, int row, int col)
|
|
|
|
{
|
|
|
|
return (PQgetvalue(pgsql->result, row, col));
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2014-08-21 16:36:12 +02:00
|
|
|
void
|
|
|
|
kore_pgsql_queue_remove(struct http_request *req)
|
|
|
|
{
|
|
|
|
struct pgsql_wait *pgw, *next;
|
|
|
|
|
2017-02-07 22:35:09 +01:00
|
|
|
TAILQ_FOREACH_SAFE(pgw, &pgsql_wait_queue, list, next) {
|
2014-08-21 16:36:12 +02:00
|
|
|
if (pgw->req != req)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
TAILQ_REMOVE(&pgsql_wait_queue, pgw, list);
|
|
|
|
kore_pool_put(&pgsql_wait_pool, pgw);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
static struct pgsql_conn *
|
|
|
|
pgsql_conn_next(struct kore_pgsql *pgsql, struct pgsql_db *db,
|
|
|
|
struct http_request *req)
|
2014-09-28 21:39:16 +02:00
|
|
|
{
|
|
|
|
struct pgsql_conn *conn;
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
conn = NULL;
|
2014-09-28 21:39:16 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
TAILQ_FOREACH(conn, &pgsql_conn_free, list) {
|
|
|
|
if (!(conn->flags & PGSQL_CONN_FREE))
|
|
|
|
fatal("got a pgsql connection that was not free?");
|
|
|
|
if (!strcmp(conn->name, db->name))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (conn == NULL) {
|
2014-09-28 21:39:16 +02:00
|
|
|
if (pgsql_conn_count >= pgsql_conn_max) {
|
2016-01-04 11:12:43 +01:00
|
|
|
if (pgsql->flags & KORE_PGSQL_ASYNC) {
|
|
|
|
pgsql_queue_add(req);
|
|
|
|
} else {
|
|
|
|
pgsql_set_error(pgsql,
|
|
|
|
"no available connection");
|
|
|
|
}
|
|
|
|
|
|
|
|
return (NULL);
|
2014-09-28 21:39:16 +02:00
|
|
|
}
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
if ((conn = pgsql_conn_create(pgsql, db)) == NULL)
|
|
|
|
return (NULL);
|
2014-09-28 21:39:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
conn->flags &= ~PGSQL_CONN_FREE;
|
|
|
|
TAILQ_REMOVE(&pgsql_conn_free, conn, list);
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
return (conn);
|
|
|
|
}
|
2014-09-28 21:39:16 +02:00
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
static void
|
|
|
|
pgsql_set_error(struct kore_pgsql *pgsql, const char *msg)
|
|
|
|
{
|
|
|
|
if (pgsql->error != NULL)
|
2016-07-12 13:54:14 +02:00
|
|
|
kore_free(pgsql->error);
|
2016-01-04 11:12:43 +01:00
|
|
|
|
|
|
|
pgsql->error = kore_strdup(msg);
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_ERROR;
|
2014-09-28 21:39:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-01-04 11:12:43 +01:00
|
|
|
pgsql_schedule(struct kore_pgsql *pgsql)
|
2014-09-28 21:39:16 +02:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = PQsocket(pgsql->conn->db);
|
|
|
|
if (fd < 0)
|
|
|
|
fatal("PQsocket returned < 0 fd on open connection");
|
|
|
|
|
|
|
|
kore_platform_schedule_read(fd, pgsql->conn);
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_WAIT;
|
2017-01-29 10:34:53 +01:00
|
|
|
pgsql->flags |= KORE_PGSQL_SCHEDULED;
|
2014-09-28 21:39:16 +02:00
|
|
|
}
|
|
|
|
|
2014-08-21 16:36:12 +02:00
|
|
|
static void
|
|
|
|
pgsql_queue_add(struct http_request *req)
|
|
|
|
{
|
|
|
|
struct pgsql_wait *pgw;
|
|
|
|
|
|
|
|
http_request_sleep(req);
|
|
|
|
|
|
|
|
pgw = kore_pool_get(&pgsql_wait_pool);
|
|
|
|
pgw->req = req;
|
|
|
|
pgw->req->flags |= HTTP_REQUEST_PGSQL_QUEUE;
|
|
|
|
|
|
|
|
TAILQ_INSERT_TAIL(&pgsql_wait_queue, pgw, list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pgsql_queue_wakeup(void)
|
|
|
|
{
|
|
|
|
struct pgsql_wait *pgw, *next;
|
|
|
|
|
2017-02-07 22:35:09 +01:00
|
|
|
TAILQ_FOREACH_SAFE(pgw, &pgsql_wait_queue, list, next) {
|
2014-08-21 16:36:12 +02:00
|
|
|
if (pgw->req->flags & HTTP_REQUEST_DELETE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
http_request_wakeup(pgw->req);
|
|
|
|
pgw->req->flags &= ~HTTP_REQUEST_PGSQL_QUEUE;
|
|
|
|
|
|
|
|
TAILQ_REMOVE(&pgsql_wait_queue, pgw, list);
|
|
|
|
kore_pool_put(&pgsql_wait_pool, pgw);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
static struct pgsql_conn *
|
|
|
|
pgsql_conn_create(struct kore_pgsql *pgsql, struct pgsql_db *db)
|
2014-03-30 23:54:35 +02:00
|
|
|
{
|
|
|
|
struct pgsql_conn *conn;
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
if (db == NULL || db->conn_string == NULL)
|
2014-04-14 08:45:31 +02:00
|
|
|
fatal("pgsql_conn_create: no connection string");
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
pgsql_conn_count++;
|
2017-01-10 15:29:03 +01:00
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
conn = kore_malloc(sizeof(*conn));
|
2017-01-10 15:29:03 +01:00
|
|
|
conn->job = NULL;
|
|
|
|
conn->flags = PGSQL_CONN_FREE;
|
|
|
|
conn->type = KORE_TYPE_PGSQL_CONN;
|
|
|
|
conn->name = kore_strdup(db->name);
|
|
|
|
TAILQ_INSERT_TAIL(&pgsql_conn_free, conn, list);
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
kore_debug("pgsql_conn_create(): %p", conn);
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
conn->db = PQconnectdb(db->conn_string);
|
2014-03-30 23:54:35 +02:00
|
|
|
if (conn->db == NULL || (PQstatus(conn->db) != CONNECTION_OK)) {
|
2016-01-04 11:12:43 +01:00
|
|
|
pgsql_set_error(pgsql, PQerrorMessage(conn->db));
|
2014-03-30 23:54:35 +02:00
|
|
|
pgsql_conn_cleanup(conn);
|
2016-01-04 11:12:43 +01:00
|
|
|
return (NULL);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
return (conn);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2014-08-14 14:46:21 +02:00
|
|
|
static void
|
|
|
|
pgsql_conn_release(struct kore_pgsql *pgsql)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (pgsql->conn == NULL)
|
|
|
|
return;
|
|
|
|
|
2016-01-04 11:12:43 +01:00
|
|
|
/* Async query cleanup */
|
|
|
|
if (pgsql->flags & KORE_PGSQL_ASYNC) {
|
2017-02-06 11:40:33 +01:00
|
|
|
if (pgsql->flags & KORE_PGSQL_SCHEDULED) {
|
|
|
|
fd = PQsocket(pgsql->conn->db);
|
|
|
|
kore_platform_disable_read(fd);
|
|
|
|
|
2017-02-06 20:01:16 +01:00
|
|
|
if (pgsql->state != KORE_PGSQL_STATE_DONE)
|
|
|
|
pgsql_cancel(pgsql);
|
2016-01-04 11:12:43 +01:00
|
|
|
}
|
2017-02-06 11:40:33 +01:00
|
|
|
kore_pool_put(&pgsql_job_pool, pgsql->conn->job);
|
2016-01-04 11:12:43 +01:00
|
|
|
}
|
2014-08-14 14:46:21 +02:00
|
|
|
|
2014-08-14 16:43:40 +02:00
|
|
|
/* Drain just in case. */
|
|
|
|
while (PQgetResult(pgsql->conn->db) != NULL)
|
|
|
|
;
|
|
|
|
|
2014-08-14 14:46:21 +02:00
|
|
|
pgsql->conn->job = NULL;
|
|
|
|
pgsql->conn->flags |= PGSQL_CONN_FREE;
|
|
|
|
TAILQ_INSERT_TAIL(&pgsql_conn_free, pgsql->conn, list);
|
|
|
|
|
|
|
|
pgsql->conn = NULL;
|
2014-08-21 16:36:12 +02:00
|
|
|
pgsql->state = KORE_PGSQL_STATE_COMPLETE;
|
|
|
|
|
|
|
|
pgsql_queue_wakeup();
|
2014-08-14 14:46:21 +02:00
|
|
|
}
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
static void
|
|
|
|
pgsql_conn_cleanup(struct pgsql_conn *conn)
|
|
|
|
{
|
|
|
|
struct http_request *req;
|
2014-08-14 14:34:23 +02:00
|
|
|
struct kore_pgsql *pgsql;
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
kore_debug("pgsql_conn_cleanup(): %p", conn);
|
|
|
|
|
|
|
|
if (conn->flags & PGSQL_CONN_FREE)
|
|
|
|
TAILQ_REMOVE(&pgsql_conn_free, conn, list);
|
|
|
|
|
|
|
|
if (conn->job) {
|
|
|
|
req = conn->job->req;
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql = conn->job->pgsql;
|
2014-07-04 16:51:19 +02:00
|
|
|
http_request_wakeup(req);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->conn = NULL;
|
2016-01-04 11:12:43 +01:00
|
|
|
pgsql_set_error(pgsql, PQerrorMessage(conn->db));
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-08-21 16:36:12 +02:00
|
|
|
kore_pool_put(&pgsql_job_pool, conn->job);
|
2014-03-30 23:54:35 +02:00
|
|
|
conn->job = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (conn->db != NULL)
|
|
|
|
PQfinish(conn->db);
|
|
|
|
|
|
|
|
pgsql_conn_count--;
|
2016-07-12 13:54:14 +02:00
|
|
|
kore_free(conn->name);
|
|
|
|
kore_free(conn);
|
2014-03-30 23:54:35 +02:00
|
|
|
}
|
2014-03-31 01:04:22 +02:00
|
|
|
|
|
|
|
static void
|
2016-01-04 11:12:43 +01:00
|
|
|
pgsql_read_result(struct kore_pgsql *pgsql)
|
2014-03-31 01:04:22 +02:00
|
|
|
{
|
2016-01-04 11:12:43 +01:00
|
|
|
if (PQisBusy(pgsql->conn->db)) {
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_WAIT;
|
|
|
|
return;
|
2014-03-31 01:04:22 +02:00
|
|
|
}
|
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->result = PQgetResult(pgsql->conn->db);
|
|
|
|
if (pgsql->result == NULL) {
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_DONE;
|
2014-03-31 01:04:22 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-08-14 14:34:23 +02:00
|
|
|
switch (PQresultStatus(pgsql->result)) {
|
2014-03-31 01:04:22 +02:00
|
|
|
case PGRES_COPY_OUT:
|
|
|
|
case PGRES_COPY_IN:
|
|
|
|
case PGRES_NONFATAL_ERROR:
|
|
|
|
case PGRES_COPY_BOTH:
|
|
|
|
break;
|
|
|
|
case PGRES_COMMAND_OK:
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->state = KORE_PGSQL_STATE_DONE;
|
2014-03-31 01:04:22 +02:00
|
|
|
break;
|
|
|
|
case PGRES_TUPLES_OK:
|
2014-07-03 22:58:04 +02:00
|
|
|
#if PG_VERSION_NUM >= 90200
|
2014-03-31 01:04:22 +02:00
|
|
|
case PGRES_SINGLE_TUPLE:
|
2014-07-03 22:58:04 +02:00
|
|
|
#endif
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->state = KORE_PGSQL_STATE_RESULT;
|
2014-03-31 01:04:22 +02:00
|
|
|
break;
|
|
|
|
case PGRES_EMPTY_QUERY:
|
|
|
|
case PGRES_BAD_RESPONSE:
|
|
|
|
case PGRES_FATAL_ERROR:
|
2016-01-04 11:12:43 +01:00
|
|
|
pgsql_set_error(pgsql, PQresultErrorMessage(pgsql->result));
|
2014-03-31 01:04:22 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-02-06 20:01:16 +01:00
|
|
|
|
|
|
|
static void
|
|
|
|
pgsql_cancel(struct kore_pgsql *pgsql)
|
|
|
|
{
|
|
|
|
PGcancel *cancel;
|
|
|
|
char buf[256];
|
|
|
|
|
|
|
|
if ((cancel = PQgetCancel(pgsql->conn->db)) != NULL) {
|
|
|
|
if (!PQcancel(cancel, buf, sizeof(buf)))
|
|
|
|
kore_log(LOG_ERR, "failed to cancel: %s", buf);
|
|
|
|
PQfreeCancel(cancel);
|
|
|
|
}
|
|
|
|
}
|