/*

+----------------------------------------------------------------------+

| PHP Version 4 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2002 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 2.02 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available at through the world-wide-web at |

| http://www.php.net/license/2_02.txt. |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Zeev Suraski <zeev@zend.com> |

| Jouni Ahto <jouni.ahto@exdec.fi> |

| Yasuo Ohgaki <yohgaki@php.net> |

| Youichi Iwakiri <yiwakiri@st.rim.or.jp> (pg_copy_*) |

+----------------------------------------------------------------------+

*/

/* $Id$ */

#include <stdlib.h>

#define PHP_PGSQL_PRIVATE 1

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#define SMART_STR_PREALLOC 512

#include "php.h"

#include "php_ini.h"

#include "ext/standard/php_standard.h"

#include "ext/standard/php_smart_str.h"

#include "php_pgsql.h"

#include "php_globals.h"

#if HAVE_PGSQL

#ifndef InvalidOid

#define InvalidOid ((Oid) 0)

#endif

#define PGSQL_ASSOC 1<<0

#define PGSQL_NUM 1<<1

#define PGSQL_BOTH (PGSQL_ASSOC|PGSQL_NUM)

#define PGSQL_STATUS_LONG 1

#define PGSQL_STATUS_STRING 2

#define PGSQL_MAX_LENGTH_OF_LONG 30

#define PGSQL_MAX_LENGTH_OF_DOUBLE 60

#define PGSQL_RETURN_OID(oid) do { \

if (oid > LONG_MAX) { \

smart_str s = {0}; \

smart_str_append_unsigned(&s, oid); \

smart_str_0(&s); \

RETURN_STRINGL(s.c, s.len, 0); \

} \

RETURN_LONG((long)oid); \

} while(0)

#if HAVE_PQSETNONBLOCKING

#define PQ_SETNONBLOCKING(pg_link, flag) PQsetnonblocking(pg_link, flag)

#else

#define PQ_SETNONBLOCKING(pg_link, flag) 0

#endif

#define CHECK_DEFAULT_LINK(x) if ((x) == -1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "No PostgreSQL link opened yet."); }

/* {{{ pgsql_functions[]

*/

function_entry pgsql_functions[] = {

/* connection functions */

PHP_FE(pg_connect, NULL)

PHP_FE(pg_pconnect, NULL)

PHP_FE(pg_close, NULL)

PHP_FE(pg_connection_status, NULL)

PHP_FE(pg_connection_busy, NULL)

PHP_FE(pg_connection_reset, NULL)

PHP_FE(pg_host, NULL)

PHP_FE(pg_dbname, NULL)

PHP_FE(pg_port, NULL)

PHP_FE(pg_tty, NULL)

PHP_FE(pg_options, NULL)

PHP_FE(pg_ping, NULL)

/* query functions */

PHP_FE(pg_query, NULL)

PHP_FE(pg_send_query, NULL)

PHP_FE(pg_cancel_query, NULL)

/* result functions */

PHP_FE(pg_fetch_result, NULL)

PHP_FE(pg_fetch_row, NULL)

PHP_FE(pg_fetch_assoc, NULL)

PHP_FE(pg_fetch_array, NULL)

PHP_FE(pg_fetch_object, NULL)

PHP_FE(pg_fetch_all, NULL)

PHP_FE(pg_affected_rows,NULL)

PHP_FE(pg_get_result, NULL)

PHP_FE(pg_result_seek, NULL)

PHP_FE(pg_result_status,NULL)

PHP_FE(pg_free_result, NULL)

PHP_FE(pg_last_oid, NULL)

PHP_FE(pg_num_rows, NULL)

PHP_FE(pg_num_fields, NULL)

PHP_FE(pg_field_name, NULL)

PHP_FE(pg_field_num, NULL)

PHP_FE(pg_field_size, NULL)

PHP_FE(pg_field_type, NULL)

PHP_FE(pg_field_prtlen, NULL)

PHP_FE(pg_field_is_null,NULL)

/* async message function */

PHP_FE(pg_get_notify, NULL)

PHP_FE(pg_get_pid, NULL)

/* error message functions */

PHP_FE(pg_result_error, NULL)

PHP_FE(pg_last_error, NULL)

PHP_FE(pg_last_notice, NULL)

/* copy functions */

PHP_FE(pg_put_line, NULL)

PHP_FE(pg_end_copy, NULL)

PHP_FE(pg_copy_to, NULL)

PHP_FE(pg_copy_from, NULL)

/* debug functions */

PHP_FE(pg_trace, NULL)

PHP_FE(pg_untrace, NULL)

/* large object functions */

PHP_FE(pg_lo_create, NULL)

PHP_FE(pg_lo_unlink, NULL)

PHP_FE(pg_lo_open, NULL)

PHP_FE(pg_lo_close, NULL)

PHP_FE(pg_lo_read, NULL)

PHP_FE(pg_lo_write, NULL)

PHP_FE(pg_lo_read_all, NULL)

PHP_FE(pg_lo_import, NULL)

PHP_FE(pg_lo_export, NULL)

PHP_FE(pg_lo_seek, NULL)

PHP_FE(pg_lo_tell, NULL)

/* utility functions */

#if HAVE_PQESCAPE

PHP_FE(pg_escape_string,NULL)

PHP_FE(pg_escape_bytea, NULL)

PHP_FE(pg_unescape_bytea, NULL)

#endif

#if HAVE_PQCLIENTENCODING

PHP_FE(pg_client_encoding, NULL)

PHP_FE(pg_set_client_encoding, NULL)

#endif

/* misc function */

PHP_FE(pg_meta_data, NULL)

PHP_FE(pg_convert, NULL)

PHP_FE(pg_insert, NULL)

PHP_FE(pg_update, NULL)

PHP_FE(pg_delete, NULL)

PHP_FE(pg_select, NULL)

/* aliases for downwards compatibility */

PHP_FALIAS(pg_exec, pg_query, NULL)

PHP_FALIAS(pg_getlastoid, pg_last_oid, NULL)

PHP_FALIAS(pg_cmdtuples, pg_affected_rows, NULL)

PHP_FALIAS(pg_errormessage, pg_last_error, NULL)

PHP_FALIAS(pg_numrows, pg_num_rows, NULL)

PHP_FALIAS(pg_numfields, pg_num_fields, NULL)

PHP_FALIAS(pg_fieldname, pg_field_name, NULL)

PHP_FALIAS(pg_fieldsize, pg_field_size, NULL)

PHP_FALIAS(pg_fieldtype, pg_field_type, NULL)

PHP_FALIAS(pg_fieldnum, pg_field_num, NULL)

PHP_FALIAS(pg_fieldprtlen, pg_field_prtlen, NULL)

PHP_FALIAS(pg_fieldisnull, pg_field_is_null, NULL)

PHP_FALIAS(pg_freeresult, pg_free_result, NULL)

PHP_FALIAS(pg_result, pg_fetch_result, NULL)

PHP_FALIAS(pg_loreadall, pg_lo_read_all, NULL)

PHP_FALIAS(pg_locreate, pg_lo_create, NULL)

PHP_FALIAS(pg_lounlink, pg_lo_unlink, NULL)

PHP_FALIAS(pg_loopen, pg_lo_open, NULL)

PHP_FALIAS(pg_loclose, pg_lo_close, NULL)

PHP_FALIAS(pg_loread, pg_lo_read, NULL)

PHP_FALIAS(pg_lowrite, pg_lo_write, NULL)

PHP_FALIAS(pg_loimport, pg_lo_import, NULL)

PHP_FALIAS(pg_loexport, pg_lo_export, NULL)

#if HAVE_PQCLIENTENCODING

PHP_FALIAS(pg_clientencoding, pg_client_encoding, NULL)

PHP_FALIAS(pg_setclientencoding, pg_set_client_encoding, NULL)

#endif

{NULL, NULL, NULL}

};

/* }}} */

/* {{{ pgsql_module_entry

*/

zend_module_entry pgsql_module_entry = {

STANDARD_MODULE_HEADER,

"pgsql",

pgsql_functions,

PHP_MINIT(pgsql),

PHP_MSHUTDOWN(pgsql),

PHP_RINIT(pgsql),

PHP_RSHUTDOWN(pgsql),

PHP_MINFO(pgsql),

NO_VERSION_YET,

STANDARD_MODULE_PROPERTIES

};

/* }}} */

#ifdef COMPILE_DL_PGSQL

ZEND_GET_MODULE(pgsql)

#endif

static int le_link, le_plink, le_result, le_lofp, le_string;

#ifdef ZTS

int pgsql_globals_id;

#else

php_pgsql_globals pgsql_globals;

#endif

/* {{{ php_pgsql_set_default_link

*/

static void php_pgsql_set_default_link(int id TSRMLS_DC)

{

zend_list_addref(id);

if (PGG(default_link) != -1) {

zend_list_delete(PGG(default_link));

}

PGG(default_link) = id;

}

/* }}} */

/* {{{ _close_pgsql_link

*/

static void _close_pgsql_link(zend_rsrc_list_entry *rsrc TSRMLS_DC)

{

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

PGresult *res;

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

PQclear(res);

}

PQfinish(link);

PGG(num_links)--;

}

/* }}} */

/* {{{ _close_pgsql_plink

*/

static void _close_pgsql_plink(zend_rsrc_list_entry *rsrc TSRMLS_DC)

{

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

PGresult *res;

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

PQclear(res);

}

PQfinish(link);

PGG(num_persistent)--;

PGG(num_links)--;

}

/* }}} */

/* {{{ _php_pgsql_notice_handler

*/

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

{

php_pgsql_notice *notice;

TSRMLS_FETCH();

if (! PGG(ignore_notices)) {

if (PGG(log_notices)) {

php_log_err((char *) message TSRMLS_CC);

}

notice = (php_pgsql_notice *)emalloc(sizeof(php_pgsql_notice));

notice->len = strlen(message);

notice->message = estrndup(message, notice->len);

zend_hash_index_update(&PGG(notices), *(int *)resource_id, (void **)&notice, sizeof(php_pgsql_notice *), NULL);

}

}

/* }}} */

#define PHP_PGSQL_NOTICE_PTR_DTOR (void (*)(void *))_php_pgsql_notice_ptr_dtor

/* {{{ _php_pgsql_notice_dtor

*/

static void _php_pgsql_notice_ptr_dtor(void **ptr)

{

php_pgsql_notice *notice = (php_pgsql_notice *)*ptr;

efree(notice->message);

efree(notice);

}

/* }}} */

/* {{{ _rollback_transactions

*/

static int _rollback_transactions(zend_rsrc_list_entry *rsrc TSRMLS_DC)

{

PGconn *link;

PGresult *res;

int orig;

if (Z_TYPE_P(rsrc) != le_plink)

return 0;

link = (PGconn *) rsrc->ptr;

if (PQ_SETNONBLOCKING(link, 0)) {

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

return -1;

}

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

PQclear(res);

}

orig = PGG(ignore_notices);

PGG(ignore_notices) = 1;

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

PQclear(res);

PGG(ignore_notices) = orig;

return 0;

}

/* }}} */

/* {{{ _free_ptr

*/

static void _free_ptr(zend_rsrc_list_entry *rsrc TSRMLS_DC)

{

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

efree(lofp);

}

/* }}} */

/* {{{ _free_result

*/

static void _free_result(zend_rsrc_list_entry *rsrc TSRMLS_DC)

{

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

PQclear(pg_result->result);

efree(pg_result);

}

/* }}} */

/* {{{ PHP_INI

*/

PHP_INI_BEGIN()

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

STD_PHP_INI_ENTRY_EX("pgsql.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateInt, max_persistent, php_pgsql_globals, pgsql_globals, display_link_numbers)

STD_PHP_INI_ENTRY_EX("pgsql.max_links", "-1", PHP_INI_SYSTEM, OnUpdateInt, max_links, php_pgsql_globals, pgsql_globals, display_link_numbers)

STD_PHP_INI_BOOLEAN("pgsql.auto_reset_persistent", "0", PHP_INI_SYSTEM, OnUpdateBool, auto_reset_persistent, php_pgsql_globals, pgsql_globals)

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

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

PHP_INI_END()

/* }}} */

/* {{{ php_pgsql_init_globals

*/

static void php_pgsql_init_globals(php_pgsql_globals *pgsql_globals_p TSRMLS_DC)

{

PGG(num_persistent) = 0;

/* Initilize notice message hash at MINIT only */

zend_hash_init_ex(&PGG(notices), 0, NULL, PHP_PGSQL_NOTICE_PTR_DTOR, 1, 0);

}

/* }}} */

/* {{{ PHP_MINIT_FUNCTION

*/

PHP_MINIT_FUNCTION(pgsql)

{

#ifdef ZTS

ts_allocate_id(&pgsql_globals_id, sizeof(php_pgsql_globals), (ts_allocate_ctor) php_pgsql_init_globals, NULL);

#else

php_pgsql_init_globals(&pgsql_globals TSRMLS_CC);

#endif

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

/* For connection option */

REGISTER_LONG_CONSTANT("PGSQL_CONNECT_FORCE_NEW", PGSQL_CONNECT_FORCE_NEW, 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_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);

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

/* 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_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

*/

PHP_MSHUTDOWN_FUNCTION(pgsql)

{

UNREGISTER_INI_ENTRIES();

zend_hash_destroy(&PGG(notices));

return SUCCESS;

}

/* }}} */

/* {{{ PHP_RINIT_FUNCTION

*/

PHP_RINIT_FUNCTION(pgsql)

{

PGG(default_link)=-1;

PGG(num_links) = PGG(num_persistent);

return SUCCESS;

}

/* }}} */

/* {{{ PHP_RSHUTDOWN_FUNCTION

*/

PHP_RSHUTDOWN_FUNCTION(pgsql)

{

/* clean up notice messages */

zend_hash_clean(&PGG(notices));

/* clean up persistent connection */

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

return SUCCESS;

}

/* }}} */

/* {{{ PHP_MINFO_FUNCTION

*/

PHP_MINFO_FUNCTION(pgsql)

{

char buf[256];

php_info_print_table_start();

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

#if HAVE_PG_CONFIG_H

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

#ifdef HAVE_PGSQL_WITH_MULTIBYTE_SUPPORT

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

#else

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

#endif

#ifdef USE_SSL

php_info_print_table_row(2, "SSL support", "enabled");

#else

php_info_print_table_row(2, "SSL support", "disabled");

#endif

#endif /* HAVE_PG_CONFIG_H */

sprintf(buf, "%ld", PGG(num_persistent));

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

sprintf(buf, "%ld", PGG(num_links));

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

php_info_print_table_end();

DISPLAY_INI_ENTRIES();

}

/* }}} */

/* {{{ php_pgsql_do_connect

*/

static void php_pgsql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)

{

char *host=NULL,*port=NULL,*options=NULL,*tty=NULL,*dbname=NULL,*connstring=NULL;

PGconn *pgsql;

smart_str str = {0};

zval **args[5];

int i, connect_type = 0;

if (ZEND_NUM_ARGS() < 1 || ZEND_NUM_ARGS() > 5

|| zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {

WRONG_PARAM_COUNT;

}

smart_str_appends(&str, "pgsql");

for (i = 0; i < ZEND_NUM_ARGS(); i++) {

convert_to_string_ex(args[i]);

smart_str_appendc(&str, '_');

smart_str_appendl(&str, Z_STRVAL_PP(args[i]), Z_STRLEN_PP(args[i]));

}

smart_str_0(&str);

if (ZEND_NUM_ARGS() == 1) { /* new style, using connection string */

connstring = Z_STRVAL_PP(args[0]);

} else if (ZEND_NUM_ARGS() == 2 ) { /* Safe to add conntype_option, since 2 args was illegal */

connstring = Z_STRVAL_PP(args[0]);

convert_to_long_ex(args[1]);

connect_type = Z_LVAL_PP(args[1]);

} else {

host = Z_STRVAL_PP(args[0]);

port = Z_STRVAL_PP(args[1]);

dbname = Z_STRVAL_PP(args[ZEND_NUM_ARGS()-1]);

switch (ZEND_NUM_ARGS()) {

case 5:

tty = Z_STRVAL_PP(args[3]);

/* fall through */

case 4:

options = Z_STRVAL_PP(args[2]);

break;

}

}

if (persistent && PGG(allow_persistent)) {

list_entry *le;

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

if (zend_hash_find(&EG(persistent_list), str.c, str.len+1, (void **) &le)==FAILURE) { /* we don't */

list_entry new_le;

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

php_error_docref(NULL TSRMLS_CC, E_WARNING,

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

goto err;

}

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

php_error_docref(NULL TSRMLS_CC, E_WARNING,

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

goto err;

}

/* create the link */

if (connstring) {

pgsql=PQconnectdb(connstring);

} else {

pgsql=PQsetdb(host,port,options,tty,dbname);

}

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

php_error_docref(NULL TSRMLS_CC, E_WARNING,

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

if (pgsql) {

PQfinish(pgsql);

}

goto err;

}

/* hash it up */

Z_TYPE(new_le) = le_plink;

new_le.ptr = pgsql;

if (zend_hash_update(&EG(persistent_list), str.c, str.len+1, (void *) &new_le, sizeof(list_entry), NULL)==FAILURE) {

goto err;

}

PGG(num_links)++;

PGG(num_persistent)++;

} else { /* we do */

if (Z_TYPE_P(le) != le_plink) {

RETURN_FALSE;

}

/* ensure that the link did not die */

if (PGG(auto_reset_persistent)) {

/* need to send & get something from backend to

make sure we catch CONNECTION_BAD everytime */

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

if (connstring) {

le->ptr=PQconnectdb(connstring);

} else {

le->ptr=PQsetdb(host,port,options,tty,dbname);

}

}

else {

PQreset(le->ptr);

}

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

php_error_docref(NULL TSRMLS_CC, E_WARNING,"PostgreSQL link lost, unable to reconnect.");

zend_hash_del(&EG(persistent_list),str.c,str.len+1);

goto err;

}

}

pgsql = (PGconn *) le->ptr;

}

ZEND_REGISTER_RESOURCE(return_value, pgsql, le_plink);

} else { // Non persistent connection

list_entry *index_ptr,new_index_ptr;

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

* it should point us to the right offset where the actual pgsql link sits.

* if it doesn't, open a new pgsql link, add it to the resource list,

* and add a pointer to it with hashed_details as the key.

*/

if (!(connect_type & PGSQL_CONNECT_FORCE_NEW)

&& zend_hash_find(&EG(regular_list),str.c,str.len+1,(void **) &index_ptr)==SUCCESS) {

int type,link;

void *ptr;

if (Z_TYPE_P(index_ptr) != le_index_ptr) {

RETURN_FALSE;

}

link = (int) index_ptr->ptr;

ptr = zend_list_find(link,&type); /* check if the link is still there */

if (ptr && (type==le_link || type==le_plink)) {

Z_LVAL_P(return_value) = link;

zend_list_addref(link);

php_pgsql_set_default_link(link TSRMLS_CC);

Z_TYPE_P(return_value) = IS_RESOURCE;

goto cleanup;

} else {

zend_hash_del(&EG(regular_list),str.c,str.len+1);

}

}

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

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

goto err;

}

if (connstring) {

pgsql = PQconnectdb(connstring);

} else {

pgsql = PQsetdb(host,port,options,tty,dbname);

}

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

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to connect to PostgreSQL server: %s.", PQerrorMessage(pgsql));

goto err;

}

/* add it to the list */

ZEND_REGISTER_RESOURCE(return_value, pgsql, le_link);

/* add it to the hash */

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

Z_TYPE(new_index_ptr) = le_index_ptr;

if (zend_hash_update(&EG(regular_list),str.c,str.len+1,(void *) &new_index_ptr, sizeof(list_entry), NULL)==FAILURE) {

goto err;

}

PGG(num_links)++;

}

/* set notice processer */

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

PQsetNoticeProcessor(pgsql, _php_pgsql_notice_handler, (void *)&Z_RESVAL_P(return_value));

}

php_pgsql_set_default_link(Z_LVAL_P(return_value) TSRMLS_CC);

cleanup:

smart_str_free(&str);

return;

err:

smart_str_free(&str);

RETURN_FALSE;

}

/* }}} */

#if 0

/* {{{ php_pgsql_get_default_link

*/

static int php_pgsql_get_default_link(INTERNAL_FUNCTION_PARAMETERS)

{

if (PGG(default_link)==-1) { /* no link opened yet, implicitly open one */

ht = 0;

php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);

}

return PGG(default_link);

}

/* }}} */

#endif

/* {{{ proto resource pg_connect(string connection_string[, int connect_type] | [string host, string port [, string options [, string tty,]]] string database)

Open a PostgreSQL connection */

PHP_FUNCTION(pg_connect)

{

php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);

}

/* }}} */

/* {{{ proto resource pg_pconnect(string connection_string | [string host, string port [, string options [, string tty,]]] string database)

Open a persistent PostgreSQL connection */

PHP_FUNCTION(pg_pconnect)

{

php_pgsql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);

}

/* }}} */

/* {{{ proto bool pg_close([resource connection])

Close a PostgreSQL connection */

PHP_FUNCTION(pg_close)

{

zval **pgsql_link = NULL;

int id;

PGconn *pgsql;

switch (ZEND_NUM_ARGS()) {

case 0:

id = PGG(default_link);

CHECK_DEFAULT_LINK(id);

break;

case 1:

if (zend_get_parameters_ex(1, &pgsql_link)==FAILURE) {

RETURN_FALSE;

}

id = -1;

break;

default:

WRONG_PARAM_COUNT;

break;

}

ZEND_FETCH_RESOURCE2(pgsql, PGconn *, pgsql_link, id, "PostgreSQL link", le_link, le_plink);

if (id==-1) { /* explicit resource number */

zend_list_delete(Z_RESVAL_PP(pgsql_link));

}

if (id!=-1

|| (pgsql_link && Z_RESVAL_PP(pgsql_link)==PGG(default_link))) {

zend_list_delete(PGG(default_link));

PGG(default_link) = -1;

}

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

/* {{{ php_pgsql_get_link_info

*/

static void php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)

{

zval **pgsql_link = NULL;

int id = -1;

PGconn *pgsql;

switch(ZEND_NUM_ARGS()) {

case 0:

id = PGG(default_link);

CHECK_DEFAULT_LINK(id);

break;

case 1:

if (zend_get_parameters_ex(1, &pgsql_link)==FAILURE) {

RETURN_FALSE;

}

break;

default:

WRONG_PARAM_COUNT;

break;

}

ZEND_FETCH_RESOURCE2(pgsql, PGconn *, pgsql_link, id, "PostgreSQL link", le_link, le_plink);

switch(entry_type) {

case PHP_PG_DBNAME:

Z_STRVAL_P(return_value) = PQdb(pgsql);

break;

case PHP_PG_ERROR_MESSAGE:

Z_STRVAL_P(return_value) = PQerrorMessage(pgsql);

break;

case PHP_PG_OPTIONS:

Z_STRVAL_P(return_value) = PQoptions(pgsql);

break;

case PHP_PG_PORT:

Z_STRVAL_P(return_value) = PQport(pgsql);

break;

case PHP_PG_TTY:

Z_STRVAL_P(return_value) = PQtty(pgsql);

break;

case PHP_PG_HOST:

Z_STRVAL_P(return_value) = PQhost(pgsql);

break;

default:

RETURN_FALSE;

}

Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));

Z_STRVAL_P(return_value) = (char *) estrdup(Z_STRVAL_P(return_value));

Z_TYPE_P(return_value) = IS_STRING;

}

/* }}} */

/* {{{ proto string pg_dbname([resource connection])

Get the database name */

PHP_FUNCTION(pg_dbname)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_DBNAME);

}

/* }}} */

/* {{{ proto string pg_last_error([resource connection])

Get the error message string */

PHP_FUNCTION(pg_last_error)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_ERROR_MESSAGE);

}

/* }}} */

/* {{{ proto string pg_options([resource connection])

Get the options associated with the connection */

PHP_FUNCTION(pg_options)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_OPTIONS);

}

/* }}} */

/* {{{ proto int pg_port([resource connection])

Return the port number associated with the connection */

PHP_FUNCTION(pg_port)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_PORT);

}

/* }}} */

/* {{{ proto string pg_tty([resource connection])

Return the tty name associated with the connection */

PHP_FUNCTION(pg_tty)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_TTY);

}

/* }}} */

/* {{{ proto string pg_host([resource connection])

Returns the host name associated with the connection */

PHP_FUNCTION(pg_host)

{

php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_HOST);

}

/* }}} */

/* {{{ proto bool pg_ping(resource connection)

Ping database. If connection is bad, try to reconnect. */

PHP_FUNCTION(pg_ping)

{

zval *pgsql_link = NULL;

int id = -1;

PGconn *pgsql;

if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "r",

&pgsql_link) == FAILURE) {

RETURN_FALSE;

}

ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);

/* ping connection */

PQexec(pgsql, "SELECT 1;");

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

}

/* }}} */

/* {{{ proto resource pg_query([resource connection,] string query)

Execute a query */

PHP_FUNCTION(pg_query)

{

zval **query, **pgsql_link = NULL;

int id = -1;

int leftover = 0;

PGconn *pgsql;

PGresult *pgsql_result;

ExecStatusType status;

pgsql_result_handle *pg_result;

switch(ZEND_NUM_ARGS()) {

case 1:

if (zend_get_parameters_ex(1, &query)==FAILURE) {

RETURN_FALSE;

}

id = PGG(default_link);

CHECK_DEFAULT_LINK(id);

break;

case 2:

if (zend_get_parameters_ex(2, &pgsql_link, &query)==FAILURE) {

RETURN_FALSE;

}

break;

default:

WRONG_PARAM_COUNT;

break;

}

ZEND_FETCH_RESOURCE2(pgsql, PGconn *, pgsql_link, id, "PostgreSQL link", le_link, le_plink);

convert_to_string_ex(query);

if (PQ_SETNONBLOCKING(pgsql, 0)) {

php_error_docref(NULL TSRMLS_CC, E_NOTICE,"Cannot set connection to blocking mode.");

RETURN_FALSE;

}

while ((pgsql_result = PQgetResult(pgsql))) {

PQclear(pgsql_result);

leftover = 1;

}

if (leftover) {

php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Found results on this connection. Use pg_get_result() to get these results first.");

}

pgsql_result = PQexec(pgsql, Z_STRVAL_PP(query));

if (pgsql_result) {

status = PQresultStatus(pgsql_result);

} else {

status = (ExecStatusType) PQstatus(pgsql);

}

switch (status) {

case PGRES_EMPTY_QUERY:

case PGRES_BAD_RESPONSE:

case PGRES_NONFATAL_ERROR:

case PGRES_FATAL_ERROR:

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Query failed: %s.", PQerrorMessage(pgsql));

RETURN_FALSE;

break;

case PGRES_COMMAND_OK: /* successful command that did not return rows */

default:

if (pgsql_result) {

pg_result = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));

pg_result->conn = pgsql;

pg_result->result = pgsql_result;

pg_result->row = -1;

ZEND_REGISTER_RESOURCE(return_value, pg_result, le_result);

} else {

RETURN_FALSE;

}

break;

}

}

/* }}} */

#define PHP_PG_NUM_ROWS 1

#define PHP_PG_NUM_FIELDS 2

#define PHP_PG_CMD_TUPLES 3

/* {{{ php_pgsql_get_result_info

*/

static void php_pgsql_get_result_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)

{

zval **result;

PGresult *pgsql_result;

pgsql_result_handle *pg_result;

if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &result)==FAILURE) {

WRONG_PARAM_COUNT;

}

ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, result, -1, "PostgreSQL result", le_result);

pgsql_result = pg_result->result;

switch (entry_type) {

case PHP_PG_NUM_ROWS:

Z_LVAL_P(return_value) = PQntuples(pgsql_result);

break;

case PHP_PG_NUM_FIELDS:

Z_LVAL_P(return_value) = PQnfields(pgsql_result);

break;

case PHP_PG_CMD_TUPLES:

#if HAVE_PQCMDTUPLES

Z_LVAL_P(return_value) = atoi(PQcmdTuples(pgsql_result));

#else

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not supportted under this build.");

Z_LVAL_P(return_value) = 0;

#endif

break;

default:

RETURN_FALSE;