This source file includes following definitions.
- _pdo_sqlite_error
- pdo_sqlite_fetch_error_func
- pdo_sqlite_cleanup_callbacks
- sqlite_handle_closer
- sqlite_handle_preparer
- sqlite_handle_doer
- pdo_sqlite_last_insert_id
- sqlite_handle_quoter
- sqlite_handle_begin
- sqlite_handle_commit
- sqlite_handle_rollback
- pdo_sqlite_get_attribute
- pdo_sqlite_set_attr
- do_callback
- php_sqlite3_func_callback
- php_sqlite3_func_step_callback
- php_sqlite3_func_final_callback
- php_sqlite3_collation_callback
- PHP_METHOD
- PHP_METHOD
- PHP_METHOD
- get_driver_methods
- pdo_sqlite_request_shutdown
- make_filename_safe
- authorizer
- pdo_sqlite_handle_factory
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include "php.h"
26 #include "php_ini.h"
27 #include "ext/standard/info.h"
28 #include "pdo/php_pdo.h"
29 #include "pdo/php_pdo_driver.h"
30 #include "php_pdo_sqlite.h"
31 #include "php_pdo_sqlite_int.h"
32 #include "zend_exceptions.h"
33
34 int _pdo_sqlite_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line TSRMLS_DC)
35 {
36 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
37 pdo_error_type *pdo_err = stmt ? &stmt->error_code : &dbh->error_code;
38 pdo_sqlite_error_info *einfo = &H->einfo;
39
40 einfo->errcode = sqlite3_errcode(H->db);
41 einfo->file = file;
42 einfo->line = line;
43
44 if (einfo->errcode != SQLITE_OK) {
45 if (einfo->errmsg) {
46 pefree(einfo->errmsg, dbh->is_persistent);
47 }
48 einfo->errmsg = pestrdup((char*)sqlite3_errmsg(H->db), dbh->is_persistent);
49 } else {
50 strncpy(*pdo_err, PDO_ERR_NONE, sizeof(PDO_ERR_NONE));
51 return 0;
52 }
53 switch (einfo->errcode) {
54 case SQLITE_NOTFOUND:
55 strncpy(*pdo_err, "42S02", sizeof("42S02"));
56 break;
57
58 case SQLITE_INTERRUPT:
59 strncpy(*pdo_err, "01002", sizeof("01002"));
60 break;
61
62 case SQLITE_NOLFS:
63 strncpy(*pdo_err, "HYC00", sizeof("HYC00"));
64 break;
65
66 case SQLITE_TOOBIG:
67 strncpy(*pdo_err, "22001", sizeof("22001"));
68 break;
69
70 case SQLITE_CONSTRAINT:
71 strncpy(*pdo_err, "23000", sizeof("23000"));
72 break;
73
74 case SQLITE_ERROR:
75 default:
76 strncpy(*pdo_err, "HY000", sizeof("HY000"));
77 break;
78 }
79
80 if (!dbh->methods) {
81 zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s",
82 *pdo_err, einfo->errcode, einfo->errmsg);
83 }
84
85 return einfo->errcode;
86 }
87
88
89 static int pdo_sqlite_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC)
90 {
91 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
92 pdo_sqlite_error_info *einfo = &H->einfo;
93
94 if (einfo->errcode) {
95 add_next_index_long(info, einfo->errcode);
96 add_next_index_string(info, einfo->errmsg, 1);
97 }
98
99 return 1;
100 }
101
102 static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
103 {
104 struct pdo_sqlite_func *func;
105
106 while (H->funcs) {
107 func = H->funcs;
108 H->funcs = func->next;
109
110 if (H->db) {
111
112 sqlite3_create_function(H->db,
113 func->funcname,
114 func->argc,
115 SQLITE_UTF8,
116 func,
117 NULL, NULL, NULL);
118 }
119
120 efree((char*)func->funcname);
121 if (func->func) {
122 zval_ptr_dtor(&func->func);
123 }
124 if (func->step) {
125 zval_ptr_dtor(&func->step);
126 }
127 if (func->fini) {
128 zval_ptr_dtor(&func->fini);
129 }
130 efree(func);
131 }
132
133 while (H->collations) {
134 struct pdo_sqlite_collation *collation;
135 collation = H->collations;
136 H->collations = collation->next;
137
138 if (H->db) {
139
140 sqlite3_create_collation(H->db,
141 collation->name,
142 SQLITE_UTF8,
143 collation,
144 NULL);
145 }
146
147 efree((char*)collation->name);
148 if (collation->callback) {
149 zval_ptr_dtor(&collation->callback);
150 }
151 efree(collation);
152 }
153 }
154
155 static int sqlite_handle_closer(pdo_dbh_t *dbh TSRMLS_DC)
156 {
157 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
158
159 if (H) {
160 pdo_sqlite_error_info *einfo = &H->einfo;
161
162 pdo_sqlite_cleanup_callbacks(H TSRMLS_CC);
163 if (H->db) {
164 sqlite3_close(H->db);
165 H->db = NULL;
166 }
167 if (einfo->errmsg) {
168 pefree(einfo->errmsg, dbh->is_persistent);
169 einfo->errmsg = NULL;
170 }
171 pefree(H, dbh->is_persistent);
172 dbh->driver_data = NULL;
173 }
174 return 0;
175 }
176
177
178 static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
179 {
180 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
181 pdo_sqlite_stmt *S = ecalloc(1, sizeof(pdo_sqlite_stmt));
182 int i;
183 const char *tail;
184
185 S->H = H;
186 stmt->driver_data = S;
187 stmt->methods = &sqlite_stmt_methods;
188 stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL|PDO_PLACEHOLDER_NAMED;
189
190 if (PDO_CURSOR_FWDONLY != pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY TSRMLS_CC)) {
191 H->einfo.errcode = SQLITE_ERROR;
192 pdo_sqlite_error(dbh);
193 return 0;
194 }
195
196 i = sqlite3_prepare(H->db, sql, sql_len, &S->stmt, &tail);
197 if (i == SQLITE_OK) {
198 return 1;
199 }
200
201 pdo_sqlite_error(dbh);
202
203 return 0;
204 }
205
206 static long sqlite_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
207 {
208 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
209 char *errmsg = NULL;
210
211 if (sqlite3_exec(H->db, sql, NULL, NULL, &errmsg) != SQLITE_OK) {
212 pdo_sqlite_error(dbh);
213 if (errmsg)
214 sqlite3_free(errmsg);
215
216 return -1;
217 } else {
218 return sqlite3_changes(H->db);
219 }
220 }
221
222 static char *pdo_sqlite_last_insert_id(pdo_dbh_t *dbh, const char *name, unsigned int *len TSRMLS_DC)
223 {
224 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
225 char *id;
226
227 id = php_pdo_int64_to_str(sqlite3_last_insert_rowid(H->db) TSRMLS_CC);
228 *len = strlen(id);
229 return id;
230 }
231
232
233 static int sqlite_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype TSRMLS_DC)
234 {
235 *quoted = safe_emalloc(2, unquotedlen, 3);
236 sqlite3_snprintf(2*unquotedlen + 3, *quoted, "'%q'", unquoted);
237 *quotedlen = strlen(*quoted);
238 return 1;
239 }
240
241 static int sqlite_handle_begin(pdo_dbh_t *dbh TSRMLS_DC)
242 {
243 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
244 char *errmsg = NULL;
245
246 if (sqlite3_exec(H->db, "BEGIN", NULL, NULL, &errmsg) != SQLITE_OK) {
247 pdo_sqlite_error(dbh);
248 if (errmsg)
249 sqlite3_free(errmsg);
250 return 0;
251 }
252 return 1;
253 }
254
255 static int sqlite_handle_commit(pdo_dbh_t *dbh TSRMLS_DC)
256 {
257 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
258 char *errmsg = NULL;
259
260 if (sqlite3_exec(H->db, "COMMIT", NULL, NULL, &errmsg) != SQLITE_OK) {
261 pdo_sqlite_error(dbh);
262 if (errmsg)
263 sqlite3_free(errmsg);
264 return 0;
265 }
266 return 1;
267 }
268
269 static int sqlite_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC)
270 {
271 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
272 char *errmsg = NULL;
273
274 if (sqlite3_exec(H->db, "ROLLBACK", NULL, NULL, &errmsg) != SQLITE_OK) {
275 pdo_sqlite_error(dbh);
276 if (errmsg)
277 sqlite3_free(errmsg);
278 return 0;
279 }
280 return 1;
281 }
282
283 static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC)
284 {
285 switch (attr) {
286 case PDO_ATTR_CLIENT_VERSION:
287 case PDO_ATTR_SERVER_VERSION:
288 ZVAL_STRING(return_value, (char *)sqlite3_libversion(), 1);
289 break;
290
291 default:
292 return 0;
293 }
294
295 return 1;
296 }
297
298 static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
299 {
300 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
301
302 switch (attr) {
303 case PDO_ATTR_TIMEOUT:
304 convert_to_long(val);
305 sqlite3_busy_timeout(H->db, Z_LVAL_P(val) * 1000);
306 return 1;
307 }
308 return 0;
309 }
310
311 static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
312 int argc, sqlite3_value **argv, sqlite3_context *context,
313 int is_agg TSRMLS_DC)
314 {
315 zval ***zargs = NULL;
316 zval *retval = NULL;
317 int i;
318 int ret;
319 int fake_argc;
320 zval **agg_context = NULL;
321
322 if (is_agg) {
323 is_agg = 2;
324 }
325
326 fake_argc = argc + is_agg;
327
328 fc->fci.size = sizeof(fc->fci);
329 fc->fci.function_table = EG(function_table);
330 fc->fci.function_name = cb;
331 fc->fci.symbol_table = NULL;
332 fc->fci.object_ptr = NULL;
333 fc->fci.retval_ptr_ptr = &retval;
334 fc->fci.param_count = fake_argc;
335
336
337
338 if (fake_argc) {
339 zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
340 }
341
342 if (is_agg) {
343
344 agg_context = (zval**)sqlite3_aggregate_context(context, sizeof(zval*));
345 if (!*agg_context) {
346 MAKE_STD_ZVAL(*agg_context);
347 ZVAL_NULL(*agg_context);
348 }
349 zargs[0] = agg_context;
350
351 zargs[1] = emalloc(sizeof(zval*));
352 MAKE_STD_ZVAL(*zargs[1]);
353 ZVAL_LONG(*zargs[1], sqlite3_aggregate_count(context));
354 }
355
356 for (i = 0; i < argc; i++) {
357 zargs[i + is_agg] = emalloc(sizeof(zval *));
358 MAKE_STD_ZVAL(*zargs[i + is_agg]);
359
360
361 switch (sqlite3_value_type(argv[i])) {
362 case SQLITE_INTEGER:
363 ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
364 break;
365
366 case SQLITE_FLOAT:
367 ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
368 break;
369
370 case SQLITE_NULL:
371 ZVAL_NULL(*zargs[i + is_agg]);
372 break;
373
374 case SQLITE_BLOB:
375 case SQLITE3_TEXT:
376 default:
377 ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]),
378 sqlite3_value_bytes(argv[i]), 1);
379 break;
380 }
381 }
382
383
384 fc->fci.params = zargs;
385
386
387 if ((ret = zend_call_function(&fc->fci, &fc->fcc TSRMLS_CC)) == FAILURE) {
388 php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
389 }
390
391
392 if (zargs) {
393 for (i = is_agg; i < fake_argc; i++) {
394 zval_ptr_dtor(zargs[i]);
395 efree(zargs[i]);
396 }
397 if (is_agg) {
398 zval_ptr_dtor(zargs[1]);
399 efree(zargs[1]);
400 }
401 efree(zargs);
402 }
403
404 if (!is_agg || !argv) {
405
406
407 if (retval) {
408 switch (Z_TYPE_P(retval)) {
409 case IS_LONG:
410 sqlite3_result_int(context, Z_LVAL_P(retval));
411 break;
412
413 case IS_NULL:
414 sqlite3_result_null(context);
415 break;
416
417 case IS_DOUBLE:
418 sqlite3_result_double(context, Z_DVAL_P(retval));
419 break;
420
421 default:
422 convert_to_string_ex(&retval);
423 sqlite3_result_text(context, Z_STRVAL_P(retval),
424 Z_STRLEN_P(retval), SQLITE_TRANSIENT);
425 break;
426 }
427 } else {
428 sqlite3_result_error(context, "failed to invoke callback", 0);
429 }
430
431 if (agg_context) {
432 zval_ptr_dtor(agg_context);
433 }
434 } else {
435
436
437 if (agg_context) {
438 zval_ptr_dtor(agg_context);
439 }
440 if (retval) {
441 *agg_context = retval;
442 retval = NULL;
443 } else {
444 *agg_context = NULL;
445 }
446 }
447
448 if (retval) {
449 zval_ptr_dtor(&retval);
450 }
451
452 return ret;
453 }
454
455 static void php_sqlite3_func_callback(sqlite3_context *context, int argc,
456 sqlite3_value **argv)
457 {
458 struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
459 TSRMLS_FETCH();
460
461 do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
462 }
463
464 static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
465 sqlite3_value **argv)
466 {
467 struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
468 TSRMLS_FETCH();
469
470 do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
471 }
472
473 static void php_sqlite3_func_final_callback(sqlite3_context *context)
474 {
475 struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
476 TSRMLS_FETCH();
477
478 do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
479 }
480
481 static int php_sqlite3_collation_callback(void *context,
482 int string1_len, const void *string1,
483 int string2_len, const void *string2)
484 {
485 int ret;
486 zval *zstring1, *zstring2;
487 zval **zargs[2];
488 zval *retval = NULL;
489 struct pdo_sqlite_collation *collation = (struct pdo_sqlite_collation*) context;
490 TSRMLS_FETCH();
491
492 collation->fc.fci.size = sizeof(collation->fc.fci);
493 collation->fc.fci.function_table = EG(function_table);
494 collation->fc.fci.function_name = collation->callback;
495 collation->fc.fci.symbol_table = NULL;
496 collation->fc.fci.object_ptr = NULL;
497 collation->fc.fci.retval_ptr_ptr = &retval;
498
499
500 MAKE_STD_ZVAL(zstring1);
501 ZVAL_STRINGL(zstring1, (char *) string1, string1_len, 1);
502 zargs[0] = &zstring1;
503 MAKE_STD_ZVAL(zstring2);
504 ZVAL_STRINGL(zstring2, (char *) string2, string2_len, 1);
505 zargs[1] = &zstring2;
506 collation->fc.fci.param_count = 2;
507 collation->fc.fci.params = zargs;
508
509 if ((ret = zend_call_function(&collation->fc.fci, &collation->fc.fcc TSRMLS_CC)) == FAILURE) {
510 php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
511 }
512 else if (retval) {
513 if (Z_TYPE_P(retval) != IS_LONG) {
514 convert_to_long_ex(&retval);
515 }
516 ret = 0;
517 if (Z_LVAL_P(retval) > 0) {
518 ret = 1;
519 }
520 else if (Z_LVAL_P(retval) < 0) {
521 ret = -1;
522 }
523 zval_ptr_dtor(&retval);
524 }
525
526 zval_ptr_dtor(zargs[0]);
527 zval_ptr_dtor(zargs[1]);
528
529 return ret;
530 }
531
532
533
534 static PHP_METHOD(SQLite, sqliteCreateFunction)
535 {
536 struct pdo_sqlite_func *func;
537 zval *callback;
538 char *func_name;
539 int func_name_len;
540 long argc = -1;
541 char *cbname = NULL;
542 pdo_dbh_t *dbh;
543 pdo_sqlite_db_handle *H;
544 int ret;
545
546 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l",
547 &func_name, &func_name_len, &callback, &argc)) {
548 RETURN_FALSE;
549 }
550
551 dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
552 PDO_CONSTRUCT_CHECK;
553
554 if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
555 php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
556 efree(cbname);
557 RETURN_FALSE;
558 }
559 efree(cbname);
560
561 H = (pdo_sqlite_db_handle *)dbh->driver_data;
562
563 func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
564
565 ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
566 func, php_sqlite3_func_callback, NULL, NULL);
567 if (ret == SQLITE_OK) {
568 func->funcname = estrdup(func_name);
569
570 MAKE_STD_ZVAL(func->func);
571 MAKE_COPY_ZVAL(&callback, func->func);
572
573 func->argc = argc;
574
575 func->next = H->funcs;
576 H->funcs = func;
577
578 RETURN_TRUE;
579 }
580
581 efree(func);
582 RETURN_FALSE;
583 }
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605 static PHP_METHOD(SQLite, sqliteCreateAggregate)
606 {
607 struct pdo_sqlite_func *func;
608 zval *step_callback, *fini_callback;
609 char *func_name;
610 int func_name_len;
611 long argc = -1;
612 char *cbname = NULL;
613 pdo_dbh_t *dbh;
614 pdo_sqlite_db_handle *H;
615 int ret;
616
617 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l",
618 &func_name, &func_name_len, &step_callback, &fini_callback, &argc)) {
619 RETURN_FALSE;
620 }
621
622 dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
623 PDO_CONSTRUCT_CHECK;
624
625 if (!zend_is_callable(step_callback, 0, &cbname TSRMLS_CC)) {
626 php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
627 efree(cbname);
628 RETURN_FALSE;
629 }
630 efree(cbname);
631 if (!zend_is_callable(fini_callback, 0, &cbname TSRMLS_CC)) {
632 php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
633 efree(cbname);
634 RETURN_FALSE;
635 }
636 efree(cbname);
637
638 H = (pdo_sqlite_db_handle *)dbh->driver_data;
639
640 func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
641
642 ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
643 func, NULL, php_sqlite3_func_step_callback, php_sqlite3_func_final_callback);
644 if (ret == SQLITE_OK) {
645 func->funcname = estrdup(func_name);
646
647 MAKE_STD_ZVAL(func->step);
648 MAKE_COPY_ZVAL(&step_callback, func->step);
649
650 MAKE_STD_ZVAL(func->fini);
651 MAKE_COPY_ZVAL(&fini_callback, func->fini);
652
653 func->argc = argc;
654
655 func->next = H->funcs;
656 H->funcs = func;
657
658 RETURN_TRUE;
659 }
660
661 efree(func);
662 RETURN_FALSE;
663 }
664
665
666
667
668 static PHP_METHOD(SQLite, sqliteCreateCollation)
669 {
670 struct pdo_sqlite_collation *collation;
671 zval *callback;
672 char *collation_name;
673 int collation_name_len;
674 char *cbname = NULL;
675 pdo_dbh_t *dbh;
676 pdo_sqlite_db_handle *H;
677 int ret;
678
679 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
680 &collation_name, &collation_name_len, &callback)) {
681 RETURN_FALSE;
682 }
683
684 dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
685 PDO_CONSTRUCT_CHECK;
686
687 if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
688 php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
689 efree(cbname);
690 RETURN_FALSE;
691 }
692 efree(cbname);
693
694 H = (pdo_sqlite_db_handle *)dbh->driver_data;
695
696 collation = (struct pdo_sqlite_collation*)ecalloc(1, sizeof(*collation));
697
698 ret = sqlite3_create_collation(H->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_collation_callback);
699 if (ret == SQLITE_OK) {
700 collation->name = estrdup(collation_name);
701
702 MAKE_STD_ZVAL(collation->callback);
703 MAKE_COPY_ZVAL(&callback, collation->callback);
704
705 collation->next = H->collations;
706 H->collations = collation;
707
708 RETURN_TRUE;
709 }
710
711 efree(collation);
712 RETURN_FALSE;
713 }
714
715
716 static const zend_function_entry dbh_methods[] = {
717 PHP_ME(SQLite, sqliteCreateFunction, NULL, ZEND_ACC_PUBLIC)
718 PHP_ME(SQLite, sqliteCreateAggregate, NULL, ZEND_ACC_PUBLIC)
719 PHP_ME(SQLite, sqliteCreateCollation, NULL, ZEND_ACC_PUBLIC)
720 PHP_FE_END
721 };
722
723 static const zend_function_entry *get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
724 {
725 switch (kind) {
726 case PDO_DBH_DRIVER_METHOD_KIND_DBH:
727 return dbh_methods;
728
729 default:
730 return NULL;
731 }
732 }
733
734 static void pdo_sqlite_request_shutdown(pdo_dbh_t *dbh TSRMLS_DC)
735 {
736 pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
737
738
739 if (H) {
740 pdo_sqlite_cleanup_callbacks(H TSRMLS_CC);
741 }
742 }
743
744 static struct pdo_dbh_methods sqlite_methods = {
745 sqlite_handle_closer,
746 sqlite_handle_preparer,
747 sqlite_handle_doer,
748 sqlite_handle_quoter,
749 sqlite_handle_begin,
750 sqlite_handle_commit,
751 sqlite_handle_rollback,
752 pdo_sqlite_set_attr,
753 pdo_sqlite_last_insert_id,
754 pdo_sqlite_fetch_error_func,
755 pdo_sqlite_get_attribute,
756 NULL,
757 get_driver_methods,
758 pdo_sqlite_request_shutdown
759 };
760
761 static char *make_filename_safe(const char *filename TSRMLS_DC)
762 {
763 if (*filename && memcmp(filename, ":memory:", sizeof(":memory:"))) {
764 char *fullpath = expand_filepath(filename, NULL TSRMLS_CC);
765
766 if (!fullpath) {
767 return NULL;
768 }
769
770 if (php_check_open_basedir(fullpath TSRMLS_CC)) {
771 efree(fullpath);
772 return NULL;
773 }
774 return fullpath;
775 }
776 return estrdup(filename);
777 }
778
779 static int authorizer(void *autharg, int access_type, const char *arg3, const char *arg4,
780 const char *arg5, const char *arg6)
781 {
782 char *filename;
783 switch (access_type) {
784 case SQLITE_COPY: {
785 TSRMLS_FETCH();
786 filename = make_filename_safe(arg4 TSRMLS_CC);
787 if (!filename) {
788 return SQLITE_DENY;
789 }
790 efree(filename);
791 return SQLITE_OK;
792 }
793
794 case SQLITE_ATTACH: {
795 TSRMLS_FETCH();
796 filename = make_filename_safe(arg3 TSRMLS_CC);
797 if (!filename) {
798 return SQLITE_DENY;
799 }
800 efree(filename);
801 return SQLITE_OK;
802 }
803
804 default:
805
806 return SQLITE_OK;
807 }
808 }
809
810 static int pdo_sqlite_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS_DC)
811 {
812 pdo_sqlite_db_handle *H;
813 int i, ret = 0;
814 long timeout = 60;
815 char *filename;
816
817 H = pecalloc(1, sizeof(pdo_sqlite_db_handle), dbh->is_persistent);
818
819 H->einfo.errcode = 0;
820 H->einfo.errmsg = NULL;
821 dbh->driver_data = H;
822
823 filename = make_filename_safe(dbh->data_source TSRMLS_CC);
824
825 if (!filename) {
826 zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC,
827 "open_basedir prohibits opening %s",
828 dbh->data_source);
829 goto cleanup;
830 }
831
832 i = sqlite3_open(filename, &H->db);
833 efree(filename);
834
835 if (i != SQLITE_OK) {
836 pdo_sqlite_error(dbh);
837 goto cleanup;
838 }
839
840 if (PG(open_basedir) && *PG(open_basedir)) {
841 sqlite3_set_authorizer(H->db, authorizer, NULL);
842 }
843
844 if (driver_options) {
845 timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, timeout TSRMLS_CC);
846 }
847 sqlite3_busy_timeout(H->db, timeout * 1000);
848
849 dbh->alloc_own_columns = 1;
850 dbh->max_escaped_char_length = 2;
851
852 ret = 1;
853
854 cleanup:
855 dbh->methods = &sqlite_methods;
856
857 return ret;
858 }
859
860
861 pdo_driver_t pdo_sqlite_driver = {
862 PDO_DRIVER_HEADER(sqlite),
863 pdo_sqlite_handle_factory
864 };
865
866
867
868
869
870
871
872
873