third_party/sqlite/src/test/corruptC.test

   1 # 2004 August 30
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 # This file implements regression tests for SQLite library.
  12 #
  13 # This file implements tests to make sure SQLite does not crash or
  14 # segfault if it sees a corrupt database file.  It creates a base
  15 # data base file, then tests that single byte corruptions in
  16 # increasingly larger quantities are handled gracefully.
  17 #
  18 # $Id: corruptC.test,v 1.14 2009/07/11 06:55:34 danielk1977 Exp $
  19
  20 catch {file delete -force test.db test.db-journal test.bu}
  21
  22 set testdir [file dirname $argv0]
  23 source $testdir/tester.tcl
  24
  25 # Do not use a codec for tests in this file, as the database file is
  26 # manipulated directly using tcl scripts (using the [hexio_write] command).
  27 #
  28 do_not_use_codec
  29
  30 # Construct a compact, dense database for testing.
  31 #
  32 do_test corruptC-1.1 {
  33   execsql {
  34     PRAGMA auto_vacuum = 0;
  35     PRAGMA legacy_file_format=1;
  36     BEGIN;
  37     CREATE TABLE t1(x,y);
  38     INSERT INTO t1 VALUES(1,1);
  39     INSERT OR IGNORE INTO t1 SELECT x*2,y FROM t1;
  40     INSERT OR IGNORE INTO t1 SELECT x*3,y FROM t1;
  41     INSERT OR IGNORE INTO t1 SELECT x*5,y FROM t1;
  42     INSERT OR IGNORE INTO t1 SELECT x*7,y FROM t1;
  43     INSERT OR IGNORE INTO t1 SELECT x*11,y FROM t1;
  44     INSERT OR IGNORE INTO t1 SELECT x*13,y FROM t1;
  45     CREATE INDEX t1i1 ON t1(x);
  46     CREATE TABLE t2 AS SELECT x,2 as y FROM t1 WHERE rowid%5!=0;
  47     COMMIT;
  48   }
  49 } {}
  50
  51 ifcapable {integrityck} {
  52   integrity_check corruptC-1.2
  53 }
  54
  55 # Generate random integer
  56 #
  57 proc random {range} {
  58   return [expr {round(rand()*$range)}]
  59 }
  60
  61 # Copy file $from into $to
  62 #
  63 proc copy_file {from to} {
  64   file copy -force $from $to
  65 }
  66
  67 # Setup for the tests.  Make a backup copy of the good database in test.bu.
  68 #
  69 db close
  70 copy_file test.db test.bu
  71 sqlite3 db test.db
  72 set fsize [file size test.db]
  73
  74 # Set a quasi-random random seed.
  75 if {[info exists ::G(issoak)]} {
  76   # If we are doing SOAK tests, we want a different
  77   # random seed for each run.  Ideally we would like
  78   # to use [clock clicks] or something like that here.
  79   set qseed [file mtime test.db]
  80 } else {
  81   # If we are not doing soak tests,
  82   # make it repeatable.
  83   set qseed 0
  84 }
  85 expr srand($qseed)
  86
  87 #
  88 # First test some specific corruption tests found from earlier runs
  89 # with specific seeds.
  90 #
  91
  92 # test that a corrupt content offset size is handled (seed 5577)
  93 do_test corruptC-2.1 {
  94   db close
  95   copy_file test.bu test.db
  96
  97   # insert corrupt byte(s)
  98   hexio_write test.db 2053 [format %02x 0x04]
  99
 100   sqlite3 db test.db
 101   catchsql {PRAGMA integrity_check}
 102 } {1 {database disk image is malformed}}
 103
 104 # test that a corrupt content offset size is handled (seed 5649)
 105 do_test corruptC-2.2 {
 106   db close
 107   copy_file test.bu test.db
 108
 109   # insert corrupt byte(s)
 110   hexio_write test.db 27   [format %02x 0x08]
 111   hexio_write test.db 233  [format %02x 0x6a]
 112   hexio_write test.db 328  [format %02x 0x67]
 113   hexio_write test.db 750  [format %02x 0x1f]
 114   hexio_write test.db 1132 [format %02x 0x52]
 115   hexio_write test.db 1133 [format %02x 0x84]
 116   hexio_write test.db 1220 [format %02x 0x01]
 117   hexio_write test.db 3688 [format %02x 0xc1]
 118   hexio_write test.db 3714 [format %02x 0x58]
 119   hexio_write test.db 3746 [format %02x 0x9a]
 120
 121   sqlite3 db test.db
 122   catchsql {UPDATE t1 SET y=1}
 123 } {1 {database disk image is malformed}}
 124
 125 # test that a corrupt free cell size is handled (seed 13329)
 126 do_test corruptC-2.3 {
 127   db close
 128   copy_file test.bu test.db
 129
 130   # insert corrupt byte(s)
 131   hexio_write test.db 1094 [format %02x 0x76]
 132
 133   sqlite3 db test.db
 134   catchsql {UPDATE t1 SET y=1}
 135 } {1 {database disk image is malformed}}
 136
 137 # test that a corrupt free cell size is handled (seed 169571)
 138 do_test corruptC-2.4 {
 139   db close
 140   copy_file test.bu test.db
 141
 142   # insert corrupt byte(s)
 143   hexio_write test.db 3119 [format %02x 0xdf]
 144
 145   sqlite3 db test.db
 146   catchsql {UPDATE t2 SET y='abcdef-uvwxyz'}
 147 } {1 {database disk image is malformed}}
 148
 149 # test that a corrupt free cell size is handled (seed 169571)
 150 do_test corruptC-2.5 {
 151   db close
 152   copy_file test.bu test.db
 153
 154   # insert corrupt byte(s)
 155   hexio_write test.db 3119 [format %02x 0xdf]
 156   hexio_write test.db 4073 [format %02x 0xbf]
 157
 158   sqlite3 db test.db
 159   catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
 160   catchsql {PRAGMA integrity_check}
 161 } {0 {{*** in database main ***
 162 Page 4: btreeInitPage() returns error code 11}}}
 163
 164 # {0 {{*** in database main ***
 165 # Corruption detected in cell 710 on page 4
 166 # Multiple uses for byte 661 of page 4
 167 # Fragmented space is 249 byte reported as 21 on page 4}}}
 168
 169 # test that a corrupt free cell size is handled (seed 169595)
 170 do_test corruptC-2.6 {
 171   db close
 172   copy_file test.bu test.db
 173
 174   # insert corrupt byte(s)
 175   hexio_write test.db 619 [format %02x 0xe2]
 176   hexio_write test.db 3150 [format %02x 0xa8]
 177
 178   sqlite3 db test.db
 179   catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
 180 } {1 {database disk image is malformed}}
 181
 182 # corruption (seed 178692)
 183 do_test corruptC-2.7 {
 184   db close
 185   copy_file test.bu test.db
 186
 187   # insert corrupt byte(s)
 188   hexio_write test.db 3074 [format %02x 0xa0]
 189
 190   sqlite3 db test.db
 191   catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
 192 } {1 {database disk image is malformed}}
 193
 194 # corruption (seed 179069)
 195 do_test corruptC-2.8 {
 196   db close
 197   copy_file test.bu test.db
 198
 199   # insert corrupt byte(s)
 200   hexio_write test.db 1393 [format %02x 0x7d]
 201   hexio_write test.db 84 [format %02x 0x19]
 202   hexio_write test.db 3287 [format %02x 0x3b]
 203   hexio_write test.db 2564 [format %02x 0xed]
 204   hexio_write test.db 2139 [format %02x 0x55]
 205
 206   sqlite3 db test.db
 207   catchsql {BEGIN; DELETE FROM t1 WHERE x>13; ROLLBACK;}
 208 } {1 {database disk image is malformed}}
 209
 210 # corruption (seed 170434)
 211 do_test corruptC-2.9 {
 212   db close
 213   copy_file test.bu test.db
 214
 215   # insert corrupt byte(s)
 216   hexio_write test.db 2095 [format %02x 0xd6]
 217
 218   sqlite3 db test.db
 219   catchsql {BEGIN; DELETE FROM t1 WHERE x>13; ROLLBACK;}
 220 } {1 {database disk image is malformed}}
 221
 222 # corruption (seed 186504)
 223 do_test corruptC-2.10 {
 224   db close
 225   copy_file test.bu test.db
 226
 227   # insert corrupt byte(s)
 228   hexio_write test.db 3130 [format %02x 0x02]
 229
 230   sqlite3 db test.db
 231   catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
 232 } {1 {database disk image is malformed}}
 233
 234 # corruption (seed 1589)
 235 do_test corruptC-2.11 {
 236   db close
 237   copy_file test.bu test.db
 238
 239   # insert corrupt byte(s)
 240   hexio_write test.db 55 [format %02x 0xa7]
 241
 242   sqlite3 db test.db
 243   catchsql {BEGIN; CREATE TABLE t3 AS SELECT x,3 as y FROM t2 WHERE rowid%5!=0; ROLLBACK;}
 244 } {1 {database disk image is malformed}}
 245
 246 # corruption (seed 14166)
 247 do_test corruptC-2.12 {
 248   db close
 249   copy_file test.bu test.db
 250
 251   # insert corrupt byte(s)
 252   hexio_write test.db 974 [format %02x 0x2e]
 253
 254   sqlite3 db test.db
 255   catchsql {SELECT count(*) FROM sqlite_master;}
 256 } {1 {malformed database schema (t1i1) - corrupt database}}
 257
 258 # corruption (seed 218803)
 259 do_test corruptC-2.13 {
 260   db close
 261   copy_file test.bu test.db
 262
 263   # insert corrupt byte(s)
 264   hexio_write test.db 102 [format %02x 0x12]
 265
 266   sqlite3 db test.db
 267   catchsql {BEGIN; CREATE TABLE t3 AS SELECT x,3 as y FROM t2 WHERE rowid%5!=0; ROLLBACK;}
 268 } {1 {database disk image is malformed}}
 269
 270 do_test corruptC-2.14 {
 271   db close
 272   copy_file test.bu test.db
 273
 274   sqlite3 db test.db
 275   set blob [string repeat abcdefghij 10000]
 276   execsql { INSERT INTO t1 VALUES (1, $blob) }
 277
 278   sqlite3 db test.db
 279   set filesize [file size test.db]
 280   hexio_write test.db [expr $filesize-2048] 00000001
 281   catchsql {DELETE FROM t1 WHERE rowid = (SELECT max(rowid) FROM t1)}
 282 } {1 {database disk image is malformed}}
 283
 284 # At one point this particular corrupt database was causing a buffer
 285 # overread. Which caused a crash in a run of all.test once.
 286 #
 287 do_test corruptC-2.15 {
 288   db close
 289   copy_file test.bu test.db
 290   hexio_write test.db 986 b9
 291   sqlite3 db test.db
 292   catchsql {SELECT count(*) FROM sqlite_master;}
 293 } {1 {malformed database schema (t1i1) - no such table: main.t1}}
 294
 295 #
 296 # Now test for a series of quasi-random seeds.
 297 # We loop over the entire file size and touch
 298 # each byte at least once.
 299 for {set tn 0} {$tn<$fsize} {incr tn 1} {
 300
 301   # setup for test
 302   db close
 303   copy_file test.bu test.db
 304   sqlite3 db test.db
 305
 306   # Seek to a random location in the file, and write a random single byte
 307   # value.  Then do various operations on the file to make sure that
 308   # the database engine can handle the corruption gracefully.
 309   #
 310   set last 0
 311   for {set i 1} {$i<=512 && !$last} {incr i 1} {
 312
 313     db close
 314     if {$i==1} {
 315       # on the first corrupt value, use location $tn
 316       # this ensures that we touch each location in the
 317       # file at least once.
 318       set roffset $tn
 319     } else {
 320       # insert random byte at random location
 321       set roffset [random $fsize]
 322     }
 323     set rbyte [format %02x [random 255]]
 324
 325     # You can uncomment the following to have it trace
 326     # exactly how it's corrupting the file.  This is
 327     # useful for generating the "seed specific" tests
 328     # above.
 329     # set rline "$roffset $rbyte"
 330     # puts stdout $rline
 331
 332     hexio_write test.db $roffset $rbyte
 333     sqlite3 db test.db
 334
 335     # do a few random operations to make sure that if
 336     # they error, they error gracefully instead of crashing.
 337     do_test corruptC-3.$tn.($qseed).$i.1 {
 338       catchsql {SELECT count(*) FROM sqlite_master}
 339       set x {}
 340     } {}
 341     do_test corruptC-3.$tn.($qseed).$i.2 {
 342       catchsql {SELECT count(*) FROM t1}
 343       set x {}
 344     } {}
 345     do_test corruptC-3.$tn.($qseed).$i.3 {
 346       catchsql {SELECT count(*) FROM t1 WHERE x>13}
 347       set x {}
 348     } {}
 349     do_test corruptC-3.$tn.($qseed).$i.4 {
 350       catchsql {SELECT count(*) FROM t2}
 351       set x {}
 352     } {}
 353     do_test corruptC-3.$tn.($qseed).$i.5 {
 354       catchsql {SELECT count(*) FROM t2 WHERE x<13}
 355       set x {}
 356     } {}
 357     do_test corruptC-3.$tn.($qseed).$i.6 {
 358       catchsql {BEGIN; UPDATE t1 SET y=1; ROLLBACK;}
 359       set x {}
 360     } {}
 361     do_test corruptC-3.$tn.($qseed).$i.7 {
 362       catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
 363       set x {}
 364     } {}
 365     do_test corruptC-3.$tn.($qseed).$i.8 {
 366       catchsql {BEGIN; DELETE FROM t1 WHERE x>13; ROLLBACK;}
 367       set x {}
 368     } {}
 369     do_test corruptC-3.$tn.($qseed).$i.9 {
 370       catchsql {BEGIN; DELETE FROM t2 WHERE x<13; ROLLBACK;}
 371       set x {}
 372     } {}
 373     do_test corruptC-3.$tn.($qseed).$i.10 {
 374       catchsql {BEGIN; CREATE TABLE t3 AS SELECT x,3 as y FROM t2 WHERE rowid%5!=0; ROLLBACK;}
 375       set x {}
 376     } {}
 377
 378     # check the integrity of the database.
 379     # once the corruption is detected, we can stop.
 380     ifcapable {integrityck} {
 381       set res [ catchsql {PRAGMA integrity_check} ]
 382       set ans [lindex $res 1]
 383       if { [ string compare $ans "ok" ] != 0 } {
 384         set last -1
 385       }
 386     }
 387     # if we are not capable of doing an integrity check,
 388     # stop after corrupting 5 bytes.
 389     ifcapable {!integrityck} {
 390       if { $i > 5 } {
 391         set last -1
 392       }
 393     }
 394
 395     # Check that no page references were leaked.
 396     # TBD:  need to figure out why this doesn't work
 397     # work with ROLLBACKs...
 398     if {0} {
 399       do_test corruptC-3.$tn.($qseed).$i.11 {
 400         set bt [btree_from_db db]
 401         db_enter db
 402         array set stats [btree_pager_stats $bt]
 403         db_leave db
 404         set stats(ref)
 405       } {0}
 406     }
 407   }
 408   # end for i
 409
 410 }
 411 # end for tn
 412
 413 finish_test