1 /*
2   +----------------------------------------------------------------------+
3   | PHP Version 5                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2014 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   | Author: Ard Biesheuvel <abies@php.net>                               |
16   +----------------------------------------------------------------------+
17 */
18 
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22 
23 #define _GNU_SOURCE
24 
25 #include "php.h"
26 #ifdef ZEND_ENGINE_2
27 # include "zend_exceptions.h"
28 #endif
29 #include "php_ini.h"
30 #include "ext/standard/info.h"
31 #include "pdo/php_pdo.h"
32 #include "pdo/php_pdo_driver.h"
33 #include "php_pdo_firebird.h"
34 #include "php_pdo_firebird_int.h"
35 
36 static int firebird_alloc_prepare_stmt(pdo_dbh_t*, const char*, long, XSQLDA*, isc_stmt_handle*,
37 	HashTable* TSRMLS_DC);
38 
39 /* map driver specific error message to PDO error */
_firebird_error(pdo_dbh_t * dbh,pdo_stmt_t * stmt,char const * file,long line TSRMLS_DC)40 void _firebird_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, char const *file, long line TSRMLS_DC) /* {{{ */
41 {
42 #if 0
43 	pdo_firebird_db_handle *H = stmt ? ((pdo_firebird_stmt *)stmt->driver_data)->H
44 		: (pdo_firebird_db_handle *)dbh->driver_data;
45 #endif
46 	pdo_error_type *const error_code = stmt ? &stmt->error_code : &dbh->error_code;
47 
48 #if 0
49 	switch (isc_sqlcode(H->isc_status)) {
50 
51 		case 0:
52 			*error_code = PDO_ERR_NONE;
53 			break;
54 		default:
55 			*error_code = PDO_ERR_CANT_MAP;
56 			break;
57 		case -104:
58 			*error_code = PDO_ERR_SYNTAX;
59 			break;
60 		case -530:
61 		case -803:
62 			*error_code = PDO_ERR_CONSTRAINT;
63 			break;
64 		case -204:
65 		case -205:
66 		case -206:
67 		case -829:
68 			*error_code = PDO_ERR_NOT_FOUND;
69 			break;
70 
71 			*error_code = PDO_ERR_ALREADY_EXISTS;
72 			break;
73 
74 			*error_code = PDO_ERR_NOT_IMPLEMENTED;
75 			break;
76 		case -313:
77 		case -804:
78 			*error_code = PDO_ERR_MISMATCH;
79 			break;
80 		case -303:
81 		case -314:
82 		case -413:
83 			*error_code = PDO_ERR_TRUNCATED;
84 			break;
85 
86 			*error_code = PDO_ERR_DISCONNECTED;
87 			break;
88 	}
89 #else
90 	strcpy(*error_code, "HY000");
91 #endif
92 }
93 /* }}} */
94 
95 #define RECORD_ERROR(dbh) _firebird_error(dbh, NULL, __FILE__, __LINE__ TSRMLS_CC)
96 
97 /* called by PDO to close a db handle */
firebird_handle_closer(pdo_dbh_t * dbh TSRMLS_DC)98 static int firebird_handle_closer(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
99 {
100 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
101 
102 	if (dbh->in_txn) {
103 		if (dbh->auto_commit) {
104 			if (isc_commit_transaction(H->isc_status, &H->tr)) {
105 				RECORD_ERROR(dbh);
106 			}
107 		} else {
108 			if (isc_rollback_transaction(H->isc_status, &H->tr)) {
109 				RECORD_ERROR(dbh);
110 			}
111 		}
112 	}
113 
114 	if (isc_detach_database(H->isc_status, &H->db)) {
115 		RECORD_ERROR(dbh);
116 	}
117 
118 	if (H->date_format) {
119 		efree(H->date_format);
120 	}
121 	if (H->time_format) {
122 		efree(H->time_format);
123 	}
124 	if (H->timestamp_format) {
125 		efree(H->timestamp_format);
126 	}
127 
128 	pefree(H, dbh->is_persistent);
129 
130 	return 0;
131 }
132 /* }}} */
133 
134 /* called by PDO to prepare an SQL query */
firebird_handle_preparer(pdo_dbh_t * dbh,const char * sql,long sql_len,pdo_stmt_t * stmt,zval * driver_options TSRMLS_DC)135 static int firebird_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, /* {{{ */
136 	pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
137 {
138 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
139 	pdo_firebird_stmt *S = NULL;
140 	HashTable *np;
141 
142 	do {
143 		isc_stmt_handle s = NULL;
144 		XSQLDA num_sqlda;
145 		static char const info[] = { isc_info_sql_stmt_type };
146 		char result[8];
147 
148 		num_sqlda.version = PDO_FB_SQLDA_VERSION;
149 		num_sqlda.sqln = 1;
150 
151 		ALLOC_HASHTABLE(np);
152 		zend_hash_init(np, 8, NULL, NULL, 0);
153 
154 		/* allocate and prepare statement */
155 		if (!firebird_alloc_prepare_stmt(dbh, sql, sql_len, &num_sqlda, &s, np TSRMLS_CC)) {
156 			break;
157 		}
158 
159 		/* allocate a statement handle struct of the right size (struct out_sqlda is inlined) */
160 		S = ecalloc(1, sizeof(*S)-sizeof(XSQLDA) + XSQLDA_LENGTH(num_sqlda.sqld));
161 		S->H = H;
162 		S->stmt = s;
163 		S->fetch_buf = ecalloc(1,sizeof(char*) * num_sqlda.sqld);
164 		S->out_sqlda.version = PDO_FB_SQLDA_VERSION;
165 		S->out_sqlda.sqln = stmt->column_count = num_sqlda.sqld;
166 		S->named_params = np;
167 
168 		/* determine the statement type */
169 		if (isc_dsql_sql_info(H->isc_status, &s, sizeof(info), const_cast(info), sizeof(result),
170 				result)) {
171 			break;
172 		}
173 		S->statement_type = result[3];
174 
175 		/* fill the output sqlda with information about the prepared query */
176 		if (isc_dsql_describe(H->isc_status, &s, PDO_FB_SQLDA_VERSION, &S->out_sqlda)) {
177 			RECORD_ERROR(dbh);
178 			break;
179 		}
180 
181 		/* allocate the input descriptors */
182 		if (isc_dsql_describe_bind(H->isc_status, &s, PDO_FB_SQLDA_VERSION, &num_sqlda)) {
183 			break;
184 		}
185 
186 		if (num_sqlda.sqld) {
187 			S->in_sqlda = ecalloc(1,XSQLDA_LENGTH(num_sqlda.sqld));
188 			S->in_sqlda->version = PDO_FB_SQLDA_VERSION;
189 			S->in_sqlda->sqln = num_sqlda.sqld;
190 
191 			if (isc_dsql_describe_bind(H->isc_status, &s, PDO_FB_SQLDA_VERSION, S->in_sqlda)) {
192 				break;
193 			}
194 		}
195 
196 		stmt->driver_data = S;
197 		stmt->methods = &firebird_stmt_methods;
198 		stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL;
199 
200 		return 1;
201 
202 	} while (0);
203 
204 	RECORD_ERROR(dbh);
205 
206 	zend_hash_destroy(np);
207 	FREE_HASHTABLE(np);
208 
209 	if (S) {
210 		if (S->in_sqlda) {
211 			efree(S->in_sqlda);
212 		}
213 		efree(S);
214 	}
215 
216 	return 0;
217 }
218 /* }}} */
219 
220 /* called by PDO to execute a statement that doesn't produce a result set */
firebird_handle_doer(pdo_dbh_t * dbh,const char * sql,long sql_len TSRMLS_DC)221 static long firebird_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC) /* {{{ */
222 {
223 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
224 	isc_stmt_handle stmt = NULL;
225 	static char const info_count[] = { isc_info_sql_records };
226 	char result[64];
227 	int ret = 0;
228 	XSQLDA in_sqlda, out_sqlda;
229 
230 	/* TODO no placeholders in exec() for now */
231 	in_sqlda.version = out_sqlda.version = PDO_FB_SQLDA_VERSION;
232 	in_sqlda.sqld = out_sqlda.sqld = 0;
233 	out_sqlda.sqln = 1;
234 
235 	/* allocate and prepare statement */
236 	if (!firebird_alloc_prepare_stmt(dbh, sql, sql_len, &out_sqlda, &stmt, 0 TSRMLS_CC)) {
237 		return -1;
238 	}
239 
240 	/* execute the statement */
241 	if (isc_dsql_execute2(H->isc_status, &H->tr, &stmt, PDO_FB_SQLDA_VERSION, &in_sqlda, &out_sqlda)) {
242 		RECORD_ERROR(dbh);
243 		return -1;
244 	}
245 
246 	/* find out how many rows were affected */
247 	if (isc_dsql_sql_info(H->isc_status, &stmt, sizeof(info_count), const_cast(info_count),
248 			sizeof(result),	result)) {
249 		RECORD_ERROR(dbh);
250 		return -1;
251 	}
252 
253 	if (result[0] == isc_info_sql_records) {
254 		unsigned i = 3, result_size = isc_vax_integer(&result[1],2);
255 
256 		while (result[i] != isc_info_end && i < result_size) {
257 			short len = (short)isc_vax_integer(&result[i+1],2);
258 			if (result[i] != isc_info_req_select_count) {
259 				ret += isc_vax_integer(&result[i+3],len);
260 			}
261 			i += len+3;
262 		}
263 	}
264 
265 	/* commit if we're in auto_commit mode */
266 	if (dbh->auto_commit && isc_commit_retaining(H->isc_status, &H->tr)) {
267 		RECORD_ERROR(dbh);
268 	}
269 
270 	return ret;
271 }
272 /* }}} */
273 
274 /* called by the PDO SQL parser to add quotes to values that are copied into SQL */
firebird_handle_quoter(pdo_dbh_t * dbh,const char * unquoted,int unquotedlen,char ** quoted,int * quotedlen,enum pdo_param_type paramtype TSRMLS_DC)275 static int firebird_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, /* {{{ */
276 	char **quoted, int *quotedlen, enum pdo_param_type paramtype TSRMLS_DC)
277 {
278 	int qcount = 0;
279 	char const *co, *l, *r;
280 	char *c;
281 
282 	if (!unquotedlen) {
283 		*quotedlen = 2;
284 		*quoted = emalloc(*quotedlen+1);
285 		strcpy(*quoted, "''");
286 		return 1;
287 	}
288 
289 	/* Firebird only requires single quotes to be doubled if string lengths are used */
290 	/* count the number of ' characters */
291 	for (co = unquoted; (co = strchr(co,'\'')); qcount++, co++);
292 
293 	*quotedlen = unquotedlen + qcount + 2;
294 	*quoted = c = emalloc(*quotedlen+1);
295 	*c++ = '\'';
296 
297 	/* foreach (chunk that ends in a quote) */
298 	for (l = unquoted; (r = strchr(l,'\'')); l = r+1) {
299 		strncpy(c, l, r-l+1);
300 		c += (r-l+1);
301 		/* add the second quote */
302 		*c++ = '\'';
303 	}
304 
305 	/* copy the remainder */
306 	strncpy(c, l, *quotedlen-(c-*quoted)-1);
307 	(*quoted)[*quotedlen-1] = '\'';
308 	(*quoted)[*quotedlen]   = '\0';
309 
310 	return 1;
311 }
312 /* }}} */
313 
314 /* called by PDO to start a transaction */
firebird_handle_begin(pdo_dbh_t * dbh TSRMLS_DC)315 static int firebird_handle_begin(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
316 {
317 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
318 	char tpb[8] = { isc_tpb_version3 }, *ptpb = tpb+1;
319 #if abies_0
320 	if (dbh->transaction_flags & PDO_TRANS_ISOLATION_LEVEL) {
321 		if (dbh->transaction_flags & PDO_TRANS_READ_UNCOMMITTED) {
322 			/* this is a poor fit, but it's all we have */
323 			*ptpb++ = isc_tpb_read_committed;
324 			*ptpb++ = isc_tpb_rec_version;
325 			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_READ_UNCOMMITTED);
326 		} else if (dbh->transaction_flags & PDO_TRANS_READ_COMMITTED) {
327 			*ptpb++ = isc_tpb_read_committed;
328 			*ptpb++ = isc_tpb_no_rec_version;
329 			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_READ_COMMITTED);
330 		} else if (dbh->transaction_flags & PDO_TRANS_REPEATABLE_READ) {
331 			*ptpb++ = isc_tpb_concurrency;
332 			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_REPEATABLE_READ);
333 		} else {
334 			*ptpb++ = isc_tpb_consistency;
335 			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_SERIALIZABLE);
336 		}
337 	}
338 
339 	if (dbh->transaction_flags & PDO_TRANS_ACCESS_MODE) {
340 		if (dbh->transaction_flags & PDO_TRANS_READONLY) {
341 			*ptpb++ = isc_tpb_read;
342 			dbh->transaction_flags &= ~(PDO_TRANS_ACCESS_MODE^PDO_TRANS_READONLY);
343 		} else {
344 			*ptpb++ = isc_tpb_write;
345 			dbh->transaction_flags &= ~(PDO_TRANS_ACCESS_MODE^PDO_TRANS_READWRITE);
346 		}
347 	}
348 
349 	if (dbh->transaction_flags & PDO_TRANS_CONFLICT_RESOLUTION) {
350 		if (dbh->transaction_flags & PDO_TRANS_RETRY) {
351 			*ptpb++ = isc_tpb_wait;
352 			dbh->transaction_flags &= ~(PDO_TRANS_CONFLICT_RESOLUTION^PDO_TRANS_RETRY);
353 		} else {
354 			*ptpb++ = isc_tpb_nowait;
355 			dbh->transaction_flags &= ~(PDO_TRANS_CONFLICT_RESOLUTION^PDO_TRANS_ABORT);
356 		}
357 	}
358 #endif
359 	if (isc_start_transaction(H->isc_status, &H->tr, 1, &H->db, (unsigned short)(ptpb-tpb), tpb)) {
360 		RECORD_ERROR(dbh);
361 		return 0;
362 	}
363 	return 1;
364 }
365 /* }}} */
366 
367 /* called by PDO to commit a transaction */
firebird_handle_commit(pdo_dbh_t * dbh TSRMLS_DC)368 static int firebird_handle_commit(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
369 {
370 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
371 
372 	if (isc_commit_transaction(H->isc_status, &H->tr)) {
373 		RECORD_ERROR(dbh);
374 		return 0;
375 	}
376 	return 1;
377 }
378 /* }}} */
379 
380 /* called by PDO to rollback a transaction */
firebird_handle_rollback(pdo_dbh_t * dbh TSRMLS_DC)381 static int firebird_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
382 {
383 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
384 
385 	if (isc_rollback_transaction(H->isc_status, &H->tr)) {
386 		RECORD_ERROR(dbh);
387 		return 0;
388 	}
389 	return 1;
390 }
391 /* }}} */
392 
393 /* used by prepare and exec to allocate a statement handle and prepare the SQL */
firebird_alloc_prepare_stmt(pdo_dbh_t * dbh,const char * sql,long sql_len,XSQLDA * out_sqlda,isc_stmt_handle * s,HashTable * named_params TSRMLS_DC)394 static int firebird_alloc_prepare_stmt(pdo_dbh_t *dbh, const char *sql, long sql_len, /* {{{ */
395 	XSQLDA *out_sqlda, isc_stmt_handle *s, HashTable *named_params TSRMLS_DC)
396 {
397 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
398 	char *c, *new_sql, in_quote, in_param, pname[64], *ppname;
399 	long l, pindex = -1;
400 
401 	/* Firebird allows SQL statements up to 64k, so bail if it doesn't fit */
402 	if (sql_len > 65536) {
403 		strcpy(dbh->error_code, "01004");
404 		return 0;
405 	}
406 
407 	/* start a new transaction implicitly if auto_commit is enabled and no transaction is open */
408 	if (dbh->auto_commit && !dbh->in_txn) {
409 		/* dbh->transaction_flags = PDO_TRANS_READ_UNCOMMITTED; */
410 
411 		if (!firebird_handle_begin(dbh TSRMLS_CC)) {
412 			return 0;
413 		}
414 		dbh->in_txn = 1;
415 	}
416 
417 	/* allocate the statement */
418 	if (isc_dsql_allocate_statement(H->isc_status, &H->db, s)) {
419 		RECORD_ERROR(dbh);
420 		return 0;
421 	}
422 
423 	/* in order to support named params, which Firebird itself doesn't,
424 	   we need to replace :foo by ?, and store the name we just replaced */
425 	new_sql = c = emalloc(sql_len+1);
426 
427 	for (l = in_quote = in_param = 0; l <= sql_len; ++l) {
428 		if ( !(in_quote ^= (sql[l] == '\''))) {
429 			if (!in_param) {
430 				switch (sql[l]) {
431 					case ':':
432 						in_param = 1;
433 						ppname = pname;
434 						*ppname++ = sql[l];
435 					case '?':
436 						*c++ = '?';
437 						++pindex;
438 					continue;
439 				}
440 			} else {
441                                 if ((in_param &= ((sql[l] >= 'A' && sql[l] <= 'Z') || (sql[l] >= 'a' && sql[l] <= 'z')
442                                         || (sql[l] >= '0' && sql[l] <= '9') || sql[l] == '_' || sql[l] == '-'))) {
443 
444 
445 					*ppname++ = sql[l];
446 					continue;
447 				} else {
448 					*ppname++ = 0;
449 					if (named_params) {
450 						zend_hash_update(named_params, pname, (unsigned int)(ppname-pname),
451 							(void*)&pindex, sizeof(long)+1,NULL);
452 					}
453 				}
454 			}
455 		}
456 		*c++ = sql[l];
457 	}
458 
459 	/* prepare the statement */
460 	if (isc_dsql_prepare(H->isc_status, &H->tr, s, 0, new_sql, PDO_FB_DIALECT, out_sqlda)) {
461 		RECORD_ERROR(dbh);
462 		efree(new_sql);
463 		return 0;
464 	}
465 
466 	efree(new_sql);
467 	return 1;
468 }
469 /* }}} */
470 
471 /* called by PDO to set a driver-specific dbh attribute */
firebird_handle_set_attribute(pdo_dbh_t * dbh,long attr,zval * val TSRMLS_DC)472 static int firebird_handle_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC) /* {{{ */
473 {
474 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
475 
476 	switch (attr) {
477 		case PDO_ATTR_AUTOCOMMIT:
478 
479 			convert_to_boolean(val);
480 
481 			/* ignore if the new value equals the old one */
482 			if (dbh->auto_commit ^ Z_BVAL_P(val)) {
483 				if (dbh->in_txn) {
484 					if (Z_BVAL_P(val)) {
485 						/* turning on auto_commit with an open transaction is illegal, because
486 						   we won't know what to do with it */
487 						H->last_app_error = "Cannot enable auto-commit while a transaction is already open";
488 						return 0;
489 					} else {
490 						/* close the transaction */
491 						if (!firebird_handle_commit(dbh TSRMLS_CC)) {
492 							break;
493 						}
494 						dbh->in_txn = 0;
495 					}
496 				}
497 				dbh->auto_commit = Z_BVAL_P(val);
498 			}
499 			return 1;
500 
501 		case PDO_ATTR_FETCH_TABLE_NAMES:
502 			convert_to_boolean(val);
503 			H->fetch_table_names = Z_BVAL_P(val);
504 			return 1;
505 
506 		case PDO_FB_ATTR_DATE_FORMAT:
507 			convert_to_string(val);
508 			if (H->date_format) {
509 				efree(H->date_format);
510 			}
511 			spprintf(&H->date_format, 0, "%s", Z_STRVAL_P(val));
512 			return 1;
513 
514 		case PDO_FB_ATTR_TIME_FORMAT:
515 			convert_to_string(val);
516 			if (H->time_format) {
517 				efree(H->time_format);
518 			}
519 			spprintf(&H->time_format, 0, "%s", Z_STRVAL_P(val));
520 			return 1;
521 
522 		case PDO_FB_ATTR_TIMESTAMP_FORMAT:
523 			convert_to_string(val);
524 			if (H->timestamp_format) {
525 				efree(H->timestamp_format);
526 			}
527 			spprintf(&H->timestamp_format, 0, "%s", Z_STRVAL_P(val));
528 			return 1;
529 	}
530 	return 0;
531 }
532 /* }}} */
533 
534 /* callback to used to report database server info */
firebird_info_cb(void * arg,char const * s)535 static void firebird_info_cb(void *arg, char const *s) /* {{{ */
536 {
537 	if (arg) {
538 		if (*(char*)arg) { /* second call */
539 			strcat(arg, " ");
540 		}
541 		strcat(arg, s);
542 	}
543 }
544 /* }}} */
545 
546 /* called by PDO to get a driver-specific dbh attribute */
firebird_handle_get_attribute(pdo_dbh_t * dbh,long attr,zval * val TSRMLS_DC)547 static int firebird_handle_get_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC) /* {{{ */
548 {
549 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
550 
551 	switch (attr) {
552 		char tmp[512];
553 
554 		case PDO_ATTR_AUTOCOMMIT:
555 			ZVAL_LONG(val,dbh->auto_commit);
556 			return 1;
557 
558 		case PDO_ATTR_CONNECTION_STATUS:
559 			ZVAL_BOOL(val, !isc_version(&H->db, firebird_info_cb, NULL));
560 			return 1;
561 
562 		case PDO_ATTR_CLIENT_VERSION: {
563 #if defined(__GNUC__) || defined(PHP_WIN32)
564 			info_func_t info_func = NULL;
565 #ifdef __GNUC__
566 			info_func = (info_func_t)dlsym(RTLD_DEFAULT, "isc_get_client_version");
567 #else
568 			HMODULE l = GetModuleHandle("fbclient");
569 
570 			if (!l) {
571 				break;
572 			}
573 			info_func = (info_func_t)GetProcAddress(l, "isc_get_client_version");
574 #endif
575 			if (info_func) {
576 				info_func(tmp);
577 				ZVAL_STRING(val,tmp,1);
578 			}
579 #else
580 			ZVAL_NULL(val);
581 #endif
582 			}
583 			return 1;
584 
585 		case PDO_ATTR_SERVER_VERSION:
586 		case PDO_ATTR_SERVER_INFO:
587 			*tmp = 0;
588 
589 			if (!isc_version(&H->db, firebird_info_cb, (void*)tmp)) {
590 				ZVAL_STRING(val,tmp,1);
591 				return 1;
592 			}
593 
594 		case PDO_ATTR_FETCH_TABLE_NAMES:
595 			ZVAL_BOOL(val, H->fetch_table_names);
596 			return 1;
597 	}
598 	return 0;
599 }
600 /* }}} */
601 
602 /* called by PDO to retrieve driver-specific information about an error that has occurred */
pdo_firebird_fetch_error_func(pdo_dbh_t * dbh,pdo_stmt_t * stmt,zval * info TSRMLS_DC)603 static int pdo_firebird_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC) /* {{{ */
604 {
605 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
606 	const ISC_STATUS *s = H->isc_status;
607 	char buf[400];
608 	long i = 0, l, sqlcode = isc_sqlcode(s);
609 
610 	if (sqlcode) {
611 		add_next_index_long(info, sqlcode);
612 
613 		while ((sizeof(buf)>(i+2))&&(l = fb_interpret(&buf[i],(sizeof(buf)-i-2),&s))) {
614 			i += l;
615 			strcpy(&buf[i++], " ");
616 		}
617 		add_next_index_string(info, buf, 1);
618 	} else if (H->last_app_error) {
619 		add_next_index_long(info, -999);
620 		add_next_index_string(info, const_cast(H->last_app_error),1);
621 	}
622 	return 1;
623 }
624 /* }}} */
625 
626 static struct pdo_dbh_methods firebird_methods = { /* {{{ */
627 	firebird_handle_closer,
628 	firebird_handle_preparer,
629 	firebird_handle_doer,
630 	firebird_handle_quoter,
631 	firebird_handle_begin,
632 	firebird_handle_commit,
633 	firebird_handle_rollback,
634 	firebird_handle_set_attribute,
635 	NULL, /* last_id not supported */
636 	pdo_firebird_fetch_error_func,
637 	firebird_handle_get_attribute,
638 	NULL /* check_liveness */
639 };
640 /* }}} */
641 
642 /* the driver-specific PDO handle constructor */
pdo_firebird_handle_factory(pdo_dbh_t * dbh,zval * driver_options TSRMLS_DC)643 static int pdo_firebird_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS_DC) /* {{{ */
644 {
645 	struct pdo_data_src_parser vars[] = {
646 		{ "dbname", NULL, 0 },
647 		{ "charset",  NULL,	0 },
648 		{ "role", NULL,	0 }
649 	};
650 	int i, ret = 0;
651 	short buf_len = 256, dpb_len;
652 
653 	pdo_firebird_db_handle *H = dbh->driver_data = pecalloc(1,sizeof(*H),dbh->is_persistent);
654 
655 	php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, 3);
656 
657 	do {
658 		static char const dpb_flags[] = {
659 			isc_dpb_user_name, isc_dpb_password, isc_dpb_lc_ctype, isc_dpb_sql_role_name };
660 		char const *dpb_values[] = { dbh->username, dbh->password, vars[1].optval, vars[2].optval };
661 		char dpb_buffer[256] = { isc_dpb_version1 }, *dpb;
662 
663 		dpb = dpb_buffer + 1;
664 
665 		/* loop through all the provided arguments and set dpb fields accordingly */
666 		for (i = 0; i < sizeof(dpb_flags); ++i) {
667 			if (dpb_values[i] && buf_len > 0) {
668 				dpb_len = slprintf(dpb, buf_len, "%c%c%s", dpb_flags[i], (unsigned char)strlen(dpb_values[i]),
669 					dpb_values[i]);
670 				dpb += dpb_len;
671 				buf_len -= dpb_len;
672 			}
673 		}
674 
675 		/* fire it up baby! */
676 		if (isc_attach_database(H->isc_status, 0, vars[0].optval, &H->db,(short)(dpb-dpb_buffer), dpb_buffer)) {
677 			break;
678 		}
679 
680 		dbh->methods = &firebird_methods;
681 		dbh->native_case = PDO_CASE_UPPER;
682 		dbh->alloc_own_columns = 1;
683 
684 		ret = 1;
685 
686 	} while (0);
687 
688 	for (i = 0; i < sizeof(vars)/sizeof(vars[0]); ++i) {
689 		if (vars[i].freeme) {
690 			efree(vars[i].optval);
691 		}
692 	}
693 
694 	if (!dbh->methods) {
695 		char errmsg[512];
696 		const ISC_STATUS *s = H->isc_status;
697 		fb_interpret(errmsg, sizeof(errmsg),&s);
698 		zend_throw_exception_ex(php_pdo_get_exception(), H->isc_status[1] TSRMLS_CC, "SQLSTATE[%s] [%d] %s",
699 				"HY000", H->isc_status[1], errmsg);
700 	}
701 
702 	if (!ret) {
703 		firebird_handle_closer(dbh TSRMLS_CC);
704 	}
705 
706 	return ret;
707 }
708 /* }}} */
709 
710 
711 pdo_driver_t pdo_firebird_driver = { /* {{{ */
712 	PDO_DRIVER_HEADER(firebird),
713 	pdo_firebird_handle_factory
714 };
715 /* }}} */
716 
717 /*
718  * Local variables:
719  * tab-width: 4
720  * c-basic-offset: 4
721  * End:
722  * vim600: noet sw=4 ts=4 fdm=marker
723  * vim<600: noet sw=4 ts=4
724  */
725