1 /*
2 ** 2006 June 7
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains code used to dynamically load extensions into
13 ** the SQLite library.
14 */
15
16 #ifndef SQLITE_CORE
17 #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
18 #endif
19 #include "sqlite3ext.h"
20 #include "sqliteInt.h"
21 #include <string.h>
22
23 #ifndef SQLITE_OMIT_LOAD_EXTENSION
24
25 /*
26 ** Some API routines are omitted when various features are
27 ** excluded from a build of SQLite. Substitute a NULL pointer
28 ** for any missing APIs.
29 */
30 #ifndef SQLITE_ENABLE_COLUMN_METADATA
31 # define sqlite3_column_database_name 0
32 # define sqlite3_column_database_name16 0
33 # define sqlite3_column_table_name 0
34 # define sqlite3_column_table_name16 0
35 # define sqlite3_column_origin_name 0
36 # define sqlite3_column_origin_name16 0
37 # define sqlite3_table_column_metadata 0
38 #endif
39
40 #ifdef SQLITE_OMIT_AUTHORIZATION
41 # define sqlite3_set_authorizer 0
42 #endif
43
44 #ifdef SQLITE_OMIT_UTF16
45 # define sqlite3_bind_text16 0
46 # define sqlite3_collation_needed16 0
47 # define sqlite3_column_decltype16 0
48 # define sqlite3_column_name16 0
49 # define sqlite3_column_text16 0
50 # define sqlite3_complete16 0
51 # define sqlite3_create_collation16 0
52 # define sqlite3_create_function16 0
53 # define sqlite3_errmsg16 0
54 # define sqlite3_open16 0
55 # define sqlite3_prepare16 0
56 # define sqlite3_prepare16_v2 0
57 # define sqlite3_result_error16 0
58 # define sqlite3_result_text16 0
59 # define sqlite3_result_text16be 0
60 # define sqlite3_result_text16le 0
61 # define sqlite3_value_text16 0
62 # define sqlite3_value_text16be 0
63 # define sqlite3_value_text16le 0
64 # define sqlite3_column_database_name16 0
65 # define sqlite3_column_table_name16 0
66 # define sqlite3_column_origin_name16 0
67 #endif
68
69 #ifdef SQLITE_OMIT_COMPLETE
70 # define sqlite3_complete 0
71 # define sqlite3_complete16 0
72 #endif
73
74 #ifdef SQLITE_OMIT_DECLTYPE
75 # define sqlite3_column_decltype16 0
76 # define sqlite3_column_decltype 0
77 #endif
78
79 #ifdef SQLITE_OMIT_PROGRESS_CALLBACK
80 # define sqlite3_progress_handler 0
81 #endif
82
83 #ifdef SQLITE_OMIT_VIRTUALTABLE
84 # define sqlite3_create_module 0
85 # define sqlite3_create_module_v2 0
86 # define sqlite3_declare_vtab 0
87 #endif
88
89 #ifdef SQLITE_OMIT_SHARED_CACHE
90 # define sqlite3_enable_shared_cache 0
91 #endif
92
93 #ifdef SQLITE_OMIT_TRACE
94 # define sqlite3_profile 0
95 # define sqlite3_trace 0
96 #endif
97
98 #ifdef SQLITE_OMIT_GET_TABLE
99 # define sqlite3_free_table 0
100 # define sqlite3_get_table 0
101 #endif
102
103 #ifdef SQLITE_OMIT_INCRBLOB
104 #define sqlite3_bind_zeroblob 0
105 #define sqlite3_blob_bytes 0
106 #define sqlite3_blob_close 0
107 #define sqlite3_blob_open 0
108 #define sqlite3_blob_read 0
109 #define sqlite3_blob_write 0
110 #endif
111
112 /*
113 ** The following structure contains pointers to all SQLite API routines.
114 ** A pointer to this structure is passed into extensions when they are
115 ** loaded so that the extension can make calls back into the SQLite
116 ** library.
117 **
118 ** When adding new APIs, add them to the bottom of this structure
119 ** in order to preserve backwards compatibility.
120 **
121 ** Extensions that use newer APIs should first call the
122 ** sqlite3_libversion_number() to make sure that the API they
123 ** intend to use is supported by the library. Extensions should
124 ** also check to make sure that the pointer to the function is
125 ** not NULL before calling it.
126 */
127 static const sqlite3_api_routines sqlite3Apis = {
128 sqlite3_aggregate_context,
129 #ifndef SQLITE_OMIT_DEPRECATED
130 sqlite3_aggregate_count,
131 #else
132 0,
133 #endif
134 sqlite3_bind_blob,
135 sqlite3_bind_double,
136 sqlite3_bind_int,
137 sqlite3_bind_int64,
138 sqlite3_bind_null,
139 sqlite3_bind_parameter_count,
140 sqlite3_bind_parameter_index,
141 sqlite3_bind_parameter_name,
142 sqlite3_bind_text,
143 sqlite3_bind_text16,
144 sqlite3_bind_value,
145 sqlite3_busy_handler,
146 sqlite3_busy_timeout,
147 sqlite3_changes,
148 sqlite3_close,
149 sqlite3_collation_needed,
150 sqlite3_collation_needed16,
151 sqlite3_column_blob,
152 sqlite3_column_bytes,
153 sqlite3_column_bytes16,
154 sqlite3_column_count,
155 sqlite3_column_database_name,
156 sqlite3_column_database_name16,
157 sqlite3_column_decltype,
158 sqlite3_column_decltype16,
159 sqlite3_column_double,
160 sqlite3_column_int,
161 sqlite3_column_int64,
162 sqlite3_column_name,
163 sqlite3_column_name16,
164 sqlite3_column_origin_name,
165 sqlite3_column_origin_name16,
166 sqlite3_column_table_name,
167 sqlite3_column_table_name16,
168 sqlite3_column_text,
169 sqlite3_column_text16,
170 sqlite3_column_type,
171 sqlite3_column_value,
172 sqlite3_commit_hook,
173 sqlite3_complete,
174 sqlite3_complete16,
175 sqlite3_create_collation,
176 sqlite3_create_collation16,
177 sqlite3_create_function,
178 sqlite3_create_function16,
179 sqlite3_create_module,
180 sqlite3_data_count,
181 sqlite3_db_handle,
182 sqlite3_declare_vtab,
183 sqlite3_enable_shared_cache,
184 sqlite3_errcode,
185 sqlite3_errmsg,
186 sqlite3_errmsg16,
187 sqlite3_exec,
188 #ifndef SQLITE_OMIT_DEPRECATED
189 sqlite3_expired,
190 #else
191 0,
192 #endif
193 sqlite3_finalize,
194 sqlite3_free,
195 sqlite3_free_table,
196 sqlite3_get_autocommit,
197 sqlite3_get_auxdata,
198 sqlite3_get_table,
199 0, /* Was sqlite3_global_recover(), but that function is deprecated */
200 sqlite3_interrupt,
201 sqlite3_last_insert_rowid,
202 sqlite3_libversion,
203 sqlite3_libversion_number,
204 sqlite3_malloc,
205 sqlite3_mprintf,
206 sqlite3_open,
207 sqlite3_open16,
208 sqlite3_prepare,
209 sqlite3_prepare16,
210 sqlite3_profile,
211 sqlite3_progress_handler,
212 sqlite3_realloc,
213 sqlite3_reset,
214 sqlite3_result_blob,
215 sqlite3_result_double,
216 sqlite3_result_error,
217 sqlite3_result_error16,
218 sqlite3_result_int,
219 sqlite3_result_int64,
220 sqlite3_result_null,
221 sqlite3_result_text,
222 sqlite3_result_text16,
223 sqlite3_result_text16be,
224 sqlite3_result_text16le,
225 sqlite3_result_value,
226 sqlite3_rollback_hook,
227 sqlite3_set_authorizer,
228 sqlite3_set_auxdata,
229 sqlite3_snprintf,
230 sqlite3_step,
231 sqlite3_table_column_metadata,
232 #ifndef SQLITE_OMIT_DEPRECATED
233 sqlite3_thread_cleanup,
234 #else
235 0,
236 #endif
237 sqlite3_total_changes,
238 sqlite3_trace,
239 #ifndef SQLITE_OMIT_DEPRECATED
240 sqlite3_transfer_bindings,
241 #else
242 0,
243 #endif
244 sqlite3_update_hook,
245 sqlite3_user_data,
246 sqlite3_value_blob,
247 sqlite3_value_bytes,
248 sqlite3_value_bytes16,
249 sqlite3_value_double,
250 sqlite3_value_int,
251 sqlite3_value_int64,
252 sqlite3_value_numeric_type,
253 sqlite3_value_text,
254 sqlite3_value_text16,
255 sqlite3_value_text16be,
256 sqlite3_value_text16le,
257 sqlite3_value_type,
258 sqlite3_vmprintf,
259 /*
260 ** The original API set ends here. All extensions can call any
261 ** of the APIs above provided that the pointer is not NULL. But
262 ** before calling APIs that follow, extension should check the
263 ** sqlite3_libversion_number() to make sure they are dealing with
264 ** a library that is new enough to support that API.
265 *************************************************************************
266 */
267 sqlite3_overload_function,
268
269 /*
270 ** Added after 3.3.13
271 */
272 sqlite3_prepare_v2,
273 sqlite3_prepare16_v2,
274 sqlite3_clear_bindings,
275
276 /*
277 ** Added for 3.4.1
278 */
279 sqlite3_create_module_v2,
280
281 /*
282 ** Added for 3.5.0
283 */
284 sqlite3_bind_zeroblob,
285 sqlite3_blob_bytes,
286 sqlite3_blob_close,
287 sqlite3_blob_open,
288 sqlite3_blob_read,
289 sqlite3_blob_write,
290 sqlite3_create_collation_v2,
291 sqlite3_file_control,
292 sqlite3_memory_highwater,
293 sqlite3_memory_used,
294 #ifdef SQLITE_MUTEX_OMIT
295 0,
296 0,
297 0,
298 0,
299 0,
300 #else
301 sqlite3_mutex_alloc,
302 sqlite3_mutex_enter,
303 sqlite3_mutex_free,
304 sqlite3_mutex_leave,
305 sqlite3_mutex_try,
306 #endif
307 sqlite3_open_v2,
308 sqlite3_release_memory,
309 sqlite3_result_error_nomem,
310 sqlite3_result_error_toobig,
311 sqlite3_sleep,
312 sqlite3_soft_heap_limit,
313 sqlite3_vfs_find,
314 sqlite3_vfs_register,
315 sqlite3_vfs_unregister,
316
317 /*
318 ** Added for 3.5.8
319 */
320 sqlite3_threadsafe,
321 sqlite3_result_zeroblob,
322 sqlite3_result_error_code,
323 sqlite3_test_control,
324 sqlite3_randomness,
325 sqlite3_context_db_handle,
326
327 /*
328 ** Added for 3.6.0
329 */
330 sqlite3_extended_result_codes,
331 sqlite3_limit,
332 sqlite3_next_stmt,
333 sqlite3_sql,
334 sqlite3_status,
335
336 /*
337 ** Added for 3.7.4
338 */
339 sqlite3_backup_finish,
340 sqlite3_backup_init,
341 sqlite3_backup_pagecount,
342 sqlite3_backup_remaining,
343 sqlite3_backup_step,
344 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
345 sqlite3_compileoption_get,
346 sqlite3_compileoption_used,
347 #else
348 0,
349 0,
350 #endif
351 sqlite3_create_function_v2,
352 sqlite3_db_config,
353 sqlite3_db_mutex,
354 sqlite3_db_status,
355 sqlite3_extended_errcode,
356 sqlite3_log,
357 sqlite3_soft_heap_limit64,
358 sqlite3_sourceid,
359 sqlite3_stmt_status,
360 sqlite3_strnicmp,
361 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
362 sqlite3_unlock_notify,
363 #else
364 0,
365 #endif
366 #ifndef SQLITE_OMIT_WAL
367 sqlite3_wal_autocheckpoint,
368 sqlite3_wal_checkpoint,
369 sqlite3_wal_hook,
370 #else
371 0,
372 0,
373 0,
374 #endif
375 };
376
377 /*
378 ** Attempt to load an SQLite extension library contained in the file
379 ** zFile. The entry point is zProc. zProc may be 0 in which case a
380 ** default entry point name (sqlite3_extension_init) is used. Use
381 ** of the default name is recommended.
382 **
383 ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
384 **
385 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
386 ** error message text. The calling function should free this memory
387 ** by calling sqlite3DbFree(db, ).
388 */
sqlite3LoadExtension(sqlite3 * db,const char * zFile,const char * zProc,char ** pzErrMsg)389 static int sqlite3LoadExtension(
390 sqlite3 *db, /* Load the extension into this database connection */
391 const char *zFile, /* Name of the shared library containing extension */
392 const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
393 char **pzErrMsg /* Put error message here if not 0 */
394 ){
395 sqlite3_vfs *pVfs = db->pVfs;
396 void *handle;
397 int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
398 char *zErrmsg = 0;
399 void **aHandle;
400 const int nMsg = 300;
401
402 if( pzErrMsg ) *pzErrMsg = 0;
403
404 /* Ticket #1863. To avoid a creating security problems for older
405 ** applications that relink against newer versions of SQLite, the
406 ** ability to run load_extension is turned off by default. One
407 ** must call sqlite3_enable_load_extension() to turn on extension
408 ** loading. Otherwise you get the following error.
409 */
410 if( (db->flags & SQLITE_LoadExtension)==0 ){
411 if( pzErrMsg ){
412 *pzErrMsg = sqlite3_mprintf("not authorized");
413 }
414 return SQLITE_ERROR;
415 }
416
417 if( zProc==0 ){
418 zProc = "sqlite3_extension_init";
419 }
420
421 handle = sqlite3OsDlOpen(pVfs, zFile);
422 if( handle==0 ){
423 if( pzErrMsg ){
424 *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
425 if( zErrmsg ){
426 sqlite3_snprintf(nMsg, zErrmsg,
427 "unable to open shared library [%s]", zFile);
428 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
429 }
430 }
431 return SQLITE_ERROR;
432 }
433 xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
434 sqlite3OsDlSym(pVfs, handle, zProc);
435 if( xInit==0 ){
436 if( pzErrMsg ){
437 *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
438 if( zErrmsg ){
439 sqlite3_snprintf(nMsg, zErrmsg,
440 "no entry point [%s] in shared library [%s]", zProc,zFile);
441 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
442 }
443 sqlite3OsDlClose(pVfs, handle);
444 }
445 return SQLITE_ERROR;
446 }else if( xInit(db, &zErrmsg, &sqlite3Apis) ){
447 if( pzErrMsg ){
448 *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
449 }
450 sqlite3_free(zErrmsg);
451 sqlite3OsDlClose(pVfs, handle);
452 return SQLITE_ERROR;
453 }
454
455 /* Append the new shared library handle to the db->aExtension array. */
456 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
457 if( aHandle==0 ){
458 return SQLITE_NOMEM;
459 }
460 if( db->nExtension>0 ){
461 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
462 }
463 sqlite3DbFree(db, db->aExtension);
464 db->aExtension = aHandle;
465
466 db->aExtension[db->nExtension++] = handle;
467 return SQLITE_OK;
468 }
sqlite3_load_extension(sqlite3 * db,const char * zFile,const char * zProc,char ** pzErrMsg)469 int sqlite3_load_extension(
470 sqlite3 *db, /* Load the extension into this database connection */
471 const char *zFile, /* Name of the shared library containing extension */
472 const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
473 char **pzErrMsg /* Put error message here if not 0 */
474 ){
475 int rc;
476 sqlite3_mutex_enter(db->mutex);
477 rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);
478 rc = sqlite3ApiExit(db, rc);
479 sqlite3_mutex_leave(db->mutex);
480 return rc;
481 }
482
483 /*
484 ** Call this routine when the database connection is closing in order
485 ** to clean up loaded extensions
486 */
sqlite3CloseExtensions(sqlite3 * db)487 void sqlite3CloseExtensions(sqlite3 *db){
488 int i;
489 assert( sqlite3_mutex_held(db->mutex) );
490 for(i=0; i<db->nExtension; i++){
491 sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
492 }
493 sqlite3DbFree(db, db->aExtension);
494 }
495
496 /*
497 ** Enable or disable extension loading. Extension loading is disabled by
498 ** default so as not to open security holes in older applications.
499 */
sqlite3_enable_load_extension(sqlite3 * db,int onoff)500 int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
501 sqlite3_mutex_enter(db->mutex);
502 if( onoff ){
503 db->flags |= SQLITE_LoadExtension;
504 }else{
505 db->flags &= ~SQLITE_LoadExtension;
506 }
507 sqlite3_mutex_leave(db->mutex);
508 return SQLITE_OK;
509 }
510
511 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
512
513 /*
514 ** The auto-extension code added regardless of whether or not extension
515 ** loading is supported. We need a dummy sqlite3Apis pointer for that
516 ** code if regular extension loading is not available. This is that
517 ** dummy pointer.
518 */
519 #ifdef SQLITE_OMIT_LOAD_EXTENSION
520 static const sqlite3_api_routines sqlite3Apis = { 0 };
521 #endif
522
523
524 /*
525 ** The following object holds the list of automatically loaded
526 ** extensions.
527 **
528 ** This list is shared across threads. The SQLITE_MUTEX_STATIC_MASTER
529 ** mutex must be held while accessing this list.
530 */
531 typedef struct sqlite3AutoExtList sqlite3AutoExtList;
532 static SQLITE_WSD struct sqlite3AutoExtList {
533 int nExt; /* Number of entries in aExt[] */
534 void (**aExt)(void); /* Pointers to the extension init functions */
535 } sqlite3Autoext = { 0, 0 };
536
537 /* The "wsdAutoext" macro will resolve to the autoextension
538 ** state vector. If writable static data is unsupported on the target,
539 ** we have to locate the state vector at run-time. In the more common
540 ** case where writable static data is supported, wsdStat can refer directly
541 ** to the "sqlite3Autoext" state vector declared above.
542 */
543 #ifdef SQLITE_OMIT_WSD
544 # define wsdAutoextInit \
545 sqlite3AutoExtList *x = &GLOBAL(sqlite3AutoExtList,sqlite3Autoext)
546 # define wsdAutoext x[0]
547 #else
548 # define wsdAutoextInit
549 # define wsdAutoext sqlite3Autoext
550 #endif
551
552
553 /*
554 ** Register a statically linked extension that is automatically
555 ** loaded by every new database connection.
556 */
sqlite3_auto_extension(void (* xInit)(void))557 int sqlite3_auto_extension(void (*xInit)(void)){
558 int rc = SQLITE_OK;
559 #ifndef SQLITE_OMIT_AUTOINIT
560 rc = sqlite3_initialize();
561 if( rc ){
562 return rc;
563 }else
564 #endif
565 {
566 int i;
567 #if SQLITE_THREADSAFE
568 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
569 #endif
570 wsdAutoextInit;
571 sqlite3_mutex_enter(mutex);
572 for(i=0; i<wsdAutoext.nExt; i++){
573 if( wsdAutoext.aExt[i]==xInit ) break;
574 }
575 if( i==wsdAutoext.nExt ){
576 int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
577 void (**aNew)(void);
578 aNew = sqlite3_realloc(wsdAutoext.aExt, nByte);
579 if( aNew==0 ){
580 rc = SQLITE_NOMEM;
581 }else{
582 wsdAutoext.aExt = aNew;
583 wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
584 wsdAutoext.nExt++;
585 }
586 }
587 sqlite3_mutex_leave(mutex);
588 assert( (rc&0xff)==rc );
589 return rc;
590 }
591 }
592
593 /*
594 ** Reset the automatic extension loading mechanism.
595 */
sqlite3_reset_auto_extension(void)596 void sqlite3_reset_auto_extension(void){
597 #ifndef SQLITE_OMIT_AUTOINIT
598 if( sqlite3_initialize()==SQLITE_OK )
599 #endif
600 {
601 #if SQLITE_THREADSAFE
602 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
603 #endif
604 wsdAutoextInit;
605 sqlite3_mutex_enter(mutex);
606 sqlite3_free(wsdAutoext.aExt);
607 wsdAutoext.aExt = 0;
608 wsdAutoext.nExt = 0;
609 sqlite3_mutex_leave(mutex);
610 }
611 }
612
613 /*
614 ** Load all automatic extensions.
615 **
616 ** If anything goes wrong, set an error in the database connection.
617 */
sqlite3AutoLoadExtensions(sqlite3 * db)618 void sqlite3AutoLoadExtensions(sqlite3 *db){
619 int i;
620 int go = 1;
621 int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
622
623 wsdAutoextInit;
624 if( wsdAutoext.nExt==0 ){
625 /* Common case: early out without every having to acquire a mutex */
626 return;
627 }
628 for(i=0; go; i++){
629 char *zErrmsg;
630 #if SQLITE_THREADSAFE
631 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
632 #endif
633 sqlite3_mutex_enter(mutex);
634 if( i>=wsdAutoext.nExt ){
635 xInit = 0;
636 go = 0;
637 }else{
638 xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
639 wsdAutoext.aExt[i];
640 }
641 sqlite3_mutex_leave(mutex);
642 zErrmsg = 0;
643 if( xInit && xInit(db, &zErrmsg, &sqlite3Apis) ){
644 sqlite3Error(db, SQLITE_ERROR,
645 "automatic extension loading failed: %s", zErrmsg);
646 go = 0;
647 }
648 sqlite3_free(zErrmsg);
649 }
650 }
651