Return to php_odbc.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / odbc |
1.1 ! misho 1: /* ! 2: +----------------------------------------------------------------------+ ! 3: | PHP Version 5 | ! 4: +----------------------------------------------------------------------+ ! 5: | Copyright (c) 1997-2012 The PHP Group | ! 6: +----------------------------------------------------------------------+ ! 7: | This source file is subject to version 3.01 of the PHP license, | ! 8: | that is bundled with this package in the file LICENSE, and is | ! 9: | available through the world-wide-web at the following url: | ! 10: | http://www.php.net/license/3_01.txt | ! 11: | If you did not receive a copy of the PHP license and are unable to | ! 12: | obtain it through the world-wide-web, please send a note to | ! 13: | license@php.net so we can mail you a copy immediately. | ! 14: +----------------------------------------------------------------------+ ! 15: | Authors: Stig Sæther Bakken <ssb@php.net> | ! 16: | Andreas Karajannis <Andreas.Karajannis@gmd.de> | ! 17: | Frank M. Kromann <frank@kromann.info> Support for DB/2 CLI | ! 18: | Kevin N. Shallow <kshallow@tampabay.rr.com> Birdstep Support| ! 19: | Daniel R. Kalowsky <kalowsky@php.net> | ! 20: +----------------------------------------------------------------------+ ! 21: */ ! 22: ! 23: /* $Id: php_odbc.c 321634 2012-01-01 13:15:04Z felipe $ */ ! 24: ! 25: #ifdef HAVE_CONFIG_H ! 26: #include "config.h" ! 27: #endif ! 28: ! 29: #include "php.h" ! 30: #include "php_globals.h" ! 31: ! 32: #include "ext/standard/info.h" ! 33: #include "ext/standard/php_string.h" ! 34: #include "ext/standard/php_standard.h" ! 35: ! 36: #include "php_odbc.h" ! 37: #include "php_odbc_includes.h" ! 38: #include "php_globals.h" ! 39: ! 40: #if HAVE_UODBC ! 41: ! 42: #include <fcntl.h> ! 43: #include "ext/standard/head.h" ! 44: #include "php_ini.h" ! 45: ! 46: #ifdef PHP_WIN32 ! 47: #include <winsock2.h> ! 48: ! 49: #define ODBC_TYPE "Win32" ! 50: #define PHP_ODBC_TYPE ODBC_TYPE ! 51: ! 52: #endif ! 53: ! 54: /* ! 55: * not defined elsewhere ! 56: */ ! 57: ! 58: #ifndef TRUE ! 59: #define TRUE 1 ! 60: #define FALSE 0 ! 61: #endif ! 62: ! 63: void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent); ! 64: ! 65: static int le_result, le_conn, le_pconn; ! 66: ! 67: #define SAFE_SQL_NTS(n) ((SQLSMALLINT) ((n)?(SQL_NTS):0)) ! 68: ! 69: /* {{{ arginfo */ ! 70: ZEND_BEGIN_ARG_INFO(arginfo_odbc_close_all, 0) ! 71: ZEND_END_ARG_INFO() ! 72: ! 73: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_binmode, 0, 0, 2) ! 74: ZEND_ARG_INFO(0, result_id) ! 75: ZEND_ARG_INFO(0, mode) ! 76: ZEND_END_ARG_INFO() ! 77: ! 78: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_longreadlen, 0, 0, 2) ! 79: ZEND_ARG_INFO(0, result_id) ! 80: ZEND_ARG_INFO(0, length) ! 81: ZEND_END_ARG_INFO() ! 82: ! 83: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_prepare, 0, 0, 2) ! 84: ZEND_ARG_INFO(0, connection_id) ! 85: ZEND_ARG_INFO(0, query) ! 86: ZEND_END_ARG_INFO() ! 87: ! 88: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_execute, 0, 0, 1) ! 89: ZEND_ARG_INFO(0, result_id) ! 90: ZEND_ARG_INFO(0, parameters_array) ! 91: ZEND_END_ARG_INFO() ! 92: ! 93: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_cursor, 0, 0, 1) ! 94: ZEND_ARG_INFO(0, result_id) ! 95: ZEND_END_ARG_INFO() ! 96: ! 97: #ifdef HAVE_SQLDATASOURCES ! 98: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_data_source, 0, 0, 2) ! 99: ZEND_ARG_INFO(0, connection_id) ! 100: ZEND_ARG_INFO(0, fetch_type) ! 101: ZEND_END_ARG_INFO() ! 102: #endif ! 103: ! 104: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_exec, 0, 0, 2) ! 105: ZEND_ARG_INFO(0, connection_id) ! 106: ZEND_ARG_INFO(0, query) ! 107: ZEND_ARG_INFO(0, flags) ! 108: ZEND_END_ARG_INFO() ! 109: ! 110: #ifdef PHP_ODBC_HAVE_FETCH_HASH ! 111: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_object, 0, 0, 1) ! 112: ZEND_ARG_INFO(0, result) ! 113: ZEND_ARG_INFO(0, rownumber) ! 114: ZEND_END_ARG_INFO() ! 115: ! 116: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_array, 0, 0, 1) ! 117: ZEND_ARG_INFO(0, result) ! 118: ZEND_ARG_INFO(0, rownumber) ! 119: ZEND_END_ARG_INFO() ! 120: #endif ! 121: ! 122: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_into, 0, 0, 2) ! 123: ZEND_ARG_INFO(0, result_id) ! 124: ZEND_ARG_INFO(1, result_array) ! 125: ZEND_ARG_INFO(0, rownumber) ! 126: ZEND_END_ARG_INFO() ! 127: ! 128: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_row, 0, 0, 1) ! 129: ZEND_ARG_INFO(0, result_id) ! 130: ZEND_ARG_INFO(0, row_number) ! 131: ZEND_END_ARG_INFO() ! 132: ! 133: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_result, 0, 0, 2) ! 134: ZEND_ARG_INFO(0, result_id) ! 135: ZEND_ARG_INFO(0, field) ! 136: ZEND_END_ARG_INFO() ! 137: ! 138: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_result_all, 0, 0, 1) ! 139: ZEND_ARG_INFO(0, result_id) ! 140: ZEND_ARG_INFO(0, format) ! 141: ZEND_END_ARG_INFO() ! 142: ! 143: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_free_result, 0, 0, 1) ! 144: ZEND_ARG_INFO(0, result_id) ! 145: ZEND_END_ARG_INFO() ! 146: ! 147: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_connect, 0, 0, 3) ! 148: ZEND_ARG_INFO(0, dsn) ! 149: ZEND_ARG_INFO(0, user) ! 150: ZEND_ARG_INFO(0, password) ! 151: ZEND_ARG_INFO(0, cursor_option) ! 152: ZEND_END_ARG_INFO() ! 153: ! 154: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_pconnect, 0, 0, 3) ! 155: ZEND_ARG_INFO(0, dsn) ! 156: ZEND_ARG_INFO(0, user) ! 157: ZEND_ARG_INFO(0, password) ! 158: ZEND_ARG_INFO(0, cursor_option) ! 159: ZEND_END_ARG_INFO() ! 160: ! 161: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_close, 0, 0, 1) ! 162: ZEND_ARG_INFO(0, connection_id) ! 163: ZEND_END_ARG_INFO() ! 164: ! 165: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_num_rows, 0, 0, 1) ! 166: ZEND_ARG_INFO(0, result_id) ! 167: ZEND_END_ARG_INFO() ! 168: ! 169: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) ! 170: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_next_result, 0, 0, 1) ! 171: ZEND_ARG_INFO(0, result_id) ! 172: ZEND_END_ARG_INFO() ! 173: #endif ! 174: ! 175: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_num_fields, 0, 0, 1) ! 176: ZEND_ARG_INFO(0, result_id) ! 177: ZEND_END_ARG_INFO() ! 178: ! 179: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_name, 0, 0, 2) ! 180: ZEND_ARG_INFO(0, result_id) ! 181: ZEND_ARG_INFO(0, field_number) ! 182: ZEND_END_ARG_INFO() ! 183: ! 184: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_type, 0, 0, 2) ! 185: ZEND_ARG_INFO(0, result_id) ! 186: ZEND_ARG_INFO(0, field_number) ! 187: ZEND_END_ARG_INFO() ! 188: ! 189: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_len, 0, 0, 2) ! 190: ZEND_ARG_INFO(0, result_id) ! 191: ZEND_ARG_INFO(0, field_number) ! 192: ZEND_END_ARG_INFO() ! 193: ! 194: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_scale, 0, 0, 2) ! 195: ZEND_ARG_INFO(0, result_id) ! 196: ZEND_ARG_INFO(0, field_number) ! 197: ZEND_END_ARG_INFO() ! 198: ! 199: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_num, 0, 0, 2) ! 200: ZEND_ARG_INFO(0, result_id) ! 201: ZEND_ARG_INFO(0, field_name) ! 202: ZEND_END_ARG_INFO() ! 203: ! 204: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_autocommit, 0, 0, 1) ! 205: ZEND_ARG_INFO(0, connection_id) ! 206: ZEND_ARG_INFO(0, onoff) ! 207: ZEND_END_ARG_INFO() ! 208: ! 209: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_commit, 0, 0, 1) ! 210: ZEND_ARG_INFO(0, connection_id) ! 211: ZEND_END_ARG_INFO() ! 212: ! 213: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_rollback, 0, 0, 1) ! 214: ZEND_ARG_INFO(0, connection_id) ! 215: ZEND_END_ARG_INFO() ! 216: ! 217: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_error, 0, 0, 0) ! 218: ZEND_ARG_INFO(0, connection_id) ! 219: ZEND_END_ARG_INFO() ! 220: ! 221: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_errormsg, 0, 0, 0) ! 222: ZEND_ARG_INFO(0, connection_id) ! 223: ZEND_END_ARG_INFO() ! 224: ! 225: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_setoption, 0, 0, 4) ! 226: ZEND_ARG_INFO(0, conn_id) ! 227: ZEND_ARG_INFO(0, which) ! 228: ZEND_ARG_INFO(0, option) ! 229: ZEND_ARG_INFO(0, value) ! 230: ZEND_END_ARG_INFO() ! 231: ! 232: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_tables, 0, 0, 1) ! 233: ZEND_ARG_INFO(0, connection_id) ! 234: ZEND_ARG_INFO(0, qualifier) ! 235: ZEND_ARG_INFO(0, owner) ! 236: ZEND_ARG_INFO(0, name) ! 237: ZEND_ARG_INFO(0, table_types) ! 238: ZEND_END_ARG_INFO() ! 239: ! 240: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_columns, 0, 0, 1) ! 241: ZEND_ARG_INFO(0, connection_id) ! 242: ZEND_ARG_INFO(0, qualifier) ! 243: ZEND_ARG_INFO(0, owner) ! 244: ZEND_ARG_INFO(0, table_name) ! 245: ZEND_ARG_INFO(0, column_name) ! 246: ZEND_END_ARG_INFO() ! 247: ! 248: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_gettypeinfo, 0, 0, 1) ! 249: ZEND_ARG_INFO(0, connection_id) ! 250: ZEND_ARG_INFO(0, data_type) ! 251: ZEND_END_ARG_INFO() ! 252: ! 253: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_primarykeys, 0, 0, 4) ! 254: ZEND_ARG_INFO(0, connection_id) ! 255: ZEND_ARG_INFO(0, qualifier) ! 256: ZEND_ARG_INFO(0, owner) ! 257: ZEND_ARG_INFO(0, table) ! 258: ZEND_END_ARG_INFO() ! 259: ! 260: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) ! 261: #if !defined(HAVE_BIRDSTEP) ! 262: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_procedurecolumns, 0, 0, 1) ! 263: ZEND_ARG_INFO(0, connection_id) ! 264: ZEND_ARG_INFO(0, qualifier) ! 265: ZEND_ARG_INFO(0, owner) ! 266: ZEND_ARG_INFO(0, proc) ! 267: ZEND_ARG_INFO(0, column) ! 268: ZEND_END_ARG_INFO() ! 269: #endif ! 270: ! 271: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_procedures, 0, 0, 1) ! 272: ZEND_ARG_INFO(0, connection_id) ! 273: ZEND_ARG_INFO(0, qualifier) ! 274: ZEND_ARG_INFO(0, owner) ! 275: ZEND_ARG_INFO(0, name) ! 276: ZEND_END_ARG_INFO() ! 277: ! 278: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_foreignkeys, 0, 0, 7) ! 279: ZEND_ARG_INFO(0, connection_id) ! 280: ZEND_ARG_INFO(0, pk_qualifier) ! 281: ZEND_ARG_INFO(0, pk_owner) ! 282: ZEND_ARG_INFO(0, pk_table) ! 283: ZEND_ARG_INFO(0, fk_qualifier) ! 284: ZEND_ARG_INFO(0, fk_owner) ! 285: ZEND_ARG_INFO(0, fk_table) ! 286: ZEND_END_ARG_INFO() ! 287: #endif ! 288: ! 289: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_specialcolumns, 0, 0, 7) ! 290: ZEND_ARG_INFO(0, connection_id) ! 291: ZEND_ARG_INFO(0, type) ! 292: ZEND_ARG_INFO(0, qualifier) ! 293: ZEND_ARG_INFO(0, owner) ! 294: ZEND_ARG_INFO(0, table) ! 295: ZEND_ARG_INFO(0, scope) ! 296: ZEND_ARG_INFO(0, nullable) ! 297: ZEND_END_ARG_INFO() ! 298: ! 299: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_statistics, 0, 0, 6) ! 300: ZEND_ARG_INFO(0, connection_id) ! 301: ZEND_ARG_INFO(0, qualifier) ! 302: ZEND_ARG_INFO(0, owner) ! 303: ZEND_ARG_INFO(0, name) ! 304: ZEND_ARG_INFO(0, unique) ! 305: ZEND_ARG_INFO(0, accuracy) ! 306: ZEND_END_ARG_INFO() ! 307: ! 308: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) &&!defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP) ! 309: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_tableprivileges, 0, 0, 4) ! 310: ZEND_ARG_INFO(0, connection_id) ! 311: ZEND_ARG_INFO(0, qualifier) ! 312: ZEND_ARG_INFO(0, owner) ! 313: ZEND_ARG_INFO(0, name) ! 314: ZEND_END_ARG_INFO() ! 315: ! 316: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_columnprivileges, 0, 0, 5) ! 317: ZEND_ARG_INFO(0, connection_id) ! 318: ZEND_ARG_INFO(0, catalog) ! 319: ZEND_ARG_INFO(0, schema) ! 320: ZEND_ARG_INFO(0, table) ! 321: ZEND_ARG_INFO(0, column) ! 322: ZEND_END_ARG_INFO() ! 323: #endif ! 324: /* }}} */ ! 325: ! 326: /* {{{ odbc_functions[] ! 327: */ ! 328: const zend_function_entry odbc_functions[] = { ! 329: PHP_FE(odbc_autocommit, arginfo_odbc_autocommit) ! 330: PHP_FE(odbc_binmode, arginfo_odbc_binmode) ! 331: PHP_FE(odbc_close, arginfo_odbc_close) ! 332: PHP_FE(odbc_close_all, arginfo_odbc_close_all) ! 333: PHP_FE(odbc_columns, arginfo_odbc_columns) ! 334: PHP_FE(odbc_commit, arginfo_odbc_commit) ! 335: PHP_FE(odbc_connect, arginfo_odbc_connect) ! 336: PHP_FE(odbc_cursor, arginfo_odbc_cursor) ! 337: #ifdef HAVE_SQLDATASOURCES ! 338: PHP_FE(odbc_data_source, arginfo_odbc_data_source) ! 339: #endif ! 340: PHP_FE(odbc_execute, arginfo_odbc_execute) ! 341: PHP_FE(odbc_error, arginfo_odbc_error) ! 342: PHP_FE(odbc_errormsg, arginfo_odbc_errormsg) ! 343: PHP_FE(odbc_exec, arginfo_odbc_exec) ! 344: #ifdef PHP_ODBC_HAVE_FETCH_HASH ! 345: PHP_FE(odbc_fetch_array, arginfo_odbc_fetch_array) ! 346: PHP_FE(odbc_fetch_object, arginfo_odbc_fetch_object) ! 347: #endif ! 348: PHP_FE(odbc_fetch_row, arginfo_odbc_fetch_row) ! 349: PHP_FE(odbc_fetch_into, arginfo_odbc_fetch_into) ! 350: PHP_FE(odbc_field_len, arginfo_odbc_field_len) ! 351: PHP_FE(odbc_field_scale, arginfo_odbc_field_scale) ! 352: PHP_FE(odbc_field_name, arginfo_odbc_field_name) ! 353: PHP_FE(odbc_field_type, arginfo_odbc_field_type) ! 354: PHP_FE(odbc_field_num, arginfo_odbc_field_num) ! 355: PHP_FE(odbc_free_result, arginfo_odbc_free_result) ! 356: PHP_FE(odbc_gettypeinfo, arginfo_odbc_gettypeinfo) ! 357: PHP_FE(odbc_longreadlen, arginfo_odbc_longreadlen) ! 358: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) ! 359: PHP_FE(odbc_next_result, arginfo_odbc_next_result) ! 360: #endif ! 361: PHP_FE(odbc_num_fields, arginfo_odbc_num_fields) ! 362: PHP_FE(odbc_num_rows, arginfo_odbc_num_rows) ! 363: PHP_FE(odbc_pconnect, arginfo_odbc_pconnect) ! 364: PHP_FE(odbc_prepare, arginfo_odbc_prepare) ! 365: PHP_FE(odbc_result, arginfo_odbc_result) ! 366: PHP_FE(odbc_result_all, arginfo_odbc_result_all) ! 367: PHP_FE(odbc_rollback, arginfo_odbc_rollback) ! 368: PHP_FE(odbc_setoption, arginfo_odbc_setoption) ! 369: PHP_FE(odbc_specialcolumns, arginfo_odbc_specialcolumns) ! 370: PHP_FE(odbc_statistics, arginfo_odbc_statistics) ! 371: PHP_FE(odbc_tables, arginfo_odbc_tables) ! 372: PHP_FE(odbc_primarykeys, arginfo_odbc_primarykeys) ! 373: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) &&!defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP) /* not supported now */ ! 374: PHP_FE(odbc_columnprivileges, arginfo_odbc_columnprivileges) ! 375: PHP_FE(odbc_tableprivileges, arginfo_odbc_tableprivileges) ! 376: #endif ! 377: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) /* not supported */ ! 378: PHP_FE(odbc_foreignkeys, arginfo_odbc_foreignkeys) ! 379: PHP_FE(odbc_procedures, arginfo_odbc_procedures) ! 380: #if !defined(HAVE_BIRDSTEP) ! 381: PHP_FE(odbc_procedurecolumns, arginfo_odbc_procedurecolumns) ! 382: #endif ! 383: #endif ! 384: PHP_FALIAS(odbc_do, odbc_exec, arginfo_odbc_exec) ! 385: PHP_FALIAS(odbc_field_precision, odbc_field_len, arginfo_odbc_field_len) ! 386: PHP_FE_END ! 387: }; ! 388: /* }}} */ ! 389: ! 390: ZEND_DECLARE_MODULE_GLOBALS(odbc); ! 391: static PHP_GINIT_FUNCTION(odbc); ! 392: ! 393: /* {{{ odbc_module_entry ! 394: */ ! 395: zend_module_entry odbc_module_entry = { ! 396: STANDARD_MODULE_HEADER, ! 397: "odbc", ! 398: odbc_functions, ! 399: PHP_MINIT(odbc), ! 400: PHP_MSHUTDOWN(odbc), ! 401: PHP_RINIT(odbc), ! 402: PHP_RSHUTDOWN(odbc), ! 403: PHP_MINFO(odbc), ! 404: "1.0", ! 405: PHP_MODULE_GLOBALS(odbc), ! 406: PHP_GINIT(odbc), ! 407: NULL, ! 408: NULL, ! 409: STANDARD_MODULE_PROPERTIES_EX ! 410: }; ! 411: /* }}} */ ! 412: ! 413: #ifdef COMPILE_DL_ODBC ! 414: ZEND_GET_MODULE(odbc) ! 415: #endif ! 416: ! 417: /* {{{ _free_odbc_result ! 418: */ ! 419: static void _free_odbc_result(zend_rsrc_list_entry *rsrc TSRMLS_DC) ! 420: { ! 421: odbc_result *res = (odbc_result *)rsrc->ptr; ! 422: int i; ! 423: RETCODE rc; ! 424: ! 425: if (res) { ! 426: if (res->values) { ! 427: for(i = 0; i < res->numcols; i++) { ! 428: if (res->values[i].value) ! 429: efree(res->values[i].value); ! 430: } ! 431: efree(res->values); ! 432: res->values = NULL; ! 433: } ! 434: if (res->stmt) { ! 435: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30) || defined(HAVE_SOLID_35) ! 436: SQLTransact(res->conn_ptr->henv, res->conn_ptr->hdbc, ! 437: (SQLUSMALLINT) SQL_COMMIT); ! 438: #endif ! 439: rc = SQLFreeStmt(res->stmt,SQL_DROP); ! 440: /* We don't want the connection to be closed after the last statment has been closed ! 441: * Connections will be closed on shutdown ! 442: * zend_list_delete(res->conn_ptr->id); ! 443: */ ! 444: } ! 445: efree(res); ! 446: } ! 447: } ! 448: /* }}} */ ! 449: ! 450: /* {{{ safe_odbc_disconnect ! 451: * disconnect, and if it fails, then issue a rollback for any pending transaction (lurcher) ! 452: */ ! 453: static void safe_odbc_disconnect( void *handle ) ! 454: { ! 455: int ret; ! 456: ! 457: ret = SQLDisconnect( handle ); ! 458: if ( ret == SQL_ERROR ) ! 459: { ! 460: SQLTransact( NULL, handle, SQL_ROLLBACK ); ! 461: SQLDisconnect( handle ); ! 462: } ! 463: } ! 464: /* }}} */ ! 465: ! 466: /* {{{ _close_odbc_conn ! 467: */ ! 468: static void _close_odbc_conn(zend_rsrc_list_entry *rsrc TSRMLS_DC) ! 469: { ! 470: int i, nument, type; ! 471: void *ptr; ! 472: odbc_result *res; ! 473: ! 474: odbc_connection *conn = (odbc_connection *)rsrc->ptr; ! 475: ! 476: nument = zend_hash_next_free_element(&EG(regular_list)); ! 477: for(i = 1; i < nument; i++) { ! 478: ptr = zend_list_find(i, &type); ! 479: if (ptr && (type == le_result)) { ! 480: res = (odbc_result *)ptr; ! 481: if (res->conn_ptr == conn) { ! 482: zend_list_delete(i); ! 483: } ! 484: } ! 485: } ! 486: ! 487: safe_odbc_disconnect(conn->hdbc); ! 488: SQLFreeConnect(conn->hdbc); ! 489: SQLFreeEnv(conn->henv); ! 490: efree(conn); ! 491: ODBCG(num_links)--; ! 492: } ! 493: /* }}} */ ! 494: ! 495: /* {{{ void _close_odbc_pconn ! 496: */ ! 497: static void _close_odbc_pconn(zend_rsrc_list_entry *rsrc TSRMLS_DC) ! 498: { ! 499: int i, nument, type; ! 500: void *ptr; ! 501: odbc_result *res; ! 502: odbc_connection *conn = (odbc_connection *)rsrc->ptr; ! 503: ! 504: nument = zend_hash_next_free_element(&EG(persistent_list)); ! 505: for(i = 1; i < nument; i++) { ! 506: ptr = zend_list_find(i, &type); ! 507: if (ptr && (type == le_result)) { ! 508: res = (odbc_result *)ptr; ! 509: if (res->conn_ptr == conn) { ! 510: zend_list_delete(i); ! 511: } ! 512: } ! 513: } ! 514: ! 515: safe_odbc_disconnect(conn->hdbc); ! 516: SQLFreeConnect(conn->hdbc); ! 517: SQLFreeEnv(conn->henv); ! 518: free(conn); ! 519: ! 520: ODBCG(num_links)--; ! 521: ODBCG(num_persistent)--; ! 522: } ! 523: /* }}} */ ! 524: ! 525: /* {{{ PHP_INI_DISP(display_link_nums) ! 526: */ ! 527: static PHP_INI_DISP(display_link_nums) ! 528: { ! 529: char *value; ! 530: TSRMLS_FETCH(); ! 531: ! 532: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) { ! 533: value = ini_entry->orig_value; ! 534: } else if (ini_entry->value) { ! 535: value = ini_entry->value; ! 536: } else { ! 537: value = NULL; ! 538: } ! 539: ! 540: if (value) { ! 541: if (atoi(value) == -1) { ! 542: PUTS("Unlimited"); ! 543: } else { ! 544: php_printf("%s", value); ! 545: } ! 546: } ! 547: } ! 548: /* }}} */ ! 549: ! 550: /* {{{ PHP_INI_DISP(display_defPW) ! 551: */ ! 552: static PHP_INI_DISP(display_defPW) ! 553: { ! 554: char *value; ! 555: TSRMLS_FETCH(); ! 556: ! 557: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) { ! 558: value = ini_entry->orig_value; ! 559: } else if (ini_entry->value) { ! 560: value = ini_entry->value; ! 561: } else { ! 562: value = NULL; ! 563: } ! 564: ! 565: if (value) { ! 566: #if PHP_DEBUG ! 567: php_printf("%s", value); ! 568: #else ! 569: PUTS("********"); ! 570: #endif ! 571: } else { ! 572: if (PG(html_errors)) { ! 573: PUTS("<i>no value</i>"); ! 574: } else { ! 575: PUTS("no value"); ! 576: } ! 577: } ! 578: } ! 579: /* }}} */ ! 580: ! 581: /* {{{ PHP_INI_DISP(display_binmode) ! 582: */ ! 583: static PHP_INI_DISP(display_binmode) ! 584: { ! 585: char *value; ! 586: TSRMLS_FETCH(); ! 587: ! 588: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) { ! 589: value = ini_entry->orig_value; ! 590: } else if (ini_entry->value) { ! 591: value = ini_entry->value; ! 592: } else { ! 593: value = NULL; ! 594: } ! 595: ! 596: if (value) { ! 597: switch(atoi(value)) { ! 598: case 0: ! 599: PUTS("passthru"); ! 600: break; ! 601: case 1: ! 602: PUTS("return as is"); ! 603: break; ! 604: case 2: ! 605: PUTS("return as char"); ! 606: break; ! 607: } ! 608: } ! 609: } ! 610: /* }}} */ ! 611: ! 612: /* {{{ PHP_INI_DISP(display_lrl) ! 613: */ ! 614: static PHP_INI_DISP(display_lrl) ! 615: { ! 616: char *value; ! 617: TSRMLS_FETCH(); ! 618: ! 619: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) { ! 620: value = ini_entry->orig_value; ! 621: } else if (ini_entry->value) { ! 622: value = ini_entry->value; ! 623: } else { ! 624: value = NULL; ! 625: } ! 626: ! 627: if (value) { ! 628: if (atoi(value) <= 0) { ! 629: PUTS("Passthru"); ! 630: } else { ! 631: php_printf("return up to %s bytes", value); ! 632: } ! 633: } ! 634: } ! 635: /* }}} */ ! 636: ! 637: ! 638: /* {{{ PHP_INI_DISP(display_cursortype) ! 639: */ ! 640: static PHP_INI_DISP(display_cursortype) ! 641: { ! 642: char *value; ! 643: TSRMLS_FETCH(); ! 644: ! 645: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) { ! 646: value = ini_entry->orig_value; ! 647: } else if (ini_entry->value) { ! 648: value = ini_entry->value; ! 649: } else { ! 650: value = NULL; ! 651: } ! 652: ! 653: if (value) { ! 654: switch (atoi (value)) ! 655: { ! 656: case SQL_CURSOR_FORWARD_ONLY: ! 657: PUTS ("Forward Only cursor"); ! 658: break; ! 659: ! 660: case SQL_CURSOR_STATIC: ! 661: PUTS ("Static cursor"); ! 662: break; ! 663: ! 664: case SQL_CURSOR_KEYSET_DRIVEN: ! 665: PUTS ("Keyset driven cursor"); ! 666: break; ! 667: ! 668: case SQL_CURSOR_DYNAMIC: ! 669: PUTS ("Dynamic cursor"); ! 670: break; ! 671: ! 672: default: ! 673: php_printf("Unknown cursor model %s", value); ! 674: break; ! 675: } ! 676: } ! 677: } ! 678: ! 679: /* }}} */ ! 680: ! 681: /* {{{ PHP_INI_BEGIN ! 682: */ ! 683: PHP_INI_BEGIN() ! 684: STD_PHP_INI_BOOLEAN("odbc.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateLong, ! 685: allow_persistent, zend_odbc_globals, odbc_globals) ! 686: STD_PHP_INI_ENTRY_EX("odbc.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong, ! 687: max_persistent, zend_odbc_globals, odbc_globals, display_link_nums) ! 688: STD_PHP_INI_ENTRY_EX("odbc.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong, ! 689: max_links, zend_odbc_globals, odbc_globals, display_link_nums) ! 690: STD_PHP_INI_ENTRY("odbc.default_db", NULL, PHP_INI_ALL, OnUpdateString, ! 691: defDB, zend_odbc_globals, odbc_globals) ! 692: STD_PHP_INI_ENTRY("odbc.default_user", NULL, PHP_INI_ALL, OnUpdateString, ! 693: defUser, zend_odbc_globals, odbc_globals) ! 694: STD_PHP_INI_ENTRY_EX("odbc.default_pw", NULL, PHP_INI_ALL, OnUpdateString, ! 695: defPW, zend_odbc_globals, odbc_globals, display_defPW) ! 696: STD_PHP_INI_ENTRY_EX("odbc.defaultlrl", "4096", PHP_INI_ALL, OnUpdateLong, ! 697: defaultlrl, zend_odbc_globals, odbc_globals, display_lrl) ! 698: STD_PHP_INI_ENTRY_EX("odbc.defaultbinmode", "1", PHP_INI_ALL, OnUpdateLong, ! 699: defaultbinmode, zend_odbc_globals, odbc_globals, display_binmode) ! 700: STD_PHP_INI_BOOLEAN("odbc.check_persistent", "1", PHP_INI_SYSTEM, OnUpdateLong, ! 701: check_persistent, zend_odbc_globals, odbc_globals) ! 702: STD_PHP_INI_ENTRY_EX("odbc.default_cursortype", "3", PHP_INI_ALL, OnUpdateLong, ! 703: default_cursortype, zend_odbc_globals, odbc_globals, display_cursortype) ! 704: PHP_INI_END() ! 705: /* }}} */ ! 706: ! 707: static PHP_GINIT_FUNCTION(odbc) ! 708: { ! 709: odbc_globals->num_persistent = 0; ! 710: } ! 711: ! 712: /* {{{ PHP_MINIT_FUNCTION */ ! 713: PHP_MINIT_FUNCTION(odbc) ! 714: { ! 715: #ifdef SQLANY_BUG ! 716: ODBC_SQL_CONN_T foobar; ! 717: RETCODE rc; ! 718: #endif ! 719: ! 720: REGISTER_INI_ENTRIES(); ! 721: le_result = zend_register_list_destructors_ex(_free_odbc_result, NULL, "odbc result", module_number); ! 722: le_conn = zend_register_list_destructors_ex(_close_odbc_conn, NULL, "odbc link", module_number); ! 723: le_pconn = zend_register_list_destructors_ex(NULL, _close_odbc_pconn, "odbc link persistent", module_number); ! 724: Z_TYPE(odbc_module_entry) = type; ! 725: ! 726: REGISTER_STRING_CONSTANT("ODBC_TYPE", PHP_ODBC_TYPE, CONST_CS | CONST_PERSISTENT); ! 727: REGISTER_LONG_CONSTANT("ODBC_BINMODE_PASSTHRU", 0, CONST_CS | CONST_PERSISTENT); ! 728: REGISTER_LONG_CONSTANT("ODBC_BINMODE_RETURN", 1, CONST_CS | CONST_PERSISTENT); ! 729: REGISTER_LONG_CONSTANT("ODBC_BINMODE_CONVERT", 2, CONST_CS | CONST_PERSISTENT); ! 730: /* Define Constants for options ! 731: these Constants are defined in <sqlext.h> ! 732: */ ! 733: REGISTER_LONG_CONSTANT("SQL_ODBC_CURSORS", SQL_ODBC_CURSORS, CONST_PERSISTENT | CONST_CS); ! 734: REGISTER_LONG_CONSTANT("SQL_CUR_USE_DRIVER", SQL_CUR_USE_DRIVER, CONST_PERSISTENT | CONST_CS); ! 735: REGISTER_LONG_CONSTANT("SQL_CUR_USE_IF_NEEDED", SQL_CUR_USE_IF_NEEDED, CONST_PERSISTENT | CONST_CS); ! 736: REGISTER_LONG_CONSTANT("SQL_CUR_USE_ODBC", SQL_CUR_USE_ODBC, CONST_PERSISTENT | CONST_CS); ! 737: ! 738: ! 739: REGISTER_LONG_CONSTANT("SQL_CONCURRENCY", SQL_CONCURRENCY, CONST_PERSISTENT | CONST_CS); ! 740: REGISTER_LONG_CONSTANT("SQL_CONCUR_READ_ONLY", SQL_CONCUR_READ_ONLY, CONST_PERSISTENT | CONST_CS); ! 741: REGISTER_LONG_CONSTANT("SQL_CONCUR_LOCK", SQL_CONCUR_LOCK, CONST_PERSISTENT | CONST_CS); ! 742: REGISTER_LONG_CONSTANT("SQL_CONCUR_ROWVER", SQL_CONCUR_ROWVER, CONST_PERSISTENT | CONST_CS); ! 743: REGISTER_LONG_CONSTANT("SQL_CONCUR_VALUES", SQL_CONCUR_VALUES, CONST_PERSISTENT | CONST_CS); ! 744: ! 745: REGISTER_LONG_CONSTANT("SQL_CURSOR_TYPE", SQL_CURSOR_TYPE, CONST_PERSISTENT | CONST_CS); ! 746: REGISTER_LONG_CONSTANT("SQL_CURSOR_FORWARD_ONLY", SQL_CURSOR_FORWARD_ONLY, CONST_PERSISTENT | CONST_CS); ! 747: REGISTER_LONG_CONSTANT("SQL_CURSOR_KEYSET_DRIVEN", SQL_CURSOR_KEYSET_DRIVEN, CONST_PERSISTENT | CONST_CS); ! 748: REGISTER_LONG_CONSTANT("SQL_CURSOR_DYNAMIC", SQL_CURSOR_DYNAMIC, CONST_PERSISTENT | CONST_CS); ! 749: REGISTER_LONG_CONSTANT("SQL_CURSOR_STATIC", SQL_CURSOR_STATIC, CONST_PERSISTENT | CONST_CS); ! 750: ! 751: REGISTER_LONG_CONSTANT("SQL_KEYSET_SIZE", SQL_KEYSET_SIZE, CONST_PERSISTENT | CONST_CS); ! 752: ! 753: /* these are for the Data Source type */ ! 754: REGISTER_LONG_CONSTANT("SQL_FETCH_FIRST", SQL_FETCH_FIRST, CONST_PERSISTENT | CONST_CS); ! 755: REGISTER_LONG_CONSTANT("SQL_FETCH_NEXT", SQL_FETCH_NEXT, CONST_PERSISTENT | CONST_CS); ! 756: ! 757: /* ! 758: * register the standard data types ! 759: */ ! 760: REGISTER_LONG_CONSTANT("SQL_CHAR", SQL_CHAR, CONST_PERSISTENT | CONST_CS); ! 761: REGISTER_LONG_CONSTANT("SQL_VARCHAR", SQL_VARCHAR, CONST_PERSISTENT | CONST_CS); ! 762: REGISTER_LONG_CONSTANT("SQL_LONGVARCHAR", SQL_LONGVARCHAR, CONST_PERSISTENT | CONST_CS); ! 763: REGISTER_LONG_CONSTANT("SQL_DECIMAL", SQL_DECIMAL, CONST_PERSISTENT | CONST_CS); ! 764: REGISTER_LONG_CONSTANT("SQL_NUMERIC", SQL_NUMERIC, CONST_PERSISTENT | CONST_CS); ! 765: REGISTER_LONG_CONSTANT("SQL_BIT", SQL_BIT, CONST_PERSISTENT | CONST_CS); ! 766: REGISTER_LONG_CONSTANT("SQL_TINYINT", SQL_TINYINT, CONST_PERSISTENT | CONST_CS); ! 767: REGISTER_LONG_CONSTANT("SQL_SMALLINT", SQL_SMALLINT, CONST_PERSISTENT | CONST_CS); ! 768: REGISTER_LONG_CONSTANT("SQL_INTEGER", SQL_INTEGER, CONST_PERSISTENT | CONST_CS); ! 769: REGISTER_LONG_CONSTANT("SQL_BIGINT", SQL_BIGINT, CONST_PERSISTENT | CONST_CS); ! 770: REGISTER_LONG_CONSTANT("SQL_REAL", SQL_REAL, CONST_PERSISTENT | CONST_CS); ! 771: REGISTER_LONG_CONSTANT("SQL_FLOAT", SQL_FLOAT, CONST_PERSISTENT | CONST_CS); ! 772: REGISTER_LONG_CONSTANT("SQL_DOUBLE", SQL_DOUBLE, CONST_PERSISTENT | CONST_CS); ! 773: REGISTER_LONG_CONSTANT("SQL_BINARY", SQL_BINARY, CONST_PERSISTENT | CONST_CS); ! 774: REGISTER_LONG_CONSTANT("SQL_VARBINARY", SQL_VARBINARY, CONST_PERSISTENT | CONST_CS); ! 775: REGISTER_LONG_CONSTANT("SQL_LONGVARBINARY", SQL_LONGVARBINARY, CONST_PERSISTENT | CONST_CS); ! 776: REGISTER_LONG_CONSTANT("SQL_DATE", SQL_DATE, CONST_PERSISTENT | CONST_CS); ! 777: REGISTER_LONG_CONSTANT("SQL_TIME", SQL_TIME, CONST_PERSISTENT | CONST_CS); ! 778: REGISTER_LONG_CONSTANT("SQL_TIMESTAMP", SQL_TIMESTAMP, CONST_PERSISTENT | CONST_CS); ! 779: #if defined(ODBCVER) && (ODBCVER >= 0x0300) ! 780: REGISTER_LONG_CONSTANT("SQL_TYPE_DATE", SQL_TYPE_DATE, CONST_PERSISTENT | CONST_CS); ! 781: REGISTER_LONG_CONSTANT("SQL_TYPE_TIME", SQL_TYPE_TIME, CONST_PERSISTENT | CONST_CS); ! 782: REGISTER_LONG_CONSTANT("SQL_TYPE_TIMESTAMP", SQL_TYPE_TIMESTAMP, CONST_PERSISTENT | CONST_CS); ! 783: ! 784: /* ! 785: * SQLSpecialColumns values ! 786: */ ! 787: REGISTER_LONG_CONSTANT("SQL_BEST_ROWID", SQL_BEST_ROWID, CONST_PERSISTENT | CONST_CS); ! 788: REGISTER_LONG_CONSTANT("SQL_ROWVER", SQL_ROWVER, CONST_PERSISTENT | CONST_CS); ! 789: REGISTER_LONG_CONSTANT("SQL_SCOPE_CURROW", SQL_SCOPE_CURROW, CONST_PERSISTENT | CONST_CS); ! 790: REGISTER_LONG_CONSTANT("SQL_SCOPE_TRANSACTION", SQL_SCOPE_TRANSACTION, CONST_PERSISTENT | CONST_CS); ! 791: REGISTER_LONG_CONSTANT("SQL_SCOPE_SESSION", SQL_SCOPE_SESSION, CONST_PERSISTENT | CONST_CS); ! 792: REGISTER_LONG_CONSTANT("SQL_NO_NULLS", SQL_NO_NULLS, CONST_PERSISTENT | CONST_CS); ! 793: REGISTER_LONG_CONSTANT("SQL_NULLABLE", SQL_NULLABLE, CONST_PERSISTENT | CONST_CS); ! 794: ! 795: /* ! 796: * SQLStatistics values ! 797: */ ! 798: REGISTER_LONG_CONSTANT("SQL_INDEX_UNIQUE", SQL_INDEX_UNIQUE, CONST_PERSISTENT | CONST_CS); ! 799: REGISTER_LONG_CONSTANT("SQL_INDEX_ALL", SQL_INDEX_ALL, CONST_PERSISTENT | CONST_CS); ! 800: REGISTER_LONG_CONSTANT("SQL_ENSURE", SQL_ENSURE, CONST_PERSISTENT | CONST_CS); ! 801: REGISTER_LONG_CONSTANT("SQL_QUICK", SQL_QUICK, CONST_PERSISTENT | CONST_CS); ! 802: #endif ! 803: ! 804: #if defined(HAVE_IBMDB2) && defined(_AIX) ! 805: /* atexit() handler in the DB2/AIX library segfaults in PHP CLI */ ! 806: /* DB2NOEXITLIST env variable prevents DB2 from invoking atexit() */ ! 807: putenv("DB2NOEXITLIST=TRUE"); ! 808: #endif ! 809: ! 810: return SUCCESS; ! 811: } ! 812: /* }}} */ ! 813: ! 814: /* {{{ PHP_RINIT_FUNCTION */ ! 815: PHP_RINIT_FUNCTION(odbc) ! 816: { ! 817: ODBCG(defConn) = -1; ! 818: ODBCG(num_links) = ODBCG(num_persistent); ! 819: memset(ODBCG(laststate), '\0', 6); ! 820: memset(ODBCG(lasterrormsg), '\0', SQL_MAX_MESSAGE_LENGTH); ! 821: return SUCCESS; ! 822: } ! 823: /* }}} */ ! 824: ! 825: /* {{{ PHP_RSHUTDOWN_FUNCTION */ ! 826: PHP_RSHUTDOWN_FUNCTION(odbc) ! 827: { ! 828: return SUCCESS; ! 829: } ! 830: /* }}} */ ! 831: ! 832: /* {{{ PHP_MSHUTDOWN_FUNCTION */ ! 833: PHP_MSHUTDOWN_FUNCTION(odbc) ! 834: { ! 835: UNREGISTER_INI_ENTRIES(); ! 836: return SUCCESS; ! 837: } ! 838: /* }}} */ ! 839: ! 840: /* {{{ PHP_MINFO_FUNCTION */ ! 841: PHP_MINFO_FUNCTION(odbc) ! 842: { ! 843: char buf[32]; ! 844: ! 845: php_info_print_table_start(); ! 846: php_info_print_table_header(2, "ODBC Support", "enabled"); ! 847: snprintf(buf, sizeof(buf), "%ld", ODBCG(num_persistent)); ! 848: php_info_print_table_row(2, "Active Persistent Links", buf); ! 849: snprintf(buf, sizeof(buf), "%ld", ODBCG(num_links)); ! 850: php_info_print_table_row(2, "Active Links", buf); ! 851: php_info_print_table_row(2, "ODBC library", PHP_ODBC_TYPE); ! 852: #ifndef PHP_WIN32 ! 853: php_info_print_table_row(2, "ODBC_INCLUDE", PHP_ODBC_INCLUDE); ! 854: php_info_print_table_row(2, "ODBC_LFLAGS", PHP_ODBC_LFLAGS); ! 855: php_info_print_table_row(2, "ODBC_LIBS", PHP_ODBC_LIBS); ! 856: #endif ! 857: php_info_print_table_end(); ! 858: ! 859: DISPLAY_INI_ENTRIES(); ! 860: ! 861: } ! 862: /* }}} */ ! 863: ! 864: /* {{{ odbc_sql_error */ ! 865: void odbc_sql_error(ODBC_SQL_ERROR_PARAMS) ! 866: { ! 867: char state[6]; ! 868: SQLINTEGER error; /* Not used */ ! 869: char errormsg[SQL_MAX_MESSAGE_LENGTH]; ! 870: SQLSMALLINT errormsgsize; /* Not used */ ! 871: RETCODE rc; ! 872: ODBC_SQL_ENV_T henv; ! 873: ODBC_SQL_CONN_T conn; ! 874: TSRMLS_FETCH(); ! 875: ! 876: if (conn_resource) { ! 877: henv = conn_resource->henv; ! 878: conn = conn_resource->hdbc; ! 879: } else { ! 880: henv = SQL_NULL_HENV; ! 881: conn = SQL_NULL_HDBC; ! 882: } ! 883: ! 884: /* This leads to an endless loop in many drivers! ! 885: * ! 886: while(henv != SQL_NULL_HENV){ ! 887: do { ! 888: */ ! 889: rc = SQLError(henv, conn, stmt, state, &error, errormsg, sizeof(errormsg)-1, &errormsgsize); ! 890: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 891: snprintf(state, sizeof(state), "HY000"); ! 892: snprintf(errormsg, sizeof(errormsg), "Failed to fetch error message"); ! 893: } ! 894: if (conn_resource) { ! 895: memcpy(conn_resource->laststate, state, sizeof(state)); ! 896: memcpy(conn_resource->lasterrormsg, errormsg, sizeof(errormsg)); ! 897: } ! 898: memcpy(ODBCG(laststate), state, sizeof(state)); ! 899: memcpy(ODBCG(lasterrormsg), errormsg, sizeof(errormsg)); ! 900: if (func) { ! 901: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s in %s", errormsg, state, func); ! 902: } else { ! 903: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s", errormsg, state); ! 904: } ! 905: /* ! 906: } while (SQL_SUCCEEDED(rc)); ! 907: } ! 908: */ ! 909: } ! 910: /* }}} */ ! 911: ! 912: /* {{{ php_odbc_fetch_attribs */ ! 913: void php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAMETERS, int mode) ! 914: { ! 915: odbc_result *result; ! 916: zval *pv_res; ! 917: long flag; ! 918: ! 919: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &flag) == FAILURE) { ! 920: return; ! 921: } ! 922: ! 923: if (Z_LVAL_P(pv_res)) { ! 924: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 925: if (mode) { ! 926: result->longreadlen = flag; ! 927: } else { ! 928: result->binmode = flag; ! 929: } ! 930: } else { ! 931: if (mode) { ! 932: ODBCG(defaultlrl) = flag; ! 933: } else { ! 934: ODBCG(defaultbinmode) = flag; ! 935: } ! 936: } ! 937: RETURN_TRUE; ! 938: } ! 939: /* }}} */ ! 940: ! 941: /* {{{ odbc_bindcols */ ! 942: int odbc_bindcols(odbc_result *result TSRMLS_DC) ! 943: { ! 944: RETCODE rc; ! 945: int i; ! 946: SQLSMALLINT colnamelen; /* Not used */ ! 947: SQLLEN displaysize; ! 948: ! 949: result->values = (odbc_result_value *) safe_emalloc(sizeof(odbc_result_value), result->numcols, 0); ! 950: ! 951: result->longreadlen = ODBCG(defaultlrl); ! 952: result->binmode = ODBCG(defaultbinmode); ! 953: ! 954: for(i = 0; i < result->numcols; i++) { ! 955: rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_NAME, ! 956: result->values[i].name, sizeof(result->values[i].name), &colnamelen, 0); ! 957: rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_TYPE, ! 958: NULL, 0, NULL, &result->values[i].coltype); ! 959: ! 960: /* Don't bind LONG / BINARY columns, so that fetch behaviour can ! 961: * be controlled by odbc_binmode() / odbc_longreadlen() ! 962: */ ! 963: ! 964: switch(result->values[i].coltype) { ! 965: case SQL_BINARY: ! 966: case SQL_VARBINARY: ! 967: case SQL_LONGVARBINARY: ! 968: case SQL_LONGVARCHAR: ! 969: result->values[i].value = NULL; ! 970: break; ! 971: ! 972: #ifdef HAVE_ADABAS ! 973: case SQL_TIMESTAMP: ! 974: result->values[i].value = (char *)emalloc(27); ! 975: SQLBindCol(result->stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, result->values[i].value, ! 976: 27, &result->values[i].vallen); ! 977: break; ! 978: #endif /* HAVE_ADABAS */ ! 979: default: ! 980: rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_DISPLAY_SIZE, ! 981: NULL, 0, NULL, &displaysize); ! 982: displaysize = displaysize <= result->longreadlen ? displaysize : ! 983: result->longreadlen; ! 984: /* Workaround for Oracle ODBC Driver bug (#50162) when fetching TIMESTAMP column */ ! 985: if (result->values[i].coltype == SQL_TIMESTAMP) { ! 986: displaysize += 3; ! 987: } ! 988: result->values[i].value = (char *)emalloc(displaysize + 1); ! 989: rc = SQLBindCol(result->stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, result->values[i].value, ! 990: displaysize + 1, &result->values[i].vallen); ! 991: break; ! 992: } ! 993: } ! 994: return 1; ! 995: } ! 996: /* }}} */ ! 997: ! 998: /* {{{ odbc_transact */ ! 999: void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type) ! 1000: { ! 1001: odbc_connection *conn; ! 1002: RETCODE rc; ! 1003: zval *pv_conn; ! 1004: ! 1005: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_conn) == FAILURE) { ! 1006: return; ! 1007: } ! 1008: ! 1009: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 1010: ! 1011: rc = SQLTransact(conn->henv, conn->hdbc, (SQLUSMALLINT)((type)?SQL_COMMIT:SQL_ROLLBACK)); ! 1012: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 1013: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTransact"); ! 1014: RETURN_FALSE; ! 1015: } ! 1016: ! 1017: RETURN_TRUE; ! 1018: } ! 1019: /* }}} */ ! 1020: ! 1021: /* {{{ _close_pconn_with_id */ ! 1022: static int _close_pconn_with_id(zend_rsrc_list_entry *le, int *id TSRMLS_DC) ! 1023: { ! 1024: if(Z_TYPE_P(le) == le_pconn && (((odbc_connection *)(le->ptr))->id == *id)){ ! 1025: return 1; ! 1026: }else{ ! 1027: return 0; ! 1028: } ! 1029: } ! 1030: /* }}} */ ! 1031: ! 1032: /* {{{ odbc_column_lengths */ ! 1033: void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type) ! 1034: { ! 1035: odbc_result *result; ! 1036: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30) ! 1037: /* this seems to be necessary for Solid2.3 ( tested by ! 1038: * tammy@synchronis.com) and Solid 3.0 (tested by eric@terra.telemediair.nl) ! 1039: * Solid does not seem to declare a SQLINTEGER, but it does declare a ! 1040: * SQL_INTEGER which does not work (despite being the same type as a SDWORD. ! 1041: * Solid 3.5 does not have this issue. ! 1042: */ ! 1043: SDWORD len; ! 1044: #else ! 1045: SQLLEN len; ! 1046: #endif ! 1047: zval *pv_res; ! 1048: long pv_num; ! 1049: ! 1050: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) { ! 1051: return; ! 1052: } ! 1053: ! 1054: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1055: ! 1056: if (result->numcols == 0) { ! 1057: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 1058: RETURN_FALSE; ! 1059: } ! 1060: ! 1061: if (pv_num > result->numcols) { ! 1062: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields"); ! 1063: RETURN_FALSE; ! 1064: } ! 1065: ! 1066: if (pv_num < 1) { ! 1067: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1"); ! 1068: RETURN_FALSE; ! 1069: } ! 1070: ! 1071: SQLColAttributes(result->stmt, (SQLUSMALLINT)pv_num, (SQLUSMALLINT) (type?SQL_COLUMN_SCALE:SQL_COLUMN_PRECISION), NULL, 0, NULL, &len); ! 1072: ! 1073: RETURN_LONG(len); ! 1074: } ! 1075: /* }}} */ ! 1076: ! 1077: /* Main User Functions */ ! 1078: ! 1079: /* {{{ proto void odbc_close_all(void) ! 1080: Close all ODBC connections */ ! 1081: PHP_FUNCTION(odbc_close_all) ! 1082: { ! 1083: void *ptr; ! 1084: int type; ! 1085: int i; ! 1086: int nument; ! 1087: ! 1088: if (zend_parse_parameters_none() == FAILURE) { ! 1089: return; ! 1090: } ! 1091: ! 1092: nument = zend_hash_next_free_element(&EG(regular_list)); ! 1093: ! 1094: /* Loop through list and close all statements */ ! 1095: for(i = 1; i < nument; i++) { ! 1096: ptr = zend_list_find(i, &type); ! 1097: if (ptr && (type == le_result)){ ! 1098: zend_list_delete(i); ! 1099: } ! 1100: } ! 1101: ! 1102: /* Second loop through list, now close all connections */ ! 1103: nument = zend_hash_next_free_element(&EG(regular_list)); ! 1104: ! 1105: for(i = 1; i < nument; i++) { ! 1106: ptr = zend_list_find(i, &type); ! 1107: if (ptr){ ! 1108: if(type == le_conn){ ! 1109: zend_list_delete(i); ! 1110: }else if(type == le_pconn){ ! 1111: zend_list_delete(i); ! 1112: /* Delete the persistent connection */ ! 1113: zend_hash_apply_with_argument(&EG(persistent_list), ! 1114: (apply_func_arg_t) _close_pconn_with_id, (void *) &i TSRMLS_CC); ! 1115: } ! 1116: } ! 1117: } ! 1118: } ! 1119: /* }}} */ ! 1120: ! 1121: /* {{{ proto bool odbc_binmode(int result_id, int mode) ! 1122: Handle binary column data */ ! 1123: PHP_FUNCTION(odbc_binmode) ! 1124: { ! 1125: php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); ! 1126: } ! 1127: /* }}} */ ! 1128: ! 1129: /* {{{ proto bool odbc_longreadlen(int result_id, int length) ! 1130: Handle LONG columns */ ! 1131: PHP_FUNCTION(odbc_longreadlen) ! 1132: { ! 1133: php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); ! 1134: } ! 1135: /* }}} */ ! 1136: ! 1137: /* {{{ proto resource odbc_prepare(resource connection_id, string query) ! 1138: Prepares a statement for execution */ ! 1139: PHP_FUNCTION(odbc_prepare) ! 1140: { ! 1141: zval *pv_conn; ! 1142: char *query; ! 1143: int query_len; ! 1144: odbc_result *result = NULL; ! 1145: odbc_connection *conn; ! 1146: RETCODE rc; ! 1147: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1148: SQLUINTEGER scrollopts; ! 1149: #endif ! 1150: ! 1151: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &pv_conn, &query, &query_len) == FAILURE) { ! 1152: return; ! 1153: } ! 1154: ! 1155: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 1156: ! 1157: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 1158: ! 1159: result->numparams = 0; ! 1160: ! 1161: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 1162: if (rc == SQL_INVALID_HANDLE) { ! 1163: efree(result); ! 1164: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 1165: RETURN_FALSE; ! 1166: } ! 1167: ! 1168: if (rc == SQL_ERROR) { ! 1169: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 1170: efree(result); ! 1171: RETURN_FALSE; ! 1172: } ! 1173: ! 1174: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1175: /* Solid doesn't have ExtendedFetch, if DriverManager is used, get Info, ! 1176: whether Driver supports ExtendedFetch */ ! 1177: rc = SQLGetInfo(conn->hdbc, SQL_FETCH_DIRECTION, (void *) &scrollopts, sizeof(scrollopts), NULL); ! 1178: if (rc == SQL_SUCCESS) { ! 1179: if ((result->fetch_abs = (scrollopts & SQL_FD_FETCH_ABSOLUTE))) { ! 1180: /* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other ! 1181: type if not possible. ! 1182: */ ! 1183: SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, ODBCG(default_cursortype)); ! 1184: } ! 1185: } else { ! 1186: result->fetch_abs = 0; ! 1187: } ! 1188: #endif ! 1189: ! 1190: rc = SQLPrepare(result->stmt, query, SQL_NTS); ! 1191: switch (rc) { ! 1192: case SQL_SUCCESS: ! 1193: break; ! 1194: case SQL_SUCCESS_WITH_INFO: ! 1195: odbc_sql_error(conn, result->stmt, "SQLPrepare"); ! 1196: break; ! 1197: default: ! 1198: odbc_sql_error(conn, result->stmt, "SQLPrepare"); ! 1199: RETURN_FALSE; ! 1200: } ! 1201: ! 1202: SQLNumParams(result->stmt, &(result->numparams)); ! 1203: SQLNumResultCols(result->stmt, &(result->numcols)); ! 1204: ! 1205: if (result->numcols > 0) { ! 1206: if (!odbc_bindcols(result TSRMLS_CC)) { ! 1207: efree(result); ! 1208: RETURN_FALSE; ! 1209: } ! 1210: } else { ! 1211: result->values = NULL; ! 1212: } ! 1213: zend_list_addref(conn->id); ! 1214: result->conn_ptr = conn; ! 1215: result->fetched = 0; ! 1216: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 1217: } ! 1218: /* }}} */ ! 1219: ! 1220: /* ! 1221: * Execute prepared SQL statement. Supports only input parameters. ! 1222: */ ! 1223: ! 1224: /* {{{ proto bool odbc_execute(resource result_id [, array parameters_array]) ! 1225: Execute a prepared statement */ ! 1226: PHP_FUNCTION(odbc_execute) ! 1227: { ! 1228: zval *pv_res, *pv_param_arr, **tmp; ! 1229: typedef struct params_t { ! 1230: SQLLEN vallen; ! 1231: int fp; ! 1232: } params_t; ! 1233: params_t *params = NULL; ! 1234: char *filename; ! 1235: unsigned char otype; ! 1236: SQLSMALLINT sqltype, ctype, scale; ! 1237: SQLSMALLINT nullable; ! 1238: SQLULEN precision; ! 1239: odbc_result *result; ! 1240: int numArgs, i, ne; ! 1241: RETCODE rc; ! 1242: ! 1243: numArgs = ZEND_NUM_ARGS(); ! 1244: ! 1245: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|a", &pv_res, &pv_param_arr) == FAILURE) { ! 1246: return; ! 1247: } ! 1248: ! 1249: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1250: ! 1251: /* XXX check for already bound parameters*/ ! 1252: if (result->numparams > 0 && numArgs == 1) { ! 1253: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No parameters to SQL statement given"); ! 1254: RETURN_FALSE; ! 1255: } ! 1256: ! 1257: if (result->numparams > 0) { ! 1258: if ((ne = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr))) < result->numparams) { ! 1259: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Not enough parameters (%d should be %d) given", ne, result->numparams); ! 1260: RETURN_FALSE; ! 1261: } ! 1262: ! 1263: zend_hash_internal_pointer_reset(Z_ARRVAL_P(pv_param_arr)); ! 1264: params = (params_t *)safe_emalloc(sizeof(params_t), result->numparams, 0); ! 1265: for(i = 0; i < result->numparams; i++) { ! 1266: params[i].fp = -1; ! 1267: } ! 1268: ! 1269: for(i = 1; i <= result->numparams; i++) { ! 1270: if (zend_hash_get_current_data(Z_ARRVAL_P(pv_param_arr), (void **) &tmp) == FAILURE) { ! 1271: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error getting parameter"); ! 1272: SQLFreeStmt(result->stmt,SQL_RESET_PARAMS); ! 1273: for (i = 0; i < result->numparams; i++) { ! 1274: if (params[i].fp != -1) { ! 1275: close(params[i].fp); ! 1276: } ! 1277: } ! 1278: efree(params); ! 1279: RETURN_FALSE; ! 1280: } ! 1281: ! 1282: otype = (*tmp)->type; ! 1283: convert_to_string_ex(tmp); ! 1284: if (Z_TYPE_PP(tmp) != IS_STRING) { ! 1285: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error converting parameter"); ! 1286: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); ! 1287: for (i = 0; i < result->numparams; i++) { ! 1288: if (params[i].fp != -1) { ! 1289: close(params[i].fp); ! 1290: } ! 1291: } ! 1292: efree(params); ! 1293: RETURN_FALSE; ! 1294: } ! 1295: ! 1296: rc = SQLDescribeParam(result->stmt, (SQLUSMALLINT)i, &sqltype, &precision, &scale, &nullable); ! 1297: params[i-1].vallen = Z_STRLEN_PP(tmp); ! 1298: params[i-1].fp = -1; ! 1299: if (rc == SQL_ERROR) { ! 1300: odbc_sql_error(result->conn_ptr, result->stmt, "SQLDescribeParameter"); ! 1301: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); ! 1302: for (i = 0; i < result->numparams; i++) { ! 1303: if (params[i].fp != -1) { ! 1304: close(params[i].fp); ! 1305: } ! 1306: } ! 1307: efree(params); ! 1308: RETURN_FALSE; ! 1309: } ! 1310: ! 1311: if (IS_SQL_BINARY(sqltype)) { ! 1312: ctype = SQL_C_BINARY; ! 1313: } else { ! 1314: ctype = SQL_C_CHAR; ! 1315: } ! 1316: ! 1317: if (Z_STRLEN_PP(tmp) > 2 && ! 1318: Z_STRVAL_PP(tmp)[0] == '\'' && ! 1319: Z_STRVAL_PP(tmp)[Z_STRLEN_PP(tmp) - 1] == '\'') { ! 1320: if (strlen(tmp) != Z_STRLEN_PP(tmp)) { ! 1321: RETURN_FALSE; ! 1322: } ! 1323: ! 1324: filename = estrndup(&Z_STRVAL_PP(tmp)[1], Z_STRLEN_PP(tmp) - 2); ! 1325: ! 1326: /* Check for safe mode. */ ! 1327: if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) { ! 1328: efree(filename); ! 1329: efree(params); ! 1330: RETURN_FALSE; ! 1331: } ! 1332: ! 1333: /* Check the basedir */ ! 1334: if (php_check_open_basedir(filename TSRMLS_CC)) { ! 1335: efree(filename); ! 1336: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); ! 1337: for (i = 0; i < result->numparams; i++) { ! 1338: if (params[i].fp != -1) { ! 1339: close(params[i].fp); ! 1340: } ! 1341: } ! 1342: efree(params); ! 1343: RETURN_FALSE; ! 1344: } ! 1345: ! 1346: if ((params[i-1].fp = open(filename,O_RDONLY)) == -1) { ! 1347: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Can't open file %s", filename); ! 1348: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); ! 1349: for (i = 0; i < result->numparams; i++) { ! 1350: if (params[i].fp != -1) { ! 1351: close(params[i].fp); ! 1352: } ! 1353: } ! 1354: efree(params); ! 1355: efree(filename); ! 1356: RETURN_FALSE; ! 1357: } ! 1358: ! 1359: efree(filename); ! 1360: ! 1361: params[i-1].vallen = SQL_LEN_DATA_AT_EXEC(0); ! 1362: ! 1363: rc = SQLBindParameter(result->stmt, (SQLUSMALLINT)i, SQL_PARAM_INPUT, ! 1364: ctype, sqltype, precision, scale, ! 1365: (void *)params[i-1].fp, 0, ! 1366: ¶ms[i-1].vallen); ! 1367: } else { ! 1368: #ifdef HAVE_DBMAKER ! 1369: precision = params[i-1].vallen; ! 1370: #endif ! 1371: if (otype == IS_NULL) { ! 1372: params[i-1].vallen = SQL_NULL_DATA; ! 1373: } ! 1374: ! 1375: rc = SQLBindParameter(result->stmt, (SQLUSMALLINT)i, SQL_PARAM_INPUT, ! 1376: ctype, sqltype, precision, scale, ! 1377: Z_STRVAL_PP(tmp), 0, ! 1378: ¶ms[i-1].vallen); ! 1379: } ! 1380: if (rc == SQL_ERROR) { ! 1381: odbc_sql_error(result->conn_ptr, result->stmt, "SQLBindParameter"); ! 1382: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); ! 1383: for (i = 0; i < result->numparams; i++) { ! 1384: if (params[i].fp != -1) { ! 1385: close(params[i].fp); ! 1386: } ! 1387: } ! 1388: efree(params); ! 1389: RETURN_FALSE; ! 1390: } ! 1391: zend_hash_move_forward(Z_ARRVAL_P(pv_param_arr)); ! 1392: } ! 1393: } ! 1394: /* Close cursor, needed for doing multiple selects */ ! 1395: rc = SQLFreeStmt(result->stmt, SQL_CLOSE); ! 1396: ! 1397: if (rc == SQL_ERROR) { ! 1398: odbc_sql_error(result->conn_ptr, result->stmt, "SQLFreeStmt"); ! 1399: } ! 1400: ! 1401: rc = SQLExecute(result->stmt); ! 1402: ! 1403: result->fetched = 0; ! 1404: if (rc == SQL_NEED_DATA) { ! 1405: char buf[4096]; ! 1406: int fp, nbytes; ! 1407: while (rc == SQL_NEED_DATA) { ! 1408: rc = SQLParamData(result->stmt, (void*)&fp); ! 1409: if (rc == SQL_NEED_DATA) { ! 1410: while ((nbytes = read(fp, &buf, 4096)) > 0) { ! 1411: SQLPutData(result->stmt, (void*)&buf, nbytes); ! 1412: } ! 1413: } ! 1414: } ! 1415: } else { ! 1416: switch (rc) { ! 1417: case SQL_SUCCESS: ! 1418: break; ! 1419: case SQL_NO_DATA_FOUND: ! 1420: case SQL_SUCCESS_WITH_INFO: ! 1421: odbc_sql_error(result->conn_ptr, result->stmt, "SQLExecute"); ! 1422: break; ! 1423: default: ! 1424: odbc_sql_error(result->conn_ptr, result->stmt, "SQLExecute"); ! 1425: RETVAL_FALSE; ! 1426: } ! 1427: } ! 1428: ! 1429: if (result->numparams > 0) { ! 1430: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); ! 1431: for(i = 0; i < result->numparams; i++) { ! 1432: if (params[i].fp != -1) { ! 1433: close(params[i].fp); ! 1434: } ! 1435: } ! 1436: efree(params); ! 1437: } ! 1438: ! 1439: if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO || rc == SQL_NO_DATA_FOUND) { ! 1440: RETVAL_TRUE; ! 1441: } ! 1442: ! 1443: if (result->numcols == 0) { ! 1444: SQLNumResultCols(result->stmt, &(result->numcols)); ! 1445: ! 1446: if (result->numcols > 0) { ! 1447: if (!odbc_bindcols(result TSRMLS_CC)) { ! 1448: efree(result); ! 1449: RETVAL_FALSE; ! 1450: } ! 1451: } else { ! 1452: result->values = NULL; ! 1453: } ! 1454: } ! 1455: } ! 1456: /* }}} */ ! 1457: ! 1458: /* {{{ proto string odbc_cursor(resource result_id) ! 1459: Get cursor name */ ! 1460: PHP_FUNCTION(odbc_cursor) ! 1461: { ! 1462: zval *pv_res; ! 1463: SQLUSMALLINT max_len; ! 1464: SQLSMALLINT len; ! 1465: char *cursorname; ! 1466: odbc_result *result; ! 1467: RETCODE rc; ! 1468: ! 1469: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 1470: return; ! 1471: } ! 1472: ! 1473: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1474: ! 1475: rc = SQLGetInfo(result->conn_ptr->hdbc,SQL_MAX_CURSOR_NAME_LEN, (void *)&max_len,sizeof(max_len),&len); ! 1476: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 1477: RETURN_FALSE; ! 1478: } ! 1479: ! 1480: if (max_len > 0) { ! 1481: cursorname = emalloc(max_len + 1); ! 1482: rc = SQLGetCursorName(result->stmt,cursorname,(SQLSMALLINT)max_len,&len); ! 1483: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 1484: char state[6]; /* Not used */ ! 1485: SQLINTEGER error; /* Not used */ ! 1486: char errormsg[SQL_MAX_MESSAGE_LENGTH]; ! 1487: SQLSMALLINT errormsgsize; /* Not used */ ! 1488: ! 1489: SQLError( result->conn_ptr->henv, result->conn_ptr->hdbc, ! 1490: result->stmt, state, &error, errormsg, ! 1491: sizeof(errormsg)-1, &errormsgsize); ! 1492: if (!strncmp(state,"S1015",5)) { ! 1493: snprintf(cursorname, max_len+1, "php_curs_%d", (int)result->stmt); ! 1494: if (SQLSetCursorName(result->stmt,cursorname,SQL_NTS) != SQL_SUCCESS) { ! 1495: odbc_sql_error(result->conn_ptr, result->stmt, "SQLSetCursorName"); ! 1496: RETVAL_FALSE; ! 1497: } else { ! 1498: RETVAL_STRING(cursorname,1); ! 1499: } ! 1500: } else { ! 1501: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s", errormsg, state); ! 1502: RETVAL_FALSE; ! 1503: } ! 1504: } else { ! 1505: RETVAL_STRING(cursorname,1); ! 1506: } ! 1507: efree(cursorname); ! 1508: } else { ! 1509: RETVAL_FALSE; ! 1510: } ! 1511: } ! 1512: /* }}} */ ! 1513: ! 1514: #ifdef HAVE_SQLDATASOURCES ! 1515: /* {{{ proto array odbc_data_source(resource connection_id, int fetch_type) ! 1516: Return information about the currently connected data source */ ! 1517: PHP_FUNCTION(odbc_data_source) ! 1518: { ! 1519: zval *zv_conn; ! 1520: long zv_fetch_type; ! 1521: RETCODE rc = 0; /* assume all is good */ ! 1522: odbc_connection *conn; ! 1523: UCHAR server_name[100], desc[200]; ! 1524: SQLSMALLINT len1=0, len2=0, fetch_type; ! 1525: ! 1526: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zv_conn, &zv_fetch_type) == FAILURE) { ! 1527: return; ! 1528: } ! 1529: ! 1530: fetch_type = (SQLSMALLINT) zv_fetch_type; ! 1531: ! 1532: if (!(fetch_type == SQL_FETCH_FIRST || fetch_type == SQL_FETCH_NEXT)) { ! 1533: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid fetch type (%d)", fetch_type); ! 1534: RETURN_FALSE; ! 1535: } ! 1536: ! 1537: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &zv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 1538: ! 1539: /* now we have the "connection" lets call the DataSource object */ ! 1540: rc = SQLDataSources(conn->henv, ! 1541: fetch_type, ! 1542: server_name, ! 1543: (SQLSMALLINT)sizeof(server_name), ! 1544: &len1, ! 1545: desc, ! 1546: (SQLSMALLINT)sizeof(desc), ! 1547: &len2); ! 1548: ! 1549: if (rc != SQL_SUCCESS) { ! 1550: /* ummm.... he did it */ ! 1551: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLDataSources"); ! 1552: RETURN_FALSE; ! 1553: } ! 1554: ! 1555: if (len1 == 0 || len2 == 0) { ! 1556: /* we have a non-valid entry... so stop the looping */ ! 1557: RETURN_FALSE; ! 1558: } ! 1559: ! 1560: array_init(return_value); ! 1561: ! 1562: add_assoc_string_ex(return_value, "server", sizeof("server"), server_name, 1); ! 1563: add_assoc_string_ex(return_value, "description", sizeof("description"), desc, 1); ! 1564: ! 1565: } ! 1566: /* }}} */ ! 1567: #endif /* HAVE_SQLDATASOURCES */ ! 1568: ! 1569: /* {{{ proto resource odbc_exec(resource connection_id, string query [, int flags]) ! 1570: Prepare and execute an SQL statement */ ! 1571: /* XXX Use flags */ ! 1572: PHP_FUNCTION(odbc_exec) ! 1573: { ! 1574: zval *pv_conn; ! 1575: long pv_flags; ! 1576: char *query; ! 1577: int numArgs, query_len; ! 1578: odbc_result *result = NULL; ! 1579: odbc_connection *conn; ! 1580: RETCODE rc; ! 1581: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1582: SQLUINTEGER scrollopts; ! 1583: #endif ! 1584: ! 1585: numArgs = ZEND_NUM_ARGS(); ! 1586: ! 1587: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pv_conn, &query, &query_len, &pv_flags) == FAILURE) { ! 1588: return; ! 1589: } ! 1590: ! 1591: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 1592: ! 1593: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 1594: ! 1595: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 1596: if (rc == SQL_INVALID_HANDLE) { ! 1597: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 1598: efree(result); ! 1599: RETURN_FALSE; ! 1600: } ! 1601: ! 1602: if (rc == SQL_ERROR) { ! 1603: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 1604: efree(result); ! 1605: RETURN_FALSE; ! 1606: } ! 1607: ! 1608: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1609: /* Solid doesn't have ExtendedFetch, if DriverManager is used, get Info, ! 1610: whether Driver supports ExtendedFetch */ ! 1611: rc = SQLGetInfo(conn->hdbc, SQL_FETCH_DIRECTION, (void *) &scrollopts, sizeof(scrollopts), NULL); ! 1612: if (rc == SQL_SUCCESS) { ! 1613: if ((result->fetch_abs = (scrollopts & SQL_FD_FETCH_ABSOLUTE))) { ! 1614: /* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other ! 1615: type if not possible. ! 1616: */ ! 1617: SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, ODBCG(default_cursortype)); ! 1618: } ! 1619: } else { ! 1620: result->fetch_abs = 0; ! 1621: } ! 1622: #endif ! 1623: ! 1624: rc = SQLExecDirect(result->stmt, query, SQL_NTS); ! 1625: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO && rc != SQL_NO_DATA_FOUND) { ! 1626: /* XXX FIXME we should really check out SQLSTATE with SQLError ! 1627: * in case rc is SQL_SUCCESS_WITH_INFO here. ! 1628: */ ! 1629: odbc_sql_error(conn, result->stmt, "SQLExecDirect"); ! 1630: SQLFreeStmt(result->stmt, SQL_DROP); ! 1631: efree(result); ! 1632: RETURN_FALSE; ! 1633: } ! 1634: ! 1635: SQLNumResultCols(result->stmt, &(result->numcols)); ! 1636: ! 1637: /* For insert, update etc. cols == 0 */ ! 1638: if (result->numcols > 0) { ! 1639: if (!odbc_bindcols(result TSRMLS_CC)) { ! 1640: efree(result); ! 1641: RETURN_FALSE; ! 1642: } ! 1643: } else { ! 1644: result->values = NULL; ! 1645: } ! 1646: zend_list_addref(conn->id); ! 1647: result->conn_ptr = conn; ! 1648: result->fetched = 0; ! 1649: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 1650: } ! 1651: /* }}} */ ! 1652: ! 1653: #ifdef PHP_ODBC_HAVE_FETCH_HASH ! 1654: #define ODBC_NUM 1 ! 1655: #define ODBC_OBJECT 2 ! 1656: ! 1657: /* {{{ php_odbc_fetch_hash */ ! 1658: static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type) ! 1659: { ! 1660: int i; ! 1661: odbc_result *result; ! 1662: RETCODE rc; ! 1663: SQLSMALLINT sql_c_type; ! 1664: char *buf = NULL; ! 1665: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1666: SQLULEN crow; ! 1667: SQLUSMALLINT RowStatus[1]; ! 1668: SQLLEN rownum; ! 1669: zval *pv_res, *tmp; ! 1670: long pv_row = -1; ! 1671: ! 1672: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) { ! 1673: return; ! 1674: } ! 1675: ! 1676: rownum = pv_row; ! 1677: #else ! 1678: zval *pv_res, *tmp; ! 1679: ! 1680: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 1681: return; ! 1682: } ! 1683: #endif ! 1684: ! 1685: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1686: ! 1687: if (result->numcols == 0) { ! 1688: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 1689: RETURN_FALSE; ! 1690: } ! 1691: ! 1692: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1693: if (result->fetch_abs) { ! 1694: if (rownum > 0) { ! 1695: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus); ! 1696: } else { ! 1697: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); ! 1698: } ! 1699: } else ! 1700: #endif ! 1701: rc = SQLFetch(result->stmt); ! 1702: ! 1703: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 1704: RETURN_FALSE; ! 1705: } ! 1706: ! 1707: array_init(return_value); ! 1708: ! 1709: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1710: if (rownum > 0 && result->fetch_abs) ! 1711: result->fetched = rownum; ! 1712: else ! 1713: #endif ! 1714: result->fetched++; ! 1715: ! 1716: for(i = 0; i < result->numcols; i++) { ! 1717: ALLOC_INIT_ZVAL(tmp); ! 1718: Z_TYPE_P(tmp) = IS_STRING; ! 1719: Z_STRLEN_P(tmp) = 0; ! 1720: sql_c_type = SQL_C_CHAR; ! 1721: ! 1722: switch(result->values[i].coltype) { ! 1723: case SQL_BINARY: ! 1724: case SQL_VARBINARY: ! 1725: case SQL_LONGVARBINARY: ! 1726: if (result->binmode <= 0) { ! 1727: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC(); ! 1728: break; ! 1729: } ! 1730: if (result->binmode == 1) { ! 1731: sql_c_type = SQL_C_BINARY; ! 1732: } ! 1733: case SQL_LONGVARCHAR: ! 1734: if (IS_SQL_LONG(result->values[i].coltype) && result->longreadlen <= 0) { ! 1735: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC(); ! 1736: break; ! 1737: } ! 1738: if (buf == NULL) { ! 1739: buf = emalloc(result->longreadlen + 1); ! 1740: } ! 1741: ! 1742: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(i + 1), sql_c_type, buf, result->longreadlen + 1, &result->values[i].vallen); ! 1743: ! 1744: if (rc == SQL_ERROR) { ! 1745: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); ! 1746: efree(buf); ! 1747: RETURN_FALSE; ! 1748: } ! 1749: ! 1750: if (rc == SQL_SUCCESS_WITH_INFO) { ! 1751: Z_STRLEN_P(tmp) = result->longreadlen; ! 1752: } else if (result->values[i].vallen == SQL_NULL_DATA) { ! 1753: ZVAL_NULL(tmp); ! 1754: break; ! 1755: } else { ! 1756: Z_STRLEN_P(tmp) = result->values[i].vallen; ! 1757: } ! 1758: Z_STRVAL_P(tmp) = estrndup(buf, Z_STRLEN_P(tmp)); ! 1759: break; ! 1760: ! 1761: default: ! 1762: if (result->values[i].vallen == SQL_NULL_DATA) { ! 1763: ZVAL_NULL(tmp); ! 1764: break; ! 1765: } ! 1766: Z_STRLEN_P(tmp) = result->values[i].vallen; ! 1767: Z_STRVAL_P(tmp) = estrndup(result->values[i].value,Z_STRLEN_P(tmp)); ! 1768: break; ! 1769: } ! 1770: ! 1771: if (result_type & ODBC_NUM) { ! 1772: zend_hash_index_update(Z_ARRVAL_P(return_value), i, &tmp, sizeof(zval *), NULL); ! 1773: } else { ! 1774: if (!*(result->values[i].name)) { ! 1775: zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)+1, &tmp, sizeof(zval *), NULL); ! 1776: } else { ! 1777: zend_hash_update(Z_ARRVAL_P(return_value), result->values[i].name, strlen(result->values[i].name)+1, &tmp, sizeof(zval *), NULL); ! 1778: } ! 1779: } ! 1780: } ! 1781: if (buf) { ! 1782: efree(buf); ! 1783: } ! 1784: } ! 1785: /* }}} */ ! 1786: ! 1787: ! 1788: /* {{{ proto object odbc_fetch_object(int result [, int rownumber]) ! 1789: Fetch a result row as an object */ ! 1790: PHP_FUNCTION(odbc_fetch_object) ! 1791: { ! 1792: php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, ODBC_OBJECT); ! 1793: if (Z_TYPE_P(return_value) == IS_ARRAY) { ! 1794: object_and_properties_init(return_value, ZEND_STANDARD_CLASS_DEF_PTR, Z_ARRVAL_P(return_value)); ! 1795: } ! 1796: } ! 1797: /* }}} */ ! 1798: ! 1799: /* {{{ proto array odbc_fetch_array(int result [, int rownumber]) ! 1800: Fetch a result row as an associative array */ ! 1801: PHP_FUNCTION(odbc_fetch_array) ! 1802: { ! 1803: php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, ODBC_OBJECT); ! 1804: } ! 1805: /* }}} */ ! 1806: #endif ! 1807: ! 1808: /* {{{ proto int odbc_fetch_into(resource result_id, array &result_array, [, int rownumber]) ! 1809: Fetch one result row into an array */ ! 1810: PHP_FUNCTION(odbc_fetch_into) ! 1811: { ! 1812: int i; ! 1813: odbc_result *result; ! 1814: RETCODE rc; ! 1815: SQLSMALLINT sql_c_type; ! 1816: char *buf = NULL; ! 1817: zval *pv_res, **pv_res_arr, *tmp; ! 1818: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1819: long pv_row = 0; ! 1820: SQLULEN crow; ! 1821: SQLUSMALLINT RowStatus[1]; ! 1822: SQLLEN rownum = -1; ! 1823: #endif /* HAVE_SQL_EXTENDED_FETCH */ ! 1824: ! 1825: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1826: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ|l", &pv_res, &pv_res_arr, &pv_row) == FAILURE) { ! 1827: return; ! 1828: } ! 1829: ! 1830: rownum = pv_row; ! 1831: #else ! 1832: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_res_arr) == FAILURE) { ! 1833: return; ! 1834: } ! 1835: #endif /* HAVE_SQL_EXTENDED_FETCH */ ! 1836: ! 1837: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1838: ! 1839: if (result->numcols == 0) { ! 1840: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 1841: RETURN_FALSE; ! 1842: } ! 1843: ! 1844: if (Z_TYPE_PP(pv_res_arr) != IS_ARRAY) { ! 1845: array_init(*pv_res_arr); ! 1846: } ! 1847: ! 1848: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1849: if (result->fetch_abs) { ! 1850: if (rownum > 0) { ! 1851: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus); ! 1852: } else { ! 1853: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); ! 1854: } ! 1855: } else ! 1856: #endif ! 1857: rc = SQLFetch(result->stmt); ! 1858: ! 1859: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 1860: RETURN_FALSE; ! 1861: } ! 1862: ! 1863: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1864: if (rownum > 0 && result->fetch_abs) ! 1865: result->fetched = rownum; ! 1866: else ! 1867: #endif ! 1868: result->fetched++; ! 1869: ! 1870: for(i = 0; i < result->numcols; i++) { ! 1871: MAKE_STD_ZVAL(tmp); ! 1872: Z_TYPE_P(tmp) = IS_STRING; ! 1873: Z_STRLEN_P(tmp) = 0; ! 1874: sql_c_type = SQL_C_CHAR; ! 1875: ! 1876: switch(result->values[i].coltype) { ! 1877: case SQL_BINARY: ! 1878: case SQL_VARBINARY: ! 1879: case SQL_LONGVARBINARY: ! 1880: if (result->binmode <= 0) { ! 1881: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC(); ! 1882: break; ! 1883: } ! 1884: if (result->binmode == 1) sql_c_type = SQL_C_BINARY; ! 1885: case SQL_LONGVARCHAR: ! 1886: if (IS_SQL_LONG(result->values[i].coltype) && result->longreadlen <= 0) { ! 1887: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC(); ! 1888: break; ! 1889: } ! 1890: ! 1891: if (buf == NULL) { ! 1892: buf = emalloc(result->longreadlen + 1); ! 1893: } ! 1894: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(i + 1),sql_c_type, buf, result->longreadlen + 1, &result->values[i].vallen); ! 1895: ! 1896: if (rc == SQL_ERROR) { ! 1897: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); ! 1898: efree(buf); ! 1899: RETURN_FALSE; ! 1900: } ! 1901: if (rc == SQL_SUCCESS_WITH_INFO) { ! 1902: Z_STRLEN_P(tmp) = result->longreadlen; ! 1903: } else if (result->values[i].vallen == SQL_NULL_DATA) { ! 1904: ZVAL_NULL(tmp); ! 1905: break; ! 1906: } else { ! 1907: Z_STRLEN_P(tmp) = result->values[i].vallen; ! 1908: } ! 1909: Z_STRVAL_P(tmp) = estrndup(buf, Z_STRLEN_P(tmp)); ! 1910: break; ! 1911: ! 1912: default: ! 1913: if (result->values[i].vallen == SQL_NULL_DATA) { ! 1914: ZVAL_NULL(tmp); ! 1915: break; ! 1916: } ! 1917: Z_STRLEN_P(tmp) = result->values[i].vallen; ! 1918: Z_STRVAL_P(tmp) = estrndup(result->values[i].value,Z_STRLEN_P(tmp)); ! 1919: break; ! 1920: } ! 1921: zend_hash_index_update(Z_ARRVAL_PP(pv_res_arr), i, &tmp, sizeof(zval *), NULL); ! 1922: } ! 1923: if (buf) efree(buf); ! 1924: RETURN_LONG(result->numcols); ! 1925: } ! 1926: /* }}} */ ! 1927: ! 1928: /* {{{ proto bool solid_fetch_prev(resource result_id) ! 1929: */ ! 1930: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30) || defined(HAVE_SOLID_35) ! 1931: PHP_FUNCTION(solid_fetch_prev) ! 1932: { ! 1933: odbc_result *result; ! 1934: RETCODE rc; ! 1935: zval *pv_res; ! 1936: ! 1937: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 1938: return; ! 1939: } ! 1940: ! 1941: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1942: if (result->numcols == 0) { ! 1943: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 1944: RETURN_FALSE; ! 1945: } ! 1946: rc = SQLFetchPrev(result->stmt); ! 1947: ! 1948: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 1949: RETURN_FALSE; ! 1950: } ! 1951: ! 1952: if (result->fetched > 1) { ! 1953: result->fetched--; ! 1954: } ! 1955: ! 1956: RETURN_TRUE; ! 1957: } ! 1958: #endif ! 1959: /* }}} */ ! 1960: ! 1961: /* {{{ proto bool odbc_fetch_row(resource result_id [, int row_number]) ! 1962: Fetch a row */ ! 1963: PHP_FUNCTION(odbc_fetch_row) ! 1964: { ! 1965: SQLLEN rownum; ! 1966: odbc_result *result; ! 1967: RETCODE rc; ! 1968: zval *pv_res; ! 1969: long pv_row = 1; ! 1970: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1971: SQLULEN crow; ! 1972: SQLUSMALLINT RowStatus[1]; ! 1973: #endif ! 1974: ! 1975: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) { ! 1976: return; ! 1977: } ! 1978: ! 1979: rownum = pv_row; ! 1980: ! 1981: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 1982: ! 1983: if (result->numcols == 0) { ! 1984: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 1985: RETURN_FALSE; ! 1986: } ! 1987: ! 1988: #ifdef HAVE_SQL_EXTENDED_FETCH ! 1989: if (result->fetch_abs) { ! 1990: if (ZEND_NUM_ARGS() > 1) { ! 1991: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus); ! 1992: } else { ! 1993: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); ! 1994: } ! 1995: } else ! 1996: #endif ! 1997: rc = SQLFetch(result->stmt); ! 1998: ! 1999: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 2000: RETURN_FALSE; ! 2001: } ! 2002: ! 2003: if (ZEND_NUM_ARGS() > 1) { ! 2004: result->fetched = rownum; ! 2005: } else { ! 2006: result->fetched++; ! 2007: } ! 2008: ! 2009: RETURN_TRUE; ! 2010: } ! 2011: /* }}} */ ! 2012: ! 2013: /* {{{ proto mixed odbc_result(resource result_id, mixed field) ! 2014: Get result data */ ! 2015: PHP_FUNCTION(odbc_result) ! 2016: { ! 2017: char *field; ! 2018: int field_ind; ! 2019: SQLSMALLINT sql_c_type = SQL_C_CHAR; ! 2020: odbc_result *result; ! 2021: int i = 0; ! 2022: RETCODE rc; ! 2023: SQLLEN fieldsize; ! 2024: zval *pv_res, **pv_field; ! 2025: #ifdef HAVE_SQL_EXTENDED_FETCH ! 2026: SQLULEN crow; ! 2027: SQLUSMALLINT RowStatus[1]; ! 2028: #endif ! 2029: ! 2030: field_ind = -1; ! 2031: field = NULL; ! 2032: ! 2033: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_field) == FAILURE) { ! 2034: return; ! 2035: } ! 2036: ! 2037: if (Z_TYPE_PP(pv_field) == IS_STRING) { ! 2038: field = Z_STRVAL_PP(pv_field); ! 2039: } else { ! 2040: convert_to_long_ex(pv_field); ! 2041: field_ind = Z_LVAL_PP(pv_field) - 1; ! 2042: } ! 2043: ! 2044: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2045: ! 2046: if ((result->numcols == 0)) { ! 2047: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 2048: RETURN_FALSE; ! 2049: } ! 2050: ! 2051: /* get field index if the field parameter was a string */ ! 2052: if (field != NULL) { ! 2053: if (result->values == NULL) { ! 2054: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Result set contains no data"); ! 2055: RETURN_FALSE; ! 2056: } ! 2057: ! 2058: for(i = 0; i < result->numcols; i++) { ! 2059: if (!strcasecmp(result->values[i].name, field)) { ! 2060: field_ind = i; ! 2061: break; ! 2062: } ! 2063: } ! 2064: ! 2065: if (field_ind < 0) { ! 2066: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field %s not found", field); ! 2067: RETURN_FALSE; ! 2068: } ! 2069: } else { ! 2070: /* check for limits of field_ind if the field parameter was an int */ ! 2071: if (field_ind >= result->numcols || field_ind < 0) { ! 2072: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index is larger than the number of fields"); ! 2073: RETURN_FALSE; ! 2074: } ! 2075: } ! 2076: ! 2077: if (result->fetched == 0) { ! 2078: /* User forgot to call odbc_fetch_row(), or wants to reload the results, do it now */ ! 2079: #ifdef HAVE_SQL_EXTENDED_FETCH ! 2080: if (result->fetch_abs) ! 2081: rc = SQLExtendedFetch(result->stmt, SQL_FETCH_NEXT, 1, &crow,RowStatus); ! 2082: else ! 2083: #endif ! 2084: rc = SQLFetch(result->stmt); ! 2085: ! 2086: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 2087: RETURN_FALSE; ! 2088: } ! 2089: ! 2090: result->fetched++; ! 2091: } ! 2092: ! 2093: switch(result->values[field_ind].coltype) { ! 2094: case SQL_BINARY: ! 2095: case SQL_VARBINARY: ! 2096: case SQL_LONGVARBINARY: ! 2097: if (result->binmode <= 1) { ! 2098: sql_c_type = SQL_C_BINARY; ! 2099: } ! 2100: if (result->binmode <= 0) { ! 2101: break; ! 2102: } ! 2103: case SQL_LONGVARCHAR: ! 2104: if (IS_SQL_LONG(result->values[field_ind].coltype)) { ! 2105: if (result->longreadlen <= 0) { ! 2106: break; ! 2107: } else { ! 2108: fieldsize = result->longreadlen; ! 2109: } ! 2110: } else { ! 2111: SQLColAttributes(result->stmt, (SQLUSMALLINT)(field_ind + 1), ! 2112: (SQLUSMALLINT)((sql_c_type == SQL_C_BINARY) ? SQL_COLUMN_LENGTH : ! 2113: SQL_COLUMN_DISPLAY_SIZE), ! 2114: NULL, 0, NULL, &fieldsize); ! 2115: } ! 2116: /* For char data, the length of the returned string will be longreadlen - 1 */ ! 2117: fieldsize = (result->longreadlen <= 0) ? 4096 : result->longreadlen; ! 2118: field = emalloc(fieldsize); ! 2119: ! 2120: /* SQLGetData will truncate CHAR data to fieldsize - 1 bytes and append \0. ! 2121: * For binary data it is truncated to fieldsize bytes. ! 2122: */ ! 2123: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(field_ind + 1), sql_c_type, ! 2124: field, fieldsize, &result->values[field_ind].vallen); ! 2125: ! 2126: if (rc == SQL_ERROR) { ! 2127: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); ! 2128: efree(field); ! 2129: RETURN_FALSE; ! 2130: } ! 2131: ! 2132: if (result->values[field_ind].vallen == SQL_NULL_DATA) { ! 2133: efree(field); ! 2134: RETURN_NULL(); ! 2135: } else if (rc == SQL_NO_DATA_FOUND) { ! 2136: efree(field); ! 2137: RETURN_FALSE; ! 2138: } ! 2139: /* Reduce fieldlen by 1 if we have char data. One day we might ! 2140: have binary strings... */ ! 2141: if (result->values[field_ind].coltype == SQL_LONGVARCHAR) { ! 2142: fieldsize -= 1; ! 2143: } ! 2144: /* Don't duplicate result, saves one emalloc. ! 2145: For SQL_SUCCESS, the length is in vallen. ! 2146: */ ! 2147: RETURN_STRINGL(field, (rc == SQL_SUCCESS_WITH_INFO) ? fieldsize : result->values[field_ind].vallen, 0); ! 2148: break; ! 2149: ! 2150: default: ! 2151: if (result->values[field_ind].vallen == SQL_NULL_DATA) { ! 2152: RETURN_NULL(); ! 2153: } else { ! 2154: RETURN_STRINGL(result->values[field_ind].value, result->values[field_ind].vallen, 1); ! 2155: } ! 2156: break; ! 2157: } ! 2158: ! 2159: /* If we come here, output unbound LONG and/or BINARY column data to the client */ ! 2160: ! 2161: /* We emalloc 1 byte more for SQL_C_CHAR (trailing \0) */ ! 2162: fieldsize = (sql_c_type == SQL_C_CHAR) ? 4096 : 4095; ! 2163: field = emalloc(fieldsize); ! 2164: ! 2165: /* Call SQLGetData() until SQL_SUCCESS is returned */ ! 2166: while(1) { ! 2167: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(field_ind + 1),sql_c_type, field, fieldsize, &result->values[field_ind].vallen); ! 2168: ! 2169: if (rc == SQL_ERROR) { ! 2170: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); ! 2171: efree(field); ! 2172: RETURN_FALSE; ! 2173: } ! 2174: ! 2175: if (result->values[field_ind].vallen == SQL_NULL_DATA) { ! 2176: efree(field); ! 2177: RETURN_NULL(); ! 2178: } ! 2179: /* chop the trailing \0 by outputing only 4095 bytes */ ! 2180: PHPWRITE(field,(rc == SQL_SUCCESS_WITH_INFO) ? 4095 : result->values[field_ind].vallen); ! 2181: ! 2182: if (rc == SQL_SUCCESS) { /* no more data avail */ ! 2183: efree(field); ! 2184: RETURN_TRUE; ! 2185: } ! 2186: } ! 2187: RETURN_TRUE; ! 2188: } ! 2189: /* }}} */ ! 2190: ! 2191: /* {{{ proto int odbc_result_all(resource result_id [, string format]) ! 2192: Print result as HTML table */ ! 2193: PHP_FUNCTION(odbc_result_all) ! 2194: { ! 2195: char *buf = NULL; ! 2196: odbc_result *result; ! 2197: RETCODE rc; ! 2198: zval *pv_res; ! 2199: char *pv_format = NULL; ! 2200: int i, pv_format_len = 0; ! 2201: SQLSMALLINT sql_c_type; ! 2202: #ifdef HAVE_SQL_EXTENDED_FETCH ! 2203: SQLULEN crow; ! 2204: SQLUSMALLINT RowStatus[1]; ! 2205: #endif ! 2206: ! 2207: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s", &pv_res, &pv_format, &pv_format_len) == FAILURE) { ! 2208: return; ! 2209: } ! 2210: ! 2211: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2212: ! 2213: if (result->numcols == 0) { ! 2214: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 2215: RETURN_FALSE; ! 2216: } ! 2217: #ifdef HAVE_SQL_EXTENDED_FETCH ! 2218: if (result->fetch_abs) ! 2219: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); ! 2220: else ! 2221: #endif ! 2222: rc = SQLFetch(result->stmt); ! 2223: ! 2224: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 2225: php_printf("<h2>No rows found</h2>\n"); ! 2226: RETURN_LONG(0); ! 2227: } ! 2228: ! 2229: /* Start table tag */ ! 2230: if (ZEND_NUM_ARGS() == 1) { ! 2231: php_printf("<table><tr>"); ! 2232: } else { ! 2233: php_printf("<table %s ><tr>", pv_format); ! 2234: } ! 2235: ! 2236: for (i = 0; i < result->numcols; i++) { ! 2237: php_printf("<th>%s</th>", result->values[i].name); ! 2238: } ! 2239: ! 2240: php_printf("</tr>\n"); ! 2241: ! 2242: while(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) { ! 2243: result->fetched++; ! 2244: php_printf("<tr>"); ! 2245: for(i = 0; i < result->numcols; i++) { ! 2246: sql_c_type = SQL_C_CHAR; ! 2247: switch(result->values[i].coltype) { ! 2248: case SQL_BINARY: ! 2249: case SQL_VARBINARY: ! 2250: case SQL_LONGVARBINARY: ! 2251: if (result->binmode <= 0) { ! 2252: php_printf("<td>Not printable</td>"); ! 2253: break; ! 2254: } ! 2255: if (result->binmode <= 1) sql_c_type = SQL_C_BINARY; ! 2256: case SQL_LONGVARCHAR: ! 2257: if (IS_SQL_LONG(result->values[i].coltype) && ! 2258: result->longreadlen <= 0) { ! 2259: php_printf("<td>Not printable</td>"); ! 2260: break; ! 2261: } ! 2262: ! 2263: if (buf == NULL) { ! 2264: buf = emalloc(result->longreadlen); ! 2265: } ! 2266: ! 2267: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(i + 1),sql_c_type, buf, result->longreadlen, &result->values[i].vallen); ! 2268: ! 2269: php_printf("<td>"); ! 2270: ! 2271: if (rc == SQL_ERROR) { ! 2272: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); ! 2273: php_printf("</td></tr></table>"); ! 2274: efree(buf); ! 2275: RETURN_FALSE; ! 2276: } ! 2277: if (rc == SQL_SUCCESS_WITH_INFO) { ! 2278: PHPWRITE(buf, result->longreadlen); ! 2279: } else if (result->values[i].vallen == SQL_NULL_DATA) { ! 2280: php_printf("<td>NULL</td>"); ! 2281: break; ! 2282: } else { ! 2283: PHPWRITE(buf, result->values[i].vallen); ! 2284: } ! 2285: php_printf("</td>"); ! 2286: break; ! 2287: default: ! 2288: if (result->values[i].vallen == SQL_NULL_DATA) { ! 2289: php_printf("<td>NULL</td>"); ! 2290: } else { ! 2291: php_printf("<td>%s</td>", result->values[i].value); ! 2292: } ! 2293: break; ! 2294: } ! 2295: } ! 2296: php_printf("</tr>\n"); ! 2297: ! 2298: #ifdef HAVE_SQL_EXTENDED_FETCH ! 2299: if (result->fetch_abs) ! 2300: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); ! 2301: else ! 2302: #endif ! 2303: rc = SQLFetch(result->stmt); ! 2304: } ! 2305: php_printf("</table>\n"); ! 2306: if (buf) efree(buf); ! 2307: RETURN_LONG(result->fetched); ! 2308: } ! 2309: /* }}} */ ! 2310: ! 2311: /* {{{ proto bool odbc_free_result(resource result_id) ! 2312: Free resources associated with a result */ ! 2313: PHP_FUNCTION(odbc_free_result) ! 2314: { ! 2315: zval *pv_res; ! 2316: odbc_result *result; ! 2317: int i; ! 2318: ! 2319: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 2320: return; ! 2321: } ! 2322: ! 2323: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2324: if (result->values) { ! 2325: for (i = 0; i < result->numcols; i++) { ! 2326: if (result->values[i].value) { ! 2327: efree(result->values[i].value); ! 2328: } ! 2329: } ! 2330: efree(result->values); ! 2331: result->values = NULL; ! 2332: } ! 2333: ! 2334: zend_list_delete(Z_LVAL_P(pv_res)); ! 2335: ! 2336: RETURN_TRUE; ! 2337: } ! 2338: /* }}} */ ! 2339: ! 2340: /* {{{ proto resource odbc_connect(string DSN, string user, string password [, int cursor_option]) ! 2341: Connect to a datasource */ ! 2342: PHP_FUNCTION(odbc_connect) ! 2343: { ! 2344: odbc_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); ! 2345: } ! 2346: /* }}} */ ! 2347: ! 2348: /* {{{ proto resource odbc_pconnect(string DSN, string user, string password [, int cursor_option]) ! 2349: Establish a persistent connection to a datasource */ ! 2350: PHP_FUNCTION(odbc_pconnect) ! 2351: { ! 2352: odbc_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); ! 2353: } ! 2354: /* }}} */ ! 2355: ! 2356: /* {{{ odbc_sqlconnect */ ! 2357: int odbc_sqlconnect(odbc_connection **conn, char *db, char *uid, char *pwd, int cur_opt, int persistent TSRMLS_DC) ! 2358: { ! 2359: RETCODE rc; ! 2360: ! 2361: *conn = (odbc_connection *)pemalloc(sizeof(odbc_connection), persistent); ! 2362: (*conn)->persistent = persistent; ! 2363: SQLAllocEnv(&((*conn)->henv)); ! 2364: SQLAllocConnect((*conn)->henv, &((*conn)->hdbc)); ! 2365: ! 2366: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30) ! 2367: SQLSetConnectOption((*conn)->hdbc, SQL_TRANSLATE_OPTION, ! 2368: SQL_SOLID_XLATOPT_NOCNV); ! 2369: #endif ! 2370: #ifdef HAVE_ODBC_ROUTER ! 2371: { ! 2372: #define CONNSTRSIZE 2048 ! 2373: char *lpszConnStr = emalloc(CONNSTRSIZE); ! 2374: if (lpszConnStr && db) { ! 2375: short cbszConnStr; ! 2376: if (strstr(db, ";")) { ! 2377: /* the caller has apparently passed a connection-string */ ! 2378: if (strstr(db, "uid") || strstr(db, "UID")) { ! 2379: uid = NULL; ! 2380: } ! 2381: if (strstr(db, "pwd") || strstr(db, "PWD")) { ! 2382: pwd = NULL; ! 2383: } ! 2384: strlcpy( lpszConnStr, db, CONNSTRSIZE); ! 2385: } ! 2386: else { ! 2387: strcpy(lpszConnStr, "DSN="); ! 2388: strlcat(lpszConnStr, db, CONNSTRSIZE); ! 2389: } ! 2390: if (uid) { ! 2391: if (uid[0]) { ! 2392: strlcat(lpszConnStr, ";UID=", CONNSTRSIZE); ! 2393: strlcat(lpszConnStr, uid, CONNSTRSIZE); ! 2394: strlcat(lpszConnStr, ";", CONNSTRSIZE); ! 2395: } ! 2396: if (pwd) { ! 2397: if (pwd[0]) { ! 2398: strlcat(lpszConnStr, "PWD=", CONNSTRSIZE); ! 2399: strlcat(lpszConnStr, pwd, CONNSTRSIZE); ! 2400: strlcat(lpszConnStr, ";", CONNSTRSIZE); ! 2401: } ! 2402: } ! 2403: } ! 2404: rc = SQLDriverConnect((*conn)->hdbc, NULL, lpszConnStr, SQL_NTS, lpszConnStr, CONNSTRSIZE, &cbszConnStr, SQL_DRIVER_NOPROMPT); ! 2405: efree(lpszConnStr); ! 2406: } ! 2407: } ! 2408: #else ! 2409: #ifdef HAVE_OPENLINK ! 2410: { ! 2411: char dsnbuf[1024]; ! 2412: short dsnbuflen; ! 2413: ! 2414: rc = SQLDriverConnect((*conn)->hdbc, NULL, db, SQL_NTS, dsnbuf, sizeof(dsnbuf) - 1, &dsnbuflen, SQL_DRIVER_NOPROMPT); ! 2415: } ! 2416: #else ! 2417: if (cur_opt != SQL_CUR_DEFAULT) { ! 2418: rc = SQLSetConnectOption((*conn)->hdbc, SQL_ODBC_CURSORS, cur_opt); ! 2419: if (rc != SQL_SUCCESS) { /* && rc != SQL_SUCCESS_WITH_INFO ? */ ! 2420: odbc_sql_error(*conn, SQL_NULL_HSTMT, "SQLSetConnectOption"); ! 2421: SQLFreeConnect((*conn)->hdbc); ! 2422: pefree(*conn, persistent); ! 2423: return FALSE; ! 2424: } ! 2425: } ! 2426: /* Possible fix for bug #10250 ! 2427: * Needs testing on UnixODBC < 2.0.5 though. */ ! 2428: #if defined(HAVE_EMPRESS) || defined(HAVE_UNIXODBC) || defined(PHP_WIN32) || defined (HAVE_IODBC) ! 2429: /* * Uncomment the line above, and comment line below to fully test ! 2430: * #ifdef HAVE_EMPRESS */ ! 2431: { ! 2432: int direct = 0; ! 2433: char dsnbuf[1024]; ! 2434: short dsnbuflen; ! 2435: char *ldb = 0; ! 2436: int ldb_len = 0; ! 2437: ! 2438: if (strstr((char*)db, ";")) { ! 2439: direct = 1; ! 2440: if (uid && !strstr ((char*)db, "uid") && !strstr((char*)db, "UID")) { ! 2441: spprintf(&ldb, 0, "%s;UID=%s;PWD=%s", db, uid, pwd); ! 2442: } else { ! 2443: ldb_len = strlen(db)+1; ! 2444: ldb = (char*) emalloc(ldb_len); ! 2445: memcpy(ldb, db, ldb_len); ! 2446: } ! 2447: } ! 2448: ! 2449: if (direct) { ! 2450: rc = SQLDriverConnect((*conn)->hdbc, NULL, ldb, strlen(ldb), dsnbuf, sizeof(dsnbuf) - 1, &dsnbuflen, SQL_DRIVER_NOPROMPT); ! 2451: } else { ! 2452: rc = SQLConnect((*conn)->hdbc, db, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS); ! 2453: } ! 2454: ! 2455: if (ldb) { ! 2456: efree(ldb); ! 2457: } ! 2458: } ! 2459: #else ! 2460: rc = SQLConnect((*conn)->hdbc, db, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS); ! 2461: #endif ! 2462: #endif ! 2463: #endif ! 2464: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 2465: odbc_sql_error(*conn, SQL_NULL_HSTMT, "SQLConnect"); ! 2466: SQLFreeConnect((*conn)->hdbc); ! 2467: pefree((*conn), persistent); ! 2468: return FALSE; ! 2469: } ! 2470: /* (*conn)->open = 1;*/ ! 2471: return TRUE; ! 2472: } ! 2473: /* }}} */ ! 2474: ! 2475: /* Persistent connections: two list-types le_pconn, le_conn and a plist ! 2476: * where hashed connection info is stored together with index pointer to ! 2477: * the actual link of type le_pconn in the list. Only persistent ! 2478: * connections get hashed up. Normal connections use existing pconnections. ! 2479: * Maybe this has to change with regard to transactions on pconnections? ! 2480: * Possibly set autocommit to on on request shutdown. ! 2481: * ! 2482: * We do have to hash non-persistent connections, and reuse connections. ! 2483: * In the case where two connects were being made, without closing the first ! 2484: * connect, access violations were occuring. This is because some of the ! 2485: * "globals" in this module should actualy be per-connection variables. I ! 2486: * simply fixed things to get them working for now. Shane ! 2487: */ ! 2488: /* {{{ odbc_do_connect */ ! 2489: void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent) ! 2490: { ! 2491: char *db, *uid, *pwd; ! 2492: int db_len, uid_len, pwd_len; ! 2493: long pv_opt = SQL_CUR_DEFAULT; ! 2494: odbc_connection *db_conn; ! 2495: char *hashed_details; ! 2496: int hashed_len, cur_opt; ! 2497: ! 2498: /* Now an optional 4th parameter specifying the cursor type ! 2499: * defaulting to the cursors default ! 2500: */ ! 2501: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|l", &db, &db_len, &uid, &uid_len, &pwd, &pwd_len, &pv_opt) == FAILURE) { ! 2502: return; ! 2503: } ! 2504: ! 2505: cur_opt = pv_opt; ! 2506: ! 2507: if (ZEND_NUM_ARGS() > 3) { ! 2508: /* Confirm the cur_opt range */ ! 2509: if (! (cur_opt == SQL_CUR_USE_IF_NEEDED || ! 2510: cur_opt == SQL_CUR_USE_ODBC || ! 2511: cur_opt == SQL_CUR_USE_DRIVER || ! 2512: cur_opt == SQL_CUR_DEFAULT) ) { ! 2513: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Cursor type (%d)", cur_opt); ! 2514: RETURN_FALSE; ! 2515: } ! 2516: } ! 2517: ! 2518: if (ODBCG(allow_persistent) <= 0) { ! 2519: persistent = 0; ! 2520: } ! 2521: ! 2522: hashed_len = spprintf(&hashed_details, 0, "%s_%s_%s_%s_%d", ODBC_TYPE, db, uid, pwd, cur_opt); ! 2523: ! 2524: /* FIXME the idea of checking to see if our connection is already persistent ! 2525: is good, but it adds a lot of overhead to non-persistent connections. We ! 2526: should look and see if we can fix that somehow */ ! 2527: /* try to find if we already have this link in our persistent list, ! 2528: * no matter if it is to be persistent or not ! 2529: */ ! 2530: ! 2531: try_and_get_another_connection: ! 2532: ! 2533: if (persistent) { ! 2534: zend_rsrc_list_entry *le; ! 2535: ! 2536: /* the link is not in the persistent list */ ! 2537: if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_len + 1, (void **) &le) == FAILURE) { ! 2538: zend_rsrc_list_entry new_le; ! 2539: ! 2540: if (ODBCG(max_links) != -1 && ODBCG(num_links) >= ODBCG(max_links)) { ! 2541: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%ld)", ODBCG(num_links)); ! 2542: efree(hashed_details); ! 2543: RETURN_FALSE; ! 2544: } ! 2545: if (ODBCG(max_persistent) != -1 && ODBCG(num_persistent) >= ODBCG(max_persistent)) { ! 2546: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Too many open persistent links (%ld)", ODBCG(num_persistent)); ! 2547: efree(hashed_details); ! 2548: RETURN_FALSE; ! 2549: } ! 2550: ! 2551: if (!odbc_sqlconnect(&db_conn, db, uid, pwd, cur_opt, 1 TSRMLS_CC)) { ! 2552: efree(hashed_details); ! 2553: RETURN_FALSE; ! 2554: } ! 2555: ! 2556: Z_TYPE(new_le) = le_pconn; ! 2557: new_le.ptr = db_conn; ! 2558: if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_len + 1, &new_le, ! 2559: sizeof(zend_rsrc_list_entry), NULL) == FAILURE) { ! 2560: free(db_conn); ! 2561: efree(hashed_details); ! 2562: RETURN_FALSE; ! 2563: } ! 2564: ODBCG(num_persistent)++; ! 2565: ODBCG(num_links)++; ! 2566: db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn); ! 2567: } else { /* found connection */ ! 2568: if (Z_TYPE_P(le) != le_pconn) { ! 2569: RETURN_FALSE; ! 2570: } ! 2571: /* ! 2572: * check to see if the connection is still valid ! 2573: */ ! 2574: db_conn = (odbc_connection *)le->ptr; ! 2575: ! 2576: /* ! 2577: * check to see if the connection is still in place (lurcher) ! 2578: */ ! 2579: if(ODBCG(check_persistent)){ ! 2580: RETCODE ret; ! 2581: UCHAR d_name[32]; ! 2582: SQLSMALLINT len; ! 2583: ! 2584: ret = SQLGetInfo(db_conn->hdbc, ! 2585: SQL_DATA_SOURCE_READ_ONLY, ! 2586: d_name, sizeof(d_name), &len); ! 2587: ! 2588: if(ret != SQL_SUCCESS || len == 0) { ! 2589: zend_hash_del(&EG(persistent_list), hashed_details, hashed_len + 1); ! 2590: /* Commented out to fix a possible double closure error ! 2591: * when working with persistent connections as submitted by ! 2592: * bug #15758 ! 2593: * ! 2594: * safe_odbc_disconnect(db_conn->hdbc); ! 2595: * SQLFreeConnect(db_conn->hdbc); ! 2596: */ ! 2597: goto try_and_get_another_connection; ! 2598: } ! 2599: } ! 2600: } ! 2601: db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn); ! 2602: } else { /* non persistent */ ! 2603: zend_rsrc_list_entry *index_ptr, new_index_ptr; ! 2604: ! 2605: if (zend_hash_find(&EG(regular_list), hashed_details, hashed_len + 1, (void **) &index_ptr) == SUCCESS) { ! 2606: int type, conn_id; ! 2607: void *ptr; ! 2608: ! 2609: if (Z_TYPE_P(index_ptr) != le_index_ptr) { ! 2610: RETURN_FALSE; ! 2611: } ! 2612: conn_id = (int)index_ptr->ptr; ! 2613: ptr = zend_list_find(conn_id, &type); /* check if the connection is still there */ ! 2614: ! 2615: if (ptr && (type == le_conn || type == le_pconn)) { ! 2616: zend_list_addref(conn_id); ! 2617: Z_LVAL_P(return_value) = conn_id; ! 2618: Z_TYPE_P(return_value) = IS_RESOURCE; ! 2619: efree(hashed_details); ! 2620: return; ! 2621: } else { ! 2622: zend_hash_del(&EG(regular_list), hashed_details, hashed_len + 1); ! 2623: } ! 2624: } ! 2625: if (ODBCG(max_links) != -1 && ODBCG(num_links) >= ODBCG(max_links)) { ! 2626: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Too many open connections (%ld)",ODBCG(num_links)); ! 2627: efree(hashed_details); ! 2628: RETURN_FALSE; ! 2629: } ! 2630: ! 2631: if (!odbc_sqlconnect(&db_conn, db, uid, pwd, cur_opt, 0 TSRMLS_CC)) { ! 2632: efree(hashed_details); ! 2633: RETURN_FALSE; ! 2634: } ! 2635: db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_conn); ! 2636: new_index_ptr.ptr = (void *) Z_LVAL_P(return_value); ! 2637: Z_TYPE(new_index_ptr) = le_index_ptr; ! 2638: ! 2639: if (zend_hash_update(&EG(regular_list), hashed_details, hashed_len + 1, (void *) &new_index_ptr, ! 2640: sizeof(zend_rsrc_list_entry), NULL) == FAILURE) { ! 2641: efree(hashed_details); ! 2642: RETURN_FALSE; ! 2643: /* XXX Free Connection */ ! 2644: } ! 2645: ODBCG(num_links)++; ! 2646: } ! 2647: efree(hashed_details); ! 2648: } ! 2649: /* }}} */ ! 2650: ! 2651: /* {{{ proto void odbc_close(resource connection_id) ! 2652: Close an ODBC connection */ ! 2653: PHP_FUNCTION(odbc_close) ! 2654: { ! 2655: zval *pv_conn; ! 2656: void *ptr; ! 2657: odbc_connection *conn; ! 2658: odbc_result *res; ! 2659: int nument; ! 2660: int i; ! 2661: int type; ! 2662: int is_pconn = 0; ! 2663: int found_resource_type = le_conn; ! 2664: ! 2665: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_conn) == FAILURE) { ! 2666: return; ! 2667: } ! 2668: ! 2669: conn = (odbc_connection *) zend_fetch_resource(&pv_conn TSRMLS_CC, -1, "ODBC-Link", &found_resource_type, 2, le_conn, le_pconn); ! 2670: if (found_resource_type==le_pconn) { ! 2671: is_pconn = 1; ! 2672: } ! 2673: ! 2674: nument = zend_hash_next_free_element(&EG(regular_list)); ! 2675: ! 2676: for(i = 1; i < nument; i++){ ! 2677: ptr = zend_list_find(i, &type); ! 2678: if(ptr && (type == le_result)){ ! 2679: res = (odbc_result *)ptr; ! 2680: if(res->conn_ptr == conn){ ! 2681: zend_list_delete(i); ! 2682: } ! 2683: } ! 2684: } ! 2685: ! 2686: zend_list_delete(Z_LVAL_P(pv_conn)); ! 2687: ! 2688: if(is_pconn){ ! 2689: zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) _close_pconn_with_id, (void *) &(Z_LVAL_P(pv_conn)) TSRMLS_CC); ! 2690: } ! 2691: } ! 2692: /* }}} */ ! 2693: ! 2694: /* {{{ proto int odbc_num_rows(resource result_id) ! 2695: Get number of rows in a result */ ! 2696: PHP_FUNCTION(odbc_num_rows) ! 2697: { ! 2698: odbc_result *result; ! 2699: SQLLEN rows; ! 2700: zval *pv_res; ! 2701: ! 2702: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 2703: return; ! 2704: } ! 2705: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2706: SQLRowCount(result->stmt, &rows); ! 2707: RETURN_LONG(rows); ! 2708: } ! 2709: /* }}} */ ! 2710: ! 2711: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) ! 2712: /* {{{ proto bool odbc_next_result(resource result_id) ! 2713: Checks if multiple results are avaiable */ ! 2714: PHP_FUNCTION(odbc_next_result) ! 2715: { ! 2716: odbc_result *result; ! 2717: zval *pv_res; ! 2718: int rc, i; ! 2719: ! 2720: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 2721: return; ! 2722: } ! 2723: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2724: ! 2725: if (result->values) { ! 2726: for(i = 0; i < result->numcols; i++) { ! 2727: if (result->values[i].value) { ! 2728: efree(result->values[i].value); ! 2729: } ! 2730: } ! 2731: efree(result->values); ! 2732: result->values = NULL; ! 2733: } ! 2734: ! 2735: result->fetched = 0; ! 2736: rc = SQLMoreResults(result->stmt); ! 2737: if (rc == SQL_SUCCESS_WITH_INFO || rc == SQL_SUCCESS) { ! 2738: rc = SQLFreeStmt(result->stmt, SQL_UNBIND); ! 2739: SQLNumParams(result->stmt, &(result->numparams)); ! 2740: SQLNumResultCols(result->stmt, &(result->numcols)); ! 2741: ! 2742: if (result->numcols > 0) { ! 2743: if (!odbc_bindcols(result TSRMLS_CC)) { ! 2744: efree(result); ! 2745: RETVAL_FALSE; ! 2746: } ! 2747: } else { ! 2748: result->values = NULL; ! 2749: } ! 2750: RETURN_TRUE; ! 2751: } else if (rc == SQL_NO_DATA_FOUND) { ! 2752: RETURN_FALSE; ! 2753: } else { ! 2754: odbc_sql_error(result->conn_ptr, result->stmt, "SQLMoreResults"); ! 2755: RETURN_FALSE; ! 2756: } ! 2757: } ! 2758: /* }}} */ ! 2759: #endif ! 2760: ! 2761: /* {{{ proto int odbc_num_fields(resource result_id) ! 2762: Get number of columns in a result */ ! 2763: PHP_FUNCTION(odbc_num_fields) ! 2764: { ! 2765: odbc_result *result; ! 2766: zval *pv_res; ! 2767: ! 2768: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) { ! 2769: return; ! 2770: } ! 2771: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2772: RETURN_LONG(result->numcols); ! 2773: } ! 2774: /* }}} */ ! 2775: ! 2776: /* {{{ proto string odbc_field_name(resource result_id, int field_number) ! 2777: Get a column name */ ! 2778: PHP_FUNCTION(odbc_field_name) ! 2779: { ! 2780: odbc_result *result; ! 2781: zval *pv_res; ! 2782: long pv_num; ! 2783: ! 2784: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) { ! 2785: return; ! 2786: } ! 2787: ! 2788: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2789: ! 2790: if (result->numcols == 0) { ! 2791: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 2792: RETURN_FALSE; ! 2793: } ! 2794: ! 2795: if (pv_num > result->numcols) { ! 2796: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields"); ! 2797: RETURN_FALSE; ! 2798: } ! 2799: ! 2800: if (pv_num < 1) { ! 2801: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1"); ! 2802: RETURN_FALSE; ! 2803: } ! 2804: ! 2805: RETURN_STRING(result->values[pv_num - 1].name, 1); ! 2806: } ! 2807: /* }}} */ ! 2808: ! 2809: /* {{{ proto string odbc_field_type(resource result_id, int field_number) ! 2810: Get the datatype of a column */ ! 2811: PHP_FUNCTION(odbc_field_type) ! 2812: { ! 2813: odbc_result *result; ! 2814: char tmp[32]; ! 2815: SQLSMALLINT tmplen; ! 2816: zval *pv_res; ! 2817: long pv_num; ! 2818: ! 2819: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) { ! 2820: return; ! 2821: } ! 2822: ! 2823: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2824: ! 2825: if (result->numcols == 0) { ! 2826: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 2827: RETURN_FALSE; ! 2828: } ! 2829: ! 2830: if (pv_num > result->numcols) { ! 2831: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields"); ! 2832: RETURN_FALSE; ! 2833: } ! 2834: ! 2835: if (pv_num < 1) { ! 2836: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1"); ! 2837: RETURN_FALSE; ! 2838: } ! 2839: ! 2840: SQLColAttributes(result->stmt, (SQLUSMALLINT)pv_num, SQL_COLUMN_TYPE_NAME, tmp, 31, &tmplen, NULL); ! 2841: RETURN_STRING(tmp,1) ! 2842: } ! 2843: /* }}} */ ! 2844: ! 2845: /* {{{ proto int odbc_field_len(resource result_id, int field_number) ! 2846: Get the length (precision) of a column */ ! 2847: PHP_FUNCTION(odbc_field_len) ! 2848: { ! 2849: odbc_column_lengths(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); ! 2850: } ! 2851: /* }}} */ ! 2852: ! 2853: /* {{{ proto int odbc_field_scale(resource result_id, int field_number) ! 2854: Get the scale of a column */ ! 2855: PHP_FUNCTION(odbc_field_scale) ! 2856: { ! 2857: odbc_column_lengths(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); ! 2858: } ! 2859: /* }}} */ ! 2860: ! 2861: /* {{{ proto int odbc_field_num(resource result_id, string field_name) ! 2862: Return column number */ ! 2863: PHP_FUNCTION(odbc_field_num) ! 2864: { ! 2865: char *fname; ! 2866: int i, field_ind, fname_len; ! 2867: odbc_result *result; ! 2868: zval *pv_res; ! 2869: ! 2870: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &pv_res, &fname, &fname_len) == FAILURE) { ! 2871: return; ! 2872: } ! 2873: ! 2874: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); ! 2875: ! 2876: if (result->numcols == 0) { ! 2877: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); ! 2878: RETURN_FALSE; ! 2879: } ! 2880: ! 2881: field_ind = -1; ! 2882: for(i = 0; i < result->numcols; i++) { ! 2883: if (strcasecmp(result->values[i].name, fname) == 0) { ! 2884: field_ind = i + 1; ! 2885: } ! 2886: } ! 2887: ! 2888: if (field_ind == -1) { ! 2889: RETURN_FALSE; ! 2890: } ! 2891: RETURN_LONG(field_ind); ! 2892: } ! 2893: /* }}} */ ! 2894: ! 2895: /* {{{ proto mixed odbc_autocommit(resource connection_id [, int OnOff]) ! 2896: Toggle autocommit mode or get status */ ! 2897: /* There can be problems with pconnections!*/ ! 2898: PHP_FUNCTION(odbc_autocommit) ! 2899: { ! 2900: odbc_connection *conn; ! 2901: RETCODE rc; ! 2902: zval *pv_conn; ! 2903: long pv_onoff = 0; ! 2904: ! 2905: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_conn, &pv_onoff) == FAILURE) { ! 2906: return; ! 2907: } ! 2908: ! 2909: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 2910: ! 2911: if (ZEND_NUM_ARGS() > 1) { ! 2912: rc = SQLSetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, (pv_onoff) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF); ! 2913: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 2914: odbc_sql_error(conn, SQL_NULL_HSTMT, "Set autocommit"); ! 2915: RETURN_FALSE; ! 2916: } ! 2917: RETVAL_TRUE; ! 2918: } else { ! 2919: SQLINTEGER status; ! 2920: ! 2921: rc = SQLGetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, (PTR)&status); ! 2922: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 2923: odbc_sql_error(conn, SQL_NULL_HSTMT, "Get commit status"); ! 2924: RETURN_FALSE; ! 2925: } ! 2926: RETVAL_LONG((long)status); ! 2927: } ! 2928: } ! 2929: /* }}} */ ! 2930: ! 2931: /* {{{ proto bool odbc_commit(resource connection_id) ! 2932: Commit an ODBC transaction */ ! 2933: PHP_FUNCTION(odbc_commit) ! 2934: { ! 2935: odbc_transact(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); ! 2936: } ! 2937: /* }}} */ ! 2938: ! 2939: /* {{{ proto bool odbc_rollback(resource connection_id) ! 2940: Rollback a transaction */ ! 2941: PHP_FUNCTION(odbc_rollback) ! 2942: { ! 2943: odbc_transact(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); ! 2944: } ! 2945: /* }}} */ ! 2946: ! 2947: /* {{{ php_odbc_lasterror */ ! 2948: static void php_odbc_lasterror(INTERNAL_FUNCTION_PARAMETERS, int mode) ! 2949: { ! 2950: odbc_connection *conn; ! 2951: zval *pv_handle; ! 2952: char *ptr; ! 2953: int len; ! 2954: ! 2955: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &pv_handle) == FAILURE) { ! 2956: return; ! 2957: } ! 2958: ! 2959: if (mode == 0) { /* last state */ ! 2960: len = 6; ! 2961: } else { /* last error message */ ! 2962: len = SQL_MAX_MESSAGE_LENGTH; ! 2963: } ! 2964: ! 2965: if (ZEND_NUM_ARGS() == 1) { ! 2966: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_handle, -1, "ODBC-Link", le_conn, le_pconn); ! 2967: ptr = ecalloc(len + 1, 1); ! 2968: if (mode == 0) { ! 2969: strlcpy(ptr, conn->laststate, len+1); ! 2970: } else { ! 2971: strlcpy(ptr, conn->lasterrormsg, len+1); ! 2972: } ! 2973: } else { ! 2974: ptr = ecalloc(len + 1, 1); ! 2975: if (mode == 0) { ! 2976: strlcpy(ptr, ODBCG(laststate), len+1); ! 2977: } else { ! 2978: strlcpy(ptr, ODBCG(lasterrormsg), len+1); ! 2979: } ! 2980: } ! 2981: RETVAL_STRING(ptr, 0); ! 2982: } ! 2983: /* }}} */ ! 2984: ! 2985: /* {{{ proto string odbc_error([resource connection_id]) ! 2986: Get the last error code */ ! 2987: PHP_FUNCTION(odbc_error) ! 2988: { ! 2989: php_odbc_lasterror(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); ! 2990: } ! 2991: /* }}} */ ! 2992: ! 2993: /* {{{ proto string odbc_errormsg([resource connection_id]) ! 2994: Get the last error message */ ! 2995: PHP_FUNCTION(odbc_errormsg) ! 2996: { ! 2997: php_odbc_lasterror(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); ! 2998: } ! 2999: /* }}} */ ! 3000: ! 3001: /* {{{ proto bool odbc_setoption(resource conn_id|result_id, int which, int option, int value) ! 3002: Sets connection or statement options */ ! 3003: /* This one has to be used carefully. We can't allow to set connection options for ! 3004: persistent connections. I think that SetStmtOption is of little use, since most ! 3005: of those can only be specified before preparing/executing statements. ! 3006: On the other hand, they can be made connection wide default through SetConnectOption ! 3007: - but will be overidden by calls to SetStmtOption() in odbc_prepare/odbc_do ! 3008: */ ! 3009: PHP_FUNCTION(odbc_setoption) ! 3010: { ! 3011: odbc_connection *conn; ! 3012: odbc_result *result; ! 3013: RETCODE rc; ! 3014: zval *pv_handle; ! 3015: long pv_which, pv_opt, pv_val; ! 3016: ! 3017: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &pv_handle, &pv_which, &pv_opt, &pv_val) == FAILURE) { ! 3018: return; ! 3019: } ! 3020: ! 3021: switch (pv_which) { ! 3022: case 1: /* SQLSetConnectOption */ ! 3023: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_handle, -1, "ODBC-Link", le_conn, le_pconn); ! 3024: ! 3025: if (conn->persistent) { ! 3026: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set option for persistent connection"); ! 3027: RETURN_FALSE; ! 3028: } ! 3029: rc = SQLSetConnectOption(conn->hdbc, (unsigned short) pv_opt, pv_val); ! 3030: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 3031: odbc_sql_error(conn, SQL_NULL_HSTMT, "SetConnectOption"); ! 3032: RETURN_FALSE; ! 3033: } ! 3034: break; ! 3035: case 2: /* SQLSetStmtOption */ ! 3036: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_handle, -1, "ODBC result", le_result); ! 3037: ! 3038: rc = SQLSetStmtOption(result->stmt, (unsigned short) pv_opt, pv_val); ! 3039: ! 3040: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { ! 3041: odbc_sql_error(result->conn_ptr, result->stmt, "SetStmtOption"); ! 3042: RETURN_FALSE; ! 3043: } ! 3044: break; ! 3045: default: ! 3046: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option type"); ! 3047: RETURN_FALSE; ! 3048: break; ! 3049: } ! 3050: ! 3051: RETURN_TRUE; ! 3052: } ! 3053: /* }}} */ ! 3054: ! 3055: /* ! 3056: * metadata functions ! 3057: */ ! 3058: ! 3059: /* {{{ proto resource odbc_tables(resource connection_id [, string qualifier [, string owner [, string name [, string table_types]]]]) ! 3060: Call the SQLTables function */ ! 3061: PHP_FUNCTION(odbc_tables) ! 3062: { ! 3063: zval *pv_conn; ! 3064: odbc_result *result = NULL; ! 3065: odbc_connection *conn; ! 3066: char *cat = NULL, *schema = NULL, *table = NULL, *type = NULL; ! 3067: int cat_len = 0, schema_len = 0, table_len = 0, type_len = 0; ! 3068: RETCODE rc; ! 3069: ! 3070: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len, ! 3071: &table, &table_len, &type, &type_len) == FAILURE) { ! 3072: return; ! 3073: } ! 3074: ! 3075: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3076: ! 3077: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3078: ! 3079: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3080: if (rc == SQL_INVALID_HANDLE) { ! 3081: efree(result); ! 3082: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3083: RETURN_FALSE; ! 3084: } ! 3085: ! 3086: if (rc == SQL_ERROR) { ! 3087: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3088: efree(result); ! 3089: RETURN_FALSE; ! 3090: } ! 3091: ! 3092: /* This hack is needed to access table information in Access databases (fmk) */ ! 3093: if (table && table_len && schema && schema_len == 0) { ! 3094: schema = NULL; ! 3095: } ! 3096: ! 3097: rc = SQLTables(result->stmt, ! 3098: cat, SAFE_SQL_NTS(cat), ! 3099: schema, SAFE_SQL_NTS(schema), ! 3100: table, SAFE_SQL_NTS(table), ! 3101: type, SAFE_SQL_NTS(type)); ! 3102: ! 3103: if (rc == SQL_ERROR) { ! 3104: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTables"); ! 3105: efree(result); ! 3106: RETURN_FALSE; ! 3107: } ! 3108: ! 3109: result->numparams = 0; ! 3110: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3111: ! 3112: if (result->numcols > 0) { ! 3113: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3114: efree(result); ! 3115: RETURN_FALSE; ! 3116: } ! 3117: } else { ! 3118: result->values = NULL; ! 3119: } ! 3120: result->conn_ptr = conn; ! 3121: result->fetched = 0; ! 3122: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3123: } ! 3124: /* }}} */ ! 3125: ! 3126: /* {{{ proto resource odbc_columns(resource connection_id [, string qualifier [, string owner [, string table_name [, string column_name]]]]) ! 3127: Returns a result identifier that can be used to fetch a list of column names in specified tables */ ! 3128: PHP_FUNCTION(odbc_columns) ! 3129: { ! 3130: zval *pv_conn; ! 3131: odbc_result *result = NULL; ! 3132: odbc_connection *conn; ! 3133: char *cat = NULL, *schema = NULL, *table = NULL, *column = NULL; ! 3134: int cat_len = 0, schema_len = 0, table_len = 0, column_len = 0; ! 3135: RETCODE rc; ! 3136: ! 3137: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len, ! 3138: &table, &table_len, &column, &column_len) == FAILURE) { ! 3139: return; ! 3140: } ! 3141: ! 3142: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3143: ! 3144: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3145: ! 3146: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3147: if (rc == SQL_INVALID_HANDLE) { ! 3148: efree(result); ! 3149: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3150: RETURN_FALSE; ! 3151: } ! 3152: ! 3153: if (rc == SQL_ERROR) { ! 3154: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3155: efree(result); ! 3156: RETURN_FALSE; ! 3157: } ! 3158: ! 3159: /* ! 3160: * Needed to make MS Access happy ! 3161: */ ! 3162: if (table && table_len && schema && schema_len == 0) { ! 3163: schema = NULL; ! 3164: } ! 3165: ! 3166: rc = SQLColumns(result->stmt, ! 3167: cat, (SQLSMALLINT) cat_len, ! 3168: schema, (SQLSMALLINT) schema_len, ! 3169: table, (SQLSMALLINT) table_len, ! 3170: column, (SQLSMALLINT) column_len); ! 3171: ! 3172: if (rc == SQL_ERROR) { ! 3173: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLColumns"); ! 3174: efree(result); ! 3175: RETURN_FALSE; ! 3176: } ! 3177: ! 3178: result->numparams = 0; ! 3179: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3180: ! 3181: if (result->numcols > 0) { ! 3182: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3183: efree(result); ! 3184: RETURN_FALSE; ! 3185: } ! 3186: } else { ! 3187: result->values = NULL; ! 3188: } ! 3189: result->conn_ptr = conn; ! 3190: result->fetched = 0; ! 3191: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3192: } ! 3193: /* }}} */ ! 3194: ! 3195: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP) ! 3196: /* {{{ proto resource odbc_columnprivileges(resource connection_id, string catalog, string schema, string table, string column) ! 3197: Returns a result identifier that can be used to fetch a list of columns and associated privileges for the specified table */ ! 3198: PHP_FUNCTION(odbc_columnprivileges) ! 3199: { ! 3200: zval *pv_conn; ! 3201: odbc_result *result = NULL; ! 3202: odbc_connection *conn; ! 3203: char *cat = NULL, *schema, *table, *column; ! 3204: int cat_len = 0, schema_len, table_len, column_len; ! 3205: RETCODE rc; ! 3206: ! 3207: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len, ! 3208: &table, &table_len, &column, &column_len) == FAILURE) { ! 3209: return; ! 3210: } ! 3211: ! 3212: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3213: ! 3214: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3215: ! 3216: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3217: if (rc == SQL_INVALID_HANDLE) { ! 3218: efree(result); ! 3219: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3220: RETURN_FALSE; ! 3221: } ! 3222: ! 3223: if (rc == SQL_ERROR) { ! 3224: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3225: efree(result); ! 3226: RETURN_FALSE; ! 3227: } ! 3228: ! 3229: rc = SQLColumnPrivileges(result->stmt, ! 3230: cat, SAFE_SQL_NTS(cat), ! 3231: schema, SAFE_SQL_NTS(schema), ! 3232: table, SAFE_SQL_NTS(table), ! 3233: column, SAFE_SQL_NTS(column)); ! 3234: ! 3235: if (rc == SQL_ERROR) { ! 3236: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLColumnPrivileges"); ! 3237: efree(result); ! 3238: RETURN_FALSE; ! 3239: } ! 3240: ! 3241: result->numparams = 0; ! 3242: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3243: ! 3244: if (result->numcols > 0) { ! 3245: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3246: efree(result); ! 3247: RETURN_FALSE; ! 3248: } ! 3249: } else { ! 3250: result->values = NULL; ! 3251: } ! 3252: result->conn_ptr = conn; ! 3253: result->fetched = 0; ! 3254: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3255: } ! 3256: /* }}} */ ! 3257: #endif /* HAVE_DBMAKER || HAVE_SOLID*/ ! 3258: ! 3259: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) ! 3260: /* {{{ proto resource odbc_foreignkeys(resource connection_id, string pk_qualifier, string pk_owner, string pk_table, string fk_qualifier, string fk_owner, string fk_table) ! 3261: Returns a result identifier to either a list of foreign keys in the specified table or a list of foreign keys in other tables that refer to the primary key in the specified table */ ! 3262: PHP_FUNCTION(odbc_foreignkeys) ! 3263: { ! 3264: zval *pv_conn; ! 3265: odbc_result *result = NULL; ! 3266: odbc_connection *conn; ! 3267: char *pcat = NULL, *pschema, *ptable, *fcat, *fschema, *ftable; ! 3268: int pcat_len = 0, pschema_len, ptable_len, fcat_len, fschema_len, ftable_len; ! 3269: RETCODE rc; ! 3270: ! 3271: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!sssss", &pv_conn, &pcat, &pcat_len, &pschema, &pschema_len, ! 3272: &ptable, &ptable_len, &fcat, &fcat_len, &fschema, &fschema_len, &ftable, &ftable_len) == FAILURE) { ! 3273: return; ! 3274: } ! 3275: ! 3276: #if defined(HAVE_DBMAKER) || defined(HAVE_IBMDB2) ! 3277: #define EMPTY_TO_NULL(xstr) \ ! 3278: if ((int)strlen((xstr)) == 0) (xstr) = NULL ! 3279: ! 3280: EMPTY_TO_NULL(pcat); ! 3281: EMPTY_TO_NULL(pschema); ! 3282: EMPTY_TO_NULL(ptable); ! 3283: EMPTY_TO_NULL(fcat); ! 3284: EMPTY_TO_NULL(fschema); ! 3285: EMPTY_TO_NULL(ftable); ! 3286: #endif ! 3287: ! 3288: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3289: ! 3290: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3291: ! 3292: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3293: if (rc == SQL_INVALID_HANDLE) { ! 3294: efree(result); ! 3295: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3296: RETURN_FALSE; ! 3297: } ! 3298: ! 3299: if (rc == SQL_ERROR) { ! 3300: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3301: efree(result); ! 3302: RETURN_FALSE; ! 3303: } ! 3304: ! 3305: rc = SQLForeignKeys(result->stmt, ! 3306: pcat, SAFE_SQL_NTS(pcat), ! 3307: pschema, SAFE_SQL_NTS(pschema), ! 3308: ptable, SAFE_SQL_NTS(ptable), ! 3309: fcat, SAFE_SQL_NTS(fcat), ! 3310: fschema, SAFE_SQL_NTS(fschema), ! 3311: ftable, SAFE_SQL_NTS(ftable) ); ! 3312: ! 3313: if (rc == SQL_ERROR) { ! 3314: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLForeignKeys"); ! 3315: efree(result); ! 3316: RETURN_FALSE; ! 3317: } ! 3318: ! 3319: result->numparams = 0; ! 3320: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3321: ! 3322: if (result->numcols > 0) { ! 3323: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3324: efree(result); ! 3325: RETURN_FALSE; ! 3326: } ! 3327: } else { ! 3328: result->values = NULL; ! 3329: } ! 3330: result->conn_ptr = conn; ! 3331: result->fetched = 0; ! 3332: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3333: } ! 3334: /* }}} */ ! 3335: #endif /* HAVE_SOLID */ ! 3336: ! 3337: /* {{{ proto resource odbc_gettypeinfo(resource connection_id [, int data_type]) ! 3338: Returns a result identifier containing information about data types supported by the data source */ ! 3339: PHP_FUNCTION(odbc_gettypeinfo) ! 3340: { ! 3341: zval *pv_conn; ! 3342: long pv_data_type = SQL_ALL_TYPES; ! 3343: odbc_result *result = NULL; ! 3344: odbc_connection *conn; ! 3345: RETCODE rc; ! 3346: SQLSMALLINT data_type; ! 3347: ! 3348: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_conn, &pv_data_type) == FAILURE) { ! 3349: return; ! 3350: } ! 3351: ! 3352: data_type = (SQLSMALLINT) pv_data_type; ! 3353: ! 3354: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3355: ! 3356: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3357: ! 3358: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3359: if (rc == SQL_INVALID_HANDLE) { ! 3360: efree(result); ! 3361: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3362: RETURN_FALSE; ! 3363: } ! 3364: ! 3365: if (rc == SQL_ERROR) { ! 3366: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3367: efree(result); ! 3368: RETURN_FALSE; ! 3369: } ! 3370: ! 3371: rc = SQLGetTypeInfo(result->stmt, data_type ); ! 3372: ! 3373: if (rc == SQL_ERROR) { ! 3374: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLGetTypeInfo"); ! 3375: efree(result); ! 3376: RETURN_FALSE; ! 3377: } ! 3378: ! 3379: result->numparams = 0; ! 3380: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3381: ! 3382: if (result->numcols > 0) { ! 3383: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3384: efree(result); ! 3385: RETURN_FALSE; ! 3386: } ! 3387: } else { ! 3388: result->values = NULL; ! 3389: } ! 3390: result->conn_ptr = conn; ! 3391: result->fetched = 0; ! 3392: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3393: } ! 3394: /* }}} */ ! 3395: ! 3396: /* {{{ proto resource odbc_primarykeys(resource connection_id, string qualifier, string owner, string table) ! 3397: Returns a result identifier listing the column names that comprise the primary key for a table */ ! 3398: PHP_FUNCTION(odbc_primarykeys) ! 3399: { ! 3400: zval *pv_conn; ! 3401: odbc_result *result = NULL; ! 3402: odbc_connection *conn; ! 3403: char *cat = NULL, *schema = NULL, *table = NULL; ! 3404: int cat_len = 0, schema_len, table_len; ! 3405: RETCODE rc; ! 3406: ! 3407: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!ss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &table, &table_len) == FAILURE) { ! 3408: return; ! 3409: } ! 3410: ! 3411: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3412: ! 3413: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3414: ! 3415: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3416: if (rc == SQL_INVALID_HANDLE) { ! 3417: efree(result); ! 3418: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3419: RETURN_FALSE; ! 3420: } ! 3421: ! 3422: if (rc == SQL_ERROR) { ! 3423: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3424: efree(result); ! 3425: RETURN_FALSE; ! 3426: } ! 3427: ! 3428: rc = SQLPrimaryKeys(result->stmt, ! 3429: cat, SAFE_SQL_NTS(cat), ! 3430: schema, SAFE_SQL_NTS(schema), ! 3431: table, SAFE_SQL_NTS(table) ); ! 3432: ! 3433: if (rc == SQL_ERROR) { ! 3434: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLPrimaryKeys"); ! 3435: efree(result); ! 3436: RETURN_FALSE; ! 3437: } ! 3438: ! 3439: result->numparams = 0; ! 3440: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3441: ! 3442: if (result->numcols > 0) { ! 3443: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3444: efree(result); ! 3445: RETURN_FALSE; ! 3446: } ! 3447: } else { ! 3448: result->values = NULL; ! 3449: } ! 3450: result->conn_ptr = conn; ! 3451: result->fetched = 0; ! 3452: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3453: } ! 3454: /* }}} */ ! 3455: ! 3456: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP) ! 3457: /* {{{ proto resource odbc_procedurecolumns(resource connection_id [, string qualifier, string owner, string proc, string column]) ! 3458: Returns a result identifier containing the list of input and output parameters, as well as the columns that make up the result set for the specified procedures */ ! 3459: PHP_FUNCTION(odbc_procedurecolumns) ! 3460: { ! 3461: zval *pv_conn; ! 3462: odbc_result *result = NULL; ! 3463: odbc_connection *conn; ! 3464: char *cat = NULL, *schema = NULL, *proc = NULL, *col = NULL; ! 3465: int cat_len = 0, schema_len = 0, proc_len = 0, col_len = 0; ! 3466: RETCODE rc; ! 3467: ! 3468: if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 5) { ! 3469: WRONG_PARAM_COUNT; ! 3470: } ! 3471: ! 3472: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len, ! 3473: &proc, &proc_len, &col, &col_len) == FAILURE) { ! 3474: return; ! 3475: } ! 3476: ! 3477: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3478: ! 3479: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3480: ! 3481: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3482: if (rc == SQL_INVALID_HANDLE) { ! 3483: efree(result); ! 3484: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3485: RETURN_FALSE; ! 3486: } ! 3487: ! 3488: if (rc == SQL_ERROR) { ! 3489: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3490: efree(result); ! 3491: RETURN_FALSE; ! 3492: } ! 3493: ! 3494: rc = SQLProcedureColumns(result->stmt, ! 3495: cat, SAFE_SQL_NTS(cat), ! 3496: schema, SAFE_SQL_NTS(schema), ! 3497: proc, SAFE_SQL_NTS(proc), ! 3498: col, SAFE_SQL_NTS(col) ); ! 3499: ! 3500: if (rc == SQL_ERROR) { ! 3501: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLProcedureColumns"); ! 3502: efree(result); ! 3503: RETURN_FALSE; ! 3504: } ! 3505: ! 3506: result->numparams = 0; ! 3507: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3508: ! 3509: if (result->numcols > 0) { ! 3510: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3511: efree(result); ! 3512: RETURN_FALSE; ! 3513: } ! 3514: } else { ! 3515: result->values = NULL; ! 3516: } ! 3517: result->conn_ptr = conn; ! 3518: result->fetched = 0; ! 3519: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3520: } ! 3521: /* }}} */ ! 3522: #endif /* HAVE_SOLID */ ! 3523: ! 3524: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) ! 3525: /* {{{ proto resource odbc_procedures(resource connection_id [, string qualifier, string owner, string name]) ! 3526: Returns a result identifier containg the list of procedure names in a datasource */ ! 3527: PHP_FUNCTION(odbc_procedures) ! 3528: { ! 3529: zval *pv_conn; ! 3530: odbc_result *result = NULL; ! 3531: odbc_connection *conn; ! 3532: char *cat = NULL, *schema = NULL, *proc = NULL; ! 3533: int cat_len = 0, schema_len = 0, proc_len = 0; ! 3534: RETCODE rc; ! 3535: ! 3536: if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 4) { ! 3537: WRONG_PARAM_COUNT; ! 3538: } ! 3539: ! 3540: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!ss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &proc, &proc_len) == FAILURE) { ! 3541: return; ! 3542: } ! 3543: ! 3544: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3545: ! 3546: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3547: ! 3548: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3549: if (rc == SQL_INVALID_HANDLE) { ! 3550: efree(result); ! 3551: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3552: RETURN_FALSE; ! 3553: } ! 3554: ! 3555: if (rc == SQL_ERROR) { ! 3556: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3557: efree(result); ! 3558: RETURN_FALSE; ! 3559: } ! 3560: ! 3561: rc = SQLProcedures(result->stmt, ! 3562: cat, SAFE_SQL_NTS(cat), ! 3563: schema, SAFE_SQL_NTS(schema), ! 3564: proc, SAFE_SQL_NTS(proc) ); ! 3565: ! 3566: if (rc == SQL_ERROR) { ! 3567: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLProcedures"); ! 3568: efree(result); ! 3569: RETURN_FALSE; ! 3570: } ! 3571: ! 3572: result->numparams = 0; ! 3573: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3574: ! 3575: if (result->numcols > 0) { ! 3576: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3577: efree(result); ! 3578: RETURN_FALSE; ! 3579: } ! 3580: } else { ! 3581: result->values = NULL; ! 3582: } ! 3583: result->conn_ptr = conn; ! 3584: result->fetched = 0; ! 3585: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3586: } ! 3587: /* }}} */ ! 3588: #endif /* HAVE_SOLID */ ! 3589: ! 3590: /* {{{ proto resource odbc_specialcolumns(resource connection_id, int type, string qualifier, string owner, string table, int scope, int nullable) ! 3591: Returns a result identifier containing either the optimal set of columns that uniquely identifies a row in the table or columns that are automatically updated when any value in the row is updated by a transaction */ ! 3592: PHP_FUNCTION(odbc_specialcolumns) ! 3593: { ! 3594: zval *pv_conn; ! 3595: long vtype, vscope, vnullable; ! 3596: odbc_result *result = NULL; ! 3597: odbc_connection *conn; ! 3598: char *cat = NULL, *schema = NULL, *name = NULL; ! 3599: int cat_len = 0, schema_len, name_len; ! 3600: SQLUSMALLINT type, scope, nullable; ! 3601: RETCODE rc; ! 3602: ! 3603: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls!ssll", &pv_conn, &vtype, &cat, &cat_len, &schema, &schema_len, ! 3604: &name, &name_len, &vscope, &vnullable) == FAILURE) { ! 3605: return; ! 3606: } ! 3607: ! 3608: type = (SQLUSMALLINT) vtype; ! 3609: scope = (SQLUSMALLINT) vscope; ! 3610: nullable = (SQLUSMALLINT) vnullable; ! 3611: ! 3612: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3613: ! 3614: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3615: ! 3616: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3617: if (rc == SQL_INVALID_HANDLE) { ! 3618: efree(result); ! 3619: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3620: RETURN_FALSE; ! 3621: } ! 3622: ! 3623: if (rc == SQL_ERROR) { ! 3624: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3625: efree(result); ! 3626: RETURN_FALSE; ! 3627: } ! 3628: ! 3629: rc = SQLSpecialColumns(result->stmt, ! 3630: type, ! 3631: cat, SAFE_SQL_NTS(cat), ! 3632: schema, SAFE_SQL_NTS(schema), ! 3633: name, SAFE_SQL_NTS(name), ! 3634: scope, ! 3635: nullable); ! 3636: ! 3637: if (rc == SQL_ERROR) { ! 3638: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLSpecialColumns"); ! 3639: efree(result); ! 3640: RETURN_FALSE; ! 3641: } ! 3642: ! 3643: result->numparams = 0; ! 3644: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3645: ! 3646: if (result->numcols > 0) { ! 3647: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3648: efree(result); ! 3649: RETURN_FALSE; ! 3650: } ! 3651: } else { ! 3652: result->values = NULL; ! 3653: } ! 3654: result->conn_ptr = conn; ! 3655: result->fetched = 0; ! 3656: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3657: } ! 3658: /* }}} */ ! 3659: ! 3660: /* {{{ proto resource odbc_statistics(resource connection_id, string qualifier, string owner, string name, int unique, int accuracy) ! 3661: Returns a result identifier that contains statistics about a single table and the indexes associated with the table */ ! 3662: PHP_FUNCTION(odbc_statistics) ! 3663: { ! 3664: zval *pv_conn; ! 3665: long vunique, vreserved; ! 3666: odbc_result *result = NULL; ! 3667: odbc_connection *conn; ! 3668: char *cat = NULL, *schema, *name; ! 3669: int cat_len = 0, schema_len, name_len; ! 3670: SQLUSMALLINT unique, reserved; ! 3671: RETCODE rc; ! 3672: ! 3673: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!ssll", &pv_conn, &cat, &cat_len, &schema, &schema_len, ! 3674: &name, &name_len, &vunique, &vreserved) == FAILURE) { ! 3675: return; ! 3676: } ! 3677: ! 3678: unique = (SQLUSMALLINT) vunique; ! 3679: reserved = (SQLUSMALLINT) vreserved; ! 3680: ! 3681: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3682: ! 3683: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3684: ! 3685: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3686: if (rc == SQL_INVALID_HANDLE) { ! 3687: efree(result); ! 3688: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3689: RETURN_FALSE; ! 3690: } ! 3691: ! 3692: if (rc == SQL_ERROR) { ! 3693: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3694: efree(result); ! 3695: RETURN_FALSE; ! 3696: } ! 3697: ! 3698: rc = SQLStatistics(result->stmt, ! 3699: cat, SAFE_SQL_NTS(cat), ! 3700: schema, SAFE_SQL_NTS(schema), ! 3701: name, SAFE_SQL_NTS(name), ! 3702: unique, ! 3703: reserved); ! 3704: ! 3705: if (rc == SQL_ERROR) { ! 3706: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLStatistics"); ! 3707: efree(result); ! 3708: RETURN_FALSE; ! 3709: } ! 3710: ! 3711: result->numparams = 0; ! 3712: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3713: ! 3714: if (result->numcols > 0) { ! 3715: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3716: efree(result); ! 3717: RETURN_FALSE; ! 3718: } ! 3719: } else { ! 3720: result->values = NULL; ! 3721: } ! 3722: result->conn_ptr = conn; ! 3723: result->fetched = 0; ! 3724: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3725: } ! 3726: /* }}} */ ! 3727: ! 3728: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP) ! 3729: /* {{{ proto resource odbc_tableprivileges(resource connection_id, string qualifier, string owner, string name) ! 3730: Returns a result identifier containing a list of tables and the privileges associated with each table */ ! 3731: PHP_FUNCTION(odbc_tableprivileges) ! 3732: { ! 3733: zval *pv_conn; ! 3734: odbc_result *result = NULL; ! 3735: odbc_connection *conn; ! 3736: char *cat = NULL, *schema = NULL, *table = NULL; ! 3737: int cat_len = 0, schema_len, table_len; ! 3738: RETCODE rc; ! 3739: ! 3740: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!ss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &table, &table_len) == FAILURE) { ! 3741: return; ! 3742: } ! 3743: ! 3744: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); ! 3745: ! 3746: result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); ! 3747: ! 3748: rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); ! 3749: if (rc == SQL_INVALID_HANDLE) { ! 3750: efree(result); ! 3751: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'"); ! 3752: RETURN_FALSE; ! 3753: } ! 3754: ! 3755: if (rc == SQL_ERROR) { ! 3756: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt"); ! 3757: efree(result); ! 3758: RETURN_FALSE; ! 3759: } ! 3760: ! 3761: rc = SQLTablePrivileges(result->stmt, ! 3762: cat, SAFE_SQL_NTS(cat), ! 3763: schema, SAFE_SQL_NTS(schema), ! 3764: table, SAFE_SQL_NTS(table)); ! 3765: ! 3766: if (rc == SQL_ERROR) { ! 3767: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTablePrivileges"); ! 3768: efree(result); ! 3769: RETURN_FALSE; ! 3770: } ! 3771: ! 3772: result->numparams = 0; ! 3773: SQLNumResultCols(result->stmt, &(result->numcols)); ! 3774: ! 3775: if (result->numcols > 0) { ! 3776: if (!odbc_bindcols(result TSRMLS_CC)) { ! 3777: efree(result); ! 3778: RETURN_FALSE; ! 3779: } ! 3780: } else { ! 3781: result->values = NULL; ! 3782: } ! 3783: result->conn_ptr = conn; ! 3784: result->fetched = 0; ! 3785: ZEND_REGISTER_RESOURCE(return_value, result, le_result); ! 3786: } ! 3787: /* }}} */ ! 3788: #endif /* HAVE_DBMAKER */ ! 3789: ! 3790: #endif /* HAVE_UODBC */ ! 3791: ! 3792: /* ! 3793: * Local variables: ! 3794: * tab-width: 4 ! 3795: * c-basic-offset: 4 ! 3796: * End: ! 3797: * vim600: sw=4 ts=4 fdm=marker ! 3798: * vim<600: sw=4 ts=4 ! 3799: */