AryaWu/sqlite
0
1/*2** 2006 June 73**4** The author disclaims copyright to this source code. In place of5** 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 into13** the SQLite library.14*/15 16#ifndef SQLITE_CORE17 #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */18#endif19#include "sqlite3ext.h"20#include "sqliteInt.h"21 22#ifndef SQLITE_OMIT_LOAD_EXTENSION23/*24** Some API routines are omitted when various features are25** excluded from a build of SQLite. Substitute a NULL pointer26** for any missing APIs.27*/28#ifndef SQLITE_ENABLE_COLUMN_METADATA29# define sqlite3_column_database_name 030# define sqlite3_column_database_name16 031# define sqlite3_column_table_name 032# define sqlite3_column_table_name16 033# define sqlite3_column_origin_name 034# define sqlite3_column_origin_name16 035#endif36 37#ifdef SQLITE_OMIT_AUTHORIZATION38# define sqlite3_set_authorizer 039#endif40 41#ifdef SQLITE_OMIT_UTF1642# define sqlite3_bind_text16 043# define sqlite3_collation_needed16 044# define sqlite3_column_decltype16 045# define sqlite3_column_name16 046# define sqlite3_column_text16 047# define sqlite3_complete16 048# define sqlite3_create_collation16 049# define sqlite3_create_function16 050# define sqlite3_errmsg16 051# define sqlite3_open16 052# define sqlite3_prepare16 053# define sqlite3_prepare16_v2 054# define sqlite3_prepare16_v3 055# define sqlite3_result_error16 056# define sqlite3_result_text16 057# define sqlite3_result_text16be 058# define sqlite3_result_text16le 059# define sqlite3_value_text16 060# define sqlite3_value_text16be 061# define sqlite3_value_text16le 062# define sqlite3_column_database_name16 063# define sqlite3_column_table_name16 064# define sqlite3_column_origin_name16 065#endif66 67#ifdef SQLITE_OMIT_COMPLETE68# define sqlite3_complete 069# define sqlite3_complete16 070#endif71 72#ifdef SQLITE_OMIT_DECLTYPE73# define sqlite3_column_decltype16 074# define sqlite3_column_decltype 075#endif76 77#ifdef SQLITE_OMIT_PROGRESS_CALLBACK78# define sqlite3_progress_handler 079#endif80 81#ifdef SQLITE_OMIT_VIRTUALTABLE82# define sqlite3_create_module 083# define sqlite3_create_module_v2 084# define sqlite3_declare_vtab 085# define sqlite3_vtab_config 086# define sqlite3_vtab_on_conflict 087# define sqlite3_vtab_collation 088#endif89 90#ifdef SQLITE_OMIT_SHARED_CACHE91# define sqlite3_enable_shared_cache 092#endif93 94#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED)95# define sqlite3_profile 096# define sqlite3_trace 097#endif98 99#ifdef SQLITE_OMIT_GET_TABLE100# define sqlite3_free_table 0101# define sqlite3_get_table 0102#endif103 104#ifdef SQLITE_OMIT_INCRBLOB105#define sqlite3_bind_zeroblob 0106#define sqlite3_blob_bytes 0107#define sqlite3_blob_close 0108#define sqlite3_blob_open 0109#define sqlite3_blob_read 0110#define sqlite3_blob_write 0111#define sqlite3_blob_reopen 0112#endif113 114#if defined(SQLITE_OMIT_TRACE)115# define sqlite3_trace_v2 0116#endif117 118/*119** The following structure contains pointers to all SQLite API routines.120** A pointer to this structure is passed into extensions when they are121** loaded so that the extension can make calls back into the SQLite122** library.123**124** When adding new APIs, add them to the bottom of this structure125** in order to preserve backwards compatibility.126**127** Extensions that use newer APIs should first call the128** sqlite3_libversion_number() to make sure that the API they129** intend to use is supported by the library. Extensions should130** also check to make sure that the pointer to the function is131** not NULL before calling it.132*/133static const sqlite3_api_routines sqlite3Apis = {134 sqlite3_aggregate_context,135#ifndef SQLITE_OMIT_DEPRECATED136 sqlite3_aggregate_count,137#else138 0,139#endif140 sqlite3_bind_blob,141 sqlite3_bind_double,142 sqlite3_bind_int,143 sqlite3_bind_int64,144 sqlite3_bind_null,145 sqlite3_bind_parameter_count,146 sqlite3_bind_parameter_index,147 sqlite3_bind_parameter_name,148 sqlite3_bind_text,149 sqlite3_bind_text16,150 sqlite3_bind_value,151 sqlite3_busy_handler,152 sqlite3_busy_timeout,153 sqlite3_changes,154 sqlite3_close,155 sqlite3_collation_needed,156 sqlite3_collation_needed16,157 sqlite3_column_blob,158 sqlite3_column_bytes,159 sqlite3_column_bytes16,160 sqlite3_column_count,161 sqlite3_column_database_name,162 sqlite3_column_database_name16,163 sqlite3_column_decltype,164 sqlite3_column_decltype16,165 sqlite3_column_double,166 sqlite3_column_int,167 sqlite3_column_int64,168 sqlite3_column_name,169 sqlite3_column_name16,170 sqlite3_column_origin_name,171 sqlite3_column_origin_name16,172 sqlite3_column_table_name,173 sqlite3_column_table_name16,174 sqlite3_column_text,175 sqlite3_column_text16,176 sqlite3_column_type,177 sqlite3_column_value,178 sqlite3_commit_hook,179 sqlite3_complete,180 sqlite3_complete16,181 sqlite3_create_collation,182 sqlite3_create_collation16,183 sqlite3_create_function,184 sqlite3_create_function16,185 sqlite3_create_module,186 sqlite3_data_count,187 sqlite3_db_handle,188 sqlite3_declare_vtab,189 sqlite3_enable_shared_cache,190 sqlite3_errcode,191 sqlite3_errmsg,192 sqlite3_errmsg16,193 sqlite3_exec,194#ifndef SQLITE_OMIT_DEPRECATED195 sqlite3_expired,196#else197 0,198#endif199 sqlite3_finalize,200 sqlite3_free,201 sqlite3_free_table,202 sqlite3_get_autocommit,203 sqlite3_get_auxdata,204 sqlite3_get_table,205 0, /* Was sqlite3_global_recover(), but that function is deprecated */206 sqlite3_interrupt,207 sqlite3_last_insert_rowid,208 sqlite3_libversion,209 sqlite3_libversion_number,210 sqlite3_malloc,211 sqlite3_mprintf,212 sqlite3_open,213 sqlite3_open16,214 sqlite3_prepare,215 sqlite3_prepare16,216 sqlite3_profile,217 sqlite3_progress_handler,218 sqlite3_realloc,219 sqlite3_reset,220 sqlite3_result_blob,221 sqlite3_result_double,222 sqlite3_result_error,223 sqlite3_result_error16,224 sqlite3_result_int,225 sqlite3_result_int64,226 sqlite3_result_null,227 sqlite3_result_text,228 sqlite3_result_text16,229 sqlite3_result_text16be,230 sqlite3_result_text16le,231 sqlite3_result_value,232 sqlite3_rollback_hook,233 sqlite3_set_authorizer,234 sqlite3_set_auxdata,235 sqlite3_snprintf,236 sqlite3_step,237 sqlite3_table_column_metadata,238#ifndef SQLITE_OMIT_DEPRECATED239 sqlite3_thread_cleanup,240#else241 0,242#endif243 sqlite3_total_changes,244 sqlite3_trace,245#ifndef SQLITE_OMIT_DEPRECATED246 sqlite3_transfer_bindings,247#else248 0,249#endif250 sqlite3_update_hook,251 sqlite3_user_data,252 sqlite3_value_blob,253 sqlite3_value_bytes,254 sqlite3_value_bytes16,255 sqlite3_value_double,256 sqlite3_value_int,257 sqlite3_value_int64,258 sqlite3_value_numeric_type,259 sqlite3_value_text,260 sqlite3_value_text16,261 sqlite3_value_text16be,262 sqlite3_value_text16le,263 sqlite3_value_type,264 sqlite3_vmprintf,265 /*266 ** The original API set ends here. All extensions can call any267 ** of the APIs above provided that the pointer is not NULL. But268 ** before calling APIs that follow, extension should check the269 ** sqlite3_libversion_number() to make sure they are dealing with270 ** a library that is new enough to support that API.271 *************************************************************************272 */273 sqlite3_overload_function,274 275 /*276 ** Added after 3.3.13277 */278 sqlite3_prepare_v2,279 sqlite3_prepare16_v2,280 sqlite3_clear_bindings,281 282 /*283 ** Added for 3.4.1284 */285 sqlite3_create_module_v2,286 287 /*288 ** Added for 3.5.0289 */290 sqlite3_bind_zeroblob,291 sqlite3_blob_bytes,292 sqlite3_blob_close,293 sqlite3_blob_open,294 sqlite3_blob_read,295 sqlite3_blob_write,296 sqlite3_create_collation_v2,297 sqlite3_file_control,298 sqlite3_memory_highwater,299 sqlite3_memory_used,300#ifdef SQLITE_MUTEX_OMIT301 0, 302 0, 303 0,304 0,305 0,306#else307 sqlite3_mutex_alloc,308 sqlite3_mutex_enter,309 sqlite3_mutex_free,310 sqlite3_mutex_leave,311 sqlite3_mutex_try,312#endif313 sqlite3_open_v2,314 sqlite3_release_memory,315 sqlite3_result_error_nomem,316 sqlite3_result_error_toobig,317 sqlite3_sleep,318 sqlite3_soft_heap_limit,319 sqlite3_vfs_find,320 sqlite3_vfs_register,321 sqlite3_vfs_unregister,322 323 /*324 ** Added for 3.5.8325 */326 sqlite3_threadsafe,327 sqlite3_result_zeroblob,328 sqlite3_result_error_code,329 sqlite3_test_control,330 sqlite3_randomness,331 sqlite3_context_db_handle,332 333 /*334 ** Added for 3.6.0335 */336 sqlite3_extended_result_codes,337 sqlite3_limit,338 sqlite3_next_stmt,339 sqlite3_sql,340 sqlite3_status,341 342 /*343 ** Added for 3.7.4344 */345 sqlite3_backup_finish,346 sqlite3_backup_init,347 sqlite3_backup_pagecount,348 sqlite3_backup_remaining,349 sqlite3_backup_step,350#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS351 sqlite3_compileoption_get,352 sqlite3_compileoption_used,353#else354 0,355 0,356#endif357 sqlite3_create_function_v2,358 sqlite3_db_config,359 sqlite3_db_mutex,360 sqlite3_db_status,361 sqlite3_extended_errcode,362 sqlite3_log,363 sqlite3_soft_heap_limit64,364 sqlite3_sourceid,365 sqlite3_stmt_status,366 sqlite3_strnicmp,367#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY368 sqlite3_unlock_notify,369#else370 0,371#endif372#ifndef SQLITE_OMIT_WAL373 sqlite3_wal_autocheckpoint,374 sqlite3_wal_checkpoint,375 sqlite3_wal_hook,376#else377 0,378 0,379 0,380#endif381 sqlite3_blob_reopen,382 sqlite3_vtab_config,383 sqlite3_vtab_on_conflict,384 sqlite3_close_v2,385 sqlite3_db_filename,386 sqlite3_db_readonly,387 sqlite3_db_release_memory,388 sqlite3_errstr,389 sqlite3_stmt_busy,390 sqlite3_stmt_readonly,391 sqlite3_stricmp,392 sqlite3_uri_boolean,393 sqlite3_uri_int64,394 sqlite3_uri_parameter,395 sqlite3_vsnprintf,396 sqlite3_wal_checkpoint_v2,397 /* Version 3.8.7 and later */398 sqlite3_auto_extension,399 sqlite3_bind_blob64,400 sqlite3_bind_text64,401 sqlite3_cancel_auto_extension,402 sqlite3_load_extension,403 sqlite3_malloc64,404 sqlite3_msize,405 sqlite3_realloc64,406 sqlite3_reset_auto_extension,407 sqlite3_result_blob64,408 sqlite3_result_text64,409 sqlite3_strglob,410 /* Version 3.8.11 and later */411 (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup,412 sqlite3_value_free,413 sqlite3_result_zeroblob64,414 sqlite3_bind_zeroblob64,415 /* Version 3.9.0 and later */416 sqlite3_value_subtype,417 sqlite3_result_subtype,418 /* Version 3.10.0 and later */419 sqlite3_status64,420 sqlite3_strlike,421 sqlite3_db_cacheflush,422 /* Version 3.12.0 and later */423 sqlite3_system_errno,424 /* Version 3.14.0 and later */425 sqlite3_trace_v2,426 sqlite3_expanded_sql,427 /* Version 3.18.0 and later */428 sqlite3_set_last_insert_rowid,429 /* Version 3.20.0 and later */430 sqlite3_prepare_v3,431 sqlite3_prepare16_v3,432 sqlite3_bind_pointer,433 sqlite3_result_pointer,434 sqlite3_value_pointer,435 /* Version 3.22.0 and later */436 sqlite3_vtab_nochange,437 sqlite3_value_nochange,438 sqlite3_vtab_collation,439 /* Version 3.24.0 and later */440 sqlite3_keyword_count,441 sqlite3_keyword_name,442 sqlite3_keyword_check,443 sqlite3_str_new,444 sqlite3_str_finish,445 sqlite3_str_appendf,446 sqlite3_str_vappendf,447 sqlite3_str_append,448 sqlite3_str_appendall,449 sqlite3_str_appendchar,450 sqlite3_str_reset,451 sqlite3_str_errcode,452 sqlite3_str_length,453 sqlite3_str_value,454 /* Version 3.25.0 and later */455 sqlite3_create_window_function,456 /* Version 3.26.0 and later */457#ifdef SQLITE_ENABLE_NORMALIZE458 sqlite3_normalized_sql,459#else460 0,461#endif462 /* Version 3.28.0 and later */463 sqlite3_stmt_isexplain,464 sqlite3_value_frombind,465 /* Version 3.30.0 and later */466#ifndef SQLITE_OMIT_VIRTUALTABLE467 sqlite3_drop_modules,468#else469 0,470#endif471 /* Version 3.31.0 and later */472 sqlite3_hard_heap_limit64,473 sqlite3_uri_key,474 sqlite3_filename_database,475 sqlite3_filename_journal,476 sqlite3_filename_wal,477 /* Version 3.32.0 and later */478 sqlite3_create_filename,479 sqlite3_free_filename,480 sqlite3_database_file_object,481 /* Version 3.34.0 and later */482 sqlite3_txn_state,483 /* Version 3.36.1 and later */484 sqlite3_changes64,485 sqlite3_total_changes64,486 /* Version 3.37.0 and later */487 sqlite3_autovacuum_pages,488 /* Version 3.38.0 and later */489 sqlite3_error_offset,490#ifndef SQLITE_OMIT_VIRTUALTABLE491 sqlite3_vtab_rhs_value,492 sqlite3_vtab_distinct,493 sqlite3_vtab_in,494 sqlite3_vtab_in_first,495 sqlite3_vtab_in_next,496#else497 0,498 0,499 0,500 0,501 0,502#endif503 /* Version 3.39.0 and later */504#ifndef SQLITE_OMIT_DESERIALIZE505 sqlite3_deserialize,506 sqlite3_serialize,507#else508 0,509 0,510#endif511 sqlite3_db_name,512 /* Version 3.40.0 and later */513 sqlite3_value_encoding,514 /* Version 3.41.0 and later */515 sqlite3_is_interrupted,516 /* Version 3.43.0 and later */517 sqlite3_stmt_explain,518 /* Version 3.44.0 and later */519 sqlite3_get_clientdata,520 sqlite3_set_clientdata,521 /* Version 3.50.0 and later */522 sqlite3_setlk_timeout,523 /* Version 3.51.0 and later */524 sqlite3_set_errmsg,525 sqlite3_db_status64,526 /* Version 3.52.0 and later */527 sqlite3_str_truncate,528 sqlite3_str_free529};530 531/* True if x is the directory separator character532*/533#if SQLITE_OS_WIN534# define DirSep(X) ((X)=='/'||(X)=='\\')535#else536# define DirSep(X) ((X)=='/')537#endif538 539/*540** Attempt to load an SQLite extension library contained in the file541** zFile. The entry point is zProc. zProc may be 0 in which case a542** default entry point name (sqlite3_extension_init) is used. Use543** of the default name is recommended.544**545** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.546**547** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with 548** error message text. The calling function should free this memory549** by calling sqlite3DbFree(db, ).550*/551static int sqlite3LoadExtension(552 sqlite3 *db, /* Load the extension into this database connection */553 const char *zFile, /* Name of the shared library containing extension */554 const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */555 char **pzErrMsg /* Put error message here if not 0 */556){557 sqlite3_vfs *pVfs = db->pVfs;558 void *handle;559 sqlite3_loadext_entry xInit;560 char *zErrmsg = 0;561 const char *zEntry;562 char *zAltEntry = 0;563 void **aHandle;564 u64 nMsg = strlen(zFile);565 int ii;566 int rc;567 568 /* Shared library endings to try if zFile cannot be loaded as written */569 static const char *azEndings[] = {570#if SQLITE_OS_WIN571 "dll" 572#elif defined(__APPLE__)573 "dylib"574#else575 "so"576#endif577 };578 579 580 if( pzErrMsg ) *pzErrMsg = 0;581 582 /* Ticket #1863. To avoid a creating security problems for older583 ** applications that relink against newer versions of SQLite, the584 ** ability to run load_extension is turned off by default. One585 ** must call either sqlite3_enable_load_extension(db) or586 ** sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, 0)587 ** to turn on extension loading.588 */589 if( (db->flags & SQLITE_LoadExtension)==0 ){590 if( pzErrMsg ){591 *pzErrMsg = sqlite3_mprintf("not authorized");592 }593 return SQLITE_ERROR;594 }595 596 zEntry = zProc ? zProc : "sqlite3_extension_init";597 598 /* tag-20210611-1. Some dlopen() implementations will segfault if given599 ** an oversize filename. Most filesystems have a pathname limit of 4K,600 ** so limit the extension filename length to about twice that.601 ** https://sqlite.org/forum/forumpost/08a0d6d9bf602 **603 ** Later (2023-03-25): Save an extra 6 bytes for the filename suffix.604 ** See https://sqlite.org/forum/forumpost/24083b579d.605 */606 if( nMsg>SQLITE_MAX_PATHLEN ) goto extension_not_found;607 608 /* Do not allow sqlite3_load_extension() to link to a copy of the609 ** running application, by passing in an empty filename. */610 if( nMsg==0 ) goto extension_not_found;611 612 handle = sqlite3OsDlOpen(pVfs, zFile);613#if SQLITE_OS_UNIX || SQLITE_OS_WIN614 for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){615 char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);616 if( zAltFile==0 ) return SQLITE_NOMEM_BKPT;617 if( nMsg+strlen(azEndings[ii])+1<=SQLITE_MAX_PATHLEN ){618 handle = sqlite3OsDlOpen(pVfs, zAltFile);619 }620 sqlite3_free(zAltFile);621 }622#endif623 if( handle==0 ) goto extension_not_found;624 xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);625 626 /* If no entry point was specified and the default legacy627 ** entry point name "sqlite3_extension_init" was not found, then628 ** construct an entry point name "sqlite3_X_init" where the X is629 ** replaced by the lowercase value of every ASCII alphabetic 630 ** character in the filename after the last "/" upto the first ".",631 ** and eliding the first three characters if they are "lib". 632 ** Examples:633 **634 ** /usr/local/lib/libExample5.4.3.so ==> sqlite3_example_init635 ** C:/lib/mathfuncs.dll ==> sqlite3_mathfuncs_init636 */637 if( xInit==0 && zProc==0 ){638 int iFile, iEntry, c;639 int ncFile = sqlite3Strlen30(zFile);640 zAltEntry = sqlite3_malloc64(ncFile+30);641 if( zAltEntry==0 ){642 sqlite3OsDlClose(pVfs, handle);643 return SQLITE_NOMEM_BKPT;644 }645 memcpy(zAltEntry, "sqlite3_", 8);646 for(iFile=ncFile-1; iFile>=0 && !DirSep(zFile[iFile]); iFile--){}647 iFile++;648 if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3;649 for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){650 if( sqlite3Isalpha(c) ){651 zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];652 }653 }654 memcpy(zAltEntry+iEntry, "_init", 6);655 zEntry = zAltEntry;656 xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);657 }658 if( xInit==0 ){659 if( pzErrMsg ){660 nMsg += strlen(zEntry) + 300;661 *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);662 if( zErrmsg ){663 assert( nMsg<0x7fffffff ); /* zErrmsg would be NULL if not so */664 sqlite3_snprintf((int)nMsg, zErrmsg,665 "no entry point [%s] in shared library [%s]", zEntry, zFile);666 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);667 }668 }669 sqlite3OsDlClose(pVfs, handle);670 sqlite3_free(zAltEntry);671 return SQLITE_ERROR;672 }673 sqlite3_free(zAltEntry);674 rc = xInit(db, &zErrmsg, &sqlite3Apis);675 if( rc ){676 if( rc==SQLITE_OK_LOAD_PERMANENTLY ) return SQLITE_OK;677 if( pzErrMsg ){678 *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);679 }680 sqlite3_free(zErrmsg);681 sqlite3OsDlClose(pVfs, handle);682 return SQLITE_ERROR;683 }684 685 /* Append the new shared library handle to the db->aExtension array. */686 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));687 if( aHandle==0 ){688 return SQLITE_NOMEM_BKPT;689 }690 if( db->nExtension>0 ){691 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);692 }693 sqlite3DbFree(db, db->aExtension);694 db->aExtension = aHandle;695 696 db->aExtension[db->nExtension++] = handle;697 return SQLITE_OK;698 699extension_not_found:700 if( pzErrMsg ){701 nMsg += 300;702 *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);703 if( zErrmsg ){704 assert( nMsg<0x7fffffff ); /* zErrmsg would be NULL if not so */705 sqlite3_snprintf((int)nMsg, zErrmsg,706 "unable to open shared library [%.*s]", SQLITE_MAX_PATHLEN, zFile);707 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);708 }709 }710 return SQLITE_ERROR;711}712int sqlite3_load_extension(713 sqlite3 *db, /* Load the extension into this database connection */714 const char *zFile, /* Name of the shared library containing extension */715 const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */716 char **pzErrMsg /* Put error message here if not 0 */717){718 int rc;719 sqlite3_mutex_enter(db->mutex);720 rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);721 rc = sqlite3ApiExit(db, rc);722 sqlite3_mutex_leave(db->mutex);723 return rc;724}725 726/*727** Call this routine when the database connection is closing in order728** to clean up loaded extensions729*/730void sqlite3CloseExtensions(sqlite3 *db){731 int i;732 assert( sqlite3_mutex_held(db->mutex) );733 for(i=0; i<db->nExtension; i++){734 sqlite3OsDlClose(db->pVfs, db->aExtension[i]);735 }736 sqlite3DbFree(db, db->aExtension);737}738 739/*740** Enable or disable extension loading. Extension loading is disabled by741** default so as not to open security holes in older applications.742*/743int sqlite3_enable_load_extension(sqlite3 *db, int onoff){744#ifdef SQLITE_ENABLE_API_ARMOR745 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;746#endif747 sqlite3_mutex_enter(db->mutex);748 if( onoff ){749 db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;750 }else{751 db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc);752 }753 sqlite3_mutex_leave(db->mutex);754 return SQLITE_OK;755}756 757#endif /* !defined(SQLITE_OMIT_LOAD_EXTENSION) */758 759/*760** The following object holds the list of automatically loaded761** extensions.762**763** This list is shared across threads. The SQLITE_MUTEX_STATIC_MAIN764** mutex must be held while accessing this list.765*/766typedef struct sqlite3AutoExtList sqlite3AutoExtList;767static SQLITE_WSD struct sqlite3AutoExtList {768 u32 nExt; /* Number of entries in aExt[] */769 void (**aExt)(void); /* Pointers to the extension init functions */770} sqlite3Autoext = { 0, 0 };771 772/* The "wsdAutoext" macro will resolve to the autoextension773** state vector. If writable static data is unsupported on the target,774** we have to locate the state vector at run-time. In the more common775** case where writable static data is supported, wsdStat can refer directly776** to the "sqlite3Autoext" state vector declared above.777*/778#ifdef SQLITE_OMIT_WSD779# define wsdAutoextInit \780 sqlite3AutoExtList *x = &GLOBAL(sqlite3AutoExtList,sqlite3Autoext)781# define wsdAutoext x[0]782#else783# define wsdAutoextInit784# define wsdAutoext sqlite3Autoext785#endif786 787 788/*789** Register a statically linked extension that is automatically790** loaded by every new database connection.791*/792int sqlite3_auto_extension(793 void (*xInit)(void)794){795 int rc = SQLITE_OK;796#ifdef SQLITE_ENABLE_API_ARMOR797 if( xInit==0 ) return SQLITE_MISUSE_BKPT;798#endif799#ifndef SQLITE_OMIT_AUTOINIT800 rc = sqlite3_initialize();801 if( rc ){802 return rc;803 }else804#endif805 {806 u32 i;807#if SQLITE_THREADSAFE808 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);809#endif810 wsdAutoextInit;811 sqlite3_mutex_enter(mutex);812 for(i=0; i<wsdAutoext.nExt; i++){813 if( wsdAutoext.aExt[i]==xInit ) break;814 }815 if( i==wsdAutoext.nExt ){816 u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);817 void (**aNew)(void);818 aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);819 if( aNew==0 ){820 rc = SQLITE_NOMEM_BKPT;821 }else{822 wsdAutoext.aExt = aNew;823 wsdAutoext.aExt[wsdAutoext.nExt] = xInit;824 wsdAutoext.nExt++;825 }826 }827 sqlite3_mutex_leave(mutex);828 assert( (rc&0xff)==rc );829 return rc;830 }831}832 833/*834** Cancel a prior call to sqlite3_auto_extension. Remove xInit from the835** set of routines that is invoked for each new database connection, if it836** is currently on the list. If xInit is not on the list, then this837** routine is a no-op.838**839** Return 1 if xInit was found on the list and removed. Return 0 if xInit840** was not on the list.841*/842int sqlite3_cancel_auto_extension(843 void (*xInit)(void)844){845#if SQLITE_THREADSAFE846 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);847#endif848 int i;849 int n = 0;850 wsdAutoextInit;851#ifdef SQLITE_ENABLE_API_ARMOR852 if( xInit==0 ) return 0;853#endif854 sqlite3_mutex_enter(mutex);855 for(i=(int)wsdAutoext.nExt-1; i>=0; i--){856 if( wsdAutoext.aExt[i]==xInit ){857 wsdAutoext.nExt--;858 wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt];859 n++;860 break;861 }862 }863 sqlite3_mutex_leave(mutex);864 return n;865}866 867/*868** Reset the automatic extension loading mechanism.869*/870void sqlite3_reset_auto_extension(void){871#ifndef SQLITE_OMIT_AUTOINIT872 if( sqlite3_initialize()==SQLITE_OK )873#endif874 {875#if SQLITE_THREADSAFE876 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);877#endif878 wsdAutoextInit;879 sqlite3_mutex_enter(mutex);880 sqlite3_free(wsdAutoext.aExt);881 wsdAutoext.aExt = 0;882 wsdAutoext.nExt = 0;883 sqlite3_mutex_leave(mutex);884 }885}886 887/*888** Load all automatic extensions.889**890** If anything goes wrong, set an error in the database connection.891*/892void sqlite3AutoLoadExtensions(sqlite3 *db){893 u32 i;894 int go = 1;895 int rc;896 sqlite3_loadext_entry xInit;897 898 wsdAutoextInit;899 if( wsdAutoext.nExt==0 ){900 /* Common case: early out without every having to acquire a mutex */901 return;902 }903 for(i=0; go; i++){904 char *zErrmsg;905#if SQLITE_THREADSAFE906 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);907#endif908#ifdef SQLITE_OMIT_LOAD_EXTENSION909 const sqlite3_api_routines *pThunk = 0;910#else911 const sqlite3_api_routines *pThunk = &sqlite3Apis;912#endif913 sqlite3_mutex_enter(mutex);914 if( i>=wsdAutoext.nExt ){915 xInit = 0;916 go = 0;917 }else{918 xInit = (sqlite3_loadext_entry)wsdAutoext.aExt[i];919 }920 sqlite3_mutex_leave(mutex);921 zErrmsg = 0;922 if( xInit && (rc = xInit(db, &zErrmsg, pThunk))!=0 ){923 sqlite3ErrorWithMsg(db, rc,924 "automatic extension loading failed: %s", zErrmsg);925 go = 0;926 }927 sqlite3_free(zErrmsg);928 }929}930