1 /* 2 ** 2001 September 15 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 ** Utility functions used throughout sqlite. 13 ** 14 ** This file contains functions for allocating memory, comparing 15 ** strings, and stuff like that. 16 ** 17 ** $Id: util.c,v 1.199 2007/04/06 02:32:34 drh Exp $ 18 */ 19 #include "sqliteInt.h" 20 #include "os.h" 21 #include <stdarg.h> 22 #include <ctype.h> 23 24 /* 25 ** MALLOC WRAPPER ARCHITECTURE 26 ** 27 ** The sqlite code accesses dynamic memory allocation/deallocation by invoking 28 ** the following six APIs (which may be implemented as macros). 29 ** 30 ** sqlite3Malloc() 31 ** sqlite3MallocRaw() 32 ** sqlite3Realloc() 33 ** sqlite3ReallocOrFree() 34 ** sqlite3Free() 35 ** sqlite3AllocSize() 36 ** 37 ** The function sqlite3FreeX performs the same task as sqlite3Free and is 38 ** guaranteed to be a real function. The same holds for sqlite3MallocX 39 ** 40 ** The above APIs are implemented in terms of the functions provided in the 41 ** operating-system interface. The OS interface is never accessed directly 42 ** by code outside of this file. 43 ** 44 ** sqlite3OsMalloc() 45 ** sqlite3OsRealloc() 46 ** sqlite3OsFree() 47 ** sqlite3OsAllocationSize() 48 ** 49 ** Functions sqlite3MallocRaw() and sqlite3Realloc() may invoke 50 ** sqlite3_release_memory() if a call to sqlite3OsMalloc() or 51 ** sqlite3OsRealloc() fails (or if the soft-heap-limit for the thread is 52 ** exceeded). Function sqlite3Malloc() usually invokes 53 ** sqlite3MallocRaw(). 54 ** 55 ** MALLOC TEST WRAPPER ARCHITECTURE 56 ** 57 ** The test wrapper provides extra test facilities to ensure the library 58 ** does not leak memory and handles the failure of the underlying OS level 59 ** allocation system correctly. It is only present if the library is 60 ** compiled with the SQLITE_MEMDEBUG macro set. 61 ** 62 ** * Guardposts to detect overwrites. 63 ** * Ability to cause a specific Malloc() or Realloc() to fail. 64 ** * Audit outstanding memory allocations (i.e check for leaks). 65 */ 66 67 #define MAX(x,y) ((x)>(y)?(x):(y)) 68 69 #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO) 70 /* 71 ** Set the soft heap-size limit for the current thread. Passing a negative 72 ** value indicates no limit. 73 */ 74 void sqlite3_soft_heap_limit(int n){ 75 ThreadData *pTd = sqlite3ThreadData(); 76 if( pTd ){ 77 pTd->nSoftHeapLimit = n; 78 } 79 sqlite3ReleaseThreadData(); 80 } 81 82 /* 83 ** Release memory held by SQLite instances created by the current thread. 84 */ 85 int sqlite3_release_memory(int n){ 86 return sqlite3PagerReleaseMemory(n); 87 } 88 #else 89 /* If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, then define a version 90 ** of sqlite3_release_memory() to be used by other code in this file. 91 ** This is done for no better reason than to reduce the number of 92 ** pre-processor #ifndef statements. 93 */ 94 #define sqlite3_release_memory(x) 0 /* 0 == no memory freed */ 95 #endif 96 97 #ifdef SQLITE_MEMDEBUG 98 /*-------------------------------------------------------------------------- 99 ** Begin code for memory allocation system test layer. 100 ** 101 ** Memory debugging is turned on by defining the SQLITE_MEMDEBUG macro. 102 ** 103 ** SQLITE_MEMDEBUG==1 -> Fence-posting only (thread safe) 104 ** SQLITE_MEMDEBUG==2 -> Fence-posting + linked list of allocations (not ts) 105 ** SQLITE_MEMDEBUG==3 -> Above + backtraces (not thread safe, req. glibc) 106 */ 107 108 /* Figure out whether or not to store backtrace() information for each malloc. 109 ** The backtrace() function is only used if SQLITE_MEMDEBUG is set to 2 or 110 ** greater and glibc is in use. If we don't want to use backtrace(), then just 111 ** define it as an empty macro and set the amount of space reserved to 0. 112 */ 113 #if defined(__GLIBC__) && SQLITE_MEMDEBUG>2 114 extern int backtrace(void **, int); 115 #define TESTALLOC_STACKSIZE 128 116 #define TESTALLOC_STACKFRAMES ((TESTALLOC_STACKSIZE-8)/sizeof(void*)) 117 #else 118 #define backtrace(x, y) 119 #define TESTALLOC_STACKSIZE 0 120 #define TESTALLOC_STACKFRAMES 0 121 #endif 122 123 /* 124 ** Number of 32-bit guard words. This should probably be a multiple of 125 ** 2 since on 64-bit machines we want the value returned by sqliteMalloc() 126 ** to be 8-byte aligned. 127 */ 128 #ifndef TESTALLOC_NGUARD 129 # define TESTALLOC_NGUARD 2 130 #endif 131 132 /* 133 ** Size reserved for storing file-name along with each malloc()ed blob. 134 */ 135 #define TESTALLOC_FILESIZE 64 136 137 /* 138 ** Size reserved for storing the user string. Each time a Malloc() or Realloc() 139 ** call succeeds, up to TESTALLOC_USERSIZE bytes of the string pointed to by 140 ** sqlite3_malloc_id are stored along with the other test system metadata. 141 */ 142 #define TESTALLOC_USERSIZE 64 143 const char *sqlite3_malloc_id = 0; 144 145 /* 146 ** Blocks used by the test layer have the following format: 147 ** 148 ** <sizeof(void *) pNext pointer> 149 ** <sizeof(void *) pPrev pointer> 150 ** <TESTALLOC_NGUARD 32-bit guard words> 151 ** <The application level allocation> 152 ** <TESTALLOC_NGUARD 32-bit guard words> 153 ** <32-bit line number> 154 ** <TESTALLOC_FILESIZE bytes containing null-terminated file name> 155 ** <TESTALLOC_STACKSIZE bytes of backtrace() output> 156 */ 157 158 #define TESTALLOC_OFFSET_GUARD1(p) (sizeof(void *) * 2) 159 #define TESTALLOC_OFFSET_DATA(p) ( \ 160 TESTALLOC_OFFSET_GUARD1(p) + sizeof(u32) * TESTALLOC_NGUARD \ 161 ) 162 #define TESTALLOC_OFFSET_GUARD2(p) ( \ 163 TESTALLOC_OFFSET_DATA(p) + sqlite3OsAllocationSize(p) - TESTALLOC_OVERHEAD \ 164 ) 165 #define TESTALLOC_OFFSET_LINENUMBER(p) ( \ 166 TESTALLOC_OFFSET_GUARD2(p) + sizeof(u32) * TESTALLOC_NGUARD \ 167 ) 168 #define TESTALLOC_OFFSET_FILENAME(p) ( \ 169 TESTALLOC_OFFSET_LINENUMBER(p) + sizeof(u32) \ 170 ) 171 #define TESTALLOC_OFFSET_USER(p) ( \ 172 TESTALLOC_OFFSET_FILENAME(p) + TESTALLOC_FILESIZE \ 173 ) 174 #define TESTALLOC_OFFSET_STACK(p) ( \ 175 TESTALLOC_OFFSET_USER(p) + TESTALLOC_USERSIZE + 8 - \ 176 (TESTALLOC_OFFSET_USER(p) % 8) \ 177 ) 178 179 #define TESTALLOC_OVERHEAD ( \ 180 sizeof(void *)*2 + /* pPrev and pNext pointers */ \ 181 TESTALLOC_NGUARD*sizeof(u32)*2 + /* Guard words */ \ 182 sizeof(u32) + TESTALLOC_FILESIZE + /* File and line number */ \ 183 TESTALLOC_USERSIZE + /* User string */ \ 184 TESTALLOC_STACKSIZE /* backtrace() stack */ \ 185 ) 186 187 188 /* 189 ** For keeping track of the number of mallocs and frees. This 190 ** is used to check for memory leaks. The iMallocFail and iMallocReset 191 ** values are used to simulate malloc() failures during testing in 192 ** order to verify that the library correctly handles an out-of-memory 193 ** condition. 194 */ 195 int sqlite3_nMalloc; /* Number of sqliteMalloc() calls */ 196 int sqlite3_nFree; /* Number of sqliteFree() calls */ 197 int sqlite3_memUsed; /* TODO Total memory obtained from malloc */ 198 int sqlite3_memMax; /* TODO Mem usage high-water mark */ 199 int sqlite3_iMallocFail; /* Fail sqliteMalloc() after this many calls */ 200 int sqlite3_iMallocReset = -1; /* When iMallocFail reaches 0, set to this */ 201 202 void *sqlite3_pFirst = 0; /* Pointer to linked list of allocations */ 203 int sqlite3_nMaxAlloc = 0; /* High water mark of ThreadData.nAlloc */ 204 int sqlite3_mallocDisallowed = 0; /* assert() in sqlite3Malloc() if set */ 205 int sqlite3_isFail = 0; /* True if all malloc calls should fail */ 206 const char *sqlite3_zFile = 0; /* Filename to associate debug info with */ 207 int sqlite3_iLine = 0; /* Line number for debug info */ 208 209 /* 210 ** Check for a simulated memory allocation failure. Return true if 211 ** the failure should be simulated. Return false to proceed as normal. 212 */ 213 int sqlite3TestMallocFail(){ 214 if( sqlite3_isFail ){ 215 return 1; 216 } 217 if( sqlite3_iMallocFail>=0 ){ 218 sqlite3_iMallocFail--; 219 if( sqlite3_iMallocFail==0 ){ 220 sqlite3_iMallocFail = sqlite3_iMallocReset; 221 sqlite3_isFail = 1; 222 return 1; 223 } 224 } 225 return 0; 226 } 227 228 /* 229 ** The argument is a pointer returned by sqlite3OsMalloc() or xRealloc(). 230 ** assert() that the first and last (TESTALLOC_NGUARD*4) bytes are set to the 231 ** values set by the applyGuards() function. 232 */ 233 static void checkGuards(u32 *p) 234 { 235 int i; 236 char *zAlloc = (char *)p; 237 char *z; 238 239 /* First set of guard words */ 240 z = &zAlloc[TESTALLOC_OFFSET_GUARD1(p)]; 241 for(i=0; i<TESTALLOC_NGUARD; i++){ 242 assert(((u32 *)z)[i]==0xdead1122); 243 } 244 245 /* Second set of guard words */ 246 z = &zAlloc[TESTALLOC_OFFSET_GUARD2(p)]; 247 for(i=0; i<TESTALLOC_NGUARD; i++){ 248 u32 guard = 0; 249 memcpy(&guard, &z[i*sizeof(u32)], sizeof(u32)); 250 assert(guard==0xdead3344); 251 } 252 } 253 254 /* 255 ** The argument is a pointer returned by sqlite3OsMalloc() or Realloc(). The 256 ** first and last (TESTALLOC_NGUARD*4) bytes are set to known values for use as 257 ** guard-posts. 258 */ 259 static void applyGuards(u32 *p) 260 { 261 int i; 262 char *z; 263 char *zAlloc = (char *)p; 264 265 /* First set of guard words */ 266 z = &zAlloc[TESTALLOC_OFFSET_GUARD1(p)]; 267 for(i=0; i<TESTALLOC_NGUARD; i++){ 268 ((u32 *)z)[i] = 0xdead1122; 269 } 270 271 /* Second set of guard words */ 272 z = &zAlloc[TESTALLOC_OFFSET_GUARD2(p)]; 273 for(i=0; i<TESTALLOC_NGUARD; i++){ 274 static const int guard = 0xdead3344; 275 memcpy(&z[i*sizeof(u32)], &guard, sizeof(u32)); 276 } 277 278 /* Line number */ 279 z = &((char *)z)[TESTALLOC_NGUARD*sizeof(u32)]; /* Guard words */ 280 z = &zAlloc[TESTALLOC_OFFSET_LINENUMBER(p)]; 281 memcpy(z, &sqlite3_iLine, sizeof(u32)); 282 283 /* File name */ 284 z = &zAlloc[TESTALLOC_OFFSET_FILENAME(p)]; 285 strncpy(z, sqlite3_zFile, TESTALLOC_FILESIZE); 286 z[TESTALLOC_FILESIZE - 1] = '\0'; 287 288 /* User string */ 289 z = &zAlloc[TESTALLOC_OFFSET_USER(p)]; 290 z[0] = 0; 291 if( sqlite3_malloc_id ){ 292 strncpy(z, sqlite3_malloc_id, TESTALLOC_USERSIZE); 293 z[TESTALLOC_USERSIZE-1] = 0; 294 } 295 296 /* backtrace() stack */ 297 z = &zAlloc[TESTALLOC_OFFSET_STACK(p)]; 298 backtrace((void **)z, TESTALLOC_STACKFRAMES); 299 300 /* Sanity check to make sure checkGuards() is working */ 301 checkGuards(p); 302 } 303 304 /* 305 ** The argument is a malloc()ed pointer as returned by the test-wrapper. 306 ** Return a pointer to the Os level allocation. 307 */ 308 static void *getOsPointer(void *p) 309 { 310 char *z = (char *)p; 311 return (void *)(&z[-1 * TESTALLOC_OFFSET_DATA(p)]); 312 } 313 314 315 #if SQLITE_MEMDEBUG>1 316 /* 317 ** The argument points to an Os level allocation. Link it into the threads list 318 ** of allocations. 319 */ 320 static void linkAlloc(void *p){ 321 void **pp = (void **)p; 322 pp[0] = 0; 323 pp[1] = sqlite3_pFirst; 324 if( sqlite3_pFirst ){ 325 ((void **)sqlite3_pFirst)[0] = p; 326 } 327 sqlite3_pFirst = p; 328 } 329 330 /* 331 ** The argument points to an Os level allocation. Unlinke it from the threads 332 ** list of allocations. 333 */ 334 static void unlinkAlloc(void *p) 335 { 336 void **pp = (void **)p; 337 if( p==sqlite3_pFirst ){ 338 assert(!pp[0]); 339 assert(!pp[1] || ((void **)(pp[1]))[0]==p); 340 sqlite3_pFirst = pp[1]; 341 if( sqlite3_pFirst ){ 342 ((void **)sqlite3_pFirst)[0] = 0; 343 } 344 }else{ 345 void **pprev = pp[0]; 346 void **pnext = pp[1]; 347 assert(pprev); 348 assert(pprev[1]==p); 349 pprev[1] = (void *)pnext; 350 if( pnext ){ 351 assert(pnext[0]==p); 352 pnext[0] = (void *)pprev; 353 } 354 } 355 } 356 357 /* 358 ** Pointer p is a pointer to an OS level allocation that has just been 359 ** realloc()ed. Set the list pointers that point to this entry to it's new 360 ** location. 361 */ 362 static void relinkAlloc(void *p) 363 { 364 void **pp = (void **)p; 365 if( pp[0] ){ 366 ((void **)(pp[0]))[1] = p; 367 }else{ 368 sqlite3_pFirst = p; 369 } 370 if( pp[1] ){ 371 ((void **)(pp[1]))[0] = p; 372 } 373 } 374 #else 375 #define linkAlloc(x) 376 #define relinkAlloc(x) 377 #define unlinkAlloc(x) 378 #endif 379 380 /* 381 ** This function sets the result of the Tcl interpreter passed as an argument 382 ** to a list containing an entry for each currently outstanding call made to 383 ** sqliteMalloc and friends by the current thread. Each list entry is itself a 384 ** list, consisting of the following (in order): 385 ** 386 ** * The number of bytes allocated 387 ** * The __FILE__ macro at the time of the sqliteMalloc() call. 388 ** * The __LINE__ macro ... 389 ** * The value of the sqlite3_malloc_id variable ... 390 ** * The output of backtrace() (if available) ... 391 ** 392 ** Todo: We could have a version of this function that outputs to stdout, 393 ** to debug memory leaks when Tcl is not available. 394 */ 395 #if defined(TCLSH) && defined(SQLITE_DEBUG) && SQLITE_MEMDEBUG>1 396 #include <tcl.h> 397 int sqlite3OutstandingMallocs(Tcl_Interp *interp){ 398 void *p; 399 Tcl_Obj *pRes = Tcl_NewObj(); 400 Tcl_IncrRefCount(pRes); 401 402 403 for(p=sqlite3_pFirst; p; p=((void **)p)[1]){ 404 Tcl_Obj *pEntry = Tcl_NewObj(); 405 Tcl_Obj *pStack = Tcl_NewObj(); 406 char *z; 407 u32 iLine; 408 int nBytes = sqlite3OsAllocationSize(p) - TESTALLOC_OVERHEAD; 409 char *zAlloc = (char *)p; 410 int i; 411 412 Tcl_ListObjAppendElement(0, pEntry, Tcl_NewIntObj(nBytes)); 413 414 z = &zAlloc[TESTALLOC_OFFSET_FILENAME(p)]; 415 Tcl_ListObjAppendElement(0, pEntry, Tcl_NewStringObj(z, -1)); 416 417 z = &zAlloc[TESTALLOC_OFFSET_LINENUMBER(p)]; 418 memcpy(&iLine, z, sizeof(u32)); 419 Tcl_ListObjAppendElement(0, pEntry, Tcl_NewIntObj(iLine)); 420 421 z = &zAlloc[TESTALLOC_OFFSET_USER(p)]; 422 Tcl_ListObjAppendElement(0, pEntry, Tcl_NewStringObj(z, -1)); 423 424 z = &zAlloc[TESTALLOC_OFFSET_STACK(p)]; 425 for(i=0; i<TESTALLOC_STACKFRAMES; i++){ 426 char zHex[128]; 427 sprintf(zHex, "%p", ((void **)z)[i]); 428 Tcl_ListObjAppendElement(0, pStack, Tcl_NewStringObj(zHex, -1)); 429 } 430 431 Tcl_ListObjAppendElement(0, pEntry, pStack); 432 Tcl_ListObjAppendElement(0, pRes, pEntry); 433 } 434 435 Tcl_ResetResult(interp); 436 Tcl_SetObjResult(interp, pRes); 437 Tcl_DecrRefCount(pRes); 438 return TCL_OK; 439 } 440 #endif 441 442 /* 443 ** This is the test layer's wrapper around sqlite3OsMalloc(). 444 */ 445 static void * OSMALLOC(int n){ 446 sqlite3OsEnterMutex(); 447 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 448 sqlite3_nMaxAlloc = 449 MAX(sqlite3_nMaxAlloc, sqlite3ThreadDataReadOnly()->nAlloc); 450 #endif 451 assert( !sqlite3_mallocDisallowed ); 452 if( !sqlite3TestMallocFail() ){ 453 u32 *p; 454 p = (u32 *)sqlite3OsMalloc(n + TESTALLOC_OVERHEAD); 455 assert(p); 456 sqlite3_nMalloc++; 457 applyGuards(p); 458 linkAlloc(p); 459 sqlite3OsLeaveMutex(); 460 return (void *)(&p[TESTALLOC_NGUARD + 2*sizeof(void *)/sizeof(u32)]); 461 } 462 sqlite3OsLeaveMutex(); 463 return 0; 464 } 465 466 static int OSSIZEOF(void *p){ 467 if( p ){ 468 u32 *pOs = (u32 *)getOsPointer(p); 469 return sqlite3OsAllocationSize(pOs) - TESTALLOC_OVERHEAD; 470 } 471 return 0; 472 } 473 474 /* 475 ** This is the test layer's wrapper around sqlite3OsFree(). The argument is a 476 ** pointer to the space allocated for the application to use. 477 */ 478 static void OSFREE(void *pFree){ 479 u32 *p; /* Pointer to the OS-layer allocation */ 480 sqlite3OsEnterMutex(); 481 p = (u32 *)getOsPointer(pFree); 482 checkGuards(p); 483 unlinkAlloc(p); 484 memset(pFree, 0x55, OSSIZEOF(pFree)); 485 sqlite3OsFree(p); 486 sqlite3_nFree++; 487 sqlite3OsLeaveMutex(); 488 } 489 490 /* 491 ** This is the test layer's wrapper around sqlite3OsRealloc(). 492 */ 493 static void * OSREALLOC(void *pRealloc, int n){ 494 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 495 sqlite3_nMaxAlloc = 496 MAX(sqlite3_nMaxAlloc, sqlite3ThreadDataReadOnly()->nAlloc); 497 #endif 498 assert( !sqlite3_mallocDisallowed ); 499 if( !sqlite3TestMallocFail() ){ 500 u32 *p = (u32 *)getOsPointer(pRealloc); 501 checkGuards(p); 502 p = sqlite3OsRealloc(p, n + TESTALLOC_OVERHEAD); 503 applyGuards(p); 504 relinkAlloc(p); 505 return (void *)(&p[TESTALLOC_NGUARD + 2*sizeof(void *)/sizeof(u32)]); 506 } 507 return 0; 508 } 509 510 static void OSMALLOC_FAILED(){ 511 sqlite3_isFail = 0; 512 } 513 514 #else 515 /* Define macros to call the sqlite3OsXXX interface directly if 516 ** the SQLITE_MEMDEBUG macro is not defined. 517 */ 518 #define OSMALLOC(x) sqlite3OsMalloc(x) 519 #define OSREALLOC(x,y) sqlite3OsRealloc(x,y) 520 #define OSFREE(x) sqlite3OsFree(x) 521 #define OSSIZEOF(x) sqlite3OsAllocationSize(x) 522 #define OSMALLOC_FAILED() 523 524 #endif /* SQLITE_MEMDEBUG */ 525 /* 526 ** End code for memory allocation system test layer. 527 **--------------------------------------------------------------------------*/ 528 529 /* 530 ** This routine is called when we are about to allocate n additional bytes 531 ** of memory. If the new allocation will put is over the soft allocation 532 ** limit, then invoke sqlite3_release_memory() to try to release some 533 ** memory before continuing with the allocation. 534 ** 535 ** This routine also makes sure that the thread-specific-data (TSD) has 536 ** be allocated. If it has not and can not be allocated, then return 537 ** false. The updateMemoryUsedCount() routine below will deallocate 538 ** the TSD if it ought to be. 539 ** 540 ** If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, this routine is 541 ** a no-op 542 */ 543 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 544 static int enforceSoftLimit(int n){ 545 ThreadData *pTsd = sqlite3ThreadData(); 546 if( pTsd==0 ){ 547 return 0; 548 } 549 assert( pTsd->nAlloc>=0 ); 550 if( n>0 && pTsd->nSoftHeapLimit>0 ){ 551 while( pTsd->nAlloc+n>pTsd->nSoftHeapLimit && sqlite3_release_memory(n) ){} 552 } 553 return 1; 554 } 555 #else 556 # define enforceSoftLimit(X) 1 557 #endif 558 559 /* 560 ** Update the count of total outstanding memory that is held in 561 ** thread-specific-data (TSD). If after this update the TSD is 562 ** no longer being used, then deallocate it. 563 ** 564 ** If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, this routine is 565 ** a no-op 566 */ 567 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 568 static void updateMemoryUsedCount(int n){ 569 ThreadData *pTsd = sqlite3ThreadData(); 570 if( pTsd ){ 571 pTsd->nAlloc += n; 572 assert( pTsd->nAlloc>=0 ); 573 if( pTsd->nAlloc==0 && pTsd->nSoftHeapLimit==0 ){ 574 sqlite3ReleaseThreadData(); 575 } 576 } 577 } 578 #else 579 #define updateMemoryUsedCount(x) /* no-op */ 580 #endif 581 582 /* 583 ** Allocate and return N bytes of uninitialised memory by calling 584 ** sqlite3OsMalloc(). If the Malloc() call fails, attempt to free memory 585 ** by calling sqlite3_release_memory(). 586 */ 587 void *sqlite3MallocRaw(int n, int doMemManage){ 588 void *p = 0; 589 if( n>0 && !sqlite3MallocFailed() && (!doMemManage || enforceSoftLimit(n)) ){ 590 while( (p = OSMALLOC(n))==0 && sqlite3_release_memory(n) ){} 591 if( !p ){ 592 sqlite3FailedMalloc(); 593 OSMALLOC_FAILED(); 594 }else if( doMemManage ){ 595 updateMemoryUsedCount(OSSIZEOF(p)); 596 } 597 } 598 return p; 599 } 600 601 /* 602 ** Resize the allocation at p to n bytes by calling sqlite3OsRealloc(). The 603 ** pointer to the new allocation is returned. If the Realloc() call fails, 604 ** attempt to free memory by calling sqlite3_release_memory(). 605 */ 606 void *sqlite3Realloc(void *p, int n){ 607 if( sqlite3MallocFailed() ){ 608 return 0; 609 } 610 611 if( !p ){ 612 return sqlite3Malloc(n, 1); 613 }else{ 614 void *np = 0; 615 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 616 int origSize = OSSIZEOF(p); 617 #endif 618 if( enforceSoftLimit(n - origSize) ){ 619 while( (np = OSREALLOC(p, n))==0 && sqlite3_release_memory(n) ){} 620 if( !np ){ 621 sqlite3FailedMalloc(); 622 OSMALLOC_FAILED(); 623 }else{ 624 updateMemoryUsedCount(OSSIZEOF(np) - origSize); 625 } 626 } 627 return np; 628 } 629 } 630 631 /* 632 ** Free the memory pointed to by p. p must be either a NULL pointer or a 633 ** value returned by a previous call to sqlite3Malloc() or sqlite3Realloc(). 634 */ 635 void sqlite3FreeX(void *p){ 636 if( p ){ 637 updateMemoryUsedCount(0 - OSSIZEOF(p)); 638 OSFREE(p); 639 } 640 } 641 642 /* 643 ** A version of sqliteMalloc() that is always a function, not a macro. 644 ** Currently, this is used only to alloc to allocate the parser engine. 645 */ 646 void *sqlite3MallocX(int n){ 647 return sqliteMalloc(n); 648 } 649 650 /* 651 ** sqlite3Malloc 652 ** sqlite3ReallocOrFree 653 ** 654 ** These two are implemented as wrappers around sqlite3MallocRaw(), 655 ** sqlite3Realloc() and sqlite3Free(). 656 */ 657 void *sqlite3Malloc(int n, int doMemManage){ 658 void *p = sqlite3MallocRaw(n, doMemManage); 659 if( p ){ 660 memset(p, 0, n); 661 } 662 return p; 663 } 664 void *sqlite3ReallocOrFree(void *p, int n){ 665 void *pNew; 666 pNew = sqlite3Realloc(p, n); 667 if( !pNew ){ 668 sqlite3FreeX(p); 669 } 670 return pNew; 671 } 672 673 /* 674 ** sqlite3ThreadSafeMalloc() and sqlite3ThreadSafeFree() are used in those 675 ** rare scenarios where sqlite may allocate memory in one thread and free 676 ** it in another. They are exactly the same as sqlite3Malloc() and 677 ** sqlite3Free() except that: 678 ** 679 ** * The allocated memory is not included in any calculations with 680 ** respect to the soft-heap-limit, and 681 ** 682 ** * sqlite3ThreadSafeMalloc() must be matched with ThreadSafeFree(), 683 ** not sqlite3Free(). Calling sqlite3Free() on memory obtained from 684 ** ThreadSafeMalloc() will cause an error somewhere down the line. 685 */ 686 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 687 void *sqlite3ThreadSafeMalloc(int n){ 688 (void)ENTER_MALLOC; 689 return sqlite3Malloc(n, 0); 690 } 691 void sqlite3ThreadSafeFree(void *p){ 692 (void)ENTER_MALLOC; 693 if( p ){ 694 OSFREE(p); 695 } 696 } 697 #endif 698 699 700 /* 701 ** Return the number of bytes allocated at location p. p must be either 702 ** a NULL pointer (in which case 0 is returned) or a pointer returned by 703 ** sqlite3Malloc(), sqlite3Realloc() or sqlite3ReallocOrFree(). 704 ** 705 ** The number of bytes allocated does not include any overhead inserted by 706 ** any malloc() wrapper functions that may be called. So the value returned 707 ** is the number of bytes that were available to SQLite using pointer p, 708 ** regardless of how much memory was actually allocated. 709 */ 710 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 711 int sqlite3AllocSize(void *p){ 712 return OSSIZEOF(p); 713 } 714 #endif 715 716 /* 717 ** Make a copy of a string in memory obtained from sqliteMalloc(). These 718 ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This 719 ** is because when memory debugging is turned on, these two functions are 720 ** called via macros that record the current file and line number in the 721 ** ThreadData structure. 722 */ 723 char *sqlite3StrDup(const char *z){ 724 char *zNew; 725 if( z==0 ) return 0; 726 zNew = sqlite3MallocRaw(strlen(z)+1, 1); 727 if( zNew ) strcpy(zNew, z); 728 return zNew; 729 } 730 char *sqlite3StrNDup(const char *z, int n){ 731 char *zNew; 732 if( z==0 ) return 0; 733 zNew = sqlite3MallocRaw(n+1, 1); 734 if( zNew ){ 735 memcpy(zNew, z, n); 736 zNew[n] = 0; 737 } 738 return zNew; 739 } 740 741 /* 742 ** Create a string from the 2nd and subsequent arguments (up to the 743 ** first NULL argument), store the string in memory obtained from 744 ** sqliteMalloc() and make the pointer indicated by the 1st argument 745 ** point to that string. The 1st argument must either be NULL or 746 ** point to memory obtained from sqliteMalloc(). 747 */ 748 void sqlite3SetString(char **pz, ...){ 749 va_list ap; 750 int nByte; 751 const char *z; 752 char *zResult; 753 754 assert( pz!=0 ); 755 nByte = 1; 756 va_start(ap, pz); 757 while( (z = va_arg(ap, const char*))!=0 ){ 758 nByte += strlen(z); 759 } 760 va_end(ap); 761 sqliteFree(*pz); 762 *pz = zResult = sqliteMallocRaw( nByte ); 763 if( zResult==0 ){ 764 return; 765 } 766 *zResult = 0; 767 va_start(ap, pz); 768 while( (z = va_arg(ap, const char*))!=0 ){ 769 strcpy(zResult, z); 770 zResult += strlen(zResult); 771 } 772 va_end(ap); 773 } 774 775 /* 776 ** Set the most recent error code and error string for the sqlite 777 ** handle "db". The error code is set to "err_code". 778 ** 779 ** If it is not NULL, string zFormat specifies the format of the 780 ** error string in the style of the printf functions: The following 781 ** format characters are allowed: 782 ** 783 ** %s Insert a string 784 ** %z A string that should be freed after use 785 ** %d Insert an integer 786 ** %T Insert a token 787 ** %S Insert the first element of a SrcList 788 ** 789 ** zFormat and any string tokens that follow it are assumed to be 790 ** encoded in UTF-8. 791 ** 792 ** To clear the most recent error for sqlite handle "db", sqlite3Error 793 ** should be called with err_code set to SQLITE_OK and zFormat set 794 ** to NULL. 795 */ 796 void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){ 797 if( db && (db->pErr || (db->pErr = sqlite3ValueNew())!=0) ){ 798 db->errCode = err_code; 799 if( zFormat ){ 800 char *z; 801 va_list ap; 802 va_start(ap, zFormat); 803 z = sqlite3VMPrintf(zFormat, ap); 804 va_end(ap); 805 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, sqlite3FreeX); 806 }else{ 807 sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC); 808 } 809 } 810 } 811 812 /* 813 ** Add an error message to pParse->zErrMsg and increment pParse->nErr. 814 ** The following formatting characters are allowed: 815 ** 816 ** %s Insert a string 817 ** %z A string that should be freed after use 818 ** %d Insert an integer 819 ** %T Insert a token 820 ** %S Insert the first element of a SrcList 821 ** 822 ** This function should be used to report any error that occurs whilst 823 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The 824 ** last thing the sqlite3_prepare() function does is copy the error 825 ** stored by this function into the database handle using sqlite3Error(). 826 ** Function sqlite3Error() should be used during statement execution 827 ** (sqlite3_step() etc.). 828 */ 829 void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ 830 va_list ap; 831 pParse->nErr++; 832 sqliteFree(pParse->zErrMsg); 833 va_start(ap, zFormat); 834 pParse->zErrMsg = sqlite3VMPrintf(zFormat, ap); 835 va_end(ap); 836 } 837 838 /* 839 ** Clear the error message in pParse, if any 840 */ 841 void sqlite3ErrorClear(Parse *pParse){ 842 sqliteFree(pParse->zErrMsg); 843 pParse->zErrMsg = 0; 844 pParse->nErr = 0; 845 } 846 847 /* 848 ** Convert an SQL-style quoted string into a normal string by removing 849 ** the quote characters. The conversion is done in-place. If the 850 ** input does not begin with a quote character, then this routine 851 ** is a no-op. 852 ** 853 ** 2002-Feb-14: This routine is extended to remove MS-Access style 854 ** brackets from around identifers. For example: "[a-b-c]" becomes 855 ** "a-b-c". 856 */ 857 void sqlite3Dequote(char *z){ 858 int quote; 859 int i, j; 860 if( z==0 ) return; 861 quote = z[0]; 862 switch( quote ){ 863 case '\'': break; 864 case '"': break; 865 case '`': break; /* For MySQL compatibility */ 866 case '[': quote = ']'; break; /* For MS SqlServer compatibility */ 867 default: return; 868 } 869 for(i=1, j=0; z[i]; i++){ 870 if( z[i]==quote ){ 871 if( z[i+1]==quote ){ 872 z[j++] = quote; 873 i++; 874 }else{ 875 z[j++] = 0; 876 break; 877 } 878 }else{ 879 z[j++] = z[i]; 880 } 881 } 882 } 883 884 /* An array to map all upper-case characters into their corresponding 885 ** lower-case character. 886 */ 887 const unsigned char sqlite3UpperToLower[] = { 888 #ifdef SQLITE_ASCII 889 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 890 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 891 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 892 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103, 893 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121, 894 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107, 895 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125, 896 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, 897 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, 898 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, 899 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, 900 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, 901 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, 902 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, 903 252,253,254,255 904 #endif 905 #ifdef SQLITE_EBCDIC 906 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */ 907 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */ 908 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */ 909 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */ 910 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */ 911 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */ 912 96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */ 913 112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */ 914 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */ 915 144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */ 916 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */ 917 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */ 918 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */ 919 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */ 920 224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */ 921 239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */ 922 #endif 923 }; 924 #define UpperToLower sqlite3UpperToLower 925 926 /* 927 ** Some systems have stricmp(). Others have strcasecmp(). Because 928 ** there is no consistency, we will define our own. 929 */ 930 int sqlite3StrICmp(const char *zLeft, const char *zRight){ 931 register unsigned char *a, *b; 932 a = (unsigned char *)zLeft; 933 b = (unsigned char *)zRight; 934 while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } 935 return UpperToLower[*a] - UpperToLower[*b]; 936 } 937 int sqlite3StrNICmp(const char *zLeft, const char *zRight, int N){ 938 register unsigned char *a, *b; 939 a = (unsigned char *)zLeft; 940 b = (unsigned char *)zRight; 941 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } 942 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; 943 } 944 945 /* 946 ** Return TRUE if z is a pure numeric string. Return FALSE if the 947 ** string contains any character which is not part of a number. If 948 ** the string is numeric and contains the '.' character, set *realnum 949 ** to TRUE (otherwise FALSE). 950 ** 951 ** An empty string is considered non-numeric. 952 */ 953 int sqlite3IsNumber(const char *z, int *realnum, u8 enc){ 954 int incr = (enc==SQLITE_UTF8?1:2); 955 if( enc==SQLITE_UTF16BE ) z++; 956 if( *z=='-' || *z=='+' ) z += incr; 957 if( !isdigit(*(u8*)z) ){ 958 return 0; 959 } 960 z += incr; 961 if( realnum ) *realnum = 0; 962 while( isdigit(*(u8*)z) ){ z += incr; } 963 if( *z=='.' ){ 964 z += incr; 965 if( !isdigit(*(u8*)z) ) return 0; 966 while( isdigit(*(u8*)z) ){ z += incr; } 967 if( realnum ) *realnum = 1; 968 } 969 if( *z=='e' || *z=='E' ){ 970 z += incr; 971 if( *z=='+' || *z=='-' ) z += incr; 972 if( !isdigit(*(u8*)z) ) return 0; 973 while( isdigit(*(u8*)z) ){ z += incr; } 974 if( realnum ) *realnum = 1; 975 } 976 return *z==0; 977 } 978 979 /* 980 ** The string z[] is an ascii representation of a real number. 981 ** Convert this string to a double. 982 ** 983 ** This routine assumes that z[] really is a valid number. If it 984 ** is not, the result is undefined. 985 ** 986 ** This routine is used instead of the library atof() function because 987 ** the library atof() might want to use "," as the decimal point instead 988 ** of "." depending on how locale is set. But that would cause problems 989 ** for SQL. So this routine always uses "." regardless of locale. 990 */ 991 int sqlite3AtoF(const char *z, double *pResult){ 992 #ifndef SQLITE_OMIT_FLOATING_POINT 993 int sign = 1; 994 const char *zBegin = z; 995 LONGDOUBLE_TYPE v1 = 0.0; 996 while( isspace(*z) ) z++; 997 if( *z=='-' ){ 998 sign = -1; 999 z++; 1000 }else if( *z=='+' ){ 1001 z++; 1002 } 1003 while( isdigit(*(u8*)z) ){ 1004 v1 = v1*10.0 + (*z - '0'); 1005 z++; 1006 } 1007 if( *z=='.' ){ 1008 LONGDOUBLE_TYPE divisor = 1.0; 1009 z++; 1010 while( isdigit(*(u8*)z) ){ 1011 v1 = v1*10.0 + (*z - '0'); 1012 divisor *= 10.0; 1013 z++; 1014 } 1015 v1 /= divisor; 1016 } 1017 if( *z=='e' || *z=='E' ){ 1018 int esign = 1; 1019 int eval = 0; 1020 LONGDOUBLE_TYPE scale = 1.0; 1021 z++; 1022 if( *z=='-' ){ 1023 esign = -1; 1024 z++; 1025 }else if( *z=='+' ){ 1026 z++; 1027 } 1028 while( isdigit(*(u8*)z) ){ 1029 eval = eval*10 + *z - '0'; 1030 z++; 1031 } 1032 while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; } 1033 while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; } 1034 while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; } 1035 while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; } 1036 if( esign<0 ){ 1037 v1 /= scale; 1038 }else{ 1039 v1 *= scale; 1040 } 1041 } 1042 *pResult = sign<0 ? -v1 : v1; 1043 return z - zBegin; 1044 #else 1045 return sqlite3atoi64(z, pResult); 1046 #endif /* SQLITE_OMIT_FLOATING_POINT */ 1047 } 1048 1049 /* 1050 ** Return TRUE if zNum is a 64-bit signed integer and write 1051 ** the value of the integer into *pNum. If zNum is not an integer 1052 ** or is an integer that is too large to be expressed with 64 bits, 1053 ** then return false. If n>0 and the integer is string is not 1054 ** exactly n bytes long, return false. 1055 ** 1056 ** When this routine was originally written it dealt with only 1057 ** 32-bit numbers. At that time, it was much faster than the 1058 ** atoi() library routine in RedHat 7.2. 1059 */ 1060 int sqlite3atoi64(const char *zNum, i64 *pNum){ 1061 i64 v = 0; 1062 int neg; 1063 int i, c; 1064 while( isspace(*zNum) ) zNum++; 1065 if( *zNum=='-' ){ 1066 neg = 1; 1067 zNum++; 1068 }else if( *zNum=='+' ){ 1069 neg = 0; 1070 zNum++; 1071 }else{ 1072 neg = 0; 1073 } 1074 for(i=0; (c=zNum[i])>='0' && c<='9'; i++){ 1075 v = v*10 + c - '0'; 1076 } 1077 *pNum = neg ? -v : v; 1078 return c==0 && i>0 && 1079 (i<19 || (i==19 && memcmp(zNum,"9223372036854775807",19)<=0)); 1080 } 1081 1082 /* 1083 ** The string zNum represents an integer. There might be some other 1084 ** information following the integer too, but that part is ignored. 1085 ** If the integer that the prefix of zNum represents will fit in a 1086 ** 32-bit signed integer, return TRUE. Otherwise return FALSE. 1087 ** 1088 ** This routine returns FALSE for the string -2147483648 even that 1089 ** that number will in fact fit in a 32-bit integer. But positive 1090 ** 2147483648 will not fit in 32 bits. So it seems safer to return 1091 ** false. 1092 */ 1093 static int sqlite3FitsIn32Bits(const char *zNum){ 1094 int i, c; 1095 if( *zNum=='-' || *zNum=='+' ) zNum++; 1096 for(i=0; (c=zNum[i])>='0' && c<='9'; i++){} 1097 return i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0); 1098 } 1099 1100 /* 1101 ** If zNum represents an integer that will fit in 32-bits, then set 1102 ** *pValue to that integer and return true. Otherwise return false. 1103 */ 1104 int sqlite3GetInt32(const char *zNum, int *pValue){ 1105 if( sqlite3FitsIn32Bits(zNum) ){ 1106 *pValue = atoi(zNum); 1107 return 1; 1108 } 1109 return 0; 1110 } 1111 1112 /* 1113 ** The string zNum represents an integer. There might be some other 1114 ** information following the integer too, but that part is ignored. 1115 ** If the integer that the prefix of zNum represents will fit in a 1116 ** 64-bit signed integer, return TRUE. Otherwise return FALSE. 1117 ** 1118 ** This routine returns FALSE for the string -9223372036854775808 even that 1119 ** that number will, in theory fit in a 64-bit integer. Positive 1120 ** 9223373036854775808 will not fit in 64 bits. So it seems safer to return 1121 ** false. 1122 */ 1123 int sqlite3FitsIn64Bits(const char *zNum){ 1124 int i, c; 1125 if( *zNum=='-' || *zNum=='+' ) zNum++; 1126 for(i=0; (c=zNum[i])>='0' && c<='9'; i++){} 1127 return i<19 || (i==19 && memcmp(zNum,"9223372036854775807",19)<=0); 1128 } 1129 1130 1131 /* 1132 ** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY. 1133 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN 1134 ** when this routine is called. 1135 ** 1136 ** This routine is called when entering an SQLite API. The SQLITE_MAGIC_OPEN 1137 ** value indicates that the database connection passed into the API is 1138 ** open and is not being used by another thread. By changing the value 1139 ** to SQLITE_MAGIC_BUSY we indicate that the connection is in use. 1140 ** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN 1141 ** when the API exits. 1142 ** 1143 ** This routine is a attempt to detect if two threads use the 1144 ** same sqlite* pointer at the same time. There is a race 1145 ** condition so it is possible that the error is not detected. 1146 ** But usually the problem will be seen. The result will be an 1147 ** error which can be used to debug the application that is 1148 ** using SQLite incorrectly. 1149 ** 1150 ** Ticket #202: If db->magic is not a valid open value, take care not 1151 ** to modify the db structure at all. It could be that db is a stale 1152 ** pointer. In other words, it could be that there has been a prior 1153 ** call to sqlite3_close(db) and db has been deallocated. And we do 1154 ** not want to write into deallocated memory. 1155 */ 1156 int sqlite3SafetyOn(sqlite3 *db){ 1157 if( db->magic==SQLITE_MAGIC_OPEN ){ 1158 db->magic = SQLITE_MAGIC_BUSY; 1159 return 0; 1160 }else if( db->magic==SQLITE_MAGIC_BUSY ){ 1161 db->magic = SQLITE_MAGIC_ERROR; 1162 db->u1.isInterrupted = 1; 1163 } 1164 return 1; 1165 } 1166 1167 /* 1168 ** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN. 1169 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY 1170 ** when this routine is called. 1171 */ 1172 int sqlite3SafetyOff(sqlite3 *db){ 1173 if( db->magic==SQLITE_MAGIC_BUSY ){ 1174 db->magic = SQLITE_MAGIC_OPEN; 1175 return 0; 1176 }else { 1177 db->magic = SQLITE_MAGIC_ERROR; 1178 db->u1.isInterrupted = 1; 1179 return 1; 1180 } 1181 } 1182 1183 /* 1184 ** Check to make sure we have a valid db pointer. This test is not 1185 ** foolproof but it does provide some measure of protection against 1186 ** misuse of the interface such as passing in db pointers that are 1187 ** NULL or which have been previously closed. If this routine returns 1188 ** TRUE it means that the db pointer is invalid and should not be 1189 ** dereferenced for any reason. The calling function should invoke 1190 ** SQLITE_MISUSE immediately. 1191 */ 1192 int sqlite3SafetyCheck(sqlite3 *db){ 1193 int magic; 1194 if( db==0 ) return 1; 1195 magic = db->magic; 1196 if( magic!=SQLITE_MAGIC_CLOSED && 1197 magic!=SQLITE_MAGIC_OPEN && 1198 magic!=SQLITE_MAGIC_BUSY ) return 1; 1199 return 0; 1200 } 1201 1202 /* 1203 ** The variable-length integer encoding is as follows: 1204 ** 1205 ** KEY: 1206 ** A = 0xxxxxxx 7 bits of data and one flag bit 1207 ** B = 1xxxxxxx 7 bits of data and one flag bit 1208 ** C = xxxxxxxx 8 bits of data 1209 ** 1210 ** 7 bits - A 1211 ** 14 bits - BA 1212 ** 21 bits - BBA 1213 ** 28 bits - BBBA 1214 ** 35 bits - BBBBA 1215 ** 42 bits - BBBBBA 1216 ** 49 bits - BBBBBBA 1217 ** 56 bits - BBBBBBBA 1218 ** 64 bits - BBBBBBBBC 1219 */ 1220 1221 /* 1222 ** Write a 64-bit variable-length integer to memory starting at p[0]. 1223 ** The length of data write will be between 1 and 9 bytes. The number 1224 ** of bytes written is returned. 1225 ** 1226 ** A variable-length integer consists of the lower 7 bits of each byte 1227 ** for all bytes that have the 8th bit set and one byte with the 8th 1228 ** bit clear. Except, if we get to the 9th byte, it stores the full 1229 ** 8 bits and is the last byte. 1230 */ 1231 int sqlite3PutVarint(unsigned char *p, u64 v){ 1232 int i, j, n; 1233 u8 buf[10]; 1234 if( v & (((u64)0xff000000)<<32) ){ 1235 p[8] = v; 1236 v >>= 8; 1237 for(i=7; i>=0; i--){ 1238 p[i] = (v & 0x7f) | 0x80; 1239 v >>= 7; 1240 } 1241 return 9; 1242 } 1243 n = 0; 1244 do{ 1245 buf[n++] = (v & 0x7f) | 0x80; 1246 v >>= 7; 1247 }while( v!=0 ); 1248 buf[0] &= 0x7f; 1249 assert( n<=9 ); 1250 for(i=0, j=n-1; j>=0; j--, i++){ 1251 p[i] = buf[j]; 1252 } 1253 return n; 1254 } 1255 1256 /* 1257 ** Read a 64-bit variable-length integer from memory starting at p[0]. 1258 ** Return the number of bytes read. The value is stored in *v. 1259 */ 1260 int sqlite3GetVarint(const unsigned char *p, u64 *v){ 1261 u32 x; 1262 u64 x64; 1263 int n; 1264 unsigned char c; 1265 if( ((c = p[0]) & 0x80)==0 ){ 1266 *v = c; 1267 return 1; 1268 } 1269 x = c & 0x7f; 1270 if( ((c = p[1]) & 0x80)==0 ){ 1271 *v = (x<<7) | c; 1272 return 2; 1273 } 1274 x = (x<<7) | (c&0x7f); 1275 if( ((c = p[2]) & 0x80)==0 ){ 1276 *v = (x<<7) | c; 1277 return 3; 1278 } 1279 x = (x<<7) | (c&0x7f); 1280 if( ((c = p[3]) & 0x80)==0 ){ 1281 *v = (x<<7) | c; 1282 return 4; 1283 } 1284 x64 = (x<<7) | (c&0x7f); 1285 n = 4; 1286 do{ 1287 c = p[n++]; 1288 if( n==9 ){ 1289 x64 = (x64<<8) | c; 1290 break; 1291 } 1292 x64 = (x64<<7) | (c&0x7f); 1293 }while( (c & 0x80)!=0 ); 1294 *v = x64; 1295 return n; 1296 } 1297 1298 /* 1299 ** Read a 32-bit variable-length integer from memory starting at p[0]. 1300 ** Return the number of bytes read. The value is stored in *v. 1301 */ 1302 int sqlite3GetVarint32(const unsigned char *p, u32 *v){ 1303 u32 x; 1304 int n; 1305 unsigned char c; 1306 if( ((signed char*)p)[0]>=0 ){ 1307 *v = p[0]; 1308 return 1; 1309 } 1310 x = p[0] & 0x7f; 1311 if( ((signed char*)p)[1]>=0 ){ 1312 *v = (x<<7) | p[1]; 1313 return 2; 1314 } 1315 x = (x<<7) | (p[1] & 0x7f); 1316 n = 2; 1317 do{ 1318 x = (x<<7) | ((c = p[n++])&0x7f); 1319 }while( (c & 0x80)!=0 && n<9 ); 1320 *v = x; 1321 return n; 1322 } 1323 1324 /* 1325 ** Return the number of bytes that will be needed to store the given 1326 ** 64-bit integer. 1327 */ 1328 int sqlite3VarintLen(u64 v){ 1329 int i = 0; 1330 do{ 1331 i++; 1332 v >>= 7; 1333 }while( v!=0 && i<9 ); 1334 return i; 1335 } 1336 1337 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) \ 1338 || defined(SQLITE_TEST) 1339 /* 1340 ** Translate a single byte of Hex into an integer. 1341 */ 1342 static int hexToInt(int h){ 1343 if( h>='0' && h<='9' ){ 1344 return h - '0'; 1345 }else if( h>='a' && h<='f' ){ 1346 return h - 'a' + 10; 1347 }else{ 1348 assert( h>='A' && h<='F' ); 1349 return h - 'A' + 10; 1350 } 1351 } 1352 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC || SQLITE_TEST */ 1353 1354 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) 1355 /* 1356 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary 1357 ** value. Return a pointer to its binary value. Space to hold the 1358 ** binary value has been obtained from malloc and must be freed by 1359 ** the calling routine. 1360 */ 1361 void *sqlite3HexToBlob(const char *z){ 1362 char *zBlob; 1363 int i; 1364 int n = strlen(z); 1365 if( n%2 ) return 0; 1366 1367 zBlob = (char *)sqliteMalloc(n/2); 1368 if( zBlob ){ 1369 for(i=0; i<n; i+=2){ 1370 zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]); 1371 } 1372 } 1373 return zBlob; 1374 } 1375 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */ 1376 1377 #if defined(SQLITE_TEST) 1378 /* 1379 ** Convert text generated by the "%p" conversion format back into 1380 ** a pointer. 1381 */ 1382 void *sqlite3TextToPtr(const char *z){ 1383 void *p; 1384 u64 v; 1385 u32 v2; 1386 if( z[0]=='0' && z[1]=='x' ){ 1387 z += 2; 1388 } 1389 v = 0; 1390 while( *z ){ 1391 v = (v<<4) + hexToInt(*z); 1392 z++; 1393 } 1394 if( sizeof(p)==sizeof(v) ){ 1395 memcpy(&p, &v, sizeof(p)); 1396 }else{ 1397 assert( sizeof(p)==sizeof(v2) ); 1398 v2 = (u32)v; 1399 memcpy(&p, &v2, sizeof(p)); 1400 } 1401 return p; 1402 } 1403 #endif 1404 1405 /* 1406 ** Return a pointer to the ThreadData associated with the calling thread. 1407 */ 1408 ThreadData *sqlite3ThreadData(){ 1409 ThreadData *p = (ThreadData*)sqlite3OsThreadSpecificData(1); 1410 if( !p ){ 1411 sqlite3FailedMalloc(); 1412 } 1413 return p; 1414 } 1415 1416 /* 1417 ** Return a pointer to the ThreadData associated with the calling thread. 1418 ** If no ThreadData has been allocated to this thread yet, return a pointer 1419 ** to a substitute ThreadData structure that is all zeros. 1420 */ 1421 const ThreadData *sqlite3ThreadDataReadOnly(){ 1422 static const ThreadData zeroData = {0}; /* Initializer to silence warnings 1423 ** from broken compilers */ 1424 const ThreadData *pTd = sqlite3OsThreadSpecificData(0); 1425 return pTd ? pTd : &zeroData; 1426 } 1427 1428 /* 1429 ** Check to see if the ThreadData for this thread is all zero. If it 1430 ** is, then deallocate it. 1431 */ 1432 void sqlite3ReleaseThreadData(){ 1433 sqlite3OsThreadSpecificData(-1); 1434 } 1435 1436 /* 1437 ** This function must be called before exiting any API function (i.e. 1438 ** returning control to the user) that has called sqlite3Malloc or 1439 ** sqlite3Realloc. 1440 ** 1441 ** The returned value is normally a copy of the second argument to this 1442 ** function. However, if a malloc() failure has occured since the previous 1443 ** invocation SQLITE_NOMEM is returned instead. 1444 ** 1445 ** If the first argument, db, is not NULL and a malloc() error has occured, 1446 ** then the connection error-code (the value returned by sqlite3_errcode()) 1447 ** is set to SQLITE_NOMEM. 1448 */ 1449 static int mallocHasFailed = 0; 1450 int sqlite3ApiExit(sqlite3* db, int rc){ 1451 if( sqlite3MallocFailed() ){ 1452 mallocHasFailed = 0; 1453 sqlite3OsLeaveMutex(); 1454 sqlite3Error(db, SQLITE_NOMEM, 0); 1455 rc = SQLITE_NOMEM; 1456 } 1457 return rc & (db ? db->errMask : 0xff); 1458 } 1459 1460 /* 1461 ** Return true is a malloc has failed in this thread since the last call 1462 ** to sqlite3ApiExit(), or false otherwise. 1463 */ 1464 int sqlite3MallocFailed(){ 1465 return (mallocHasFailed && sqlite3OsInMutex(1)); 1466 } 1467 1468 /* 1469 ** Set the "malloc has failed" condition to true for this thread. 1470 */ 1471 void sqlite3FailedMalloc(){ 1472 if( !sqlite3MallocFailed() ){ 1473 sqlite3OsEnterMutex(); 1474 assert( mallocHasFailed==0 ); 1475 mallocHasFailed = 1; 1476 } 1477 } 1478 1479 #ifdef SQLITE_MEMDEBUG 1480 /* 1481 ** This function sets a flag in the thread-specific-data structure that will 1482 ** cause an assert to fail if sqliteMalloc() or sqliteRealloc() is called. 1483 */ 1484 void sqlite3MallocDisallow(){ 1485 assert( sqlite3_mallocDisallowed>=0 ); 1486 sqlite3_mallocDisallowed++; 1487 } 1488 1489 /* 1490 ** This function clears the flag set in the thread-specific-data structure set 1491 ** by sqlite3MallocDisallow(). 1492 */ 1493 void sqlite3MallocAllow(){ 1494 assert( sqlite3_mallocDisallowed>0 ); 1495 sqlite3_mallocDisallowed--; 1496 } 1497 #endif 1498