test/dbfuzz.c

   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 }