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

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

intern->std.handlers = &pgsql_link_object_handlers;

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

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

intern->std.handlers = &pgsql_result_object_handlers;

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

intern->std.handlers = &pgsql_lob_object_handlers;

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

}

#ifndef HAVE_PGSQL_WITH_MULTIBYTE_SUPPORT

#define pg_encoding_to_char(x) "SQL_ASCII"

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

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

}

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

zend_hash_init(&pgsql_globals->connections, 0, NULL, NULL, 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_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;

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;

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;

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

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

pgsql_link_handle *link;

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 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 (PQprotocolVersion(pgsql) >= 3 && 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) {

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;

}

}

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;

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

RETURN_THROWS();

}

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;

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

RETURN_THROWS();

}

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

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;

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

RETURN_THROWS();

}

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

pgsql_link_handle *link;

PGconn *pgsql;

char *param;

size_t len;

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

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

RETURN_THROWS();