#include <stdlib.h>

#define PHP_PGSQL_PRIVATE 1

#ifdef HAVE_CONFIG_H

#include <config.h>

#include "php.h"

#include "php_ini.h"

#include "ext/standard/info.h"

#include "zend_smart_str.h"

#include "ext/pcre/php_pcre.h"

#ifdef PHP_WIN32

# include "win32/time.h"

#include "php_pgsql.h"

#include "php_globals.h"

#include "zend_exceptions.h"

#include "zend_attributes.h"

#include "zend_interfaces.h"

#include "php_network.h"

#ifdef HAVE_PGSQL

#ifndef InvalidOid

#define InvalidOid ((Oid) 0)

#define PGSQL_ASSOC 1<<0

#define PGSQL_NUM 1<<1

#define PGSQL_BOTH (PGSQL_ASSOC|PGSQL_NUM)

#define PGSQL_NOTICE_LAST 1 /* Get the last notice */

#define PGSQL_NOTICE_ALL 2 /* Get all notices */

#define PGSQL_NOTICE_CLEAR 3 /* Remove notices */

#define PGSQL_STATUS_LONG 1

#define PGSQL_STATUS_STRING 2

#define PGSQL_MAX_LENGTH_OF_LONG 30

#define PGSQL_MAX_LENGTH_OF_DOUBLE 60

char pgsql_libpq_version[16];

#include "pgsql_arginfo.h"

#if ZEND_LONG_MAX < UINT_MAX

#define PGSQL_RETURN_OID(oid) do { \

if (oid > ZEND_LONG_MAX) { \

RETURN_STR(zend_ulong_to_str(oid)); \

} \

RETURN_LONG((zend_long)oid); \

} while(0)

#define PGSQL_RETURN_OID(oid) RETURN_LONG((zend_long)oid)

#define CHECK_DEFAULT_LINK(x) \

if ((x) == NULL) { \

zend_throw_error(NULL, "No PostgreSQL connection opened yet"); \

RETURN_THROWS(); \

}

#define FETCH_DEFAULT_LINK() \

(PGG(default_link) ? pgsql_link_from_obj(PGG(default_link)) : NULL); \

php_error_docref(NULL, E_DEPRECATED, "Automatic fetching of PostgreSQL connection is deprecated")

#define FETCH_DEFAULT_LINK_NO_WARNING() \

(PGG(default_link) ? pgsql_link_from_obj(PGG(default_link)) : NULL)

#define CHECK_PGSQL_LINK(link_handle) \

if (link_handle->conn == NULL) { \

zend_throw_error(NULL, "PostgreSQL connection has already been closed"); \

RETURN_THROWS(); \

}

#define CHECK_PGSQL_RESULT(result_handle) \

if (result_handle->result == NULL) { \

zend_throw_error(NULL, "PostgreSQL result has already been closed"); \

RETURN_THROWS(); \

}

#define CHECK_PGSQL_LOB(lob) \

if (lob->conn == NULL) { \

zend_throw_error(NULL, "PostgreSQL large object has already been closed"); \

RETURN_THROWS(); \

}

#ifndef HAVE_PQERRORS_SQLSTATE

#define PQERRORS_SQLSTATE 0

ZEND_DECLARE_MODULE_GLOBALS(pgsql)

static PHP_GINIT_FUNCTION(pgsql);

static const zend_module_dep pgsql_module_deps[] = {

ZEND_MOD_REQUIRED("pcre")

ZEND_MOD_END

};

zend_module_entry pgsql_module_entry = {

STANDARD_MODULE_HEADER_EX, NULL,

pgsql_module_deps,

"pgsql",

ext_functions,

PHP_MINIT(pgsql),

PHP_MSHUTDOWN(pgsql),

PHP_RINIT(pgsql),

PHP_RSHUTDOWN(pgsql),

PHP_MINFO(pgsql),

PHP_PGSQL_VERSION,

PHP_MODULE_GLOBALS(pgsql),

PHP_GINIT(pgsql),

NULL,

NULL,

STANDARD_MODULE_PROPERTIES_EX

};

#ifdef COMPILE_DL_PGSQL

#ifdef ZTS

ZEND_TSRMLS_CACHE_DEFINE()

ZEND_GET_MODULE(pgsql)

static int le_plink;

static zend_class_entry *pgsql_link_ce, *pgsql_result_ce, *pgsql_lob_ce;

static zend_object_handlers pgsql_link_object_handlers, pgsql_result_object_handlers, pgsql_lob_object_handlers;

static inline pgsql_link_handle *pgsql_link_from_obj(zend_object *obj) {

return (pgsql_link_handle *)((char *)(obj) - XtOffsetOf(pgsql_link_handle, std));

}

#define Z_PGSQL_LINK_P(zv) pgsql_link_from_obj(Z_OBJ_P(zv))

static zend_object *pgsql_link_create_object(zend_class_entry *class_type) {

pgsql_link_handle *intern = zend_object_alloc(sizeof(pgsql_link_handle), class_type);

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *pgsql_link_get_constructor(zend_object *object) {

zend_throw_error(NULL, "Cannot directly construct PgSql\\Connection, use pg_connect() or pg_pconnect() instead");

return NULL;

}

static void pgsql_link_free(pgsql_link_handle *link)

{

PGresult *res;

while ((res = PQgetResult(link->conn))) {

PQclear(res);

}

if (!link->persistent) {

PQuntrace(link->conn);

PQfinish(link->conn);

}

PGG(num_links)--;

zend_hash_del(&PGG(connections), link->hash);

link->conn = NULL;

zend_string_release(link->hash);

if (link->notices) {

zend_hash_destroy(link->notices);

FREE_HASHTABLE(link->notices);

link->notices = NULL;

}

}

static void pgsql_link_free_obj(zend_object *obj)

{

pgsql_link_handle *link = pgsql_link_from_obj(obj);

if (link->conn) {

pgsql_link_free(link);

}

zend_object_std_dtor(&link->std);

}

static inline pgsql_result_handle *pgsql_result_from_obj(zend_object *obj) {

return (pgsql_result_handle *)((char *)(obj) - XtOffsetOf(pgsql_result_handle, std));

}

#define Z_PGSQL_RESULT_P(zv) pgsql_result_from_obj(Z_OBJ_P(zv))

static zend_object *pgsql_result_create_object(zend_class_entry *class_type) {

pgsql_result_handle *intern = zend_object_alloc(sizeof(pgsql_result_handle), class_type);

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *pgsql_result_get_constructor(zend_object *object) {

zend_throw_error(NULL, "Cannot directly construct PgSql\\Result, use a dedicated function instead");

return NULL;

}

static void pgsql_result_free(pgsql_result_handle *pg_result)

{

PQclear(pg_result->result);

pg_result->result = NULL;

}

static void pgsql_result_free_obj(zend_object *obj)

{

pgsql_result_handle *pg_result = pgsql_result_from_obj(obj);

if (pg_result->result) {

pgsql_result_free(pg_result);

}

zend_object_std_dtor(&pg_result->std);

}

static inline pgLofp *pgsql_lob_from_obj(zend_object *obj) {

return (pgLofp *)((char *)(obj) - XtOffsetOf(pgLofp, std));

}

#define Z_PGSQL_LOB_P(zv) pgsql_lob_from_obj(Z_OBJ_P(zv))

static zend_object *pgsql_lob_create_object(zend_class_entry *class_type) {

pgLofp *intern = zend_object_alloc(sizeof(pgLofp), class_type);

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *pgsql_lob_get_constructor(zend_object *object) {

zend_throw_error(NULL, "Cannot directly construct PgSql\\Lob, use pg_lo_open() instead");

return NULL;

}

static void pgsql_lob_free_obj(zend_object *obj)

{

pgLofp *lofp = pgsql_lob_from_obj(obj);

zend_object_std_dtor(&lofp->std);

}

static zend_string *_php_pgsql_trim_message(const char *message)

{

size_t i = strlen(message);

if (i>2 && (message[i-2] == '\r' || message[i-2] == '\n') && message[i-1] == '.') {

--i;

}

while (i>1 && (message[i-1] == '\r' || message[i-1] == '\n')) {

--i;

}

return zend_string_init(message, i, 0);

}

#define PHP_PQ_ERROR(text, pgsql) { \

zend_string *msgbuf = _php_pgsql_trim_message(PQerrorMessage(pgsql)); \

php_error_docref(NULL, E_WARNING, text, ZSTR_VAL(msgbuf)); \

zend_string_release(msgbuf); \

} \

static void php_pgsql_set_default_link(zend_object *obj)

{

GC_ADDREF(obj);

if (PGG(default_link) != NULL) {

zend_object_release(PGG(default_link));

}

PGG(default_link) = obj;

}

static void _close_pgsql_plink(zend_resource *rsrc)

{

PGconn *link = (PGconn *)rsrc->ptr;

PGresult *res;

while ((res = PQgetResult(link))) {

PQclear(res);

}

PQfinish(link);

PGG(num_persistent)--;

PGG(num_links)--;

rsrc->ptr = NULL;

}

static void _php_pgsql_notice_handler(void *l, const char *message)

{

if (l == NULL) {

/* This connection does not currently have a valid context, ignore this notice */

return;

}

if (PGG(ignore_notices)) {

return;

}

zval tmp;

pgsql_link_handle *link = (pgsql_link_handle *) l;

if (!link->notices) {

link->notices = zend_new_array(1);

}

zend_string *trimmed_message = _php_pgsql_trim_message(message);

if (PGG(log_notices)) {

php_error_docref(NULL, E_NOTICE, "%s", ZSTR_VAL(trimmed_message));

}

ZVAL_STR(&tmp, trimmed_message);

zend_hash_next_index_insert(link->notices, &tmp);

}

static int _rollback_transactions(zval *el)

{

PGconn *link;

PGresult *res;

zend_resource *rsrc = Z_RES_P(el);

if (rsrc->type != le_plink) {

return ZEND_HASH_APPLY_KEEP;

}

link = (PGconn *) rsrc->ptr;

/* unset notice processor if we initially did set it */

if (PQsetNoticeProcessor(link, NULL, NULL) == _php_pgsql_notice_handler) {

PQsetNoticeProcessor(link, _php_pgsql_notice_handler, NULL);

}

if (PQsetnonblocking(link, 0)) {

php_error_docref("ref.pgsql", E_NOTICE, "Cannot set connection to blocking mode");

return -1;

}

while ((res = PQgetResult(link))) {

PQclear(res);

}

if (PQtransactionStatus(link) != PQTRANS_IDLE) {

int orig = PGG(ignore_notices);

PGG(ignore_notices) = 1;

res = PQexec(link,"ROLLBACK;");

PQclear(res);

PGG(ignore_notices) = orig;

}

return ZEND_HASH_APPLY_KEEP;

}

static void release_string(zval *zv)

{

zend_string_release((zend_string *) Z_PTR_P(zv));

}

static bool _php_pgsql_identifier_is_escaped(const char *identifier, size_t len) /* {{{ */

{

/* Handle edge case. Cannot be a escaped string */

if (len <= 2) {

return false;

}

/* Detect double quotes */

if (identifier[0] == '"' && identifier[len-1] == '"') {

size_t i;

/* Detect wrong format of " inside of escaped string */

for (i = 1; i < len-1; i++) {

if (identifier[i] == '"' && (identifier[++i] != '"' || i == len-1)) {

return false;

}

}

} else {

return false;

}

/* Escaped properly */

return true;

}

#ifndef HAVE_PG_CHANGE_PASSWORD

static PGresult *PQchangePassword(PGconn *conn, const char *user, const char *passwd)

{

/**

char *enc = PQencryptPasswordConn(conn, passwd, user, NULL);

if (!enc) {

return NULL;

}

char *fmtenc = PQescapeLiteral(conn, enc, strlen(enc));

PQfreemem(enc);

if (!fmtenc) {

return NULL;

}

char *fmtuser = PQescapeIdentifier(conn, user, strlen(user));

if (!fmtuser) {

PQfreemem(fmtenc);

return NULL;

}

char *query;

spprintf(&query, 0, "ALTER USER %s PASSWORD %s", fmtuser, fmtenc);

PGresult *pg_result = PQexec(conn, query);

efree(query);

PQfreemem(fmtuser);

PQfreemem(fmtenc);

return pg_result;

}

#if !defined(HAVE_PG_SOCKET_POLL)

static int PQsocketPoll(int socket, int read, int write, time_t timeout)

{

if (!read && !write)

return 0;

php_pollfd fd;

int ts = -1;

fd.fd = socket;

fd.events = POLLERR;

fd.revents = 0;

if (read) {

fd.events |= POLLIN;

}

if (write) {

fd.events |= POLLOUT;

}

if (timeout != (time_t)ts) {

time_t cur = time(NULL);

if (timeout > cur) {

ts = (timeout - cur) * 1000;

} else {

ts = 0;

}

}

return php_poll2(&fd, 1, ts);

}

PHP_INI_BEGIN()

STD_PHP_INI_BOOLEAN( "pgsql.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateBool, allow_persistent, zend_pgsql_globals, pgsql_globals)

STD_PHP_INI_ENTRY_EX("pgsql.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_persistent, zend_pgsql_globals, pgsql_globals, display_link_numbers)

STD_PHP_INI_ENTRY_EX("pgsql.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_links, zend_pgsql_globals, pgsql_globals, display_link_numbers)

STD_PHP_INI_BOOLEAN( "pgsql.auto_reset_persistent", "0", PHP_INI_SYSTEM, OnUpdateLong, auto_reset_persistent, zend_pgsql_globals, pgsql_globals)

STD_PHP_INI_BOOLEAN( "pgsql.ignore_notice", "0", PHP_INI_ALL, OnUpdateBool, ignore_notices, zend_pgsql_globals, pgsql_globals)

STD_PHP_INI_BOOLEAN( "pgsql.log_notice", "0", PHP_INI_ALL, OnUpdateBool, log_notices, zend_pgsql_globals, pgsql_globals)

PHP_INI_END()

static PHP_GINIT_FUNCTION(pgsql)

{

#if defined(COMPILE_DL_PGSQL) && defined(ZTS)

ZEND_TSRMLS_CACHE_UPDATE();

size_t i = 0;

memset(pgsql_globals, 0, sizeof(zend_pgsql_globals));

zend_hash_init(&pgsql_globals->connections, 0, NULL, NULL, 1);

#define ADD_REGEX(reg) \

do { \

ZEND_ASSERT(i < PGSQL_MAX_REGEXES); \

pgsql_globals->regexes[i ++] = zend_string_init(reg, strlen(reg), true);\

} while(0)

ADD_REGEX("#^([+-]{0,1}[0-9]+)$#n");

ADD_REGEX("#^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$#n");

ADD_REGEX("#^[+-]{0,1}(inf)(inity){0,1}$#ni");

ADD_REGEX("#^[0-9]+$#n");

ADD_REGEX("#^((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])(\\/[0-9]{1,3})?$#n");

ADD_REGEX("#^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))(\\/[0-9]{1,3})?$#n");

ADD_REGEX("#^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})(([ \\t]+|T)(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}(\\.[0-9]+){0,1}([ \\t]*([+-][0-9]{1,4}(:[0-9]{1,2}){0,1}|[-a-zA-Z_/+]{1,50})){0,1})){0,1}$#ni");

ADD_REGEX("#^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})$#ni");

ADD_REGEX("#^(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}){0,1}$#ni");

ADD_REGEX("#^(@?[ \\t]+)?("

/* Textual time units and their abbreviations: */

"(([-+]?[ \\t]+)?"

"[0-9]+(\\.[0-9]*)?[ \\t]*"

"(millenniums|millennia|millennium|mil|mils|"

"centuries|century|cent|c|"

"decades|decade|dec|decs|"

"years|year|y|"

"months|month|mon|"

"weeks|week|w|"

"days|day|d|"

"hours|hour|hr|hrs|h|"

"minutes|minute|mins|min|m|"

"seconds|second|secs|sec|s))+|"

/* Textual time units plus (dd)* hh[:mm[:ss]] */

"((([-+]?[ \\t]+)?"

"[0-9]+(\\.[0-9]*)?[ \\t]*"

"(millenniums|millennia|millennium|mil|mils|"

"centuries|century|cent|c|"

"decades|decade|dec|decs|"

"years|year|y|"

"months|month|mon|"

"weeks|week|w|"

"days|day|d))+"

"([-+]?[ \\t]+"

"([0-9]+[ \\t]+)+" /* dd */

"(([0-9]{1,2}:){0,2}[0-9]{0,2})" /* hh:[mm:[ss]] */

")?))"

"([ \\t]+ago)?$#ni");

ADD_REGEX("#^([0-9a-f]{2,2}:){5,5}[0-9a-f]{2,2}$#ni");

}

static void php_libpq_version(char *buf, size_t len)

{

int version = PQlibVersion();

int major = version / 10000;

if (major >= 10) {

int minor = version % 10000;

snprintf(buf, len, "%d.%d", major, minor);

} else {

int minor = version / 100 % 100;

int revision = version % 100;

snprintf(buf, len, "%d.%d.%d", major, minor, revision);

}

}

PHP_MINIT_FUNCTION(pgsql)

{

REGISTER_INI_ENTRIES();

le_plink = zend_register_list_destructors_ex(NULL, _close_pgsql_plink, "pgsql link persistent", module_number);

pgsql_link_ce = register_class_PgSql_Connection();

pgsql_link_ce->create_object = pgsql_link_create_object;

pgsql_link_ce->default_object_handlers = &pgsql_link_object_handlers;

memcpy(&pgsql_link_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));

pgsql_link_object_handlers.offset = XtOffsetOf(pgsql_link_handle, std);

pgsql_link_object_handlers.free_obj = pgsql_link_free_obj;

pgsql_link_object_handlers.get_constructor = pgsql_link_get_constructor;

pgsql_link_object_handlers.clone_obj = NULL;

pgsql_link_object_handlers.compare = zend_objects_not_comparable;

pgsql_result_ce = register_class_PgSql_Result();

pgsql_result_ce->create_object = pgsql_result_create_object;

pgsql_result_ce->default_object_handlers = &pgsql_result_object_handlers;

memcpy(&pgsql_result_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));

pgsql_result_object_handlers.offset = XtOffsetOf(pgsql_result_handle, std);

pgsql_result_object_handlers.free_obj = pgsql_result_free_obj;

pgsql_result_object_handlers.get_constructor = pgsql_result_get_constructor;

pgsql_result_object_handlers.clone_obj = NULL;

pgsql_result_object_handlers.compare = zend_objects_not_comparable;

pgsql_lob_ce = register_class_PgSql_Lob();

pgsql_lob_ce->create_object = pgsql_lob_create_object;

pgsql_lob_ce->default_object_handlers = &pgsql_lob_object_handlers;

memcpy(&pgsql_lob_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));

pgsql_lob_object_handlers.offset = XtOffsetOf(pgLofp, std);

pgsql_lob_object_handlers.free_obj = pgsql_lob_free_obj;

pgsql_lob_object_handlers.get_constructor = pgsql_lob_get_constructor;

pgsql_lob_object_handlers.clone_obj = NULL;

pgsql_lob_object_handlers.compare = zend_objects_not_comparable;

/* libpq version */

php_libpq_version(pgsql_libpq_version, sizeof(pgsql_libpq_version));

register_pgsql_symbols(module_number);

return SUCCESS;

}

PHP_MSHUTDOWN_FUNCTION(pgsql)

{

UNREGISTER_INI_ENTRIES();

zend_hash_destroy(&PGG(connections));

for (size_t i = 0; i < PGSQL_MAX_REGEXES; i ++)

zend_string_release_ex(PGG(regexes[i]), true);

return SUCCESS;

}

PHP_RINIT_FUNCTION(pgsql)

{

PGG(default_link) = NULL;

PGG(num_links) = PGG(num_persistent);

zend_hash_init(&PGG(field_oids), 0, NULL, release_string, 0);

zend_hash_init(&PGG(table_oids), 0, NULL, release_string, 0);

return SUCCESS;

}

PHP_RSHUTDOWN_FUNCTION(pgsql)

{

if (PGG(default_link)) {

zend_object_release(PGG(default_link));

PGG(default_link) = NULL;

}

zend_hash_destroy(&PGG(field_oids));

zend_hash_destroy(&PGG(table_oids));

/* clean up persistent connection */

zend_hash_apply(&EG(persistent_list), (apply_func_t) _rollback_transactions);

return SUCCESS;

}

PHP_MINFO_FUNCTION(pgsql)

{

char buf[256];

php_info_print_table_start();

php_info_print_table_row(2, "PostgreSQL Support", "enabled");

php_info_print_table_row(2, "PostgreSQL (libpq) Version", pgsql_libpq_version);

php_info_print_table_row(2, "Multibyte character support", "enabled");

snprintf(buf, sizeof(buf), ZEND_LONG_FMT, PGG(num_persistent));

php_info_print_table_row(2, "Active Persistent Links", buf);

snprintf(buf, sizeof(buf), ZEND_LONG_FMT, PGG(num_links));

php_info_print_table_row(2, "Active Links", buf);

php_info_print_table_end();

DISPLAY_INI_ENTRIES();

}

static void php_pgsql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)

{

char *connstring;

size_t connstring_len;

pgsql_link_handle *link;

PGconn *pgsql;

smart_str str = {0};

zend_long connect_type = 0;

PGresult *pg_result;

ZEND_PARSE_PARAMETERS_START(1, 2)

Z_PARAM_PATH(connstring, connstring_len)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(connect_type)

ZEND_PARSE_PARAMETERS_END();

smart_str_appends(&str, "pgsql");

smart_str_appendl(&str, connstring, connstring_len);

smart_str_appendc(&str, '_');

/* make sure that the PGSQL_CONNECT_FORCE_NEW bit is not part of the hash so that subsequent

smart_str_append_long(&str, connect_type & ~PGSQL_CONNECT_FORCE_NEW);

smart_str_0(&str);

if (persistent && PGG(allow_persistent)) {

zend_resource *le;

/* try to find if we already have this link in our persistent list */

if ((le = zend_hash_find_ptr(&EG(persistent_list), str.s)) == NULL) { /* we don't */

if (PGG(max_links) != -1 && PGG(num_links) >= PGG(max_links)) {

php_error_docref(NULL, E_WARNING,

"Cannot create new link. Too many open links (" ZEND_LONG_FMT ")", PGG(num_links));

goto err;

}

if (PGG(max_persistent) != -1 && PGG(num_persistent) >= PGG(max_persistent)) {

php_error_docref(NULL, E_WARNING,

"Cannot create new link. Too many open persistent links (" ZEND_LONG_FMT ")", PGG(num_persistent));

goto err;

}

/* create the link */

pgsql = PQconnectdb(connstring);

if (pgsql == NULL || PQstatus(pgsql) == CONNECTION_BAD) {

zend_string *msgbuf = _php_pgsql_trim_message(PQerrorMessage(pgsql));

if (pgsql) {

PQfinish(pgsql);

}

php_error_docref(NULL, E_WARNING, "Unable to connect to PostgreSQL server: %s", ZSTR_VAL(msgbuf));

zend_string_release(msgbuf);

goto err;

}

/* hash it up */

if (zend_register_persistent_resource(ZSTR_VAL(str.s), ZSTR_LEN(str.s), pgsql, le_plink) == NULL) {

goto err;

}

PGG(num_links)++;

PGG(num_persistent)++;

} else { /* we do */

if (le->type != le_plink) {

goto err;

}

if (connect_type & PGSQL_CONNECT_FORCE_NEW) {

PGresult *pg_result;

while ((pg_result = PQgetResult(le->ptr))) {

PQclear(pg_result);

}

PQreset(le->ptr);

}

/* ensure that the link did not die */

if (PGG(auto_reset_persistent) & 1) {

/* need to send & get something from backend to

PGresult *pg_result;

pg_result = PQexec(le->ptr, "select 1");

PQclear(pg_result);

}

if (PQstatus(le->ptr) == CONNECTION_BAD) { /* the link died */

if (le->ptr == NULL) {

le->ptr = PQconnectdb(connstring);

}

else {

PQreset(le->ptr);

}

if (le->ptr == NULL || PQstatus(le->ptr) == CONNECTION_BAD) {

php_error_docref(NULL, E_WARNING,"PostgreSQL connection lost, unable to reconnect");

zend_hash_del(&EG(persistent_list), str.s);

goto err;

}

}

pgsql = (PGconn *) le->ptr;

/* consider to use php_version_compare() here */

if (zend_strtod(PQparameterStatus(pgsql, "server_version"), NULL) >= 7.2) {

pg_result = PQexec(pgsql, "RESET ALL;");

PQclear(pg_result);

}

}

object_init_ex(return_value, pgsql_link_ce);

link = Z_PGSQL_LINK_P(return_value);

link->conn = pgsql;

link->hash = zend_string_copy(str.s);

link->notices = NULL;

link->persistent = 1;

} else { /* Non persistent connection */

zval *index_ptr;

/* first we check the hash for the hashed_details key. If it exists,

if (!(connect_type & PGSQL_CONNECT_FORCE_NEW)

&& (index_ptr = zend_hash_find(&PGG(connections), str.s)) != NULL) {

php_pgsql_set_default_link(Z_OBJ_P(index_ptr));

ZVAL_COPY(return_value, index_ptr);

goto cleanup;

}

if (PGG(max_links) != -1 && PGG(num_links) >= PGG(max_links)) {

php_error_docref(NULL, E_WARNING, "Cannot create new link. Too many open links (" ZEND_LONG_FMT ")", PGG(num_links));

goto err;

}

/* Non-blocking connect */

if (connect_type & PGSQL_CONNECT_ASYNC) {

pgsql = PQconnectStart(connstring);

if (pgsql==NULL || PQstatus(pgsql)==CONNECTION_BAD) {

zend_string *msgbuf = _php_pgsql_trim_message(PQerrorMessage(pgsql));

if (pgsql) {

PQfinish(pgsql);

}

php_error_docref(NULL, E_WARNING, "Unable to connect to PostgreSQL server: %s", ZSTR_VAL(msgbuf));

zend_string_release(msgbuf);

goto err;

}

} else {

pgsql = PQconnectdb(connstring);

if (pgsql==NULL || PQstatus(pgsql)==CONNECTION_BAD) {

zend_string *msgbuf = _php_pgsql_trim_message(PQerrorMessage(pgsql));

if (pgsql) {

PQfinish(pgsql);

}

php_error_docref(NULL, E_WARNING, "Unable to connect to PostgreSQL server: %s", ZSTR_VAL(msgbuf));

zend_string_release(msgbuf);

goto err;

}

}

object_init_ex(return_value, pgsql_link_ce);

link = Z_PGSQL_LINK_P(return_value);

link->conn = pgsql;

link->hash = zend_string_copy(str.s);

link->notices = NULL;

link->persistent = 0;

/* add it to the hash */

zend_hash_update(&PGG(connections), str.s, return_value);

/* Keep track of link => hash mapping, so we can remove the hash entry from connections

PGG(num_links)++;

}

/* set notice processor */

if (! PGG(ignore_notices) && Z_TYPE_P(return_value) == IS_OBJECT) {

PQsetNoticeProcessor(pgsql, _php_pgsql_notice_handler, link);

}

php_pgsql_set_default_link(Z_OBJ_P(return_value));

cleanup:

smart_str_free(&str);

return;

err:

smart_str_free(&str);

RETURN_FALSE;

}

PHP_FUNCTION(pg_connect)

{

php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);

}

PHP_FUNCTION(pg_connect_poll)

{

zval *pgsql_link;

pgsql_link_handle *pgsql_handle;

PGconn *pgsql;

int ret;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_OBJECT_OF_CLASS(pgsql_link, pgsql_link_ce)

ZEND_PARSE_PARAMETERS_END();

pgsql_handle = Z_PGSQL_LINK_P(pgsql_link);

CHECK_PGSQL_LINK(pgsql_handle);

pgsql = pgsql_handle->conn;

ret = PQconnectPoll(pgsql);

RETURN_LONG(ret);

}

PHP_FUNCTION(pg_pconnect)

{

php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);

}

PHP_FUNCTION(pg_close)

{

zval *pgsql_link = NULL;

pgsql_link_handle *link;

ZEND_PARSE_PARAMETERS_START(0, 1)

Z_PARAM_OPTIONAL

Z_PARAM_OBJECT_OF_CLASS_OR_NULL(pgsql_link, pgsql_link_ce)

ZEND_PARSE_PARAMETERS_END();

if (!pgsql_link) {

link = FETCH_DEFAULT_LINK();

CHECK_DEFAULT_LINK(link);

zend_object_release(PGG(default_link));

PGG(default_link) = NULL;

RETURN_TRUE;

}

link = Z_PGSQL_LINK_P(pgsql_link);

CHECK_PGSQL_LINK(link);

if (link == FETCH_DEFAULT_LINK_NO_WARNING()) {

GC_DELREF(PGG(default_link));

PGG(default_link) = NULL;

}

pgsql_link_free(link);

RETURN_TRUE;

}

#define PHP_PG_DBNAME 1

#define PHP_PG_ERROR_MESSAGE 2

#define PHP_PG_OPTIONS 3

#define PHP_PG_PORT 4

#define PHP_PG_TTY 5

#define PHP_PG_HOST 6

#define PHP_PG_VERSION 7

#define PHP_PG_JIT 8

#define PHP_PG_SERVICE 9

static void php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)

{

pgsql_link_handle *link;

zval *pgsql_link = NULL;

PGconn *pgsql;

char *result;

ZEND_PARSE_PARAMETERS_START(0, 1)

Z_PARAM_OPTIONAL

Z_PARAM_OBJECT_OF_CLASS_OR_NULL(pgsql_link, pgsql_link_ce)

ZEND_PARSE_PARAMETERS_END();

if (!pgsql_link) {

link = FETCH_DEFAULT_LINK();

CHECK_DEFAULT_LINK(link);

} else {

link = Z_PGSQL_LINK_P(pgsql_link);

CHECK_PGSQL_LINK(link);

}

pgsql = link->conn;

switch(entry_type) {

case PHP_PG_DBNAME:

result = PQdb(pgsql);

break;

case PHP_PG_ERROR_MESSAGE:

RETURN_STR(_php_pgsql_trim_message(PQerrorMessage(pgsql)));

case PHP_PG_OPTIONS:

result = PQoptions(pgsql);

break;

case PHP_PG_PORT:

result = PQport(pgsql);

break;

case PHP_PG_TTY:

result = PQtty(pgsql);

break;

case PHP_PG_HOST:

result = PQhost(pgsql);

break;

case PHP_PG_VERSION: {

array_init(return_value);

char *tmp;

add_assoc_string(return_value, "client", pgsql_libpq_version);

add_assoc_long(return_value, "protocol", PQprotocolVersion(pgsql));

add_assoc_string(return_value, "server", (char*)PQparameterStatus(pgsql, "server_version"));

#define PHP_PQ_COPY_PARAM(_x) tmp = (char*)PQparameterStatus(pgsql, _x); \

if(tmp) add_assoc_string(return_value, _x, tmp); \

else add_assoc_null(return_value, _x);

PHP_PQ_COPY_PARAM("server_encoding");

PHP_PQ_COPY_PARAM("client_encoding");

PHP_PQ_COPY_PARAM("is_superuser");

PHP_PQ_COPY_PARAM("session_authorization");

PHP_PQ_COPY_PARAM("DateStyle");

PHP_PQ_COPY_PARAM("IntervalStyle");

PHP_PQ_COPY_PARAM("TimeZone");

PHP_PQ_COPY_PARAM("integer_datetimes");

PHP_PQ_COPY_PARAM("standard_conforming_strings");

PHP_PQ_COPY_PARAM("application_name");

return;

}

case PHP_PG_JIT: {

PGresult *res;

array_init(return_value);

res = PQexec(pgsql, "SHOW jit_provider");

if (PQresultStatus(res) != PGRES_TUPLES_OK) {

add_assoc_null(return_value, "jit_provider");

} else {

add_assoc_string(return_value, "jit_provider", PQgetvalue(res, 0, 0));

}

PQclear(res);