#ifdef HAVE_CONFIG_H

#include <config.h>

#include "php.h"

#include "php_globals.h"

#include "zend_attributes.h"

#include "ext/standard/info.h"

#include "Zend/zend_interfaces.h"

#include "zend_smart_str.h"

#include "php_odbc.h"

#include "php_odbc_includes.h"

#include "php_odbc_utils.h"

#ifdef HAVE_UODBC

#include <fcntl.h>

#include "php_ini.h"

#define PHP_ODBC_BINMODE_PASSTHRU 0

#define PHP_ODBC_BINMODE_RETURN 1

#define PHP_ODBC_BINMODE_CONVERT 2

#include "odbc_arginfo.h"

#define CHECK_ODBC_CONNECTION(conn) \

if (conn == NULL) { \

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

RETURN_THROWS(); \

}

#define CHECK_ODBC_RESULT(result) \

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

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

RETURN_THROWS(); \

}

void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent);

static void safe_odbc_disconnect(void *handle);

static void close_results_with_connection(odbc_connection *conn);

static inline odbc_result *odbc_result_from_obj(zend_object *obj);

static int le_pconn;

static zend_class_entry *odbc_connection_ce, *odbc_result_ce;

static zend_object_handlers odbc_connection_object_handlers, odbc_result_object_handlers;

#define Z_ODBC_LINK_P(zv) odbc_link_from_obj(Z_OBJ_P(zv))

#define Z_ODBC_CONNECTION_P(zv) Z_ODBC_LINK_P(zv)->connection

#define Z_ODBC_RESULT_P(zv) odbc_result_from_obj(Z_OBJ_P(zv))

static void odbc_insert_new_result(odbc_connection *connection, zval *result)

{

ZEND_ASSERT(Z_TYPE_P(result) == IS_OBJECT);

#if ZEND_DEBUG

ZEND_ASSERT(instanceof_function(Z_OBJCE_P(result), odbc_result_ce));

odbc_result *res = Z_ODBC_RESULT_P(result);

res->index = connection->results.nNextFreeElement;

zend_hash_index_add_new(&connection->results, res->index, result);

Z_ADDREF_P(result);

}

static inline odbc_link *odbc_link_from_obj(zend_object *obj)

{

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

}

static int _close_pconn_with_res(zval *zv, void *p)

{

zend_resource *le = Z_RES_P(zv);

if (le->ptr == p) {

return ZEND_HASH_APPLY_REMOVE;

}

return ZEND_HASH_APPLY_KEEP;

}

static int _close_pconn(zval *zv)

{

zend_resource *le = Z_RES_P(zv);

if (le->type == le_pconn) {

return ZEND_HASH_APPLY_REMOVE;

} else {

return ZEND_HASH_APPLY_KEEP;

}

}

static void safe_odbc_disconnect( void *handle )

{

int ret = SQLDisconnect( handle );

if ( ret == SQL_ERROR )

{

SQLTransact( NULL, handle, SQL_ROLLBACK );

SQLDisconnect( handle );

}

}

static void free_connection(odbc_connection *conn, bool persistent)

{

/* If aborted via timer expiration, don't try to call any unixODBC function */

if (!(PG(connection_status) & PHP_CONNECTION_TIMEOUT)) {

safe_odbc_disconnect(conn->hdbc);

SQLFreeConnect(conn->hdbc);

SQLFreeEnv(conn->henv);

}

conn->hdbc = NULL;

conn->henv = NULL;

zend_hash_destroy(&conn->results);

pefree(conn, persistent);

ODBCG(num_links)--;

if (persistent) {

ODBCG(num_persistent)--;

}

}

static void odbc_link_free(odbc_link *link)

{

ZEND_ASSERT(link->connection && "link has already been closed");

close_results_with_connection(link->connection);

if (!link->persistent) {

free_connection(link->connection, link->persistent);

}

link->connection = NULL;

if (link->hash) {

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

zend_string_release_ex(link->hash, link->persistent);

link->hash = NULL;

}

}

static zend_object *odbc_connection_create_object(zend_class_entry *class_type)

{

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

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *odbc_connection_get_constructor(zend_object *object)

{

zend_throw_error(NULL, "Cannot directly construct Odbc\\Connection, use odbc_connect() or odbc_pconnect() instead");

return NULL;

}

static zend_result odbc_connection_cast_object(zend_object *obj, zval *result, int type)

{

if (type == IS_LONG) {

ZVAL_LONG(result, obj->handle);

return SUCCESS;

}

return zend_std_cast_object_tostring(obj, result, type);

}

static void odbc_connection_free_obj(zend_object *obj)

{

odbc_link *link = odbc_link_from_obj(obj);

if (link->connection) {

odbc_link_free(link);

}

zend_object_std_dtor(&link->std);

}

static inline odbc_result *odbc_result_from_obj(zend_object *obj)

{

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

}

static zend_object *odbc_result_create_object(zend_class_entry *class_type)

{

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

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *odbc_result_get_constructor(zend_object *object)

{

zend_throw_error(NULL, "Cannot directly construct Odbc\\Result, use an appropriate odbc_* function instead");

return NULL;

}

static zend_result odbc_result_cast_object(zend_object *obj, zval *result, int type)

{

if (type == IS_LONG) {

ZVAL_LONG(result, obj->handle);

return SUCCESS;

}

return zend_std_cast_object_tostring(obj, result, type);

}

static void odbc_result_free(odbc_result *res)

{

ZEND_ASSERT(res->conn_ptr && "result has already been closed");

if (res->values) {

for (int i = 0; i < res->numcols; i++) {

if (res->values[i].value) {

efree(res->values[i].value);

}

}

efree(res->values);

res->values = NULL;

res->numcols = 0;

}

/* If aborted via timer expiration, don't try to call any unixODBC function */

if (res->stmt && !(PG(connection_status) & PHP_CONNECTION_TIMEOUT)) {

SQLFreeStmt(res->stmt,SQL_DROP);

/* We don't want the connection to be closed after the last statement has been closed

res->stmt = NULL;

}

if (res->param_info) {

efree(res->param_info);

res->param_info = NULL;

}

HashTable *results = &res->conn_ptr->results;

res->conn_ptr = NULL;

zend_result status = zend_hash_index_del(results, res->index);

ZEND_ASSERT(status == SUCCESS);

}

static void odbc_result_free_obj(zend_object *obj)

{

odbc_result *result = odbc_result_from_obj(obj);

if (result->conn_ptr) {

odbc_result_free(result);

}

zend_object_std_dtor(&result->std);

}

#define SAFE_SQL_NTS(n) ((SQLSMALLINT) ((n)?(SQL_NTS):0))

PHP_ODBC_API ZEND_DECLARE_MODULE_GLOBALS(odbc)

static PHP_GINIT_FUNCTION(odbc);

static PHP_GSHUTDOWN_FUNCTION(odbc);

zend_module_entry odbc_module_entry = {

STANDARD_MODULE_HEADER,

"odbc",

ext_functions,

PHP_MINIT(odbc),

PHP_MSHUTDOWN(odbc),

PHP_RINIT(odbc),

PHP_RSHUTDOWN(odbc),

PHP_MINFO(odbc),

PHP_ODBC_VERSION,

PHP_MODULE_GLOBALS(odbc),

PHP_GINIT(odbc),

PHP_GSHUTDOWN(odbc),

NULL,

STANDARD_MODULE_PROPERTIES_EX

};

#ifdef COMPILE_DL_ODBC

#ifdef ZTS

ZEND_TSRMLS_CACHE_DEFINE()

ZEND_GET_MODULE(odbc)

static void close_results_with_connection(odbc_connection *conn)

{

zval *p;

ZEND_HASH_FOREACH_VAL(&conn->results, p) {

odbc_result *result = Z_ODBC_RESULT_P(p);

if (result->conn_ptr) {

odbc_result_free(result);

}

} ZEND_HASH_FOREACH_END();

zend_hash_clean(&conn->results);

}

static void _close_odbc_pconn(zend_resource *rsrc)

{

odbc_connection *conn = (odbc_connection *)rsrc->ptr;

close_results_with_connection(conn);

free_connection(conn, true);

rsrc->ptr = NULL;

}

static PHP_INI_DISP(display_link_nums)

{

const zend_string *value;

if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {

value = ini_entry->orig_value;

} else if (ini_entry->value) {

value = ini_entry->value;

} else {

value = NULL;

}

if (value) {

if (atoi(ZSTR_VAL(value)) == -1) {

PUTS("Unlimited");

} else {

php_output_write(ZSTR_VAL(value), ZSTR_LEN(value));

}

}

}

static PHP_INI_DISP(display_binmode)

{

char *value;

if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {

value = ZSTR_VAL(ini_entry->orig_value);

} else if (ini_entry->value) {

value = ZSTR_VAL(ini_entry->value);

} else {

value = NULL;

}

if (value) {

switch(atoi(value)) {

case 0:

PUTS("passthru");

break;

case 1:

PUTS("return as is");

break;

case 2:

PUTS("return as char");

break;

}

}

}

static PHP_INI_DISP(display_lrl)

{

char *value;

if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {

value = ZSTR_VAL(ini_entry->orig_value);

} else if (ini_entry->value) {

value = ZSTR_VAL(ini_entry->value);

} else {

value = NULL;

}

if (value) {

if (atoi(value) <= 0) {

PUTS("Passthru");

} else {

php_printf("return up to %s bytes", value);

}

}

}

static PHP_INI_DISP(display_cursortype)

{

char *value;

if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {

value = ZSTR_VAL(ini_entry->orig_value);

} else if (ini_entry->value) {

value = ZSTR_VAL(ini_entry->value);

} else {

value = NULL;

}

if (value) {

switch (atoi (value))

{

case SQL_CURSOR_FORWARD_ONLY:

PUTS ("Forward Only cursor");

break;

case SQL_CURSOR_STATIC:

PUTS ("Static cursor");

break;

case SQL_CURSOR_KEYSET_DRIVEN:

PUTS ("Keyset driven cursor");

break;

case SQL_CURSOR_DYNAMIC:

PUTS ("Dynamic cursor");

break;

default:

php_printf("Unknown cursor model %s", value);

break;

}

}

}

PHP_INI_BEGIN()

STD_PHP_INI_BOOLEAN("odbc.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateBool,

allow_persistent, zend_odbc_globals, odbc_globals)

STD_PHP_INI_ENTRY_EX("odbc.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong,

max_persistent, zend_odbc_globals, odbc_globals, display_link_nums)

STD_PHP_INI_ENTRY_EX("odbc.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong,

max_links, zend_odbc_globals, odbc_globals, display_link_nums)

STD_PHP_INI_ENTRY_EX("odbc.defaultlrl", "4096", PHP_INI_ALL, OnUpdateLong,

defaultlrl, zend_odbc_globals, odbc_globals, display_lrl)

STD_PHP_INI_ENTRY_EX("odbc.defaultbinmode", "1", PHP_INI_ALL, OnUpdateLong,

defaultbinmode, zend_odbc_globals, odbc_globals, display_binmode)

STD_PHP_INI_BOOLEAN("odbc.check_persistent", "1", PHP_INI_SYSTEM, OnUpdateBool,

check_persistent, zend_odbc_globals, odbc_globals)

STD_PHP_INI_ENTRY_EX("odbc.default_cursortype", "3", PHP_INI_ALL, OnUpdateLong,

default_cursortype, zend_odbc_globals, odbc_globals, display_cursortype)

PHP_INI_END()

static PHP_GINIT_FUNCTION(odbc)

{

#if defined(COMPILE_DL_ODBC) && defined(ZTS)

ZEND_TSRMLS_CACHE_UPDATE();

odbc_globals->num_persistent = 0;

zend_hash_init(&odbc_globals->connections, 0, NULL, NULL, true);

GC_MAKE_PERSISTENT_LOCAL(&odbc_globals->connections);

}

static PHP_GSHUTDOWN_FUNCTION(odbc)

{

zend_hash_destroy(&odbc_globals->connections);

}

PHP_MINIT_FUNCTION(odbc)

{

#ifdef SQLANY_BUG

ODBC_SQL_CONN_T foobar;

RETCODE rc;

REGISTER_INI_ENTRIES();

le_pconn = zend_register_list_destructors_ex(NULL, _close_odbc_pconn, "odbc link persistent", module_number);

odbc_module_entry.type = type;

register_odbc_symbols(module_number);

odbc_connection_ce = register_class_Odbc_Connection();

odbc_connection_ce->create_object = odbc_connection_create_object;

odbc_connection_ce->default_object_handlers = &odbc_connection_object_handlers;

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

odbc_connection_object_handlers.offset = XtOffsetOf(odbc_link, std);

odbc_connection_object_handlers.free_obj = odbc_connection_free_obj;

odbc_connection_object_handlers.get_constructor = odbc_connection_get_constructor;

odbc_connection_object_handlers.clone_obj = NULL;

odbc_connection_object_handlers.cast_object = odbc_connection_cast_object;

odbc_connection_object_handlers.compare = zend_objects_not_comparable;

odbc_result_ce = register_class_Odbc_Result();

odbc_result_ce->create_object = odbc_result_create_object;

odbc_result_ce->default_object_handlers = &odbc_result_object_handlers;

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

odbc_result_object_handlers.offset = XtOffsetOf(odbc_result, std);

odbc_result_object_handlers.free_obj = odbc_result_free_obj;

odbc_result_object_handlers.get_constructor = odbc_result_get_constructor;

odbc_result_object_handlers.clone_obj = NULL;

odbc_result_object_handlers.cast_object = odbc_result_cast_object;

odbc_result_object_handlers.compare = zend_objects_not_comparable;

#if defined(HAVE_IBMDB2) && defined(_AIX)

/* atexit() handler in the DB2/AIX library segfaults in PHP CLI */

/* DB2NOEXITLIST env variable prevents DB2 from invoking atexit() */

putenv("DB2NOEXITLIST=TRUE");

return SUCCESS;

}

PHP_RINIT_FUNCTION(odbc)

{

ODBCG(num_links) = ODBCG(num_persistent);

memset(ODBCG(laststate), '\0', 6);

memset(ODBCG(lasterrormsg), '\0', SQL_MAX_MESSAGE_LENGTH);

return SUCCESS;

}

PHP_RSHUTDOWN_FUNCTION(odbc)

{

return SUCCESS;

}

PHP_MSHUTDOWN_FUNCTION(odbc)

{

UNREGISTER_INI_ENTRIES();

return SUCCESS;

}

PHP_MINFO_FUNCTION(odbc)

{

char buf[32];

php_info_print_table_start();

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

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

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

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

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

php_info_print_table_row(2, "ODBC library", PHP_ODBC_TYPE);

#ifndef PHP_WIN32

php_info_print_table_row(2, "ODBC_CFLAGS", PHP_ODBC_CFLAGS);

php_info_print_table_row(2, "ODBC_LFLAGS", PHP_ODBC_LFLAGS);

php_info_print_table_row(2, "ODBC_LIBS", PHP_ODBC_LIBS);

php_info_print_table_end();

DISPLAY_INI_ENTRIES();

}

void odbc_sql_error(ODBC_SQL_ERROR_PARAMS)

{

SQLINTEGER error; /* Not used */

SQLSMALLINT errormsgsize; /* Not used */

RETCODE rc;

ODBC_SQL_ENV_T henv;

ODBC_SQL_CONN_T conn;

if (conn_resource) {

henv = conn_resource->henv;

conn = conn_resource->hdbc;

} else {

henv = SQL_NULL_HENV;

conn = SQL_NULL_HDBC;

}

/* This leads to an endless loop in many drivers!

rc = SQLError(henv, conn, stmt, (SQLCHAR *) ODBCG(laststate), &error, (SQLCHAR *) ODBCG(lasterrormsg), sizeof(ODBCG(lasterrormsg))-1, &errormsgsize);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {

snprintf(ODBCG(laststate), sizeof(ODBCG(laststate)), "HY000");

snprintf(ODBCG(lasterrormsg), sizeof(ODBCG(lasterrormsg)), "Failed to fetch error message");

}

if (conn_resource) {

memcpy(conn_resource->laststate, ODBCG(laststate), sizeof(ODBCG(laststate)));

memcpy(conn_resource->lasterrormsg, ODBCG(lasterrormsg), sizeof(ODBCG(lasterrormsg)));

}

if (func) {

php_error_docref(NULL, E_WARNING, "SQL error: %s, SQL state %s in %s", ODBCG(lasterrormsg), ODBCG(laststate), func);

} else {

php_error_docref(NULL, E_WARNING, "SQL error: %s, SQL state %s", ODBCG(lasterrormsg), ODBCG(laststate));

}

/*

}

void php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAMETERS, int mode)

{

odbc_result *result;

zval *pv_res;

zend_long flag;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &pv_res, odbc_result_ce, &flag) == FAILURE) {

RETURN_THROWS();

}

result = Z_ODBC_RESULT_P(pv_res);

CHECK_ODBC_RESULT(result);

if (mode) {

result->longreadlen = flag;

} else {

result->binmode = flag;

}

RETURN_TRUE;

}

void odbc_bindcols(odbc_result *result)

{

RETCODE rc;

int i;

SQLSMALLINT colnamelen; /* Not used */

SQLLEN displaysize;

SQLUSMALLINT colfieldid;

result->values = (odbc_result_value *) safe_emalloc(sizeof(odbc_result_value), result->numcols, 0);

result->longreadlen = ODBCG(defaultlrl);

result->binmode = ODBCG(defaultbinmode);

for(i = 0; i < result->numcols; i++) {

bool char_extra_alloc = false;

colfieldid = SQL_COLUMN_DISPLAY_SIZE;

rc = SQLColAttribute(result->stmt, (SQLUSMALLINT)(i+1), SQL_DESC_NAME,

result->values[i].name, sizeof(result->values[i].name), &colnamelen, 0);

result->values[i].coltype = 0;

rc = SQLColAttribute(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_TYPE,

NULL, 0, NULL, &result->values[i].coltype);

/* Don't bind LONG / BINARY columns, so that fetch behaviour can

switch(result->values[i].coltype) {

case SQL_BINARY:

case SQL_VARBINARY:

case SQL_LONGVARBINARY:

case SQL_LONGVARCHAR:

case SQL_WLONGVARCHAR:

result->values[i].value = NULL;

break;

case SQL_CHAR:

case SQL_VARCHAR:

case SQL_WCHAR:

case SQL_WVARCHAR:

colfieldid = SQL_DESC_OCTET_LENGTH;

/* TODO: Check this is the intended behaviour */

ZEND_FALLTHROUGH;

default:

rc = SQLColAttribute(result->stmt, (SQLUSMALLINT)(i+1), colfieldid,

NULL, 0, NULL, &displaysize);

if (rc != SQL_SUCCESS) {

displaysize = 0;

}

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO && colfieldid == SQL_DESC_OCTET_LENGTH) {

SQLINTEGER err;

SQLCHAR errtxt[128];

SQLCHAR state[6];

memset(errtxt, '\0', 128);

memset(state, '\0', 6);

if (SQL_SUCCESS == SQLGetDiagRec(SQL_HANDLE_STMT, result->stmt, 1, state, &err, errtxt, 128, NULL)) {

errtxt[127] = '\0';

state[5] = '\0';

php_error_docref(NULL, E_WARNING, "SQLColAttribute can't handle SQL_DESC_OCTET_LENGTH: [%s] %s", state, errtxt);

}

/* This is a quirk for ODBC 2.0 compatibility for broken driver implementations.

char_extra_alloc = true;

rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_DISPLAY_SIZE,

NULL, 0, NULL, &displaysize);

if (rc != SQL_SUCCESS) {

displaysize = 0;

}

}

/* Workaround for drivers that report NVARCHAR(MAX) columns as SQL_WVARCHAR with size 0 (bug #69975) */

if (result->values[i].coltype == SQL_WVARCHAR && displaysize == 0) {

result->values[i].coltype = SQL_WLONGVARCHAR;

result->values[i].value = NULL;

break;

}

/* Workaround for drivers that report VARCHAR(MAX) columns as SQL_VARCHAR (bug #73725) */

if (SQL_VARCHAR == result->values[i].coltype && displaysize == 0) {

result->values[i].coltype = SQL_LONGVARCHAR;

result->values[i].value = NULL;

break;

}

/* Workaround for Oracle ODBC Driver bug (#50162) when fetching TIMESTAMP column */

if (result->values[i].coltype == SQL_TIMESTAMP) {

displaysize += 3;

}

if (char_extra_alloc) {

/* Since we don't know the exact # of bytes, allocate extra */

displaysize *= 4;

}

result->values[i].value = (char *)emalloc(displaysize + 1);

rc = SQLBindCol(result->stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, result->values[i].value,

displaysize + 1, &result->values[i].vallen);

break;

}

}

}

void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type)

{

RETCODE rc;

zval *pv_conn;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &pv_conn, odbc_connection_ce) == FAILURE) {

RETURN_THROWS();

}

odbc_connection *conn = Z_ODBC_CONNECTION_P(pv_conn);

CHECK_ODBC_CONNECTION(conn);

rc = SQLTransact(conn->henv, conn->hdbc, (SQLUSMALLINT)((type)?SQL_COMMIT:SQL_ROLLBACK));

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {

odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTransact");

RETURN_FALSE;

}

RETURN_TRUE;

}

void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type)

{

odbc_result *result;

SQLLEN len;

zval *pv_res;

zend_long pv_num;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &pv_res, odbc_result_ce, &pv_num) == FAILURE) {

RETURN_THROWS();

}

result = Z_ODBC_RESULT_P(pv_res);

CHECK_ODBC_RESULT(result);

if (pv_num < 1) {

zend_argument_value_error(2, "must be greater than 0");

RETURN_THROWS();

}

if (result->numcols == 0) {

php_error_docref(NULL, E_WARNING, "No tuples available at this result index");

RETURN_FALSE;

}

if (pv_num > result->numcols) {

php_error_docref(NULL, E_WARNING, "Field index larger than number of fields");

RETURN_FALSE;

}

SQLColAttribute(result->stmt, (SQLUSMALLINT)pv_num, (SQLUSMALLINT) (type?SQL_COLUMN_SCALE:SQL_COLUMN_PRECISION), NULL, 0, NULL, &len);

RETURN_LONG(len);

}

PHP_FUNCTION(odbc_close_all)

{

zval *zv;

ZEND_PARSE_PARAMETERS_NONE();

/* Loop through the link list, now close all links and their results */

ZEND_HASH_FOREACH_VAL(&ODBCG(connections), zv) {

odbc_link *link = Z_ODBC_LINK_P(zv);

if (link->connection) {

odbc_link_free(link);

}

} ZEND_HASH_FOREACH_END();

zend_hash_clean(&ODBCG(connections));

zend_hash_apply(&EG(persistent_list), _close_pconn);

}

PHP_FUNCTION(odbc_binmode)

{

php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);

}

PHP_FUNCTION(odbc_longreadlen)

{

php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);

}

PHP_FUNCTION(odbc_prepare)

{

zval *pv_conn;

char *query;

size_t query_len;

odbc_result *result = NULL;

RETCODE rc;

int i;

SQLUINTEGER scrollopts;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "Os", &pv_conn, odbc_connection_ce, &query, &query_len) == FAILURE) {

RETURN_THROWS();

}

odbc_connection *conn = Z_ODBC_CONNECTION_P(pv_conn);

CHECK_ODBC_CONNECTION(conn);

object_init_ex(return_value, odbc_result_ce);

result = Z_ODBC_RESULT_P(return_value);

result->numparams = 0;

result->param_info = NULL;

rc = SQLAllocHandle(SQL_HANDLE_STMT, conn->hdbc, &(result->stmt));

if (rc == SQL_INVALID_HANDLE) {

php_error_docref(NULL, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");

zval_ptr_dtor(return_value);

RETURN_FALSE;

}

if (rc == SQL_ERROR) {

odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");

zval_ptr_dtor(return_value);

RETURN_FALSE;

}

rc = SQLGetInfo(conn->hdbc, SQL_FETCH_DIRECTION, (void *) &scrollopts, sizeof(scrollopts), NULL);

if (rc == SQL_SUCCESS) {

if ((result->fetch_abs = (scrollopts & SQL_FD_FETCH_ABSOLUTE))) {

/* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other

SQLSetStmtAttr(result->stmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER) ODBCG(default_cursortype), 0);

}

} else {

result->fetch_abs = 0;

}

rc = SQLPrepare(result->stmt, (SQLCHAR *) query, SQL_NTS);

switch (rc) {

case SQL_SUCCESS:

break;

case SQL_SUCCESS_WITH_INFO:

odbc_sql_error(conn, result->stmt, "SQLPrepare");

break;

default:

odbc_sql_error(conn, result->stmt, "SQLPrepare");

zval_ptr_dtor(return_value);

RETURN_FALSE;

}

SQLNumParams(result->stmt, &(result->numparams));

SQLNumResultCols(result->stmt, &(result->numcols));

if (result->numcols > 0) {

odbc_bindcols(result);

} else {

result->values = NULL;

}

result->conn_ptr = conn;

result->fetched = 0;

result->param_info = (odbc_param_info *) safe_emalloc(sizeof(odbc_param_info), result->numparams, 0);

for (i=0;i<result->numparams;i++) {

rc = SQLDescribeParam(result->stmt, (SQLUSMALLINT)(i+1), &result->param_info[i].sqltype, &result->param_info[i].precision,

&result->param_info[i].scale, &result->param_info[i].nullable);

if (rc == SQL_ERROR) {

odbc_sql_error(result->conn_ptr, result->stmt, "SQLDescribeParameter");

SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);

efree(result->param_info);

zval_ptr_dtor(return_value);

RETURN_FALSE;

}

}

odbc_insert_new_result(conn, return_value);

}

typedef struct odbc_params_t {

} odbc_params_t;

static void odbc_release_params(odbc_result *result, odbc_params_t *params) {

SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);

for (int i = 0; i < result->numparams; i++) {

if (params[i].fp != -1) {

close(params[i].fp);

}

if (params[i].zstr) {

zend_string_release(params[i].zstr);

}

}

efree(params);

}

PHP_FUNCTION(odbc_execute)

{

zval *pv_res, *tmp;

HashTable *pv_param_ht = (HashTable *) &zend_empty_array;

odbc_params_t *params = NULL;

SQLSMALLINT ctype;

odbc_result *result;

int i;

RETCODE rc;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|h", &pv_res, odbc_result_ce, &pv_param_ht) == FAILURE) {

RETURN_THROWS();

}

result = Z_ODBC_RESULT_P(pv_res);

CHECK_ODBC_RESULT(result);

if (result->numparams > 0) {

uint32_t ne = zend_hash_num_elements(pv_param_ht);

if (ne < result->numparams) {

php_error_docref(NULL, E_WARNING, "Not enough parameters (%" PRIu32 " should be %d) given", ne, result->numparams);

RETURN_FALSE;

}

params = (odbc_params_t *)safe_emalloc(sizeof(odbc_params_t), result->numparams, 0);

for(i = 0; i < result->numparams; i++) {

params[i].fp = -1;

params[i].zstr = NULL;

}

i = 1;