gitlab.com/CoiaPrant/sqlite3@v1.19.1/testdata/tcl/dbfuzz.c (about) 1 /* 2 ** 2016-12-17 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 ** 13 ** This program is designed for fuzz-testing SQLite database files. 14 ** 15 ** This program reads fuzzed database files from the disk files named 16 ** on the command-line. Each database is loaded into an in-memory 17 ** filesystem so that the original database file is unmolested. 18 ** 19 ** The fuzzed database is then opened, and series of SQL statements 20 ** are run against the database to ensure that SQLite can safely handle 21 ** the fuzzed database. 22 */ 23 #include <assert.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <stdarg.h> 28 #include <ctype.h> 29 #define ISSPACE(X) isspace((unsigned char)(X)) 30 #define ISDIGIT(X) isdigit((unsigned char)(X)) 31 #include "sqlite3.h" 32 #ifdef __unix__ 33 # include <signal.h> 34 # include <unistd.h> 35 #endif 36 37 /* 38 ** Print sketchy documentation for this utility program 39 */ 40 static void showHelp(const char *zArgv0){ 41 printf("Usage: %s [options] DATABASE ...\n", zArgv0); 42 printf( 43 "Read databases into an in-memory filesystem. Run test SQL as specified\n" 44 "by command-line arguments or from\n" 45 "\n" 46 " SELECT group_concat(sql) FROM autoexec;\n" 47 "\n" 48 "Options:\n" 49 " --help Show this help text\n" 50 " -q|--quiet Reduced output\n" 51 " --limit-mem N Limit memory used by test SQLite instances to N bytes\n" 52 " --limit-vdbe Panic if any test runs for more than 100,000 cycles\n" 53 " --no-lookaside Disable the lookaside memory allocator\n" 54 " --timeout N Timeout after N seconds.\n" 55 " --trace Show the results of each SQL command\n" 56 " -v|--verbose Increased output. Repeat for more output.\n" 57 ); 58 exit(0); 59 } 60 61 /* 62 ** Print an error message and quit. 63 */ 64 static void fatalError(const char *zFormat, ...){ 65 va_list ap; 66 va_start(ap, zFormat); 67 vfprintf(stderr, zFormat, ap); 68 va_end(ap); 69 fprintf(stderr, "\n"); 70 exit(1); 71 } 72 73 /* 74 ** Files in the virtual file system. 75 */ 76 typedef struct VFile VFile; 77 typedef struct VHandle VHandle; 78 struct VFile { 79 char *zFilename; /* Filename. NULL for delete-on-close. From malloc() */ 80 int sz; /* Size of the file in bytes */ 81 int nRef; /* Number of references to this file */ 82 unsigned char *a; /* Content of the file. From malloc() */ 83 }; 84 struct VHandle { 85 sqlite3_file base; /* Base class. Must be first */ 86 VFile *pVFile; /* The underlying file */ 87 }; 88 89 /* 90 ** Maximum number of files in the in-memory virtual filesystem. 91 */ 92 #define MX_FILE 10 93 94 /* 95 ** Maximum allowed file size 96 */ 97 #define MX_FILE_SZ 1000000 98 99 /* 100 ** All global variables are gathered into the "g" singleton. 101 */ 102 static struct GlobalVars { 103 VFile aFile[MX_FILE]; /* The virtual filesystem */ 104 } g; 105 106 107 /* 108 ** Initialize the virtual file system. 109 */ 110 static void formatVfs(void){ 111 int i; 112 for(i=0; i<MX_FILE; i++){ 113 g.aFile[i].sz = -1; 114 g.aFile[i].zFilename = 0; 115 g.aFile[i].a = 0; 116 g.aFile[i].nRef = 0; 117 } 118 } 119 120 121 /* 122 ** Erase all information in the virtual file system. 123 */ 124 static void reformatVfs(void){ 125 int i; 126 for(i=0; i<MX_FILE; i++){ 127 if( g.aFile[i].sz<0 ) continue; 128 if( g.aFile[i].zFilename ){ 129 free(g.aFile[i].zFilename); 130 g.aFile[i].zFilename = 0; 131 } 132 if( g.aFile[i].nRef>0 ){ 133 fatalError("file %d still open. nRef=%d", i, g.aFile[i].nRef); 134 } 135 g.aFile[i].sz = -1; 136 free(g.aFile[i].a); 137 g.aFile[i].a = 0; 138 g.aFile[i].nRef = 0; 139 } 140 } 141 142 /* 143 ** Find a VFile by name 144 */ 145 static VFile *findVFile(const char *zName){ 146 int i; 147 if( zName==0 ) return 0; 148 for(i=0; i<MX_FILE; i++){ 149 if( g.aFile[i].zFilename==0 ) continue; 150 if( strcmp(g.aFile[i].zFilename, zName)==0 ) return &g.aFile[i]; 151 } 152 return 0; 153 } 154 155 /* 156 ** Find a VFile called zName. Initialize it to the content of 157 ** disk file zDiskFile. 158 ** 159 ** Return NULL if the filesystem is full. 160 */ 161 static VFile *createVFile(const char *zName, const char *zDiskFile){ 162 VFile *pNew = findVFile(zName); 163 int i; 164 FILE *in = 0; 165 long sz = 0; 166 167 if( pNew ) return pNew; 168 for(i=0; i<MX_FILE && g.aFile[i].sz>=0; i++){} 169 if( i>=MX_FILE ) return 0; 170 if( zDiskFile ){ 171 in = fopen(zDiskFile, "rb"); 172 if( in==0 ) fatalError("no such file: \"%s\"", zDiskFile); 173 fseek(in, 0, SEEK_END); 174 sz = ftell(in); 175 rewind(in); 176 } 177 pNew = &g.aFile[i]; 178 if( zName ){ 179 int nName = (int)strlen(zName)+1; 180 pNew->zFilename = malloc(nName); 181 if( pNew->zFilename==0 ){ 182 if( in ) fclose(in); 183 return 0; 184 } 185 memcpy(pNew->zFilename, zName, nName); 186 }else{ 187 pNew->zFilename = 0; 188 } 189 pNew->nRef = 0; 190 pNew->sz = sz; 191 pNew->a = malloc(sz); 192 if( sz>0 ){ 193 if( pNew->a==0 || fread(pNew->a, sz, 1, in)<1 ){ 194 free(pNew->zFilename); 195 free(pNew->a); 196 pNew->a = 0; 197 pNew->zFilename = 0; 198 pNew->sz = -1; 199 pNew = 0; 200 } 201 } 202 if( in ) fclose(in); 203 return pNew; 204 } 205 206 /* Methods for the VHandle object 207 */ 208 static int inmemClose(sqlite3_file *pFile){ 209 VHandle *p = (VHandle*)pFile; 210 VFile *pVFile = p->pVFile; 211 pVFile->nRef--; 212 if( pVFile->nRef==0 && pVFile->zFilename==0 ){ 213 pVFile->sz = -1; 214 free(pVFile->a); 215 pVFile->a = 0; 216 } 217 return SQLITE_OK; 218 } 219 static int inmemRead( 220 sqlite3_file *pFile, /* Read from this open file */ 221 void *pData, /* Store content in this buffer */ 222 int iAmt, /* Bytes of content */ 223 sqlite3_int64 iOfst /* Start reading here */ 224 ){ 225 VHandle *pHandle = (VHandle*)pFile; 226 VFile *pVFile = pHandle->pVFile; 227 if( iOfst<0 || iOfst>=pVFile->sz ){ 228 memset(pData, 0, iAmt); 229 return SQLITE_IOERR_SHORT_READ; 230 } 231 if( iOfst+iAmt>pVFile->sz ){ 232 memset(pData, 0, iAmt); 233 iAmt = (int)(pVFile->sz - iOfst); 234 memcpy(pData, pVFile->a, iAmt); 235 return SQLITE_IOERR_SHORT_READ; 236 } 237 memcpy(pData, pVFile->a + iOfst, iAmt); 238 return SQLITE_OK; 239 } 240 static int inmemWrite( 241 sqlite3_file *pFile, /* Write to this file */ 242 const void *pData, /* Content to write */ 243 int iAmt, /* bytes to write */ 244 sqlite3_int64 iOfst /* Start writing here */ 245 ){ 246 VHandle *pHandle = (VHandle*)pFile; 247 VFile *pVFile = pHandle->pVFile; 248 if( iOfst+iAmt > pVFile->sz ){ 249 unsigned char *aNew; 250 if( iOfst+iAmt >= MX_FILE_SZ ){ 251 return SQLITE_FULL; 252 } 253 aNew = realloc(pVFile->a, (int)(iOfst+iAmt)); 254 if( aNew==0 ){ 255 return SQLITE_FULL; 256 } 257 pVFile->a = aNew; 258 if( iOfst > pVFile->sz ){ 259 memset(pVFile->a + pVFile->sz, 0, (int)(iOfst - pVFile->sz)); 260 } 261 pVFile->sz = (int)(iOfst + iAmt); 262 } 263 memcpy(pVFile->a + iOfst, pData, iAmt); 264 return SQLITE_OK; 265 } 266 static int inmemTruncate(sqlite3_file *pFile, sqlite3_int64 iSize){ 267 VHandle *pHandle = (VHandle*)pFile; 268 VFile *pVFile = pHandle->pVFile; 269 if( pVFile->sz>iSize && iSize>=0 ) pVFile->sz = (int)iSize; 270 return SQLITE_OK; 271 } 272 static int inmemSync(sqlite3_file *pFile, int flags){ 273 return SQLITE_OK; 274 } 275 static int inmemFileSize(sqlite3_file *pFile, sqlite3_int64 *pSize){ 276 *pSize = ((VHandle*)pFile)->pVFile->sz; 277 return SQLITE_OK; 278 } 279 static int inmemLock(sqlite3_file *pFile, int type){ 280 return SQLITE_OK; 281 } 282 static int inmemUnlock(sqlite3_file *pFile, int type){ 283 return SQLITE_OK; 284 } 285 static int inmemCheckReservedLock(sqlite3_file *pFile, int *pOut){ 286 *pOut = 0; 287 return SQLITE_OK; 288 } 289 static int inmemFileControl(sqlite3_file *pFile, int op, void *pArg){ 290 return SQLITE_NOTFOUND; 291 } 292 static int inmemSectorSize(sqlite3_file *pFile){ 293 return 512; 294 } 295 static int inmemDeviceCharacteristics(sqlite3_file *pFile){ 296 return 297 SQLITE_IOCAP_SAFE_APPEND | 298 SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | 299 SQLITE_IOCAP_POWERSAFE_OVERWRITE; 300 } 301 302 303 /* Method table for VHandle 304 */ 305 static sqlite3_io_methods VHandleMethods = { 306 /* iVersion */ 1, 307 /* xClose */ inmemClose, 308 /* xRead */ inmemRead, 309 /* xWrite */ inmemWrite, 310 /* xTruncate */ inmemTruncate, 311 /* xSync */ inmemSync, 312 /* xFileSize */ inmemFileSize, 313 /* xLock */ inmemLock, 314 /* xUnlock */ inmemUnlock, 315 /* xCheck... */ inmemCheckReservedLock, 316 /* xFileCtrl */ inmemFileControl, 317 /* xSectorSz */ inmemSectorSize, 318 /* xDevchar */ inmemDeviceCharacteristics, 319 /* xShmMap */ 0, 320 /* xShmLock */ 0, 321 /* xShmBarrier */ 0, 322 /* xShmUnmap */ 0, 323 /* xFetch */ 0, 324 /* xUnfetch */ 0 325 }; 326 327 /* 328 ** Open a new file in the inmem VFS. All files are anonymous and are 329 ** delete-on-close. 330 */ 331 static int inmemOpen( 332 sqlite3_vfs *pVfs, 333 const char *zFilename, 334 sqlite3_file *pFile, 335 int openFlags, 336 int *pOutFlags 337 ){ 338 VFile *pVFile = createVFile(zFilename, 0); 339 VHandle *pHandle = (VHandle*)pFile; 340 if( pVFile==0 ){ 341 return SQLITE_FULL; 342 } 343 pHandle->pVFile = pVFile; 344 pVFile->nRef++; 345 pFile->pMethods = &VHandleMethods; 346 if( pOutFlags ) *pOutFlags = openFlags; 347 return SQLITE_OK; 348 } 349 350 /* 351 ** Delete a file by name 352 */ 353 static int inmemDelete( 354 sqlite3_vfs *pVfs, 355 const char *zFilename, 356 int syncdir 357 ){ 358 VFile *pVFile = findVFile(zFilename); 359 if( pVFile==0 ) return SQLITE_OK; 360 if( pVFile->nRef==0 ){ 361 free(pVFile->zFilename); 362 pVFile->zFilename = 0; 363 pVFile->sz = -1; 364 free(pVFile->a); 365 pVFile->a = 0; 366 return SQLITE_OK; 367 } 368 return SQLITE_IOERR_DELETE; 369 } 370 371 /* Check for the existance of a file 372 */ 373 static int inmemAccess( 374 sqlite3_vfs *pVfs, 375 const char *zFilename, 376 int flags, 377 int *pResOut 378 ){ 379 VFile *pVFile = findVFile(zFilename); 380 *pResOut = pVFile!=0; 381 return SQLITE_OK; 382 } 383 384 /* Get the canonical pathname for a file 385 */ 386 static int inmemFullPathname( 387 sqlite3_vfs *pVfs, 388 const char *zFilename, 389 int nOut, 390 char *zOut 391 ){ 392 sqlite3_snprintf(nOut, zOut, "%s", zFilename); 393 return SQLITE_OK; 394 } 395 396 /* 397 ** Register the VFS that reads from the g.aFile[] set of files. 398 */ 399 static void inmemVfsRegister(void){ 400 static sqlite3_vfs inmemVfs; 401 sqlite3_vfs *pDefault = sqlite3_vfs_find(0); 402 inmemVfs.iVersion = 3; 403 inmemVfs.szOsFile = sizeof(VHandle); 404 inmemVfs.mxPathname = 200; 405 inmemVfs.zName = "inmem"; 406 inmemVfs.xOpen = inmemOpen; 407 inmemVfs.xDelete = inmemDelete; 408 inmemVfs.xAccess = inmemAccess; 409 inmemVfs.xFullPathname = inmemFullPathname; 410 inmemVfs.xRandomness = pDefault->xRandomness; 411 inmemVfs.xSleep = pDefault->xSleep; 412 inmemVfs.xCurrentTimeInt64 = pDefault->xCurrentTimeInt64; 413 sqlite3_vfs_register(&inmemVfs, 0); 414 }; 415 416 /* 417 ** Timeout handler 418 */ 419 #ifdef __unix__ 420 static void timeoutHandler(int NotUsed){ 421 (void)NotUsed; 422 fatalError("timeout\n"); 423 } 424 #endif 425 426 /* 427 ** Set the an alarm to go off after N seconds. Disable the alarm 428 ** if N==0 429 */ 430 static void setAlarm(int N){ 431 #ifdef __unix__ 432 alarm(N); 433 #else 434 (void)N; 435 #endif 436 } 437 /*************************************************************************** 438 ** String accumulator object 439 */ 440 typedef struct Str Str; 441 struct Str { 442 char *z; /* The string. Memory from malloc() */ 443 sqlite3_uint64 n; /* Bytes of input used */ 444 sqlite3_uint64 nAlloc; /* Bytes allocated to z[] */ 445 int oomErr; /* OOM error has been seen */ 446 }; 447 448 /* Initialize a Str object */ 449 static void StrInit(Str *p){ 450 memset(p, 0, sizeof(*p)); 451 } 452 453 /* Append text to the end of a Str object */ 454 static void StrAppend(Str *p, const char *z){ 455 sqlite3_uint64 n = strlen(z); 456 if( p->n + n >= p->nAlloc ){ 457 char *zNew; 458 sqlite3_uint64 nNew; 459 if( p->oomErr ) return; 460 nNew = p->nAlloc*2 + 100 + n; 461 zNew = sqlite3_realloc64(p->z, nNew); 462 if( zNew==0 ){ 463 sqlite3_free(p->z); 464 memset(p, 0, sizeof(*p)); 465 p->oomErr = 1; 466 return; 467 } 468 p->z = zNew; 469 p->nAlloc = nNew; 470 } 471 memcpy(p->z + p->n, z, (int)n); 472 p->n += n; 473 p->z[p->n] = 0; 474 } 475 476 /* Return the current string content */ 477 static char *StrStr(Str *p){ 478 return p->z; 479 } 480 481 /* Free the string */ 482 static void StrFree(Str *p){ 483 sqlite3_free(p->z); 484 StrInit(p); 485 } 486 487 /* 488 ** Return the value of a hexadecimal digit. Return -1 if the input 489 ** is not a hex digit. 490 */ 491 static int hexDigitValue(char c){ 492 if( c>='0' && c<='9' ) return c - '0'; 493 if( c>='a' && c<='f' ) return c - 'a' + 10; 494 if( c>='A' && c<='F' ) return c - 'A' + 10; 495 return -1; 496 } 497 498 /* 499 ** Interpret zArg as an integer value, possibly with suffixes. 500 */ 501 static int integerValue(const char *zArg){ 502 sqlite3_int64 v = 0; 503 static const struct { char *zSuffix; int iMult; } aMult[] = { 504 { "KiB", 1024 }, 505 { "MiB", 1024*1024 }, 506 { "GiB", 1024*1024*1024 }, 507 { "KB", 1000 }, 508 { "MB", 1000000 }, 509 { "GB", 1000000000 }, 510 { "K", 1000 }, 511 { "M", 1000000 }, 512 { "G", 1000000000 }, 513 }; 514 int i; 515 int isNeg = 0; 516 if( zArg[0]=='-' ){ 517 isNeg = 1; 518 zArg++; 519 }else if( zArg[0]=='+' ){ 520 zArg++; 521 } 522 if( zArg[0]=='0' && zArg[1]=='x' ){ 523 int x; 524 zArg += 2; 525 while( (x = hexDigitValue(zArg[0]))>=0 ){ 526 v = (v<<4) + x; 527 zArg++; 528 } 529 }else{ 530 while( ISDIGIT(zArg[0]) ){ 531 v = v*10 + zArg[0] - '0'; 532 zArg++; 533 } 534 } 535 for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){ 536 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){ 537 v *= aMult[i].iMult; 538 break; 539 } 540 } 541 if( v>0x7fffffff ) fatalError("parameter too large - max 2147483648"); 542 return (int)(isNeg? -v : v); 543 } 544 545 /* 546 ** This callback is invoked by sqlite3_log(). 547 */ 548 static void sqlLog(void *pNotUsed, int iErrCode, const char *zMsg){ 549 printf("LOG: (%d) %s\n", iErrCode, zMsg); 550 fflush(stdout); 551 } 552 553 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 554 /* 555 ** This an SQL progress handler. After an SQL statement has run for 556 ** many steps, we want to interrupt it. This guards against infinite 557 ** loops from recursive common table expressions. 558 ** 559 ** *pVdbeLimitFlag is true if the --limit-vdbe command-line option is used. 560 ** In that case, hitting the progress handler is a fatal error. 561 */ 562 static int progressHandler(void *pVdbeLimitFlag){ 563 if( *(int*)pVdbeLimitFlag ) fatalError("too many VDBE cycles"); 564 return 1; 565 } 566 #endif 567 568 /* 569 ** Allowed values for the runFlags parameter to runSql() 570 */ 571 #define SQL_TRACE 0x0001 /* Print each SQL statement as it is prepared */ 572 #define SQL_OUTPUT 0x0002 /* Show the SQL output */ 573 574 /* 575 ** Run multiple commands of SQL. Similar to sqlite3_exec(), but does not 576 ** stop if an error is encountered. 577 */ 578 static void runSql(sqlite3 *db, const char *zSql, unsigned runFlags){ 579 const char *zMore; 580 const char *zEnd = &zSql[strlen(zSql)]; 581 sqlite3_stmt *pStmt; 582 583 while( zSql && zSql[0] ){ 584 zMore = 0; 585 pStmt = 0; 586 sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zMore); 587 assert( zMore<=zEnd ); 588 if( zMore==zSql ) break; 589 if( runFlags & SQL_TRACE ){ 590 const char *z = zSql; 591 int n; 592 while( z<zMore && ISSPACE(z[0]) ) z++; 593 n = (int)(zMore - z); 594 while( n>0 && ISSPACE(z[n-1]) ) n--; 595 if( n==0 ) break; 596 if( pStmt==0 ){ 597 printf("TRACE: %.*s (error: %s)\n", n, z, sqlite3_errmsg(db)); 598 }else{ 599 printf("TRACE: %.*s\n", n, z); 600 } 601 } 602 zSql = zMore; 603 if( pStmt ){ 604 if( (runFlags & SQL_OUTPUT)==0 ){ 605 while( SQLITE_ROW==sqlite3_step(pStmt) ){} 606 }else{ 607 int nCol = -1; 608 int nRow; 609 for(nRow=0; SQLITE_ROW==sqlite3_step(pStmt); nRow++){ 610 int i; 611 if( nCol<0 ){ 612 nCol = sqlite3_column_count(pStmt); 613 } 614 for(i=0; i<nCol; i++){ 615 int eType = sqlite3_column_type(pStmt,i); 616 printf("ROW[%d].%s = ", nRow, sqlite3_column_name(pStmt,i)); 617 switch( eType ){ 618 case SQLITE_NULL: { 619 printf("NULL\n"); 620 break; 621 } 622 case SQLITE_INTEGER: { 623 printf("INT %s\n", sqlite3_column_text(pStmt,i)); 624 break; 625 } 626 case SQLITE_FLOAT: { 627 printf("FLOAT %s\n", sqlite3_column_text(pStmt,i)); 628 break; 629 } 630 case SQLITE_TEXT: { 631 printf("TEXT [%s]\n", sqlite3_column_text(pStmt,i)); 632 break; 633 } 634 case SQLITE_BLOB: { 635 printf("BLOB (%d bytes)\n", sqlite3_column_bytes(pStmt,i)); 636 break; 637 } 638 } 639 } 640 } 641 } 642 sqlite3_finalize(pStmt); 643 } 644 } 645 } 646 647 int main(int argc, char **argv){ 648 int i; /* Loop counter */ 649 int nDb = 0; /* Number of databases to fuzz */ 650 char **azDb = 0; /* Names of the databases (limit: 20) */ 651 int verboseFlag = 0; /* True for extra output */ 652 int noLookaside = 0; /* Disable lookaside if true */ 653 int vdbeLimitFlag = 0; /* Stop after 100,000 VDBE ops */ 654 int nHeap = 0; /* True for fixed heap size */ 655 int iTimeout = 0; /* Timeout delay in seconds */ 656 int rc; /* Result code from SQLite3 API calls */ 657 sqlite3 *db; /* The database connection */ 658 sqlite3_stmt *pStmt; /* A single SQL statement */ 659 Str sql; /* SQL to run */ 660 unsigned runFlags = 0; /* Flags passed to runSql */ 661 662 for(i=1; i<argc; i++){ 663 char *z = argv[i]; 664 if( z[0]!='-' ){ 665 azDb = realloc(azDb, sizeof(azDb[0])*(nDb+1)); 666 if( azDb==0 ) fatalError("out of memory"); 667 azDb[nDb++] = z; 668 continue; 669 } 670 z++; 671 if( z[0]=='-' ) z++; 672 if( strcmp(z, "help")==0 ){ 673 showHelp(argv[0]); 674 }else if( strcmp(z, "limit-mem")==0 ){ 675 if( i==argc-1 ) fatalError("missing argument to %s", argv[i]); 676 nHeap = integerValue(argv[++i]); 677 }else if( strcmp(z, "no-lookaside")==0 ){ 678 noLookaside = 1; 679 }else if( strcmp(z, "timeout")==0 ){ 680 if( i==argc-1 ) fatalError("missing argument to %s", argv[i]); 681 iTimeout = integerValue(argv[++i]); 682 }else if( strcmp(z, "trace")==0 ){ 683 runFlags |= SQL_OUTPUT|SQL_TRACE; 684 }else if( strcmp(z, "limit-vdbe")==0 ){ 685 vdbeLimitFlag = 1; 686 }else if( strcmp(z, "v")==0 || strcmp(z, "verbose")==0 ){ 687 verboseFlag = 1; 688 runFlags |= SQL_TRACE; 689 }else{ 690 fatalError("unknown command-line option: \"%s\"\n", argv[i]); 691 } 692 } 693 if( nDb==0 ){ 694 showHelp(argv[0]); 695 } 696 if( verboseFlag ){ 697 sqlite3_config(SQLITE_CONFIG_LOG, sqlLog); 698 } 699 if( nHeap>0 ){ 700 void *pHeap = malloc( nHeap ); 701 if( pHeap==0 ) fatalError("cannot allocate %d-byte heap\n", nHeap); 702 rc = sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nHeap, 32); 703 if( rc ) fatalError("heap configuration failed: %d\n", rc); 704 } 705 if( noLookaside ){ 706 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, 0, 0); 707 } 708 inmemVfsRegister(); 709 formatVfs(); 710 StrInit(&sql); 711 #ifdef __unix__ 712 signal(SIGALRM, timeoutHandler); 713 #endif 714 for(i=0; i<nDb; i++){ 715 if( verboseFlag && nDb>1 ){ 716 printf("DATABASE-FILE: %s\n", azDb[i]); 717 fflush(stdout); 718 } 719 if( iTimeout ) setAlarm(iTimeout); 720 createVFile("test.db", azDb[i]); 721 rc = sqlite3_open_v2("test.db", &db, SQLITE_OPEN_READWRITE, "inmem"); 722 if( rc ){ 723 printf("cannot open test.db for \"%s\"\n", azDb[i]); 724 reformatVfs(); 725 continue; 726 } 727 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 728 if( vdbeLimitFlag ){ 729 sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag); 730 } 731 #endif 732 rc = sqlite3_prepare_v2(db, "SELECT sql FROM autoexec", -1, &pStmt, 0); 733 if( rc==SQLITE_OK ){ 734 while( SQLITE_ROW==sqlite3_step(pStmt) ){ 735 StrAppend(&sql, (const char*)sqlite3_column_text(pStmt, 0)); 736 StrAppend(&sql, "\n"); 737 } 738 } 739 sqlite3_finalize(pStmt); 740 StrAppend(&sql, "PRAGMA integrity_check;\n"); 741 runSql(db, StrStr(&sql), runFlags); 742 sqlite3_close(db); 743 reformatVfs(); 744 StrFree(&sql); 745 if( sqlite3_memory_used()>0 ){ 746 free(azDb); 747 reformatVfs(); 748 fatalError("memory leak of %lld bytes", sqlite3_memory_used()); 749 } 750 } 751 StrFree(&sql); 752 reformatVfs(); 753 return 0; 754 }