Annotation of embedaddon/sqlite3/src/loadext.c, revision 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