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