#include <stdlib.h>

#define PHP_PGSQL_PRIVATE 1

#ifdef HAVE_CONFIG_H

#include "config.h"

#define SMART_STR_PREALLOC 512

#include "php.h"

#include "php_ini.h"

#include "ext/standard/php_standard.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 "pgsql_arginfo.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

#if ZEND_LONG_MAX < UINT_MAX

#define PGSQL_RETURN_OID(oid) do { \

if (oid > ZEND_LONG_MAX) { \

smart_str s = {0}; \

smart_str_append_unsigned(&s, oid); \

smart_str_0(&s); \

RETURN_NEW_STR(s.s); \

} \

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 link opened yet"); \

RETURN_THROWS(); \

}

#define FETCH_DEFAULT_LINK() PGG(default_link)

#ifndef HAVE_PQFREEMEM

#define PQfreemem free

ZEND_DECLARE_MODULE_GLOBALS(pgsql)

static PHP_GINIT_FUNCTION(pgsql);

zend_module_entry pgsql_module_entry = {

STANDARD_MODULE_HEADER,

"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_link, le_plink, le_result, le_lofp, le_string;

#ifndef HAVE_PGSQL_WITH_MULTIBYTE_SUPPORT

#define pg_encoding_to_char(x) "SQL_ASCII"

static char * _php_pgsql_trim_message(const char *message, size_t *len)

{

register 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;

}

if (len) {

*len = i;

}

return estrndup(message, i);

}

static inline char * _php_pgsql_trim_result(PGconn * pgsql, char **buf)

{

return *buf = _php_pgsql_trim_message(PQerrorMessage(pgsql), NULL);

}

#define PQErrorMessageTrim(pgsql, buf) _php_pgsql_trim_result(pgsql, buf)

#define PHP_PQ_ERROR(text, pgsql) { \

char *msgbuf = _php_pgsql_trim_message(PQerrorMessage(pgsql), NULL); \

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

efree(msgbuf); \

} \

static void php_pgsql_set_default_link(zend_resource *res)

{

GC_ADDREF(res);

if (PGG(default_link) != NULL) {

zend_list_delete(PGG(default_link));

}

PGG(default_link) = res;

}

static void _close_pgsql_link(zend_resource *rsrc)

{

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

PGresult *res;

zval *hash;

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

PQclear(res);

}

PQfinish(link);

PGG(num_links)--;

/* Remove connection hash for this link */

hash = zend_hash_index_find(&PGG(hashes), (uintptr_t) link);

if (hash) {

zend_hash_index_del(&PGG(hashes), (uintptr_t) link);

zend_hash_del(&EG(regular_list), Z_STR_P(hash));

}

}

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)--;

}

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

{

zval *notices;

zval tmp;

char *trimed_message;

size_t trimed_message_len;

if (! PGG(ignore_notices)) {

notices = zend_hash_index_find(&PGG(notices), (zend_ulong)resource_id);

if (!notices) {

array_init(&tmp);

notices = &tmp;

zend_hash_index_update(&PGG(notices), (zend_ulong)resource_id, notices);

}

trimed_message = _php_pgsql_trim_message(message, &trimed_message_len);

if (PGG(log_notices)) {

php_error_docref(NULL, E_NOTICE, "%s", trimed_message);

}

add_next_index_stringl(notices, trimed_message, trimed_message_len);

efree(trimed_message);

}

}

static int _rollback_transactions(zval *el)

{

PGconn *link;

PGresult *res;

zend_resource *rsrc = Z_RES_P(el);

if (rsrc->type != le_plink)

return 0;

link = (PGconn *) rsrc->ptr;

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 ((PQprotocolVersion(link) >= 3 && PQtransactionStatus(link) != PQTRANS_IDLE) || PQprotocolVersion(link) < 3) {

int orig = PGG(ignore_notices);

PGG(ignore_notices) = 1;

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

PQclear(res);

PGG(ignore_notices) = orig;

}

return 0;

}

static void _free_ptr(zend_resource *rsrc)

{

pgLofp *lofp = (pgLofp *)rsrc->ptr;

efree(lofp);

}

static void _free_result(zend_resource *rsrc)

{

pgsql_result_handle *pg_result = (pgsql_result_handle *)rsrc->ptr;

PQclear(pg_result->result);

efree(pg_result);

}

static int _php_pgsql_detect_identifier_escape(const char *identifier, size_t len) /* {{{ */

{

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

if (len <= 2) {

return FAILURE;

}

/* 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 FAILURE;

}

}

} else {

return FAILURE;

}

/* Escaped properly */

return SUCCESS;

}

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, OnUpdateBool, 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();

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

/* Initialize notice message hash at MINIT only */

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

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

}

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)

{

char buf[16];

REGISTER_INI_ENTRIES();

le_link = zend_register_list_destructors_ex(_close_pgsql_link, NULL, "pgsql link", module_number);

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

le_result = zend_register_list_destructors_ex(_free_result, NULL, "pgsql result", module_number);

le_lofp = zend_register_list_destructors_ex(_free_ptr, NULL, "pgsql large object", module_number);

le_string = zend_register_list_destructors_ex(_free_ptr, NULL, "pgsql string", module_number);

/* libpq version */

php_libpq_version(buf, sizeof(buf));

REGISTER_STRING_CONSTANT("PGSQL_LIBPQ_VERSION", buf, CONST_CS | CONST_PERSISTENT);

REGISTER_STRING_CONSTANT("PGSQL_LIBPQ_VERSION_STR", buf, CONST_CS | CONST_PERSISTENT | CONST_DEPRECATED);

/* For connection option */

REGISTER_LONG_CONSTANT("PGSQL_CONNECT_FORCE_NEW", PGSQL_CONNECT_FORCE_NEW, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECT_ASYNC", PGSQL_CONNECT_ASYNC, CONST_CS | CONST_PERSISTENT);

/* For pg_fetch_array() */

REGISTER_LONG_CONSTANT("PGSQL_ASSOC", PGSQL_ASSOC, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_NUM", PGSQL_NUM, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_BOTH", PGSQL_BOTH, CONST_CS | CONST_PERSISTENT);

/* For pg_last_notice() */

REGISTER_LONG_CONSTANT("PGSQL_NOTICE_LAST", PGSQL_NOTICE_LAST, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_NOTICE_ALL", PGSQL_NOTICE_ALL, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_NOTICE_CLEAR", PGSQL_NOTICE_CLEAR, CONST_CS | CONST_PERSISTENT);

/* For pg_connection_status() */

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_BAD", CONNECTION_BAD, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_OK", CONNECTION_OK, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_STARTED", CONNECTION_STARTED, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_MADE", CONNECTION_MADE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_AWAITING_RESPONSE", CONNECTION_AWAITING_RESPONSE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_AUTH_OK", CONNECTION_AUTH_OK, CONST_CS | CONST_PERSISTENT);

#ifdef CONNECTION_SSL_STARTUP

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_SSL_STARTUP", CONNECTION_SSL_STARTUP, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONNECTION_SETENV", CONNECTION_SETENV, CONST_CS | CONST_PERSISTENT);

/* For pg_connect_poll() */

REGISTER_LONG_CONSTANT("PGSQL_POLLING_FAILED", PGRES_POLLING_FAILED, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_POLLING_READING", PGRES_POLLING_READING, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_POLLING_WRITING", PGRES_POLLING_WRITING, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_POLLING_OK", PGRES_POLLING_OK, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_POLLING_ACTIVE", PGRES_POLLING_ACTIVE, CONST_CS | CONST_PERSISTENT);

/* For pg_transaction_status() */

REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_IDLE", PQTRANS_IDLE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_ACTIVE", PQTRANS_ACTIVE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_INTRANS", PQTRANS_INTRANS, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_INERROR", PQTRANS_INERROR, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_TRANSACTION_UNKNOWN", PQTRANS_UNKNOWN, CONST_CS | CONST_PERSISTENT);

/* For pg_set_error_verbosity() */

REGISTER_LONG_CONSTANT("PGSQL_ERRORS_TERSE", PQERRORS_TERSE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_ERRORS_DEFAULT", PQERRORS_DEFAULT, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_ERRORS_VERBOSE", PQERRORS_VERBOSE, CONST_CS | CONST_PERSISTENT);

/* For lo_seek() */

REGISTER_LONG_CONSTANT("PGSQL_SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT);

/* For pg_result_status() return value type */

REGISTER_LONG_CONSTANT("PGSQL_STATUS_LONG", PGSQL_STATUS_LONG, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_STATUS_STRING", PGSQL_STATUS_STRING, CONST_CS | CONST_PERSISTENT);

/* For pg_result_status() return value */

REGISTER_LONG_CONSTANT("PGSQL_EMPTY_QUERY", PGRES_EMPTY_QUERY, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_COMMAND_OK", PGRES_COMMAND_OK, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_TUPLES_OK", PGRES_TUPLES_OK, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_COPY_OUT", PGRES_COPY_OUT, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_COPY_IN", PGRES_COPY_IN, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_BAD_RESPONSE", PGRES_BAD_RESPONSE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_NONFATAL_ERROR", PGRES_NONFATAL_ERROR, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_FATAL_ERROR", PGRES_FATAL_ERROR, CONST_CS | CONST_PERSISTENT);

/* For pg_result_error_field() field codes */

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SEVERITY", PG_DIAG_SEVERITY, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SQLSTATE", PG_DIAG_SQLSTATE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_MESSAGE_PRIMARY", PG_DIAG_MESSAGE_PRIMARY, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_MESSAGE_DETAIL", PG_DIAG_MESSAGE_DETAIL, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_MESSAGE_HINT", PG_DIAG_MESSAGE_HINT, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_STATEMENT_POSITION", PG_DIAG_STATEMENT_POSITION, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_INTERNAL_POSITION

REGISTER_LONG_CONSTANT("PGSQL_DIAG_INTERNAL_POSITION", PG_DIAG_INTERNAL_POSITION, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_INTERNAL_QUERY

REGISTER_LONG_CONSTANT("PGSQL_DIAG_INTERNAL_QUERY", PG_DIAG_INTERNAL_QUERY, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_CONTEXT", PG_DIAG_CONTEXT, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SOURCE_FILE", PG_DIAG_SOURCE_FILE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SOURCE_LINE", PG_DIAG_SOURCE_LINE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SOURCE_FUNCTION", PG_DIAG_SOURCE_FUNCTION, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_SCHEMA_NAME

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SCHEMA_NAME", PG_DIAG_SCHEMA_NAME, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_TABLE_NAME

REGISTER_LONG_CONSTANT("PGSQL_DIAG_TABLE_NAME", PG_DIAG_TABLE_NAME, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_COLUMN_NAME

REGISTER_LONG_CONSTANT("PGSQL_DIAG_COLUMN_NAME", PG_DIAG_COLUMN_NAME, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_DATATYPE_NAME

REGISTER_LONG_CONSTANT("PGSQL_DIAG_DATATYPE_NAME", PG_DIAG_DATATYPE_NAME, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_CONSTRAINT_NAME

REGISTER_LONG_CONSTANT("PGSQL_DIAG_CONSTRAINT_NAME", PG_DIAG_CONSTRAINT_NAME, CONST_CS | CONST_PERSISTENT);

#ifdef PG_DIAG_SEVERITY_NONLOCALIZED

REGISTER_LONG_CONSTANT("PGSQL_DIAG_SEVERITY_NONLOCALIZED", PG_DIAG_SEVERITY_NONLOCALIZED, CONST_CS | CONST_PERSISTENT);

/* pg_convert options */

REGISTER_LONG_CONSTANT("PGSQL_CONV_IGNORE_DEFAULT", PGSQL_CONV_IGNORE_DEFAULT, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONV_FORCE_NULL", PGSQL_CONV_FORCE_NULL, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_CONV_IGNORE_NOT_NULL", PGSQL_CONV_IGNORE_NOT_NULL, CONST_CS | CONST_PERSISTENT);

/* pg_insert/update/delete/select options */

REGISTER_LONG_CONSTANT("PGSQL_DML_ESCAPE", PGSQL_DML_ESCAPE, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DML_NO_CONV", PGSQL_DML_NO_CONV, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DML_EXEC", PGSQL_DML_EXEC, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DML_ASYNC", PGSQL_DML_ASYNC, CONST_CS | CONST_PERSISTENT);

REGISTER_LONG_CONSTANT("PGSQL_DML_STRING", PGSQL_DML_STRING, CONST_CS | CONST_PERSISTENT);

return SUCCESS;

}

PHP_MSHUTDOWN_FUNCTION(pgsql)

{

UNREGISTER_INI_ENTRIES();

zend_hash_destroy(&PGG(notices));

zend_hash_destroy(&PGG(hashes));

return SUCCESS;

}

PHP_RINIT_FUNCTION(pgsql)

{

PGG(default_link) = NULL;

PGG(num_links) = PGG(num_persistent);

return SUCCESS;

}

PHP_RSHUTDOWN_FUNCTION(pgsql)

{

/* clean up notice messages */

zend_hash_clean(&PGG(notices));

zend_hash_clean(&PGG(hashes));

/* 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_header(2, "PostgreSQL Support", "enabled");

php_libpq_version(buf, sizeof(buf));

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

#ifdef HAVE_PGSQL_WITH_MULTIBYTE_SUPPORT

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

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

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;

PGconn *pgsql;

smart_str str = {0};

zend_long connect_type = 0;

PGresult *pg_result;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &connstring, &connstring_len, &connect_type) == FAILURE) {

RETURN_THROWS();

}

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) {

PHP_PQ_ERROR("Unable to connect to PostgreSQL server: %s", pgsql)

if (pgsql) {

PQfinish(pgsql);

}

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;

}

/* 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 link lost, unable to reconnect");

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

goto err;

}

}

pgsql = (PGconn *) le->ptr;

if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 7.2) {

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

PQclear(pg_result);

}

}

RETVAL_RES(zend_register_resource(pgsql, le_plink));

} else { /* Non persistent connection */

zend_resource *index_ptr, new_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_ptr(&EG(regular_list), str.s)) != NULL) {

zend_resource *link;

if (index_ptr->type != le_index_ptr) {

goto err;

}

link = (zend_resource *)index_ptr->ptr;

ZEND_ASSERT(link->ptr && (link->type == le_link || link->type == le_plink));

php_pgsql_set_default_link(link);

GC_ADDREF(link);

RETVAL_RES(link);

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) {

PHP_PQ_ERROR("Unable to connect to PostgreSQL server: %s", pgsql);

if (pgsql) {

PQfinish(pgsql);

}

goto err;

}

} else {

pgsql = PQconnectdb(connstring);

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

PHP_PQ_ERROR("Unable to connect to PostgreSQL server: %s", pgsql);

if (pgsql) {

PQfinish(pgsql);

}

goto err;

}

}

/* add it to the list */

RETVAL_RES(zend_register_resource(pgsql, le_link));

/* add it to the hash */

new_index_ptr.ptr = (void *) Z_RES_P(return_value);

new_index_ptr.type = le_index_ptr;

zend_hash_update_mem(&EG(regular_list), str.s, (void *) &new_index_ptr, sizeof(zend_resource));

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

{

zval tmp;

ZVAL_STR_COPY(&tmp, str.s);

zend_hash_index_update(&PGG(hashes), (uintptr_t) pgsql, &tmp);

}

PGG(num_links)++;

}

/* set notice processor */

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

PQsetNoticeProcessor(pgsql, _php_pgsql_notice_handler, (void*)(zend_uintptr_t)Z_RES_HANDLE_P(return_value));

}

php_pgsql_set_default_link(Z_RES_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;

PGconn *pgsql;

int ret;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pgsql_link) == FAILURE) {

RETURN_THROWS();

}

if ((pgsql = (PGconn *)zend_fetch_resource2(Z_RES_P(pgsql_link), "PostgreSQL link", le_link, le_plink)) == NULL) {

RETURN_THROWS();

}

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;

zend_resource *link;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &pgsql_link) == FAILURE) {

RETURN_THROWS();

}

if (!pgsql_link) {

link = PGG(default_link);

CHECK_DEFAULT_LINK(link);

zend_list_delete(link);

PGG(default_link) = NULL;

RETURN_TRUE;

}

link = Z_RES_P(pgsql_link);

if (zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink) == NULL) {

RETURN_THROWS();

}

if (link == PGG(default_link)) {

zend_list_delete(link);

PGG(default_link) = NULL;

}

zend_list_close(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

static void php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)

{

zend_resource *link;

zval *pgsql_link = NULL;

PGconn *pgsql;

char *msgbuf;

char *result;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &pgsql_link) == FAILURE) {

RETURN_THROWS();

}

if (!pgsql_link) {

link = FETCH_DEFAULT_LINK();

CHECK_DEFAULT_LINK(link);

} else {

link = Z_RES_P(pgsql_link);

}

if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {

RETURN_THROWS();

}

switch(entry_type) {

case PHP_PG_DBNAME:

result = PQdb(pgsql);

break;

case PHP_PG_ERROR_MESSAGE:

result = PQErrorMessageTrim(pgsql, &msgbuf);

RETVAL_STRING(result);

efree(result);

return;

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 buf[16];

php_libpq_version(buf, sizeof(buf));

add_assoc_string(return_value, "client", buf);

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

if (PQprotocolVersion(pgsql) >= 3) {

/* 8.0 or grater supports protorol version 3 */

char *tmp;

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;

EMPTY_SWITCH_DEFAULT_CASE()

}

if (result) {

RETURN_STRING(result);

} else {

RETURN_EMPTY_STRING();

}

}

PHP_FUNCTION(pg_dbname)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_DBNAME);

}

PHP_FUNCTION(pg_last_error)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_ERROR_MESSAGE);

}

PHP_FUNCTION(pg_options)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_OPTIONS);

}

PHP_FUNCTION(pg_port)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_PORT);

}

PHP_FUNCTION(pg_tty)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_TTY);

}

PHP_FUNCTION(pg_host)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_HOST);

}

PHP_FUNCTION(pg_version)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_VERSION);

}

PHP_FUNCTION(pg_parameter_status)

{

zval *pgsql_link = NULL;

zend_resource *link;

PGconn *pgsql;

char *param;

size_t len;

if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "rs", &pgsql_link, &param, &len) == FAILURE) {

if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &param, &len) == FAILURE) {

RETURN_THROWS();

}

link = FETCH_DEFAULT_LINK();

CHECK_DEFAULT_LINK(link);

} else {

link = Z_RES_P(pgsql_link);

}

if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {

RETURN_THROWS();

}

param = (char*)PQparameterStatus(pgsql, param);

if (param) {

RETURN_STRING(param);

} else {

RETURN_FALSE;

}

}

PHP_FUNCTION(pg_ping)

{

zval *pgsql_link = NULL;

PGconn *pgsql;

PGresult *res;

zend_resource *link;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &pgsql_link) == FAILURE) {

RETURN_THROWS();

}

if (pgsql_link == NULL) {

link = FETCH_DEFAULT_LINK();

CHECK_DEFAULT_LINK(link);

} else {

link = Z_RES_P(pgsql_link);

}

if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {

RETURN_THROWS();

}

/* ping connection */

res = PQexec(pgsql, "SELECT 1;");

PQclear(res);

/* check status. */

if (PQstatus(pgsql) == CONNECTION_OK)

RETURN_TRUE;

/* reset connection if it's broken */

PQreset(pgsql);

if (PQstatus(pgsql) == CONNECTION_OK) {

RETURN_TRUE;

}

RETURN_FALSE;

}

PHP_FUNCTION(pg_query)

{

zval *pgsql_link = NULL;

char *query;

int argc = ZEND_NUM_ARGS();

size_t query_len;

int leftover = 0;

zend_resource *link;

PGconn *pgsql;

PGresult *pgsql_result;

ExecStatusType status;

if (argc == 1) {

if (zend_parse_parameters(argc, "s", &query, &query_len) == FAILURE) {

RETURN_THROWS();

}

link = FETCH_DEFAULT_LINK();

CHECK_DEFAULT_LINK(link);

} else {

if (zend_parse_parameters(argc, "rs", &pgsql_link, &query, &query_len) == FAILURE) {

RETURN_THROWS();

}

link = Z_RES_P(pgsql_link);

}

if ((pgsql = (PGconn *)zend_fetch_resource2(link, "PostgreSQL link", le_link, le_plink)) == NULL) {

RETURN_THROWS();

}