2014-03-30 23:54:35 +02:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2014 Joris Vink <joris@coders.se>
|
|
|
|
*
|
|
|
|
* 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 {
|
|
|
|
char *query;
|
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-08-14 14:34:23 +02:00
|
|
|
#define PGSQL_IS_BLOCKING 0
|
|
|
|
#define PGSQL_IS_ASYNC 1
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
#define PGSQL_CONN_MAX 2
|
|
|
|
#define PGSQL_CONN_FREE 0x01
|
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
static void pgsql_queue_wakeup(void);
|
|
|
|
static int pgsql_conn_create(struct kore_pgsql *);
|
|
|
|
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 *);
|
2014-08-14 14:34:23 +02:00
|
|
|
static void pgsql_read_result(struct kore_pgsql *, int);
|
2014-09-28 21:39:16 +02:00
|
|
|
static void pgsql_schedule(struct kore_pgsql *, struct http_request *);
|
|
|
|
static int pgsql_prepare(struct kore_pgsql *, struct http_request *,
|
|
|
|
const char *);
|
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;
|
2014-03-30 23:54:35 +02:00
|
|
|
static u_int16_t pgsql_conn_count;
|
2014-04-14 08:41:41 +02:00
|
|
|
char *pgsql_conn_string = NULL;
|
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);
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2014-09-28 21:39:16 +02:00
|
|
|
kore_pgsql_query(struct kore_pgsql *pgsql, struct http_request *req,
|
2014-08-14 14:34:23 +02:00
|
|
|
const char *query)
|
2014-03-30 23:54:35 +02:00
|
|
|
{
|
2014-09-28 21:39:16 +02:00
|
|
|
if (!pgsql_prepare(pgsql, req, query))
|
|
|
|
return (KORE_RESULT_ERROR);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
if (!PQsendQuery(pgsql->conn->db, query)) {
|
|
|
|
pgsql_conn_cleanup(pgsql->conn);
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
pgsql_schedule(pgsql, req);
|
|
|
|
return (KORE_RESULT_OK);
|
|
|
|
}
|
2014-08-21 16:36:12 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
int
|
|
|
|
kore_pgsql_query_params(struct kore_pgsql *pgsql, struct http_request *req,
|
|
|
|
const char *query, int result, u_int8_t count, ...)
|
|
|
|
{
|
|
|
|
u_int8_t i;
|
|
|
|
va_list args;
|
|
|
|
char **values;
|
|
|
|
int *lengths, *formats;
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
if (!pgsql_prepare(pgsql, req, query))
|
|
|
|
return (KORE_RESULT_ERROR);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-10-12 01:17:35 +02:00
|
|
|
if (count > 0) {
|
|
|
|
va_start(args, count);
|
|
|
|
|
|
|
|
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 *);
|
|
|
|
lengths[i] = va_arg(args, u_int32_t);
|
|
|
|
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
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
if (!PQsendQueryParams(pgsql->conn->db, query, count, NULL,
|
|
|
|
(const char * const *)values, lengths, formats, result)) {
|
|
|
|
kore_mem_free(values);
|
|
|
|
kore_mem_free(lengths);
|
|
|
|
kore_mem_free(formats);
|
|
|
|
pgsql_conn_cleanup(pgsql->conn);
|
2014-03-30 23:54:35 +02:00
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
kore_mem_free(values);
|
|
|
|
kore_mem_free(lengths);
|
|
|
|
kore_mem_free(formats);
|
2014-03-30 23:54:35 +02:00
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
pgsql_schedule(pgsql, req);
|
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 {
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql_read_result(pgsql, PGSQL_IS_ASYNC);
|
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) {
|
|
|
|
kore_mem_free(pgsql->error);
|
|
|
|
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)
|
|
|
|
kore_mem_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
|
|
|
|
|
|
|
LIST_REMOVE(pgsql, rlist);
|
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));
|
|
|
|
}
|
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
for (pgw = TAILQ_FIRST(&pgsql_wait_queue); pgw != NULL; pgw = next) {
|
|
|
|
next = TAILQ_NEXT(pgw, list);
|
|
|
|
if (pgw->req != req)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
TAILQ_REMOVE(&pgsql_wait_queue, pgw, list);
|
|
|
|
kore_pool_put(&pgsql_wait_pool, pgw);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-28 21:39:16 +02:00
|
|
|
static int
|
|
|
|
pgsql_prepare(struct kore_pgsql *pgsql, struct http_request *req,
|
|
|
|
const char *query)
|
|
|
|
{
|
|
|
|
struct pgsql_conn *conn;
|
|
|
|
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_INIT;
|
|
|
|
pgsql->result = NULL;
|
|
|
|
pgsql->error = NULL;
|
|
|
|
pgsql->conn = NULL;
|
|
|
|
|
|
|
|
if (TAILQ_EMPTY(&pgsql_conn_free)) {
|
|
|
|
if (pgsql_conn_count >= pgsql_conn_max) {
|
|
|
|
pgsql_queue_add(req);
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pgsql_conn_create(pgsql))
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
http_request_sleep(req);
|
|
|
|
conn = TAILQ_FIRST(&pgsql_conn_free);
|
|
|
|
if (!(conn->flags & PGSQL_CONN_FREE))
|
|
|
|
fatal("received a pgsql conn that was not free?");
|
|
|
|
|
|
|
|
conn->flags &= ~PGSQL_CONN_FREE;
|
|
|
|
TAILQ_REMOVE(&pgsql_conn_free, conn, list);
|
|
|
|
|
|
|
|
pgsql->conn = conn;
|
|
|
|
conn->job = kore_pool_get(&pgsql_job_pool);
|
|
|
|
conn->job->query = kore_strdup(query);
|
|
|
|
conn->job->pgsql = pgsql;
|
|
|
|
conn->job->req = req;
|
|
|
|
|
|
|
|
LIST_INSERT_HEAD(&(req->pgsqls), pgsql, rlist);
|
|
|
|
return (KORE_RESULT_OK);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pgsql_schedule(struct kore_pgsql *pgsql, struct http_request *req)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
for (pgw = TAILQ_FIRST(&pgsql_wait_queue); pgw != NULL; pgw = next) {
|
|
|
|
next = TAILQ_NEXT(pgw, list);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
static int
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql_conn_create(struct kore_pgsql *pgsql)
|
2014-03-30 23:54:35 +02:00
|
|
|
{
|
|
|
|
struct pgsql_conn *conn;
|
|
|
|
|
2014-04-14 08:45:31 +02:00
|
|
|
if (pgsql_conn_string == NULL)
|
|
|
|
fatal("pgsql_conn_create: no connection string");
|
|
|
|
|
2014-03-30 23:54:35 +02:00
|
|
|
pgsql_conn_count++;
|
|
|
|
conn = kore_malloc(sizeof(*conn));
|
|
|
|
kore_debug("pgsql_conn_create(): %p", conn);
|
|
|
|
memset(conn, 0, sizeof(*conn));
|
|
|
|
|
2014-04-14 08:41:41 +02:00
|
|
|
conn->db = PQconnectdb(pgsql_conn_string);
|
2014-03-30 23:54:35 +02:00
|
|
|
if (conn->db == NULL || (PQstatus(conn->db) != CONNECTION_OK)) {
|
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
|
|
|
pgsql_conn_cleanup(conn);
|
|
|
|
return (KORE_RESULT_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
conn->job = NULL;
|
|
|
|
conn->flags = PGSQL_CONN_FREE;
|
|
|
|
conn->type = KORE_TYPE_PGSQL_CONN;
|
|
|
|
TAILQ_INSERT_TAIL(&pgsql_conn_free, conn, list);
|
|
|
|
|
|
|
|
return (KORE_RESULT_OK);
|
|
|
|
}
|
|
|
|
|
2014-08-14 14:46:21 +02:00
|
|
|
static void
|
|
|
|
pgsql_conn_release(struct kore_pgsql *pgsql)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (pgsql->conn == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
kore_mem_free(pgsql->conn->job->query);
|
2014-08-21 16:36:12 +02:00
|
|
|
kore_pool_put(&pgsql_job_pool, pgsql->conn->job);
|
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);
|
|
|
|
|
|
|
|
fd = PQsocket(pgsql->conn->db);
|
|
|
|
kore_platform_disable_read(fd);
|
|
|
|
|
|
|
|
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;
|
|
|
|
pgsql->state = KORE_PGSQL_STATE_ERROR;
|
|
|
|
pgsql->error = kore_strdup(PQerrorMessage(conn->db));
|
2014-03-30 23:54:35 +02:00
|
|
|
|
|
|
|
kore_mem_free(conn->job->query);
|
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--;
|
|
|
|
kore_mem_free(conn);
|
|
|
|
}
|
2014-03-31 01:04:22 +02:00
|
|
|
|
|
|
|
static void
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql_read_result(struct kore_pgsql *pgsql, int async)
|
2014-03-31 01:04:22 +02:00
|
|
|
{
|
2014-08-14 14:34:23 +02:00
|
|
|
if (async) {
|
|
|
|
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:
|
2014-08-14 14:34:23 +02:00
|
|
|
pgsql->state = KORE_PGSQL_STATE_ERROR;
|
|
|
|
pgsql->error = kore_strdup(PQresultErrorMessage(pgsql->result));
|
2014-03-31 01:04:22 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|