Annotation of embedaddon/php/ext/sybase_ct/php_sybase_ct.c, revision 1.1.1.1
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: Zeev Suraski <zeev@zend.com> |
16: | Tom May <tom@go2net.com> |
17: | Timm Friebe <php_sybase_ct@thekid.de> |
18: +----------------------------------------------------------------------+
19: */
20:
21: /* $Id: php_sybase_ct.c 321634 2012-01-01 13:15:04Z felipe $ */
22:
23:
24: #ifdef HAVE_CONFIG_H
25: #include "config.h"
26: #endif
27:
28: #include "php.h"
29: #include "php_sybase_ct.h"
30: #include "ext/standard/php_standard.h"
31: #include "ext/standard/info.h"
32: #include "php_globals.h"
33: #include "php_ini.h"
34:
35: /* True globals, no need for thread safety */
36: static int le_link, le_plink, le_result;
37:
38: #if HAVE_SYBASE_CT
39:
40: ZEND_DECLARE_MODULE_GLOBALS(sybase)
41: static PHP_GINIT_FUNCTION(sybase);
42: static PHP_GSHUTDOWN_FUNCTION(sybase);
43:
44: /* {{{ arginfo */
45: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_connect, 0, 0, 0)
46: ZEND_ARG_INFO(0, host)
47: ZEND_ARG_INFO(0, user)
48: ZEND_ARG_INFO(0, password)
49: ZEND_ARG_INFO(0, charset)
50: ZEND_ARG_INFO(0, appname)
51: ZEND_ARG_INFO(0, new)
52: ZEND_END_ARG_INFO()
53:
54: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_pconnect, 0, 0, 0)
55: ZEND_ARG_INFO(0, host)
56: ZEND_ARG_INFO(0, user)
57: ZEND_ARG_INFO(0, password)
58: ZEND_ARG_INFO(0, charset)
59: ZEND_ARG_INFO(0, appname)
60: ZEND_END_ARG_INFO()
61:
62: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_close, 0, 0, 0)
63: ZEND_ARG_INFO(0, link_id)
64: ZEND_END_ARG_INFO()
65:
66: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_select_db, 0, 0, 1)
67: ZEND_ARG_INFO(0, database)
68: ZEND_ARG_INFO(0, link_id)
69: ZEND_END_ARG_INFO()
70:
71: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_query, 0, 0, 1)
72: ZEND_ARG_INFO(0, query)
73: ZEND_ARG_INFO(0, link_id)
74: ZEND_END_ARG_INFO()
75:
76: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_unbuffered_query, 0, 0, 1)
77: ZEND_ARG_INFO(0, query)
78: ZEND_ARG_INFO(0, link_id)
79: ZEND_END_ARG_INFO()
80:
81: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_free_result, 0, 0, 1)
82: ZEND_ARG_INFO(0, result)
83: ZEND_END_ARG_INFO()
84:
85: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_get_last_message, 0, 0, 1)
86: ZEND_ARG_INFO(0, d)
87: ZEND_END_ARG_INFO()
88:
89: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_num_rows, 0, 0, 1)
90: ZEND_ARG_INFO(0, result)
91: ZEND_END_ARG_INFO()
92:
93: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_num_fields, 0, 0, 1)
94: ZEND_ARG_INFO(0, result)
95: ZEND_END_ARG_INFO()
96:
97: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_fetch_row, 0, 0, 1)
98: ZEND_ARG_INFO(0, result)
99: ZEND_END_ARG_INFO()
100:
101: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_fetch_object, 0, 0, 1)
102: ZEND_ARG_INFO(0, result)
103: ZEND_ARG_INFO(0, object)
104: ZEND_END_ARG_INFO()
105:
106: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_fetch_array, 0, 0, 1)
107: ZEND_ARG_INFO(0, result)
108: ZEND_END_ARG_INFO()
109:
110: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_fetch_assoc, 0, 0, 1)
111: ZEND_ARG_INFO(0, result)
112: ZEND_END_ARG_INFO()
113:
114: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_data_seek, 0, 0, 2)
115: ZEND_ARG_INFO(0, result)
116: ZEND_ARG_INFO(0, offset)
117: ZEND_END_ARG_INFO()
118:
119: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_fetch_field, 0, 0, 1)
120: ZEND_ARG_INFO(0, result)
121: ZEND_ARG_INFO(0, offset)
122: ZEND_END_ARG_INFO()
123:
124: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_field_seek, 0, 0, 2)
125: ZEND_ARG_INFO(0, result)
126: ZEND_ARG_INFO(0, offset)
127: ZEND_END_ARG_INFO()
128:
129: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_result, 0, 0, 3)
130: ZEND_ARG_INFO(0, result)
131: ZEND_ARG_INFO(0, row)
132: ZEND_ARG_INFO(0, field)
133: ZEND_END_ARG_INFO()
134:
135: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_affected_rows, 0, 0, 0)
136: ZEND_ARG_INFO(0, link_id)
137: ZEND_END_ARG_INFO()
138:
139: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_min_client_severity, 0, 0, 1)
140: ZEND_ARG_INFO(0, severity)
141: ZEND_END_ARG_INFO()
142:
143: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_min_server_severity, 0, 0, 1)
144: ZEND_ARG_INFO(0, severity)
145: ZEND_END_ARG_INFO()
146:
147: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_deadlock_retry_count, 0, 0, 1)
148: ZEND_ARG_INFO(0, retry_count)
149: ZEND_END_ARG_INFO()
150:
151: ZEND_BEGIN_ARG_INFO_EX(arginfo_sybase_set_message_handler, 0, 0, 1)
152: ZEND_ARG_INFO(0, error_func)
153: ZEND_ARG_INFO(0, connection)
154: ZEND_END_ARG_INFO()
155: /* }}} */
156:
157: const zend_function_entry sybase_functions[] = {
158: PHP_FE(sybase_connect, arginfo_sybase_connect)
159: PHP_FE(sybase_pconnect, arginfo_sybase_pconnect)
160: PHP_FE(sybase_close, arginfo_sybase_close)
161: PHP_FE(sybase_select_db, arginfo_sybase_select_db)
162: PHP_FE(sybase_query, arginfo_sybase_query)
163: PHP_FE(sybase_unbuffered_query, arginfo_sybase_unbuffered_query)
164: PHP_FE(sybase_free_result, arginfo_sybase_free_result)
165: PHP_FE(sybase_get_last_message, arginfo_sybase_get_last_message)
166: PHP_FE(sybase_num_rows, arginfo_sybase_num_rows)
167: PHP_FE(sybase_num_fields, arginfo_sybase_num_fields)
168: PHP_FE(sybase_fetch_row, arginfo_sybase_fetch_row)
169: PHP_FE(sybase_fetch_array, arginfo_sybase_fetch_array)
170: PHP_FE(sybase_fetch_assoc, arginfo_sybase_fetch_assoc)
171: PHP_FE(sybase_fetch_object, arginfo_sybase_fetch_object)
172: PHP_FE(sybase_data_seek, arginfo_sybase_data_seek)
173: PHP_FE(sybase_fetch_field, arginfo_sybase_fetch_field)
174: PHP_FE(sybase_field_seek, arginfo_sybase_field_seek)
175: PHP_FE(sybase_result, arginfo_sybase_result)
176: PHP_FE(sybase_affected_rows, arginfo_sybase_affected_rows)
177: PHP_FE(sybase_min_client_severity, arginfo_sybase_min_client_severity)
178: PHP_FE(sybase_min_server_severity, arginfo_sybase_min_server_severity)
179: PHP_FE(sybase_set_message_handler, arginfo_sybase_set_message_handler)
180: PHP_FE(sybase_deadlock_retry_count, arginfo_sybase_deadlock_retry_count)
181:
182: #if !defined(PHP_WIN32) && !defined(HAVE_MSSQL)
183: PHP_FALIAS(mssql_connect, sybase_connect, arginfo_sybase_connect)
184: PHP_FALIAS(mssql_pconnect, sybase_pconnect, arginfo_sybase_pconnect)
185: PHP_FALIAS(mssql_close, sybase_close, arginfo_sybase_close)
186: PHP_FALIAS(mssql_select_db, sybase_select_db, arginfo_sybase_select_db)
187: PHP_FALIAS(mssql_query, sybase_query, arginfo_sybase_query)
188: PHP_FALIAS(mssql_unbuffered_query, sybase_unbuffered_query, arginfo_sybase_unbuffered_query)
189: PHP_FALIAS(mssql_free_result, sybase_free_result, arginfo_sybase_free_result)
190: PHP_FALIAS(mssql_get_last_message, sybase_get_last_message, arginfo_sybase_get_last_message)
191: PHP_FALIAS(mssql_num_rows, sybase_num_rows, arginfo_sybase_num_rows)
192: PHP_FALIAS(mssql_num_fields, sybase_num_fields, arginfo_sybase_num_fields)
193: PHP_FALIAS(mssql_fetch_row, sybase_fetch_row, arginfo_sybase_fetch_row)
194: PHP_FALIAS(mssql_fetch_array, sybase_fetch_array, arginfo_sybase_fetch_array)
195: PHP_FALIAS(mssql_fetch_assoc, sybase_fetch_assoc, arginfo_sybase_fetch_assoc)
196: PHP_FALIAS(mssql_fetch_object, sybase_fetch_object, arginfo_sybase_fetch_object)
197: PHP_FALIAS(mssql_data_seek, sybase_data_seek, arginfo_sybase_data_seek)
198: PHP_FALIAS(mssql_fetch_field, sybase_fetch_field, arginfo_sybase_fetch_field)
199: PHP_FALIAS(mssql_field_seek, sybase_field_seek, arginfo_sybase_field_seek)
200: PHP_FALIAS(mssql_result, sybase_result, arginfo_sybase_result)
201: PHP_FALIAS(mssql_affected_rows, sybase_affected_rows, arginfo_sybase_affected_rows)
202: PHP_FALIAS(mssql_min_client_severity, sybase_min_client_severity, arginfo_sybase_min_client_severity)
203: PHP_FALIAS(mssql_min_server_severity, sybase_min_server_severity, arginfo_sybase_min_server_severity)
204: PHP_FALIAS(mssql_set_message_handler, sybase_set_message_handler, arginfo_sybase_set_message_handler)
205: PHP_FALIAS(mssql_deadlock_retry_count, sybase_deadlock_retry_count, arginfo_sybase_deadlock_retry_count)
206: #endif
207: PHP_FE_END
208: };
209:
210: zend_module_entry sybase_module_entry = {
211: STANDARD_MODULE_HEADER,
212: "sybase_ct",
213: sybase_functions,
214: PHP_MINIT(sybase),
215: PHP_MSHUTDOWN(sybase),
216: PHP_RINIT(sybase),
217: PHP_RSHUTDOWN(sybase),
218: PHP_MINFO(sybase),
219: NO_VERSION_YET,
220: PHP_MODULE_GLOBALS(sybase),
221: PHP_GINIT(sybase),
222: PHP_GSHUTDOWN(sybase),
223: NULL,
224: STANDARD_MODULE_PROPERTIES_EX
225: };
226:
227: /* static CS_CONTEXT *context; */
228:
229: #ifdef COMPILE_DL_SYBASE_CT
230: ZEND_GET_MODULE(sybase)
231: #endif
232:
233: ZEND_DECLARE_MODULE_GLOBALS(sybase)
234:
235: #define CHECK_LINK(link) { if (link==-1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: A link to the server could not be established"); RETURN_FALSE; } }
236:
237:
238: static int _clean_invalid_results(zend_rsrc_list_entry *le TSRMLS_DC)
239: {
240: if (Z_TYPE_P(le) == le_result) {
241: sybase_link *sybase_ptr = ((sybase_result *) le->ptr)->sybase_ptr;
242:
243: if (!sybase_ptr->valid) {
244: return 1;
245: }
246: }
247: return 0;
248: }
249:
250: #define efree_n(x) { efree(x); x = NULL; }
251: #define efree_if(x) if (x) efree_n(x)
252:
253: #ifdef PHP_SYBASE_DEBUG
254: #define FREE_SYBASE_RESULT(result) \
255: if (result) { \
256: fprintf(stderr, "_free_sybase_result(%p) called from line #%d\n", result, __LINE__); \
257: fflush(stderr); \
258: _free_sybase_result(result); \
259: result = NULL; \
260: }
261: #else
262: #define FREE_SYBASE_RESULT(result) \
263: if (result) { \
264: _free_sybase_result(result); \
265: result = NULL; \
266: }
267: #endif
268: static void _free_sybase_result(sybase_result *result)
269: {
270: int i, j;
271:
272: if (result->data) {
273: for (i = 0; i < (result->store ? result->num_rows : MIN(1, result->num_rows)); i++) {
274: for (j=0; j<result->num_fields; j++) {
275: zval_dtor(&result->data[i][j]);
276: }
277: efree(result->data[i]);
278: }
279: efree(result->data);
280: }
281:
282: if (result->fields) {
283: for (i=0; i<result->num_fields; i++) {
284: STR_FREE(result->fields[i].name);
285: STR_FREE(result->fields[i].column_source);
286: }
287: efree(result->fields);
288: }
289:
290: if (result->tmp_buffer) {
291: for (i=0; i<result->num_fields; i++) {
292: efree(result->tmp_buffer[i]);
293: }
294: efree(result->tmp_buffer);
295: }
296:
297: efree_if(result->lengths);
298: efree_if(result->indicators);
299: efree_if(result->datafmt);
300: efree_if(result->numerics);
301: efree_if(result->types);
302:
303: efree(result);
304: }
305:
306: /* Forward declaration */
307: static int php_sybase_finish_results (sybase_result *result TSRMLS_DC);
308:
309: static void php_free_sybase_result(zend_rsrc_list_entry *rsrc TSRMLS_DC)
310: {
311: sybase_result *result = (sybase_result *)rsrc->ptr;
312:
313: /* Check to see if we've read all rows */
314: if (result->sybase_ptr && result->sybase_ptr->active_result_index) {
315: if (result->sybase_ptr->cmd) {
316: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_ALL);
317: }
318: php_sybase_finish_results(result TSRMLS_CC);
319: }
320:
321: FREE_SYBASE_RESULT(result);
322: }
323:
324: static void _close_sybase_link(zend_rsrc_list_entry *rsrc TSRMLS_DC)
325: {
326: sybase_link *sybase_ptr = (sybase_link *)rsrc->ptr;
327: CS_INT con_status;
328:
329: sybase_ptr->valid = 0;
330: if (sybase_ptr->callback_name != NULL) {
331: zval_ptr_dtor(&sybase_ptr->callback_name);
332: sybase_ptr->callback_name= NULL;
333: }
334: zend_hash_apply(&EG(regular_list), (apply_func_t) _clean_invalid_results TSRMLS_CC);
335:
336: /* Non-persistent connections will always be connected or we wouldn't
337: * get here, but since we want to check the death status anyway
338: * we might as well double-check the connect status.
339: */
340: if (ct_con_props(sybase_ptr->connection, CS_GET, CS_CON_STATUS,
341: &con_status, CS_UNUSED, NULL)!=CS_SUCCEED) {
342: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to get connection status on close");
343: /* Assume the worst. */
344: con_status = CS_CONSTAT_CONNECTED | CS_CONSTAT_DEAD;
345: }
346: if (con_status & CS_CONSTAT_CONNECTED) {
347: if ((con_status & CS_CONSTAT_DEAD) || ct_close(sybase_ptr->connection, CS_UNUSED)!=CS_SUCCEED) {
348: ct_close(sybase_ptr->connection, CS_FORCE_CLOSE);
349: }
350: }
351:
352: ct_cmd_drop(sybase_ptr->cmd);
353: ct_con_drop(sybase_ptr->connection);
354: efree(sybase_ptr);
355: SybCtG(num_links)--;
356: }
357:
358:
359: static void _close_sybase_plink(zend_rsrc_list_entry *rsrc TSRMLS_DC)
360: {
361: sybase_link *sybase_ptr = (sybase_link *)rsrc->ptr;
362: CS_INT con_status;
363:
364: /* Persistent connections may have been closed before a failed
365: * reopen attempt.
366: */
367: if (ct_con_props(sybase_ptr->connection, CS_GET, CS_CON_STATUS,
368: &con_status, CS_UNUSED, NULL)!=CS_SUCCEED) {
369: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to get connection status on close");
370: /* Assume the worst. */
371: con_status = CS_CONSTAT_CONNECTED | CS_CONSTAT_DEAD;
372: }
373: if (con_status & CS_CONSTAT_CONNECTED) {
374: if ((con_status & CS_CONSTAT_DEAD) || ct_close(sybase_ptr->connection, CS_UNUSED)!=CS_SUCCEED) {
375: ct_close(sybase_ptr->connection, CS_FORCE_CLOSE);
376: }
377: }
378:
379: ct_con_drop(sybase_ptr->connection);
380: free(sybase_ptr);
381: SybCtG(num_persistent)--;
382: SybCtG(num_links)--;
383: }
384:
385:
386: static CS_RETCODE CS_PUBLIC _client_message_handler(CS_CONTEXT *context, CS_CONNECTION *connection, CS_CLIENTMSG *errmsg)
387: {
388: TSRMLS_FETCH();
389:
390: if (CS_SEVERITY(errmsg->msgnumber) >= SybCtG(min_client_severity)) {
391: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Client message: %s (severity %ld)", errmsg->msgstring, (long)CS_SEVERITY(errmsg->msgnumber));
392: }
393: STR_FREE(SybCtG(server_message));
394: SybCtG(server_message) = estrdup(errmsg->msgstring);
395:
396:
397: /* If this is a timeout message, return CS_FAIL to cancel the
398: * operation and mark the connection as dead.
399: */
400: if (CS_SEVERITY(errmsg->msgnumber) == CS_SV_RETRY_FAIL &&
401: CS_NUMBER(errmsg->msgnumber) == 63 &&
402: CS_ORIGIN(errmsg->msgnumber) == 2 &&
403: CS_LAYER(errmsg->msgnumber) == 1)
404: {
405: return CS_FAIL;
406: }
407:
408: return CS_SUCCEED;
409: }
410:
411: static int _call_message_handler(zval *callback_name, CS_SERVERMSG *srvmsg TSRMLS_DC)
412: {
413: int handled = 0;
414: zval *msgnumber, *severity, *state, *line, *text, *retval = NULL;
415: zval **args[5];
416:
417: /* Border case - empty fcall */
418: if (NULL == callback_name) return 0;
419:
420: /* Build arguments */
421: MAKE_STD_ZVAL(msgnumber);
422: ZVAL_LONG(msgnumber, srvmsg->msgnumber);
423: args[0] = &msgnumber;
424:
425: MAKE_STD_ZVAL(severity);
426: ZVAL_LONG(severity, srvmsg->severity);
427: args[1] = &severity;
428:
429: MAKE_STD_ZVAL(state);
430: ZVAL_LONG(state, srvmsg->state);
431: args[2] = &state;
432:
433: MAKE_STD_ZVAL(line);
434: ZVAL_LONG(line, srvmsg->line);
435: args[3] = &line;
436:
437: MAKE_STD_ZVAL(text);
438: ZVAL_STRING(text, srvmsg->text, 1);
439: args[4] = &text;
440:
441: if (call_user_function_ex(EG(function_table), NULL, callback_name, &retval, 5, args, 0, NULL TSRMLS_CC) == FAILURE) {
442: zval expr_copy;
443: int use_copy;
444:
445: zend_make_printable_zval(callback_name, &expr_copy, &use_copy);
446: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Cannot call the messagehandler %s", Z_STRVAL(expr_copy));
447: zval_dtor(&expr_copy);
448: }
449:
450: if (retval) {
451: handled = ((Z_TYPE_P(retval) != IS_BOOL) || (Z_BVAL_P(retval) != 0));
452: zval_ptr_dtor(&retval);
453: } else {
454: handled = 0;
455: }
456:
457: zval_ptr_dtor(&msgnumber);
458: zval_ptr_dtor(&severity);
459: zval_ptr_dtor(&state);
460: zval_ptr_dtor(&line);
461: zval_ptr_dtor(&text);
462:
463: return handled;
464: }
465:
466: static CS_RETCODE CS_PUBLIC _server_message_handler(CS_CONTEXT *context, CS_CONNECTION *connection, CS_SERVERMSG *srvmsg)
467: {
468: sybase_link *sybase;
469: int handled = 0;
470: TSRMLS_FETCH();
471:
472: /* Remember the last server message in any case */
473: STR_FREE(SybCtG(server_message));
474: SybCtG(server_message) = estrdup(srvmsg->text);
475:
476: /* Retrieve sybase link */
477: if (ct_con_props(connection, CS_GET, CS_USERDATA, &sybase, CS_SIZEOF(sybase), NULL) != CS_SUCCEED) {
478: sybase = NULL;
479: }
480:
481: /* If this is a deadlock message, set the connection's deadlock flag
482: * so we will retry the request. Sorry about the bare constant here,
483: * but it's not defined anywhere and it's a "well-known" number.
484: */
485: if (sybase && (srvmsg->msgnumber == 1205)) {
486: sybase->deadlock = 1;
487: }
488:
489: /* Check mininum server severity level */
490: if (srvmsg->severity < SybCtG(min_server_severity)) {
491: return CS_SUCCEED;
492: }
493:
494: /* Call global message handler */
495: handled = handled | _call_message_handler(SybCtG(callback_name), srvmsg TSRMLS_CC);
496:
497: /* Call link specific message handler */
498: if (sybase) {
499: handled = handled | _call_message_handler(sybase->callback_name, srvmsg TSRMLS_CC);
500: }
501:
502: /* Spit out a warning if neither of them has handled this message */
503: if (!handled) {
504: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Server message: %s (severity %ld, procedure %s)",
505: srvmsg->text, (long)srvmsg->severity, ((srvmsg->proclen>0) ? srvmsg->proc : "N/A"));
506: }
507:
508: return CS_SUCCEED;
509: }
510:
511:
512: PHP_INI_BEGIN()
513: STD_PHP_INI_BOOLEAN("sybct.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateLong, allow_persistent, zend_sybase_globals, sybase_globals)
514: STD_PHP_INI_ENTRY_EX("sybct.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_persistent, zend_sybase_globals, sybase_globals, display_link_numbers)
515: STD_PHP_INI_ENTRY_EX("sybct.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_links, zend_sybase_globals, sybase_globals, display_link_numbers)
516: STD_PHP_INI_ENTRY("sybct.min_server_severity", "10", PHP_INI_ALL, OnUpdateLong, min_server_severity, zend_sybase_globals, sybase_globals)
517: STD_PHP_INI_ENTRY("sybct.min_client_severity", "10", PHP_INI_ALL, OnUpdateLong, min_client_severity, zend_sybase_globals, sybase_globals)
518: STD_PHP_INI_ENTRY("sybct.login_timeout", "-1", PHP_INI_ALL, OnUpdateLong, login_timeout, zend_sybase_globals, sybase_globals)
519: STD_PHP_INI_ENTRY("sybct.hostname", NULL, PHP_INI_ALL, OnUpdateString, hostname, zend_sybase_globals, sybase_globals)
520: STD_PHP_INI_ENTRY_EX("sybct.deadlock_retry_count", "0", PHP_INI_ALL, OnUpdateLong, deadlock_retry_count, zend_sybase_globals, sybase_globals, display_link_numbers)
521: PHP_INI_END()
522:
523:
524: static PHP_GINIT_FUNCTION(sybase)
525: {
526: long opt;
527:
528: if (cs_ctx_alloc(CTLIB_VERSION, &sybase_globals->context)!=CS_SUCCEED || ct_init(sybase_globals->context, CTLIB_VERSION)!=CS_SUCCEED) {
529: return;
530: }
531:
532: /* Initialize message handlers */
533: if (ct_callback(sybase_globals->context, NULL, CS_SET, CS_SERVERMSG_CB, (CS_VOID *)_server_message_handler)!=CS_SUCCEED) {
534: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to set server message handler");
535: }
536:
537: if (ct_callback(sybase_globals->context, NULL, CS_SET, CS_CLIENTMSG_CB, (CS_VOID *)_client_message_handler)!=CS_SUCCEED) {
538: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to set client message handler");
539: }
540:
541: /* Set datetime conversion format to "Nov 3 1998 8:06PM".
542: * This is the default format for the ct-lib that comes with
543: * Sybase ASE 11.5.1 for Solaris, but the Linux libraries that
544: * come with 11.0.3.3 default to "03/11/98" which is singularly
545: * useless. This levels the playing field for all platforms.
546: */
547: {
548: CS_INT dt_convfmt = CS_DATES_SHORT;
549: if (cs_dt_info(sybase_globals->context, CS_SET, NULL, CS_DT_CONVFMT, CS_UNUSED, &dt_convfmt, sizeof(dt_convfmt), NULL)!=CS_SUCCEED) {
550: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to set datetime conversion format");
551: }
552: }
553:
554: /* Set the timeout, which is per context and can't be set with
555: * ct_con_props(), so set it globally from the config value if
556: * requested. The default is CS_NO_LIMIT.
557: *
558: * Note that despite some noise in the documentation about using
559: * signals to implement timeouts, they are actually implemented
560: * by using poll() or select() on Solaris and Linux.
561: */
562: if (cfg_get_long("sybct.timeout", &opt)==SUCCESS) {
563: CS_INT cs_timeout = opt;
564: if (ct_config(sybase_globals->context, CS_SET, CS_TIMEOUT, &cs_timeout, CS_UNUSED, NULL)!=CS_SUCCEED) {
565: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to update the timeout");
566: }
567: }
568:
569: sybase_globals->num_persistent=0;
570: sybase_globals->callback_name = NULL;
571: }
572:
573:
574: static PHP_GSHUTDOWN_FUNCTION(sybase)
575: {
576: ct_exit(sybase_globals->context, CS_UNUSED);
577: cs_ctx_drop(sybase_globals->context);
578: }
579:
580: PHP_MINIT_FUNCTION(sybase)
581: {
582: REGISTER_INI_ENTRIES();
583:
584: le_link = zend_register_list_destructors_ex(_close_sybase_link, NULL, "sybase-ct link", module_number);
585: le_plink = zend_register_list_destructors_ex(NULL, _close_sybase_plink, "sybase-ct link persistent", module_number);
586: le_result = zend_register_list_destructors_ex(php_free_sybase_result, NULL, "sybase-ct result", module_number);
587:
588: return SUCCESS;
589: }
590:
591:
592:
593: PHP_RINIT_FUNCTION(sybase)
594: {
595: SybCtG(default_link)=-1;
596: SybCtG(num_links) = SybCtG(num_persistent);
597: SybCtG(appname) = estrndup("PHP " PHP_VERSION, sizeof("PHP " PHP_VERSION));
598: SybCtG(server_message) = STR_EMPTY_ALLOC();
599: return SUCCESS;
600: }
601:
602:
603:
604: PHP_MSHUTDOWN_FUNCTION(sybase)
605: {
606: UNREGISTER_INI_ENTRIES();
607: #if 0
608: ct_exit(context, CS_UNUSED);
609: cs_ctx_drop(context);
610: #endif
611: return SUCCESS;
612: }
613:
614:
615: PHP_RSHUTDOWN_FUNCTION(sybase)
616: {
617: efree(SybCtG(appname));
618: SybCtG(appname) = NULL;
619: if (SybCtG(callback_name)) {
620: zval_ptr_dtor(&SybCtG(callback_name));
621: SybCtG(callback_name)= NULL;
622: }
623: STR_FREE(SybCtG(server_message));
624: SybCtG(server_message) = NULL;
625: return SUCCESS;
626: }
627:
628:
629: static int php_sybase_do_connect_internal(sybase_link *sybase, char *host, char *user, char *passwd, char *charset, char *appname TSRMLS_DC)
630: {
631: CS_LOCALE *tmp_locale;
632: long packetsize;
633:
634: /* set a CS_CONNECTION record */
635: if (ct_con_alloc(SybCtG(context), &sybase->connection)!=CS_SUCCEED) {
636: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to allocate connection record");
637: return 0;
638: }
639:
640: /* Note - this saves a copy of sybase, not a pointer to it. */
641: if (ct_con_props(sybase->connection, CS_SET, CS_USERDATA, &sybase, CS_SIZEOF(sybase), NULL)!=CS_SUCCEED) {
642: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to set userdata");
643: ct_con_drop(sybase->connection);
644: return 0;
645: }
646:
647: if (user) {
648: ct_con_props(sybase->connection, CS_SET, CS_USERNAME, user, CS_NULLTERM, NULL);
649: }
650: if (passwd) {
651: ct_con_props(sybase->connection, CS_SET, CS_PASSWORD, passwd, CS_NULLTERM, NULL);
652: }
653: if (appname) {
654: ct_con_props(sybase->connection, CS_SET, CS_APPNAME, appname, CS_NULLTERM, NULL);
655: } else {
656: ct_con_props(sybase->connection, CS_SET, CS_APPNAME, SybCtG(appname), CS_NULLTERM, NULL);
657: }
658:
659: if (SybCtG(hostname)) {
660: ct_con_props(sybase->connection, CS_SET, CS_HOSTNAME, SybCtG(hostname), CS_NULLTERM, NULL);
661: }
662:
663: if (charset) {
664: if (cs_loc_alloc(SybCtG(context), &tmp_locale)!=CS_SUCCEED) {
665: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to allocate locale information");
666: } else {
667: if (cs_locale(SybCtG(context), CS_SET, tmp_locale, CS_LC_ALL, NULL, CS_NULLTERM, NULL)!=CS_SUCCEED) {
668: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to load default locale data");
669: } else {
670: if (cs_locale(SybCtG(context), CS_SET, tmp_locale, CS_SYB_CHARSET, charset, CS_NULLTERM, NULL)!=CS_SUCCEED) {
671: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to update character set");
672: } else {
673: if (ct_con_props(sybase->connection, CS_SET, CS_LOC_PROP, tmp_locale, CS_UNUSED, NULL)!=CS_SUCCEED) {
674: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to update connection properties");
675: }
676: }
677: }
678: }
679: }
680:
681: if (cfg_get_long("sybct.packet_size", &packetsize) == SUCCESS) {
682: if (ct_con_props(sybase->connection, CS_SET, CS_PACKETSIZE, (CS_VOID *)&packetsize, CS_UNUSED, NULL) != CS_SUCCEED) {
683: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to update connection packetsize");
684: }
685: }
686:
687: /* Set the login timeout. Actually, the login timeout is per context
688: * and not per connection, but we will update the context here to
689: * allow for code such as the following:
690: *
691: * ini_set('sybct.login_timeout', $timeout);
692: * sybase_connect(...)
693: *
694: * Note that preceding calls to sybase_connect() will now use the
695: * updated value and not the default one!
696: *
697: * The default value for CS_LOGIN_TIMEOUT is 60 (1 minute).
698: */
699: if (SybCtG(login_timeout) != -1) {
700: CS_INT cs_login_timeout = SybCtG(login_timeout);
701: if (ct_config(SybCtG(context), CS_SET, CS_LOGIN_TIMEOUT, &cs_login_timeout, CS_UNUSED, NULL)!=CS_SUCCEED) {
702: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to update the login timeout");
703: }
704: }
705:
706: sybase->valid = 1;
707: sybase->dead = 0;
708: sybase->active_result_index = 0;
709: sybase->callback_name = NULL;
710:
711: /* create the link */
712: if (ct_connect(sybase->connection, host, CS_NULLTERM)!=CS_SUCCEED) {
713: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to connect");
714: ct_con_drop(sybase->connection);
715: return 0;
716: }
717:
718: if (ct_cmd_alloc(sybase->connection, &sybase->cmd)!=CS_SUCCEED) {
719: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to allocate command record");
720: ct_close(sybase->connection, CS_UNUSED);
721: ct_con_drop(sybase->connection);
722: return 0;
723: }
724:
725: return 1;
726: }
727:
728:
729: static void php_sybase_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
730: {
731: char *user = NULL, *passwd = NULL, *host = NULL, *charset = NULL, *appname = NULL;
732: char *hashed_details;
733: int hashed_details_length, len;
734: zend_bool new = 0;
735: sybase_link *sybase_ptr;
736:
737: host= user= passwd= charset= appname= NULL;
738: if (persistent) {
739: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!s!s!s!", &host, &len, &user, &len, &passwd, &len, &charset, &len, &appname, &len) == FAILURE) {
740: return;
741: }
742: } else {
743: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!s!s!s!b", &host, &len, &user, &len, &passwd, &len, &charset, &len, &appname, &len, &new) == FAILURE) {
744: return;
745: }
746: }
747: hashed_details_length = spprintf(
748: &hashed_details,
749: 0,
750: "sybase_%s_%s_%s_%s_%s",
751: host ? host : "",
752: user ? user : "",
753: passwd ? passwd : "",
754: charset ? charset : "",
755: appname ? appname : ""
756: );
757:
758: if (!SybCtG(allow_persistent)) {
759: persistent=0;
760: }
761: if (persistent) {
762: zend_rsrc_list_entry *le;
763:
764: /* try to find if we already have this link in our persistent list */
765: if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_length+1, (void **) &le)==FAILURE) { /* we don't */
766: zend_rsrc_list_entry new_le;
767:
768: if (SybCtG(max_links)!=-1 && SybCtG(num_links)>=SybCtG(max_links)) {
769: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Too many open links (%ld)", SybCtG(num_links));
770: efree(hashed_details);
771: RETURN_FALSE;
772: }
773: if (SybCtG(max_persistent)!=-1 && SybCtG(num_persistent)>=SybCtG(max_persistent)) {
774: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Too many open persistent links (%ld)", SybCtG(num_persistent));
775: efree(hashed_details);
776: RETURN_FALSE;
777: }
778:
779: sybase_ptr = (sybase_link *) malloc(sizeof(sybase_link));
780: if (!sybase_ptr) {
781: efree(hashed_details);
782: RETURN_FALSE;
783: }
784: if (!php_sybase_do_connect_internal(sybase_ptr, host, user, passwd, charset, appname TSRMLS_CC)) {
785: free(sybase_ptr);
786: efree(hashed_details);
787: RETURN_FALSE;
788: }
789:
790: /* hash it up */
791: Z_TYPE(new_le) = le_plink;
792: new_le.ptr = sybase_ptr;
793: if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_details_length+1, (void *) &new_le, sizeof(zend_rsrc_list_entry), NULL)==FAILURE) {
794: ct_close(sybase_ptr->connection, CS_UNUSED);
795: ct_con_drop(sybase_ptr->connection);
796: free(sybase_ptr);
797: efree(hashed_details);
798: RETURN_FALSE;
799: }
800: SybCtG(num_persistent)++;
801: SybCtG(num_links)++;
802: } else { /* we do */
803: CS_INT con_status;
804:
805: if (Z_TYPE_P(le) != le_plink) {
806: efree(hashed_details);
807: RETURN_FALSE;
808: }
809:
810: sybase_ptr = (sybase_link *) le->ptr;
811:
812: /* If the link has died, close it and overwrite it with a new one. */
813:
814: if (ct_con_props(sybase_ptr->connection, CS_GET, CS_CON_STATUS,
815: &con_status, CS_UNUSED, NULL)!=CS_SUCCEED) {
816: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Unable to get connection status");
817: efree(hashed_details);
818: RETURN_FALSE;
819: }
820: if (!(con_status & CS_CONSTAT_CONNECTED) || (con_status & CS_CONSTAT_DEAD) || sybase_ptr->dead) {
821: sybase_link sybase;
822:
823: if (con_status & CS_CONSTAT_CONNECTED) {
824: ct_close(sybase_ptr->connection, CS_FORCE_CLOSE);
825: }
826: /* Create a new connection, then replace the old
827: * connection. If we fail to create a new connection,
828: * put the old one back so there will be a connection,
829: * even if it is a non-functional one. This is because
830: * code may still be holding an id for this connection
831: * so we can't free the CS_CONNECTION.
832: * (This is actually totally hokey, it would be better
833: * to just ct_con_drop() the connection and set
834: * sybase_ptr->connection to NULL, then test it for
835: * NULL before trying to use it elsewhere . . .)
836: */
837: memcpy(&sybase, sybase_ptr, sizeof(sybase_link));
838: if (!php_sybase_do_connect_internal(sybase_ptr, host, user, passwd, charset, appname TSRMLS_CC)) {
839: memcpy(sybase_ptr, &sybase, sizeof(sybase_link));
840: efree(hashed_details);
841: RETURN_FALSE;
842: }
843: ct_con_drop(sybase.connection); /* drop old connection */
844: }
845: }
846: ZEND_REGISTER_RESOURCE(return_value, sybase_ptr, le_plink);
847: } else { /* non persistent */
848: zend_rsrc_list_entry *index_ptr, new_index_ptr;
849:
850: /* first we check the hash for the hashed_details key. if it exists,
851: * it should point us to the right offset where the actual sybase link sits.
852: * if it doesn't, open a new sybase link, add it to the resource list,
853: * and add a pointer to it with hashed_details as the key.
854: */
855: if (!new && zend_hash_find(&EG(regular_list), hashed_details, hashed_details_length+1, (void **) &index_ptr)==SUCCESS) {
856: int type, link;
857: void *ptr;
858:
859: if (Z_TYPE_P(index_ptr) != le_index_ptr) {
860: efree(hashed_details);
861: RETURN_FALSE;
862: }
863: link = (int) index_ptr->ptr;
864: ptr = zend_list_find(link, &type); /* check if the link is still there */
865: if (ptr && (type==le_link || type==le_plink)) {
866: zend_list_addref(link);
867: Z_LVAL_P(return_value) = SybCtG(default_link) = link;
868: Z_TYPE_P(return_value) = IS_RESOURCE;
869: efree(hashed_details);
870: return;
871: } else {
872: zend_hash_del(&EG(regular_list), hashed_details, hashed_details_length+1);
873: }
874: }
875: if (SybCtG(max_links)!=-1 && SybCtG(num_links)>=SybCtG(max_links)) {
876: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Too many open links (%ld)", SybCtG(num_links));
877: efree(hashed_details);
878: RETURN_FALSE;
879: }
880:
881: sybase_ptr = (sybase_link *) emalloc(sizeof(sybase_link));
882: if (!php_sybase_do_connect_internal(sybase_ptr, host, user, passwd, charset, appname TSRMLS_CC)) {
883: efree(sybase_ptr);
884: efree(hashed_details);
885: RETURN_FALSE;
886: }
887:
888: /* add it to the list */
889: ZEND_REGISTER_RESOURCE(return_value, sybase_ptr, le_link);
890:
891: /* add it to the hash */
892: new_index_ptr.ptr = (void *) Z_LVAL_P(return_value);
893: Z_TYPE(new_index_ptr) = le_index_ptr;
894: if (zend_hash_update(&EG(regular_list), hashed_details, hashed_details_length+1, (void *) &new_index_ptr, sizeof(zend_rsrc_list_entry), NULL)==FAILURE) {
895: ct_close(sybase_ptr->connection, CS_UNUSED);
896: ct_con_drop(sybase_ptr->connection);
897: efree(sybase_ptr);
898: efree(hashed_details);
899: RETURN_FALSE;
900: }
901: SybCtG(num_links)++;
902: }
903: efree(hashed_details);
904: SybCtG(default_link)=Z_LVAL_P(return_value);
905: zend_list_addref(SybCtG(default_link));
906: }
907:
908:
909: static int php_sybase_get_default_link(INTERNAL_FUNCTION_PARAMETERS)
910: {
911: if (SybCtG(default_link)==-1) { /* no link opened yet, implicitly open one */
912: ht = 0;
913: php_sybase_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
914: }
915: return SybCtG(default_link);
916: }
917:
918:
919: /* {{{ proto int sybase_connect([string host [, string user [, string password [, string charset [, string appname [, bool new]]]]]])
920: Open Sybase server connection */
921: PHP_FUNCTION(sybase_connect)
922: {
923: php_sybase_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
924: }
925:
926: /* }}} */
927:
928: /* {{{ proto int sybase_pconnect([string host [, string user [, string password [, string charset [, string appname]]]]])
929: Open persistent Sybase connection */
930: PHP_FUNCTION(sybase_pconnect)
931: {
932: php_sybase_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
933: }
934:
935: /* }}} */
936:
937: inline static int php_sybase_connection_id(zval *sybase_link_index, int *id TSRMLS_DC)
938: {
939: if (NULL == sybase_link_index) {
940: if (-1 == SybCtG(default_link)) {
941: return FAILURE;
942: }
943: *id = SybCtG(default_link);
944: } else {
945: *id = -1; /* explicit resource number */
946: }
947: return SUCCESS;
948: }
949:
950: /* {{{ proto bool sybase_close([resource link_id])
951: Close Sybase connection */
952: PHP_FUNCTION(sybase_close)
953: {
954: zval *sybase_link_index = NULL;
955: sybase_link *sybase_ptr;
956: int id;
957:
958: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &sybase_link_index) == FAILURE) {
959: return;
960: }
961:
962: if (php_sybase_connection_id(sybase_link_index, &id TSRMLS_CC) == FAILURE) {
963: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: No connection to close");
964: RETURN_FALSE;
965: }
966:
967: ZEND_FETCH_RESOURCE2(sybase_ptr, sybase_link *, &sybase_link_index, id, "Sybase-Link", le_link, le_plink);
968:
969: if (id == -1) {
970: zend_list_delete(Z_RESVAL_P(sybase_link_index));
971: }
972: if (id != -1 || (sybase_link_index && Z_RESVAL_P(sybase_link_index) == SybCtG(default_link))) {
973: zend_list_delete(SybCtG(default_link));
974: SybCtG(default_link) = -1;
975: }
976:
977: RETURN_TRUE;
978: }
979:
980: /* }}} */
981:
982:
983: static int exec_cmd(sybase_link *sybase_ptr, char *cmdbuf)
984: {
985: CS_RETCODE retcode;
986: CS_INT restype;
987: int failure=0;
988:
989: /* Fail if we already marked this connection dead. */
990:
991: if (sybase_ptr->dead) {
992: return FAILURE;
993: }
994:
995: /*
996: ** Get a command handle, store the command string in it, and
997: ** send it to the server.
998: */
999:
1000: if (ct_command(sybase_ptr->cmd, CS_LANG_CMD, cmdbuf, CS_NULLTERM, CS_UNUSED)!=CS_SUCCEED) {
1001: sybase_ptr->dead = 1;
1002: return FAILURE;
1003: }
1004: if (ct_send(sybase_ptr->cmd)!=CS_SUCCEED) {
1005: sybase_ptr->dead = 1;
1006: return FAILURE;
1007: }
1008:
1009: while ((retcode = ct_results(sybase_ptr->cmd, &restype))==CS_SUCCEED) {
1010: switch ((int) restype) {
1011: case CS_CMD_SUCCEED:
1012: case CS_CMD_DONE:
1013: break;
1014:
1015: case CS_CMD_FAIL:
1016: failure=1;
1017: break;
1018:
1019: case CS_STATUS_RESULT:
1020: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_CURRENT);
1021: break;
1022:
1023: default:
1024: failure=1;
1025: break;
1026: }
1027: if (failure) {
1028: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1029: return FAILURE;
1030: }
1031: }
1032:
1033: switch (retcode) {
1034: case CS_END_RESULTS:
1035: return SUCCESS;
1036: break;
1037:
1038: case CS_FAIL:
1039: /* Hopefully this either cleans up the connection, or the
1040: * connection ends up marked dead so it will be reopened
1041: * if it is persistent. We may want to do
1042: * ct_close(CS_FORCE_CLOSE) if ct_cancel() fails; see the
1043: * doc for ct_results()==CS_FAIL.
1044: */
1045: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1046: /* Don't take chances with the vagaries of ct-lib. Mark it
1047: * dead ourselves.
1048: */
1049: sybase_ptr->dead = 1;
1050: return FAILURE;
1051:
1052: default:
1053: return FAILURE;
1054: }
1055: }
1056:
1057:
1058: /* {{{ proto bool sybase_select_db(string database [, resource link_id])
1059: Select Sybase database */
1060: PHP_FUNCTION(sybase_select_db)
1061: {
1062: zval *sybase_link_index = NULL;
1063: char *db, *cmdbuf;
1064: int id, len;
1065: sybase_link *sybase_ptr;
1066:
1067: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &db, &len, &sybase_link_index) == FAILURE) {
1068: return;
1069: }
1070:
1071: if (php_sybase_connection_id(sybase_link_index, &id TSRMLS_CC) == FAILURE) {
1072: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: No connection");
1073: RETURN_FALSE;
1074: }
1075:
1076: ZEND_FETCH_RESOURCE2(sybase_ptr, sybase_link *, &sybase_link_index, id, "Sybase-Link", le_link, le_plink);
1077:
1078: spprintf(&cmdbuf, 4 + len + 1, "use %s", db);
1079: if (exec_cmd(sybase_ptr, cmdbuf) == FAILURE) {
1080: efree(cmdbuf);
1081: RETURN_FALSE;
1082: } else {
1083: efree(cmdbuf);
1084: RETURN_TRUE;
1085: }
1086: }
1087:
1088: /* }}} */
1089:
1090: static int php_sybase_finish_results(sybase_result *result TSRMLS_DC)
1091: {
1092: int i, fail;
1093: CS_RETCODE retcode;
1094: CS_INT restype;
1095:
1096: efree_n(result->datafmt);
1097: efree_n(result->lengths);
1098: efree_n(result->indicators);
1099: efree_n(result->numerics);
1100: efree_n(result->types);
1101: for (i=0; i<result->num_fields; i++) {
1102: efree(result->tmp_buffer[i]);
1103: }
1104: efree_n(result->tmp_buffer);
1105:
1106: /* Indicate we have read all rows */
1107: result->sybase_ptr->active_result_index= 0;
1108:
1109: /* The only restype we should get now is CS_CMD_DONE, possibly
1110: * followed by a CS_STATUS_RESULT/CS_CMD_SUCCEED/CS_CMD_DONE
1111: * sequence if the command was a stored procedure call. But we
1112: * still need to read and discard unexpected results. We might
1113: * want to return a failure in this case because the application
1114: * won't be getting all the results it asked for.
1115: */
1116: fail = 0;
1117: while ((retcode = ct_results(result->sybase_ptr->cmd, &restype))==CS_SUCCEED) {
1118: switch ((int) restype) {
1119: case CS_CMD_SUCCEED:
1120: case CS_CMD_DONE:
1121: break;
1122:
1123: case CS_CMD_FAIL:
1124: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Command failed, cancelling rest");
1125: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_ALL);
1126: fail = 1;
1127: break;
1128:
1129: case CS_COMPUTE_RESULT:
1130: case CS_CURSOR_RESULT:
1131: case CS_PARAM_RESULT:
1132: case CS_ROW_RESULT:
1133: /* Unexpected results, cancel them. */
1134: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Sybase: Unexpected results, cancelling current");
1135: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_CURRENT);
1136: break;
1137:
1138: case CS_STATUS_RESULT:
1139: /* Status result from a stored procedure, cancel it but do not tell user */
1140: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_CURRENT);
1141: break;
1142:
1143: default:
1144: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Sybase: Unexpected results, cancelling all");
1145: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_ALL);
1146: break;
1147: }
1148:
1149: if (fail) {
1150: break;
1151: }
1152: }
1153:
1154: switch (retcode) {
1155: case CS_END_RESULTS:
1156: /* Normal. */
1157: break;
1158:
1159: case CS_FAIL:
1160: /* Hopefully this either cleans up the connection, or the
1161: * connection ends up marked dead so it will be reopened
1162: * if it is persistent. We may want to do
1163: * ct_close(CS_FORCE_CLOSE) if ct_cancel() fails; see the
1164: * doc for ct_results()==CS_FAIL.
1165: */
1166: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_ALL);
1167: /* Don't take chances with the vagaries of ct-lib. Mark it
1168: * dead ourselves.
1169: */
1170: result->sybase_ptr->dead = 1;
1171:
1172: case CS_CANCELED:
1173: default:
1174: retcode = CS_FAIL;
1175: break;
1176: }
1177:
1178: return retcode;
1179: }
1180:
1181: #define RETURN_DOUBLE_VAL(result, buf, length) \
1182: if ((length - 1) <= EG(precision)) { \
1183: errno = 0; \
1184: Z_DVAL(result) = zend_strtod(buf, NULL); \
1185: if (errno != ERANGE) { \
1186: Z_TYPE(result) = IS_DOUBLE; \
1187: } else { \
1188: ZVAL_STRINGL(&result, buf, length- 1, 1); \
1189: } \
1190: } else { \
1191: ZVAL_STRINGL(&result, buf, length- 1, 1); \
1192: }
1193:
1194: static int php_sybase_fetch_result_row (sybase_result *result, int numrows)
1195: {
1196: int i, j;
1197: CS_INT retcode;
1198: TSRMLS_FETCH();
1199:
1200: /* We've already fetched everything */
1201: if (result->last_retcode == CS_END_DATA || result->last_retcode == CS_END_RESULTS) {
1202: return result->last_retcode;
1203: }
1204:
1205: if (numrows!=-1) numrows+= result->num_rows;
1206: while ((retcode=ct_fetch(result->sybase_ptr->cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, NULL))==CS_SUCCEED || retcode == CS_ROW_FAIL) {
1207: result->num_rows++;
1208: i= result->store ? result->num_rows- 1 : 0;
1209: if (i >= result->blocks_initialized*SYBASE_ROWS_BLOCK) {
1210: result->data = (zval **) safe_erealloc(result->data, SYBASE_ROWS_BLOCK*(++result->blocks_initialized), sizeof(zval *), 0);
1211: }
1212: if (result->store || 1 == result->num_rows) {
1213: result->data[i] = (zval *) safe_emalloc(sizeof(zval), result->num_fields, 0);
1214: }
1215:
1216: for (j = 0; j < result->num_fields; j++) {
1217:
1218: /* If we are in non-storing mode, free the previous result */
1219: if (!result->store && result->num_rows > 1 && Z_TYPE(result->data[i][j]) == IS_STRING) {
1220: efree(Z_STRVAL(result->data[i][j]));
1221: }
1222:
1223: if (result->indicators[j] == -1) { /* null value */
1224: ZVAL_NULL(&result->data[i][j]);
1225: } else {
1226: switch (result->numerics[j]) {
1227: case 1: {
1228: /* This indicates a long */
1229: ZVAL_LONG(&result->data[i][j], strtol(result->tmp_buffer[j], NULL, 10));
1230: break;
1231: }
1232:
1233: case 2: {
1234: /* This indicates a float */
1235: RETURN_DOUBLE_VAL(result->data[i][j], result->tmp_buffer[j], result->lengths[j]);
1236: break;
1237: }
1238:
1239: case 3: {
1240: /* This indicates either a long or a float, which ever fits */
1241: errno = 0;
1242: Z_LVAL(result->data[i][j]) = strtol(result->tmp_buffer[j], NULL, 10);
1243: if (errno == ERANGE) {
1244:
1245: /* An overflow occurred, so try to fit it into a double */
1246: RETURN_DOUBLE_VAL(result->data[i][j], result->tmp_buffer[j], result->lengths[j]);
1247: break;
1248: }
1249: Z_TYPE(result->data[i][j]) = IS_LONG;
1250: break;
1251: }
1252:
1253: default: {
1254: /* This indicates anything else, return it as string
1255: * FreeTDS doesn't correctly set result->indicators[j] correctly
1256: * for NULL fields in some version in conjunction with ASE 12.5
1257: * but instead sets result->lengths[j] to 0, which would lead to
1258: * a negative memory allocation (and thus a segfault).
1259: */
1260: if (result->lengths[j] < 1) {
1261: ZVAL_NULL(&result->data[i][j]);
1262: } else {
1263: ZVAL_STRINGL(&result->data[i][j], result->tmp_buffer[j], result->lengths[j]- 1, 1);
1264: }
1265: break;
1266: }
1267: }
1268: }
1269: }
1270: if (numrows!=-1 && result->num_rows>=numrows) break;
1271: }
1272:
1273: if (retcode==CS_ROW_FAIL) {
1274: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Error reading row %d", result->num_rows);
1275: return retcode;
1276: }
1277: result->last_retcode= retcode;
1278: switch (retcode) {
1279: case CS_END_DATA:
1280: retcode = php_sybase_finish_results(result TSRMLS_CC);
1281: break;
1282:
1283: case CS_ROW_FAIL:
1284: case CS_SUCCEED:
1285: break;
1286:
1287: default:
1288: FREE_SYBASE_RESULT(result);
1289: result = NULL;
1290: retcode = CS_FAIL; /* Just to be sure */
1291: break;
1292: }
1293:
1294: return retcode;
1295: }
1296:
1297: static sybase_result * php_sybase_fetch_result_set (sybase_link *sybase_ptr, int buffered, int store)
1298: {
1299: int num_fields;
1300: sybase_result *result;
1301: int i, j;
1302: CS_INT retcode;
1303:
1304: /* The following (if unbuffered) is more or less the equivalent of mysql_store_result().
1305: * fetch all rows from the server into the row buffer, thus:
1306: * 1) Being able to fire up another query without explicitly reading all rows
1307: * 2) Having numrows accessible
1308: */
1309: if (ct_res_info(sybase_ptr->cmd, CS_NUMDATA, &num_fields, CS_UNUSED, NULL)!=CS_SUCCEED) {
1310: return NULL;
1311: }
1312:
1313: result = (sybase_result *) emalloc(sizeof(sybase_result));
1314: result->data = (zval **) safe_emalloc(sizeof(zval *), SYBASE_ROWS_BLOCK, 0);
1315: result->fields = NULL;
1316: result->sybase_ptr = sybase_ptr;
1317: result->cur_field=result->cur_row=result->num_rows=0;
1318: result->num_fields = num_fields;
1319: result->last_retcode = 0;
1320: result->store= store;
1321: result->blocks_initialized= 1;
1322: result->tmp_buffer = (char **) safe_emalloc(sizeof(char *), num_fields, 0);
1323: result->lengths = (CS_INT *) safe_emalloc(sizeof(CS_INT), num_fields, 0);
1324: result->indicators = (CS_SMALLINT *) safe_emalloc(sizeof(CS_INT), num_fields, 0);
1325: result->datafmt = (CS_DATAFMT *) safe_emalloc(sizeof(CS_DATAFMT), num_fields, 0);
1326: result->numerics = (unsigned char *) safe_emalloc(sizeof(unsigned char), num_fields, 0);
1327: result->types = (CS_INT *) safe_emalloc(sizeof(CS_INT), num_fields, 0);
1328:
1329: for (i=0; i<num_fields; i++) {
1330: ct_describe(sybase_ptr->cmd, i+1, &result->datafmt[i]);
1331: result->types[i] = result->datafmt[i].datatype;
1332: switch (result->datafmt[i].datatype) {
1333: case CS_CHAR_TYPE:
1334: case CS_VARCHAR_TYPE:
1335: case CS_TEXT_TYPE:
1336: case CS_IMAGE_TYPE:
1337: result->datafmt[i].maxlength++;
1338: result->numerics[i] = 0;
1339: break;
1340: case CS_BINARY_TYPE:
1341: case CS_VARBINARY_TYPE:
1342: result->datafmt[i].maxlength *= 2;
1343: result->datafmt[i].maxlength++;
1344: result->numerics[i] = 0;
1345: break;
1346: case CS_BIT_TYPE:
1347: case CS_TINYINT_TYPE:
1348: result->datafmt[i].maxlength = 4;
1349: result->numerics[i] = 1;
1350: break;
1351: case CS_SMALLINT_TYPE:
1352: result->datafmt[i].maxlength = 7;
1353: result->numerics[i] = 1;
1354: break;
1355: case CS_INT_TYPE:
1356: result->datafmt[i].maxlength = 12;
1357: result->numerics[i] = 1;
1358: break;
1359: case CS_REAL_TYPE:
1360: case CS_FLOAT_TYPE:
1361: result->datafmt[i].maxlength = 24;
1362: result->numerics[i] = 2;
1363: break;
1364: case CS_MONEY_TYPE:
1365: case CS_MONEY4_TYPE:
1366: result->datafmt[i].maxlength = 24;
1367: result->numerics[i] = 2;
1368: break;
1369: case CS_DATETIME_TYPE:
1370: case CS_DATETIME4_TYPE:
1371: result->datafmt[i].maxlength = 30;
1372: result->numerics[i] = 0;
1373: break;
1374: case CS_NUMERIC_TYPE:
1375: case CS_DECIMAL_TYPE:
1376: result->datafmt[i].maxlength = result->datafmt[i].precision + 3;
1377: /* numeric(10) vs numeric(10, 1) */
1378: result->numerics[i] = (result->datafmt[i].scale == 0) ? 3 : 2;
1379: break;
1380: default:
1381: result->datafmt[i].maxlength++;
1382: result->numerics[i] = 0;
1383: break;
1384: }
1385: result->tmp_buffer[i] = (char *)emalloc(result->datafmt[i].maxlength);
1386: result->datafmt[i].datatype = CS_CHAR_TYPE;
1387: result->datafmt[i].format = CS_FMT_NULLTERM;
1388: ct_bind(sybase_ptr->cmd, i+1, &result->datafmt[i], result->tmp_buffer[i], &result->lengths[i], &result->indicators[i]);
1389: }
1390:
1391: result->fields = (sybase_field *) safe_emalloc(sizeof(sybase_field), num_fields, 0);
1392: j=0;
1393: for (i=0; i<num_fields; i++) {
1394: char computed_buf[16];
1395:
1396: if (result->datafmt[i].namelen>0) {
1397: result->fields[i].name = estrndup(result->datafmt[i].name, result->datafmt[i].namelen);
1398: } else {
1399: if (j>0) {
1400: snprintf(computed_buf, 16, "computed%d", j);
1401: } else {
1402: strcpy(computed_buf, "computed");
1403: }
1404: result->fields[i].name = estrdup(computed_buf);
1405: j++;
1406: }
1407: result->fields[i].column_source = STR_EMPTY_ALLOC();
1408: result->fields[i].max_length = result->datafmt[i].maxlength-1;
1409: result->fields[i].numeric = result->numerics[i];
1410: Z_TYPE(result->fields[i]) = result->types[i];
1411: }
1412:
1413: if (buffered) {
1414: retcode = CS_SUCCEED;
1415: } else {
1416: if ((retcode = php_sybase_fetch_result_row(result, -1)) == CS_FAIL) {
1417: return NULL;
1418: }
1419: }
1420:
1421: result->last_retcode = retcode;
1422: return result;
1423: }
1424:
1425: static void php_sybase_query (INTERNAL_FUNCTION_PARAMETERS, int buffered)
1426: {
1427: zval *sybase_link_index = NULL;
1428: zend_bool store = 1;
1429: char *query;
1430: int len, id, deadlock_count;
1431: sybase_link *sybase_ptr;
1432: sybase_result *result;
1433: CS_INT restype;
1434: CS_RETCODE retcode;
1435: enum {
1436: Q_RESULT, /* Success with results. */
1437: Q_SUCCESS, /* Success but no results. */
1438: Q_FAILURE, /* Failure, no results. */
1439: } status;
1440:
1441: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|rb", &query, &len, &sybase_link_index, &store) == FAILURE) {
1442: return;
1443: }
1444:
1445: if (!store && !buffered) {
1446: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Sybase: Cannot use non-storing mode with buffered queries");
1447: store = 1;
1448: }
1449:
1450: if (php_sybase_connection_id(sybase_link_index, &id TSRMLS_CC) == FAILURE) {
1451: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: No connection");
1452: RETURN_FALSE;
1453: }
1454:
1455: ZEND_FETCH_RESOURCE2(sybase_ptr, sybase_link *, &sybase_link_index, id, "Sybase-Link", le_link, le_plink);
1456:
1457: /* Fail if we already marked this connection dead. */
1458: if (sybase_ptr->dead) {
1459: RETURN_FALSE;
1460: }
1461:
1462: /* Check to see if a previous sybase_unbuffered_query has read all rows */
1463: if (sybase_ptr->active_result_index) {
1464: zval *tmp = NULL;
1465:
1466: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Sybase: Called without first fetching all rows from a previous unbuffered query");
1467: if (sybase_ptr->cmd) {
1468: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1469: }
1470:
1471: /* Get the resultset and free it */
1472: ALLOC_ZVAL(tmp);
1473: Z_LVAL_P(tmp)= sybase_ptr->active_result_index;
1474: Z_TYPE_P(tmp)= IS_RESOURCE;
1475: INIT_PZVAL(tmp);
1476: ZEND_FETCH_RESOURCE(result, sybase_result *, &tmp, -1, "Sybase result", le_result);
1477:
1478: if (result) {
1479: php_sybase_finish_results(result TSRMLS_CC);
1480: }
1481:
1482: zval_ptr_dtor(&tmp);
1483: zend_list_delete(sybase_ptr->active_result_index);
1484: sybase_ptr->active_result_index= 0;
1485: }
1486:
1487: /* Repeat until we don't deadlock. */
1488: deadlock_count= 0;
1489: for (;;) {
1490: result = NULL;
1491: sybase_ptr->deadlock = 0;
1492: sybase_ptr->affected_rows = 0;
1493:
1494: /* On Solaris 11.5, ct_command() can be moved outside the
1495: * loop, but not on Linux 11.0.
1496: */
1497: if (ct_command(sybase_ptr->cmd, CS_LANG_CMD, query, CS_NULLTERM, CS_UNUSED)!=CS_SUCCEED) {
1498: /* If this didn't work, the connection is screwed but
1499: * ct-lib might not set CS_CONSTAT_DEAD. So set our own
1500: * flag. This happens sometimes when the database is restarted
1501: * and/or its machine is rebooted, and ct_command() returns
1502: * CS_BUSY for some reason.
1503: */
1504: sybase_ptr->dead = 1;
1505: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Connection is dead");
1506: RETURN_FALSE;
1507: }
1508:
1509: if (ct_send(sybase_ptr->cmd)!=CS_SUCCEED) {
1510: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1511: sybase_ptr->dead = 1;
1512: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Cannot send command");
1513: RETURN_FALSE;
1514: }
1515:
1516: /* Use the first result set or succeed/fail status and discard the
1517: * others. Applications really shouldn't be making calls that
1518: * return multiple result sets, but if they do then we need to
1519: * properly read or cancel them or the connection will become
1520: * unusable.
1521: */
1522: if (ct_results(sybase_ptr->cmd, &restype)!=CS_SUCCEED) {
1523: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1524: sybase_ptr->dead = 1;
1525: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Cannot read results");
1526: RETURN_FALSE;
1527: }
1528: switch ((int) restype) {
1529: case CS_CMD_FAIL:
1530: default:
1531: status = Q_FAILURE;
1532: break;
1533: case CS_CMD_SUCCEED:
1534: case CS_CMD_DONE: {
1535: CS_INT row_count;
1536: if (ct_res_info(sybase_ptr->cmd, CS_ROW_COUNT, &row_count, CS_UNUSED, NULL)==CS_SUCCEED) {
1537: sybase_ptr->affected_rows = (long)row_count;
1538: }
1539: }
1540: /* Fall through */
1541: case CS_COMPUTEFMT_RESULT:
1542: case CS_ROWFMT_RESULT:
1543: case CS_DESCRIBE_RESULT:
1544: case CS_MSG_RESULT:
1545: buffered= 0; /* These queries have no need for buffering */
1546: status = Q_SUCCESS;
1547: break;
1548: case CS_COMPUTE_RESULT:
1549: case CS_CURSOR_RESULT:
1550: case CS_PARAM_RESULT:
1551: case CS_ROW_RESULT:
1552: case CS_STATUS_RESULT:
1553: result = php_sybase_fetch_result_set(sybase_ptr, buffered, store);
1554: if (result == NULL) {
1555: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1556: RETURN_FALSE;
1557: }
1558: status = Q_RESULT;
1559: break;
1560: }
1561:
1562: /* Check for left-over results */
1563: if (!buffered && status != Q_RESULT) {
1564: while ((retcode = ct_results(sybase_ptr->cmd, &restype))==CS_SUCCEED) {
1565: switch ((int) restype) {
1566: case CS_CMD_SUCCEED:
1567: case CS_CMD_DONE:
1568: break;
1569:
1570: case CS_CMD_FAIL:
1571: status = Q_FAILURE;
1572: break;
1573:
1574: case CS_COMPUTE_RESULT:
1575: case CS_CURSOR_RESULT:
1576: case CS_PARAM_RESULT:
1577: case CS_ROW_RESULT:
1578: if (status != Q_RESULT) {
1579: result = php_sybase_fetch_result_set(sybase_ptr, buffered, store);
1580: if (result == NULL) {
1581: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1582: sybase_ptr->dead = 1;
1583: RETURN_FALSE;
1584: }
1585: status = Q_RESULT;
1586: retcode = result->last_retcode;
1587: } else {
1588: /* Unexpected results, cancel them. */
1589: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_CURRENT);
1590: }
1591: break;
1592: case CS_STATUS_RESULT:
1593: /* Unexpected results, cancel them. */
1594: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_CURRENT);
1595: break;
1596:
1597: default:
1598: status = Q_FAILURE;
1599: break;
1600: }
1601: if (status == Q_FAILURE) {
1602: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1603: }
1604: if (retcode == CS_END_RESULTS) {
1605: break;
1606: }
1607: }
1608: switch (retcode) {
1609: case CS_END_RESULTS:
1610: /* Normal. */
1611: break;
1612:
1613: case CS_FAIL:
1614: /* Hopefully this either cleans up the connection, or the
1615: * connection ends up marked dead so it will be reopened
1616: * if it is persistent. We may want to do
1617: * ct_close(CS_FORCE_CLOSE) if ct_cancel() fails; see the
1618: * doc for ct_results()==CS_FAIL.
1619: */
1620: ct_cancel(NULL, sybase_ptr->cmd, CS_CANCEL_ALL);
1621: /* Don't take chances with the vagaries of ct-lib. Mark it
1622: * dead ourselves.
1623: */
1624: sybase_ptr->dead = 1;
1625: case CS_CANCELED:
1626: default:
1627: status = Q_FAILURE;
1628: break;
1629: }
1630: }
1631:
1632: /* Retry deadlocks up until deadlock_retry_count times */
1633: if (sybase_ptr->deadlock && SybCtG(deadlock_retry_count) != -1 && ++deadlock_count > SybCtG(deadlock_retry_count)) {
1634: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Retried deadlock %d times [max: %ld], giving up", deadlock_count- 1, SybCtG(deadlock_retry_count));
1635: FREE_SYBASE_RESULT(result);
1636: break;
1637: }
1638:
1639: /* If query completed without deadlock, break out of the loop.
1640: * Sometimes deadlock results in failures and sometimes not,
1641: * it seems to depend on the server flavor. But we want to
1642: * retry all deadlocks.
1643: */
1644: if (sybase_ptr->dead || sybase_ptr->deadlock == 0) {
1645: break;
1646: }
1647:
1648: /* Get rid of any results we may have fetched. This happens:
1649: * e.g., our result set may be a stored procedure status which
1650: * is returned even if the stored procedure deadlocks. As an
1651: * optimization, we could try not to fetch results in known
1652: * deadlock conditions, but deadlock is (should be) rare.
1653: */
1654: FREE_SYBASE_RESULT(result);
1655: }
1656:
1657: if (status == Q_SUCCESS) {
1658: RETURN_TRUE;
1659: }
1660:
1661: if (status == Q_FAILURE) {
1662: FREE_SYBASE_RESULT(result);
1663: RETURN_FALSE;
1664: }
1665:
1666: /* Indicate we have data in case of buffered queries */
1667: id= ZEND_REGISTER_RESOURCE(return_value, result, le_result);
1668: sybase_ptr->active_result_index= buffered ? id : 0;
1669: }
1670:
1671: /* {{{ proto int sybase_query(string query [, resource link_id])
1672: Send Sybase query */
1673: PHP_FUNCTION(sybase_query)
1674: {
1675: php_sybase_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1676: }
1677: /* }}} */
1678:
1679: /* {{{ proto int sybase_unbuffered_query(string query [, resource link_id])
1680: Send Sybase query */
1681: PHP_FUNCTION(sybase_unbuffered_query)
1682: {
1683: php_sybase_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1684: }
1685:
1686: /* {{{ proto bool sybase_free_result(resource result)
1687: Free result memory */
1688: PHP_FUNCTION(sybase_free_result)
1689: {
1690: zval *sybase_result_index = NULL;
1691: sybase_result *result;
1692:
1693: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &sybase_result_index) == FAILURE) {
1694: return;
1695: }
1696: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1697:
1698: /* Did we fetch up until the end? */
1699: if (result->last_retcode != CS_END_DATA && result->last_retcode != CS_END_RESULTS) {
1700: /* php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Cancelling the rest of the results"); */
1701: ct_cancel(NULL, result->sybase_ptr->cmd, CS_CANCEL_ALL);
1702: php_sybase_finish_results(result TSRMLS_CC);
1703: }
1704:
1705: zend_list_delete(Z_LVAL_P(sybase_result_index));
1706: RETURN_TRUE;
1707: }
1708:
1709: /* }}} */
1710:
1711: /* {{{ proto string sybase_get_last_message(void)
1712: Returns the last message from server (over min_message_severity) */
1713: PHP_FUNCTION(sybase_get_last_message)
1714: {
1715: RETURN_STRING(SybCtG(server_message), 1);
1716: }
1717: /* }}} */
1718:
1719: /* {{{ proto int sybase_num_rows(resource result)
1720: Get number of rows in result */
1721: PHP_FUNCTION(sybase_num_rows)
1722: {
1723: zval *sybase_result_index = NULL;
1724: sybase_result *result;
1725:
1726: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &sybase_result_index) == FAILURE) {
1727: return;
1728: }
1729: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1730:
1731: Z_LVAL_P(return_value) = result->num_rows;
1732: Z_TYPE_P(return_value) = IS_LONG;
1733: }
1734:
1735: /* }}} */
1736:
1737: /* {{{ proto int sybase_num_fields(resource result)
1738: Get number of fields in result */
1739: PHP_FUNCTION(sybase_num_fields)
1740: {
1741: zval *sybase_result_index = NULL;
1742: sybase_result *result;
1743:
1744: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &sybase_result_index) == FAILURE) {
1745: return;
1746: }
1747: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1748:
1749: Z_LVAL_P(return_value) = result->num_fields;
1750: Z_TYPE_P(return_value) = IS_LONG;
1751: }
1752:
1753: /* }}} */
1754:
1755: /* {{{ proto array sybase_fetch_row(resource result)
1756: Get row as enumerated array */
1757: PHP_FUNCTION(sybase_fetch_row)
1758: {
1759: zval *sybase_result_index = NULL;
1760: int i;
1761: sybase_result *result;
1762: zval *field_content;
1763:
1764: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &sybase_result_index) == FAILURE) {
1765: return;
1766: }
1767: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1768:
1769: /* Unbuffered? */
1770: if (result->last_retcode != CS_END_DATA && result->last_retcode != CS_END_RESULTS) {
1771: php_sybase_fetch_result_row(result, 1);
1772: }
1773:
1774: /* At the end? */
1775: if (result->cur_row >= result->num_rows) {
1776: RETURN_FALSE;
1777: }
1778:
1779: array_init(return_value);
1780: for (i=0; i<result->num_fields; i++) {
1781: ALLOC_ZVAL(field_content);
1782: *field_content = result->data[result->store ? result->cur_row : 0][i];
1783: INIT_PZVAL(field_content);
1784: zval_copy_ctor(field_content);
1785: zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &field_content, sizeof(zval* ), NULL);
1786: }
1787: result->cur_row++;
1788: }
1789:
1790: /* }}} */
1791:
1792: static void php_sybase_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int numerics)
1793: {
1794: zval *sybase_result_index = NULL;
1795: sybase_result *result;
1796: int i, j;
1797: zval *tmp;
1798: char name[32];
1799:
1800: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &sybase_result_index) == FAILURE) {
1801: return;
1802: }
1803: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1804:
1805: /* Unbuffered ? Fetch next row */
1806: if (result->last_retcode != CS_END_DATA && result->last_retcode != CS_END_RESULTS) {
1807: php_sybase_fetch_result_row(result, 1);
1808: }
1809:
1810: /* At the end? */
1811: if (result->cur_row >= result->num_rows) {
1812: RETURN_FALSE;
1813: }
1814:
1815: array_init(return_value);
1816:
1817: j= 1;
1818: for (i=0; i<result->num_fields; i++) {
1819: ALLOC_ZVAL(tmp);
1820: *tmp = result->data[result->store ? result->cur_row : 0][i];
1821: INIT_PZVAL(tmp);
1822: if (PG(magic_quotes_runtime) && Z_TYPE_P(tmp) == IS_STRING) {
1823: Z_STRVAL_P(tmp) = php_addslashes(Z_STRVAL_P(tmp), Z_STRLEN_P(tmp), &Z_STRLEN_P(tmp), 0 TSRMLS_CC);
1824: } else {
1825: zval_copy_ctor(tmp);
1826: }
1827: if (numerics) {
1828: zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &tmp, sizeof(zval *), NULL);
1829: Z_ADDREF_P(tmp);
1830: }
1831:
1832: if (zend_hash_exists(Z_ARRVAL_P(return_value), result->fields[i].name, strlen(result->fields[i].name)+1)) {
1833: snprintf(name, 32, "%s%d", result->fields[i].name, j);
1834: result->fields[i].name= estrdup(name);
1835: j++;
1836: }
1837: zend_hash_update(Z_ARRVAL_P(return_value), result->fields[i].name, strlen(result->fields[i].name)+1, (void *) &tmp, sizeof(zval *), NULL);
1838: }
1839: result->cur_row++;
1840: }
1841:
1842:
1843: /* {{{ proto object sybase_fetch_object(resource result [, mixed object])
1844: Fetch row as object */
1845: PHP_FUNCTION(sybase_fetch_object)
1846: {
1847: zval *object = NULL;
1848: zval *sybase_result_index = NULL;
1849: zend_class_entry *ce = NULL;
1850: sybase_result *result;
1851:
1852: /* Was a second parameter given? */
1853: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|z", &sybase_result_index, &object) == FAILURE) {
1854: return;
1855: }
1856: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1857:
1858: ce = ZEND_STANDARD_CLASS_DEF_PTR;
1859: if (NULL != object) {
1860: switch (Z_TYPE_P(object)) {
1861: case IS_OBJECT: {
1862: ce = Z_OBJCE_P(object);
1863: break;
1864: }
1865:
1866: case IS_NULL: {
1867: /* Use default (ZEND_STANDARD_CLASS_DEF_PTR) */
1868: break;
1869: }
1870:
1871: default: {
1872: zend_class_entry **pce = NULL;
1873: convert_to_string(object);
1874:
1875: if (zend_lookup_class(Z_STRVAL_P(object), Z_STRLEN_P(object), &pce TSRMLS_CC) == FAILURE) {
1876: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Sybase: Class %s has not been declared", Z_STRVAL_P(object));
1877: /* Use default (ZEND_STANDARD_CLASS_DEF_PTR) */
1878: } else {
1879: ce = *pce;
1880: }
1881: }
1882: }
1883: }
1884:
1885: /* Reset no. of arguments to 1 so that we can use INTERNAL_FUNCTION_PARAM_PASSTHRU */
1886: ht= 1;
1887: php_sybase_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1888: if (Z_TYPE_P(return_value) == IS_ARRAY) {
1889: object_and_properties_init(return_value, ce, Z_ARRVAL_P(return_value));
1890: }
1891: }
1892: /* }}} */
1893:
1894: /* {{{ proto array sybase_fetch_array(resource result)
1895: Fetch row as array */
1896: PHP_FUNCTION(sybase_fetch_array)
1897: {
1898: php_sybase_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1899: }
1900: /* }}} */
1901:
1902: /* {{{ proto array sybase_fetch_assoc(resource result)
1903: Fetch row as array without numberic indices */
1904: PHP_FUNCTION(sybase_fetch_assoc)
1905: {
1906: php_sybase_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1907: }
1908: /* }}} */
1909:
1910: /* {{{ proto bool sybase_data_seek(resource result, int offset)
1911: Move internal row pointer */
1912: PHP_FUNCTION(sybase_data_seek)
1913: {
1914: zval *sybase_result_index = NULL;
1915: long offset;
1916: sybase_result *result;
1917:
1918: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &sybase_result_index, &offset) == FAILURE) {
1919: return;
1920: }
1921: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1922:
1923: /* Unbuffered ? */
1924: if (result->last_retcode != CS_END_DATA && result->last_retcode != CS_END_RESULTS && offset >= result->num_rows) {
1925: php_sybase_fetch_result_row(result, offset+ 1);
1926: }
1927:
1928: if (offset < 0 || offset >= result->num_rows) {
1929: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Bad row offset %ld, must be betweem 0 and %d", offset, result->num_rows - 1);
1930: RETURN_FALSE;
1931: }
1932:
1933: result->cur_row = offset;
1934: RETURN_TRUE;
1935: }
1936: /* }}} */
1937:
1938: static char *php_sybase_get_field_name(CS_INT type)
1939: {
1940: switch (type) {
1941: case CS_CHAR_TYPE:
1942: case CS_VARCHAR_TYPE:
1943: case CS_TEXT_TYPE:
1944: return "string";
1945: break;
1946: case CS_IMAGE_TYPE:
1947: return "image";
1948: break;
1949: case CS_BINARY_TYPE:
1950: case CS_VARBINARY_TYPE:
1951: return "blob";
1952: break;
1953: case CS_BIT_TYPE:
1954: return "bit";
1955: break;
1956: case CS_TINYINT_TYPE:
1957: case CS_SMALLINT_TYPE:
1958: case CS_INT_TYPE:
1959: return "int";
1960: break;
1961: case CS_REAL_TYPE:
1962: case CS_FLOAT_TYPE:
1963: case CS_NUMERIC_TYPE:
1964: case CS_DECIMAL_TYPE:
1965: return "real";
1966: break;
1967: case CS_MONEY_TYPE:
1968: case CS_MONEY4_TYPE:
1969: return "money";
1970: break;
1971: case CS_DATETIME_TYPE:
1972: case CS_DATETIME4_TYPE:
1973: return "datetime";
1974: break;
1975: default:
1976: return "unknown";
1977: break;
1978: }
1979: }
1980:
1981:
1982: /* {{{ proto object sybase_fetch_field(resource result [, int offset])
1983: Get field information */
1984: PHP_FUNCTION(sybase_fetch_field)
1985: {
1986: zval *sybase_result_index = NULL;
1987: long field_offset = -1;
1988: sybase_result *result;
1989:
1990: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &sybase_result_index, &field_offset) == FAILURE) {
1991: return;
1992: }
1993: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
1994:
1995: if (field_offset == -1) {
1996: field_offset = result->cur_field;
1997: result->cur_field++;
1998: }
1999:
2000: if (field_offset < 0 || field_offset >= result->num_fields) {
2001: if (ZEND_NUM_ARGS() == 2) { /* field specified explicitly */
2002: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Bad column offset");
2003: }
2004: RETURN_FALSE;
2005: }
2006:
2007: object_init(return_value);
2008:
2009: add_property_string(return_value, "name", result->fields[field_offset].name, 1);
2010: add_property_long(return_value, "max_length", result->fields[field_offset].max_length);
2011: add_property_string(return_value, "column_source", result->fields[field_offset].column_source, 1);
2012: add_property_long(return_value, "numeric", result->fields[field_offset].numeric);
2013: add_property_string(return_value, "type", php_sybase_get_field_name(Z_TYPE(result->fields[field_offset])), 1);
2014: }
2015: /* }}} */
2016:
2017:
2018: /* {{{ proto bool sybase_field_seek(resource result, int offset)
2019: Set field offset */
2020: PHP_FUNCTION(sybase_field_seek)
2021: {
2022: zval *sybase_result_index = NULL;
2023: long field_offset;
2024: sybase_result *result;
2025:
2026: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &sybase_result_index, &field_offset) == FAILURE) {
2027: return;
2028: }
2029: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
2030:
2031: if (field_offset < 0 || field_offset >= result->num_fields) {
2032: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Bad column offset");
2033: RETURN_FALSE;
2034: }
2035:
2036: result->cur_field = field_offset;
2037: RETURN_TRUE;
2038: }
2039: /* }}} */
2040:
2041:
2042: /* {{{ proto string sybase_result(resource result, int row, mixed field)
2043: Get result data */
2044: PHP_FUNCTION(sybase_result)
2045: {
2046: zval *field;
2047: zval *sybase_result_index = NULL;
2048: long row;
2049: int field_offset = 0;
2050: sybase_result *result;
2051:
2052: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &sybase_result_index, &row, &field) == FAILURE) {
2053: return;
2054: }
2055: ZEND_FETCH_RESOURCE(result, sybase_result *, &sybase_result_index, -1, "Sybase result", le_result);
2056:
2057: /* Unbuffered ? */
2058: if (result->last_retcode != CS_END_DATA && result->last_retcode != CS_END_RESULTS && row >= result->num_rows) {
2059: php_sybase_fetch_result_row(result, row);
2060: }
2061:
2062: if (row < 0 || row >= result->num_rows) {
2063: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Bad row offset (%ld)", row);
2064: RETURN_FALSE;
2065: }
2066:
2067: switch(Z_TYPE_P(field)) {
2068: case IS_STRING: {
2069: int i;
2070:
2071: for (i = 0; i < result->num_fields; i++) {
2072: if (strcasecmp(result->fields[i].name, Z_STRVAL_P(field)) == 0) {
2073: field_offset = i;
2074: break;
2075: }
2076: }
2077: if (i >= result->num_fields) { /* no match found */
2078: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: %s field not found in result", Z_STRVAL_P(field));
2079: RETURN_FALSE;
2080: }
2081: break;
2082: }
2083: default:
2084: convert_to_long(field);
2085: field_offset = Z_LVAL_P(field);
2086: if (field_offset < 0 || field_offset >= result->num_fields) {
2087: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: Bad column offset specified");
2088: RETURN_FALSE;
2089: }
2090: break;
2091: }
2092:
2093: *return_value = result->data[row][field_offset];
2094: zval_copy_ctor(return_value);
2095: }
2096: /* }}} */
2097:
2098:
2099: /* {{{ proto int sybase_affected_rows([resource link_id])
2100: Get number of affected rows in last query */
2101: PHP_FUNCTION(sybase_affected_rows)
2102: {
2103: zval *sybase_link_index = NULL;
2104: sybase_link *sybase_ptr;
2105: int id;
2106:
2107: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &sybase_link_index) == FAILURE) {
2108: return;
2109: }
2110:
2111: if (php_sybase_connection_id(sybase_link_index, &id TSRMLS_CC) == FAILURE) {
2112: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Sybase: No connection");
2113: RETURN_FALSE;
2114: }
2115:
2116: ZEND_FETCH_RESOURCE2(sybase_ptr, sybase_link *, &sybase_link_index, id, "Sybase-Link", le_link, le_plink);
2117:
2118: Z_LVAL_P(return_value) = sybase_ptr->affected_rows;
2119: Z_TYPE_P(return_value) = IS_LONG;
2120: }
2121: /* }}} */
2122:
2123:
2124: PHP_MINFO_FUNCTION(sybase)
2125: {
2126: char buf[32];
2127:
2128: php_info_print_table_start();
2129: php_info_print_table_header(2, "Sybase_CT Support", "enabled" );
2130: snprintf(buf, sizeof(buf), "%ld", SybCtG(num_persistent));
2131: php_info_print_table_row(2, "Active Persistent Links", buf);
2132: snprintf(buf, sizeof(buf), "%ld", SybCtG(num_links));
2133: php_info_print_table_row(2, "Active Links", buf);
2134: snprintf(buf, sizeof(buf), "%ld", SybCtG(min_server_severity));
2135: php_info_print_table_row(2, "Min server severity", buf);
2136: snprintf(buf, sizeof(buf), "%ld", SybCtG(min_client_severity));
2137: php_info_print_table_row(2, "Min client severity", buf);
2138: php_info_print_table_row(2, "Application Name", SybCtG(appname));
2139: snprintf(buf, sizeof(buf), "%ld", SybCtG(deadlock_retry_count));
2140: php_info_print_table_row(2, "Deadlock retry count", buf);
2141: php_info_print_table_end();
2142:
2143: DISPLAY_INI_ENTRIES();
2144: }
2145:
2146:
2147: /* {{{ proto void sybase_min_client_severity(int severity)
2148: Sets minimum client severity */
2149: PHP_FUNCTION(sybase_min_client_severity)
2150: {
2151: long severity;
2152:
2153: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &severity) == FAILURE) {
2154: return;
2155: }
2156:
2157: SybCtG(min_client_severity) = severity;
2158: }
2159: /* }}} */
2160:
2161:
2162: /* {{{ proto void sybase_min_server_severity(int severity)
2163: Sets minimum server severity */
2164: PHP_FUNCTION(sybase_min_server_severity)
2165: {
2166: long severity;
2167:
2168: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &severity) == FAILURE) {
2169: return;
2170: }
2171:
2172: SybCtG(min_server_severity) = severity;
2173: }
2174: /* }}} */
2175:
2176: /* {{{ proto void sybase_deadlock_retry_count(int retry_count)
2177: Sets deadlock retry count */
2178: PHP_FUNCTION(sybase_deadlock_retry_count)
2179: {
2180: long retry_count;
2181:
2182: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &retry_count) == FAILURE) {
2183: return;
2184: }
2185:
2186: SybCtG(deadlock_retry_count) = retry_count;
2187: }
2188: /* }}} */
2189:
2190:
2191: /* {{{ proto bool sybase_set_message_handler(mixed error_func [, resource connection])
2192: Set the error handler, to be called when a server message is raised.
2193: If error_func is NULL the handler will be deleted */
2194: PHP_FUNCTION(sybase_set_message_handler)
2195: {
2196: zend_fcall_info fci = empty_fcall_info;
2197: zend_fcall_info_cache cache = empty_fcall_info_cache;
2198: zval *sybase_link_index= NULL;
2199: sybase_link *sybase_ptr;
2200: zval **callback;
2201: int id;
2202:
2203: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f!|r", &fci, &cache, &sybase_link_index) == FAILURE) {
2204: return;
2205: }
2206:
2207: if (php_sybase_connection_id(sybase_link_index, &id TSRMLS_CC) == FAILURE) {
2208:
2209: /* Doesn't matter if we're not connected yet, use default */
2210: callback= &SybCtG(callback_name);
2211: } else if (-1 == id) {
2212:
2213: /* Connection-based message handler */
2214: ZEND_FETCH_RESOURCE2(sybase_ptr, sybase_link *, &sybase_link_index, id, "Sybase-Link", le_link, le_plink);
2215: callback= &sybase_ptr->callback_name;
2216: } else {
2217:
2218: /* Default message handler */
2219: callback= &SybCtG(callback_name);
2220: }
2221:
2222: /* Clean old callback */
2223: if (*callback) {
2224: zval_ptr_dtor(callback);
2225: *callback = NULL;
2226: }
2227:
2228: if (ZEND_FCI_INITIALIZED(fci)) {
2229: ALLOC_ZVAL(*callback);
2230: **callback = *fci.function_name;
2231: INIT_PZVAL(*callback);
2232: zval_copy_ctor(*callback);
2233: } else {
2234: callback= NULL;
2235: }
2236:
2237: RETURN_TRUE;
2238: }
2239: /* }}} */
2240:
2241:
2242: #endif
2243:
2244: /*
2245: * Local variables:
2246: * tab-width: 4
2247: * c-basic-offset: 4
2248: * End:
2249: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_sybase_ct.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sybase_ct