| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** A utility for printing content from a write-ahead log file. | |
| 3 */ | |
| 4 #include <stdio.h> | |
| 5 #include <ctype.h> | |
| 6 #include <sys/types.h> | |
| 7 #include <sys/stat.h> | |
| 8 #include <fcntl.h> | |
| 9 | |
| 10 #define ISDIGIT(X) isdigit((unsigned char)(X)) | |
| 11 #define ISPRINT(X) isprint((unsigned char)(X)) | |
| 12 | |
| 13 #if !defined(_MSC_VER) | |
| 14 #include <unistd.h> | |
| 15 #else | |
| 16 #include <io.h> | |
| 17 #endif | |
| 18 | |
| 19 #include <stdlib.h> | |
| 20 #include <string.h> | |
| 21 | |
| 22 | |
| 23 static int pagesize = 1024; /* Size of a database page */ | |
| 24 static int fd = -1; /* File descriptor for reading the WAL file */ | |
| 25 static int mxFrame = 0; /* Last frame */ | |
| 26 static int perLine = 16; /* HEX elements to print per line */ | |
| 27 | |
| 28 typedef long long int i64; /* Datatype for 64-bit integers */ | |
| 29 | |
| 30 /* Information for computing the checksum */ | |
| 31 typedef struct Cksum Cksum; | |
| 32 struct Cksum { | |
| 33 int bSwap; /* True to do byte swapping on 32-bit words */ | |
| 34 unsigned s0, s1; /* Current checksum value */ | |
| 35 }; | |
| 36 | |
| 37 /* | |
| 38 ** extract a 32-bit big-endian integer | |
| 39 */ | |
| 40 static unsigned int getInt32(const unsigned char *a){ | |
| 41 unsigned int x = (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; | |
| 42 return x; | |
| 43 } | |
| 44 | |
| 45 /* | |
| 46 ** Swap bytes on a 32-bit unsigned integer | |
| 47 */ | |
| 48 static unsigned int swab32(unsigned int x){ | |
| 49 return (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) | |
| 50 + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24); | |
| 51 } | |
| 52 | |
| 53 /* Extend the checksum. Reinitialize the checksum if bInit is true. | |
| 54 */ | |
| 55 static void extendCksum( | |
| 56 Cksum *pCksum, | |
| 57 unsigned char *aData, | |
| 58 unsigned int nByte, | |
| 59 int bInit | |
| 60 ){ | |
| 61 unsigned int *a32; | |
| 62 if( bInit ){ | |
| 63 int a = 0; | |
| 64 *((char*)&a) = 1; | |
| 65 if( a==1 ){ | |
| 66 /* Host is little-endian */ | |
| 67 pCksum->bSwap = getInt32(aData)!=0x377f0682; | |
| 68 }else{ | |
| 69 /* Host is big-endian */ | |
| 70 pCksum->bSwap = getInt32(aData)!=0x377f0683; | |
| 71 } | |
| 72 pCksum->s0 = 0; | |
| 73 pCksum->s1 = 0; | |
| 74 } | |
| 75 a32 = (unsigned int*)aData; | |
| 76 while( nByte>0 ){ | |
| 77 unsigned int x0 = a32[0]; | |
| 78 unsigned int x1 = a32[1]; | |
| 79 if( pCksum->bSwap ){ | |
| 80 x0 = swab32(x0); | |
| 81 x1 = swab32(x1); | |
| 82 } | |
| 83 pCksum->s0 += x0 + pCksum->s1; | |
| 84 pCksum->s1 += x1 + pCksum->s0; | |
| 85 nByte -= 8; | |
| 86 a32 += 2; | |
| 87 } | |
| 88 } | |
| 89 | |
| 90 /* | |
| 91 ** Convert the var-int format into i64. Return the number of bytes | |
| 92 ** in the var-int. Write the var-int value into *pVal. | |
| 93 */ | |
| 94 static int decodeVarint(const unsigned char *z, i64 *pVal){ | |
| 95 i64 v = 0; | |
| 96 int i; | |
| 97 for(i=0; i<8; i++){ | |
| 98 v = (v<<7) + (z[i]&0x7f); | |
| 99 if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; } | |
| 100 } | |
| 101 v = (v<<8) + (z[i]&0xff); | |
| 102 *pVal = v; | |
| 103 return 9; | |
| 104 } | |
| 105 | |
| 106 /* Report an out-of-memory error and die. | |
| 107 */ | |
| 108 static void out_of_memory(void){ | |
| 109 fprintf(stderr,"Out of memory...\n"); | |
| 110 exit(1); | |
| 111 } | |
| 112 | |
| 113 /* | |
| 114 ** Read content from the file. | |
| 115 ** | |
| 116 ** Space to hold the content is obtained from malloc() and needs to be | |
| 117 ** freed by the caller. | |
| 118 */ | |
| 119 static unsigned char *getContent(int ofst, int nByte){ | |
| 120 unsigned char *aData; | |
| 121 aData = malloc(nByte); | |
| 122 if( aData==0 ) out_of_memory(); | |
| 123 lseek(fd, ofst, SEEK_SET); | |
| 124 read(fd, aData, nByte); | |
| 125 return aData; | |
| 126 } | |
| 127 | |
| 128 /* | |
| 129 ** Print a range of bytes as hex and as ascii. | |
| 130 */ | |
| 131 static void print_byte_range( | |
| 132 int ofst, /* First byte in the range of bytes to print */ | |
| 133 int nByte, /* Number of bytes to print */ | |
| 134 unsigned char *aData, /* Content to print */ | |
| 135 int printOfst /* Add this amount to the index on the left column */ | |
| 136 ){ | |
| 137 int i, j; | |
| 138 const char *zOfstFmt; | |
| 139 | |
| 140 if( ((printOfst+nByte)&~0xfff)==0 ){ | |
| 141 zOfstFmt = " %03x: "; | |
| 142 }else if( ((printOfst+nByte)&~0xffff)==0 ){ | |
| 143 zOfstFmt = " %04x: "; | |
| 144 }else if( ((printOfst+nByte)&~0xfffff)==0 ){ | |
| 145 zOfstFmt = " %05x: "; | |
| 146 }else if( ((printOfst+nByte)&~0xffffff)==0 ){ | |
| 147 zOfstFmt = " %06x: "; | |
| 148 }else{ | |
| 149 zOfstFmt = " %08x: "; | |
| 150 } | |
| 151 | |
| 152 for(i=0; i<nByte; i += perLine){ | |
| 153 fprintf(stdout, zOfstFmt, i+printOfst); | |
| 154 for(j=0; j<perLine; j++){ | |
| 155 if( i+j>nByte ){ | |
| 156 fprintf(stdout, " "); | |
| 157 }else{ | |
| 158 fprintf(stdout,"%02x ", aData[i+j]); | |
| 159 } | |
| 160 } | |
| 161 for(j=0; j<perLine; j++){ | |
| 162 if( i+j>nByte ){ | |
| 163 fprintf(stdout, " "); | |
| 164 }else{ | |
| 165 fprintf(stdout,"%c", ISPRINT(aData[i+j]) ? aData[i+j] : '.'); | |
| 166 } | |
| 167 } | |
| 168 fprintf(stdout,"\n"); | |
| 169 } | |
| 170 } | |
| 171 | |
| 172 /* Print a line of decode output showing a 4-byte integer. | |
| 173 */ | |
| 174 static void print_decode_line( | |
| 175 unsigned char *aData, /* Content being decoded */ | |
| 176 int ofst, int nByte, /* Start and size of decode */ | |
| 177 int asHex, /* If true, output value as hex */ | |
| 178 const char *zMsg /* Message to append */ | |
| 179 ){ | |
| 180 int i, j; | |
| 181 int val = aData[ofst]; | |
| 182 char zBuf[100]; | |
| 183 sprintf(zBuf, " %03x: %02x", ofst, aData[ofst]); | |
| 184 i = (int)strlen(zBuf); | |
| 185 for(j=1; j<4; j++){ | |
| 186 if( j>=nByte ){ | |
| 187 sprintf(&zBuf[i], " "); | |
| 188 }else{ | |
| 189 sprintf(&zBuf[i], " %02x", aData[ofst+j]); | |
| 190 val = val*256 + aData[ofst+j]; | |
| 191 } | |
| 192 i += (int)strlen(&zBuf[i]); | |
| 193 } | |
| 194 if( asHex ){ | |
| 195 sprintf(&zBuf[i], " 0x%08x", val); | |
| 196 }else{ | |
| 197 sprintf(&zBuf[i], " %9d", val); | |
| 198 } | |
| 199 printf("%s %s\n", zBuf, zMsg); | |
| 200 } | |
| 201 | |
| 202 /* | |
| 203 ** Print an entire page of content as hex | |
| 204 */ | |
| 205 static void print_frame(int iFrame){ | |
| 206 int iStart; | |
| 207 unsigned char *aData; | |
| 208 iStart = 32 + (iFrame-1)*(pagesize+24); | |
| 209 fprintf(stdout, "Frame %d: (offsets 0x%x..0x%x)\n", | |
| 210 iFrame, iStart, iStart+pagesize+24); | |
| 211 aData = getContent(iStart, pagesize+24); | |
| 212 print_decode_line(aData, 0, 4, 0, "Page number"); | |
| 213 print_decode_line(aData, 4, 4, 0, "DB size, or 0 for non-commit"); | |
| 214 print_decode_line(aData, 8, 4, 1, "Salt-1"); | |
| 215 print_decode_line(aData,12, 4, 1, "Salt-2"); | |
| 216 print_decode_line(aData,16, 4, 1, "Checksum-1"); | |
| 217 print_decode_line(aData,20, 4, 1, "Checksum-2"); | |
| 218 print_byte_range(iStart+24, pagesize, aData+24, 0); | |
| 219 free(aData); | |
| 220 } | |
| 221 | |
| 222 /* | |
| 223 ** Summarize a single frame on a single line. | |
| 224 */ | |
| 225 static void print_oneline_frame(int iFrame, Cksum *pCksum){ | |
| 226 int iStart; | |
| 227 unsigned char *aData; | |
| 228 unsigned int s0, s1; | |
| 229 iStart = 32 + (iFrame-1)*(pagesize+24); | |
| 230 aData = getContent(iStart, 24); | |
| 231 extendCksum(pCksum, aData, 8, 0); | |
| 232 extendCksum(pCksum, getContent(iStart+24, pagesize), pagesize, 0); | |
| 233 s0 = getInt32(aData+16); | |
| 234 s1 = getInt32(aData+20); | |
| 235 fprintf(stdout, "Frame %4d: %6d %6d 0x%08x,%08x 0x%08x,%08x %s\n", | |
| 236 iFrame, | |
| 237 getInt32(aData), | |
| 238 getInt32(aData+4), | |
| 239 getInt32(aData+8), | |
| 240 getInt32(aData+12), | |
| 241 s0, | |
| 242 s1, | |
| 243 (s0==pCksum->s0 && s1==pCksum->s1) ? "" : "cksum-fail" | |
| 244 ); | |
| 245 | |
| 246 /* Reset the checksum so that a single frame checksum failure will not | |
| 247 ** cause all subsequent frames to also show a failure. */ | |
| 248 pCksum->s0 = s0; | |
| 249 pCksum->s1 = s1; | |
| 250 free(aData); | |
| 251 } | |
| 252 | |
| 253 /* | |
| 254 ** Decode the WAL header. | |
| 255 */ | |
| 256 static void print_wal_header(Cksum *pCksum){ | |
| 257 unsigned char *aData; | |
| 258 aData = getContent(0, 32); | |
| 259 if( pCksum ){ | |
| 260 extendCksum(pCksum, aData, 24, 1); | |
| 261 printf("Checksum byte order: %s\n", pCksum->bSwap ? "swapped" : "native"); | |
| 262 } | |
| 263 printf("WAL Header:\n"); | |
| 264 print_decode_line(aData, 0, 4,1,"Magic. 0x377f0682 (le) or 0x377f0683 (be)"); | |
| 265 print_decode_line(aData, 4, 4, 0, "File format"); | |
| 266 print_decode_line(aData, 8, 4, 0, "Database page size"); | |
| 267 print_decode_line(aData, 12,4, 0, "Checkpoint sequence number"); | |
| 268 print_decode_line(aData, 16,4, 1, "Salt-1"); | |
| 269 print_decode_line(aData, 20,4, 1, "Salt-2"); | |
| 270 print_decode_line(aData, 24,4, 1, "Checksum-1"); | |
| 271 print_decode_line(aData, 28,4, 1, "Checksum-2"); | |
| 272 if( pCksum ){ | |
| 273 if( pCksum->s0!=getInt32(aData+24) ){ | |
| 274 printf("**** cksum-1 mismatch: 0x%08x\n", pCksum->s0); | |
| 275 } | |
| 276 if( pCksum->s1!=getInt32(aData+28) ){ | |
| 277 printf("**** cksum-2 mismatch: 0x%08x\n", pCksum->s1); | |
| 278 } | |
| 279 } | |
| 280 free(aData); | |
| 281 } | |
| 282 /* | |
| 283 ** Describe cell content. | |
| 284 */ | |
| 285 static i64 describeContent( | |
| 286 unsigned char *a, /* Cell content */ | |
| 287 i64 nLocal, /* Bytes in a[] */ | |
| 288 char *zDesc /* Write description here */ | |
| 289 ){ | |
| 290 int nDesc = 0; | |
| 291 int n, j; | |
| 292 i64 i, x, v; | |
| 293 const unsigned char *pData; | |
| 294 const unsigned char *pLimit; | |
| 295 char sep = ' '; | |
| 296 | |
| 297 pLimit = &a[nLocal]; | |
| 298 n = decodeVarint(a, &x); | |
| 299 pData = &a[x]; | |
| 300 a += n; | |
| 301 i = x - n; | |
| 302 while( i>0 && pData<=pLimit ){ | |
| 303 n = decodeVarint(a, &x); | |
| 304 a += n; | |
| 305 i -= n; | |
| 306 nLocal -= n; | |
| 307 zDesc[0] = sep; | |
| 308 sep = ','; | |
| 309 nDesc++; | |
| 310 zDesc++; | |
| 311 if( x==0 ){ | |
| 312 sprintf(zDesc, "*"); /* NULL is a "*" */ | |
| 313 }else if( x>=1 && x<=6 ){ | |
| 314 v = (signed char)pData[0]; | |
| 315 pData++; | |
| 316 switch( x ){ | |
| 317 case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; | |
| 318 case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; | |
| 319 case 4: v = (v<<8) + pData[0]; pData++; | |
| 320 case 3: v = (v<<8) + pData[0]; pData++; | |
| 321 case 2: v = (v<<8) + pData[0]; pData++; | |
| 322 } | |
| 323 sprintf(zDesc, "%lld", v); | |
| 324 }else if( x==7 ){ | |
| 325 sprintf(zDesc, "real"); | |
| 326 pData += 8; | |
| 327 }else if( x==8 ){ | |
| 328 sprintf(zDesc, "0"); | |
| 329 }else if( x==9 ){ | |
| 330 sprintf(zDesc, "1"); | |
| 331 }else if( x>=12 ){ | |
| 332 i64 size = (x-12)/2; | |
| 333 if( (x&1)==0 ){ | |
| 334 sprintf(zDesc, "blob(%lld)", size); | |
| 335 }else{ | |
| 336 sprintf(zDesc, "txt(%lld)", size); | |
| 337 } | |
| 338 pData += size; | |
| 339 } | |
| 340 j = (int)strlen(zDesc); | |
| 341 zDesc += j; | |
| 342 nDesc += j; | |
| 343 } | |
| 344 return nDesc; | |
| 345 } | |
| 346 | |
| 347 /* | |
| 348 ** Compute the local payload size given the total payload size and | |
| 349 ** the page size. | |
| 350 */ | |
| 351 static i64 localPayload(i64 nPayload, char cType){ | |
| 352 i64 maxLocal; | |
| 353 i64 minLocal; | |
| 354 i64 surplus; | |
| 355 i64 nLocal; | |
| 356 if( cType==13 ){ | |
| 357 /* Table leaf */ | |
| 358 maxLocal = pagesize-35; | |
| 359 minLocal = (pagesize-12)*32/255-23; | |
| 360 }else{ | |
| 361 maxLocal = (pagesize-12)*64/255-23; | |
| 362 minLocal = (pagesize-12)*32/255-23; | |
| 363 } | |
| 364 if( nPayload>maxLocal ){ | |
| 365 surplus = minLocal + (nPayload-minLocal)%(pagesize-4); | |
| 366 if( surplus<=maxLocal ){ | |
| 367 nLocal = surplus; | |
| 368 }else{ | |
| 369 nLocal = minLocal; | |
| 370 } | |
| 371 }else{ | |
| 372 nLocal = nPayload; | |
| 373 } | |
| 374 return nLocal; | |
| 375 } | |
| 376 | |
| 377 /* | |
| 378 ** Create a description for a single cell. | |
| 379 ** | |
| 380 ** The return value is the local cell size. | |
| 381 */ | |
| 382 static i64 describeCell( | |
| 383 unsigned char cType, /* Page type */ | |
| 384 unsigned char *a, /* Cell content */ | |
| 385 int showCellContent, /* Show cell content if true */ | |
| 386 char **pzDesc /* Store description here */ | |
| 387 ){ | |
| 388 int i; | |
| 389 i64 nDesc = 0; | |
| 390 int n = 0; | |
| 391 int leftChild; | |
| 392 i64 nPayload; | |
| 393 i64 rowid; | |
| 394 i64 nLocal; | |
| 395 static char zDesc[1000]; | |
| 396 i = 0; | |
| 397 if( cType<=5 ){ | |
| 398 leftChild = ((a[0]*256 + a[1])*256 + a[2])*256 + a[3]; | |
| 399 a += 4; | |
| 400 n += 4; | |
| 401 sprintf(zDesc, "lx: %d ", leftChild); | |
| 402 nDesc = strlen(zDesc); | |
| 403 } | |
| 404 if( cType!=5 ){ | |
| 405 i = decodeVarint(a, &nPayload); | |
| 406 a += i; | |
| 407 n += i; | |
| 408 sprintf(&zDesc[nDesc], "n: %lld ", nPayload); | |
| 409 nDesc += strlen(&zDesc[nDesc]); | |
| 410 nLocal = localPayload(nPayload, cType); | |
| 411 }else{ | |
| 412 nPayload = nLocal = 0; | |
| 413 } | |
| 414 if( cType==5 || cType==13 ){ | |
| 415 i = decodeVarint(a, &rowid); | |
| 416 a += i; | |
| 417 n += i; | |
| 418 sprintf(&zDesc[nDesc], "r: %lld ", rowid); | |
| 419 nDesc += strlen(&zDesc[nDesc]); | |
| 420 } | |
| 421 if( nLocal<nPayload ){ | |
| 422 int ovfl; | |
| 423 unsigned char *b = &a[nLocal]; | |
| 424 ovfl = ((b[0]*256 + b[1])*256 + b[2])*256 + b[3]; | |
| 425 sprintf(&zDesc[nDesc], "ov: %d ", ovfl); | |
| 426 nDesc += strlen(&zDesc[nDesc]); | |
| 427 n += 4; | |
| 428 } | |
| 429 if( showCellContent && cType!=5 ){ | |
| 430 nDesc += describeContent(a, nLocal, &zDesc[nDesc-1]); | |
| 431 } | |
| 432 *pzDesc = zDesc; | |
| 433 return nLocal+n; | |
| 434 } | |
| 435 | |
| 436 /* | |
| 437 ** Decode a btree page | |
| 438 */ | |
| 439 static void decode_btree_page( | |
| 440 unsigned char *a, /* Content of the btree page to be decoded */ | |
| 441 int pgno, /* Page number */ | |
| 442 int hdrSize, /* Size of the page1-header in bytes */ | |
| 443 const char *zArgs /* Flags to control formatting */ | |
| 444 ){ | |
| 445 const char *zType = "unknown"; | |
| 446 int nCell; | |
| 447 int i, j; | |
| 448 int iCellPtr; | |
| 449 int showCellContent = 0; | |
| 450 int showMap = 0; | |
| 451 char *zMap = 0; | |
| 452 switch( a[0] ){ | |
| 453 case 2: zType = "index interior node"; break; | |
| 454 case 5: zType = "table interior node"; break; | |
| 455 case 10: zType = "index leaf"; break; | |
| 456 case 13: zType = "table leaf"; break; | |
| 457 } | |
| 458 while( zArgs[0] ){ | |
| 459 switch( zArgs[0] ){ | |
| 460 case 'c': showCellContent = 1; break; | |
| 461 case 'm': showMap = 1; break; | |
| 462 } | |
| 463 zArgs++; | |
| 464 } | |
| 465 printf("Decode of btree page %d:\n", pgno); | |
| 466 print_decode_line(a, 0, 1, 0, zType); | |
| 467 print_decode_line(a, 1, 2, 0, "Offset to first freeblock"); | |
| 468 print_decode_line(a, 3, 2, 0, "Number of cells on this page"); | |
| 469 nCell = a[3]*256 + a[4]; | |
| 470 print_decode_line(a, 5, 2, 0, "Offset to cell content area"); | |
| 471 print_decode_line(a, 7, 1, 0, "Fragmented byte count"); | |
| 472 if( a[0]==2 || a[0]==5 ){ | |
| 473 print_decode_line(a, 8, 4, 0, "Right child"); | |
| 474 iCellPtr = 12; | |
| 475 }else{ | |
| 476 iCellPtr = 8; | |
| 477 } | |
| 478 if( nCell>0 ){ | |
| 479 printf(" key: lx=left-child n=payload-size r=rowid\n"); | |
| 480 } | |
| 481 if( showMap ){ | |
| 482 zMap = malloc(pagesize); | |
| 483 memset(zMap, '.', pagesize); | |
| 484 memset(zMap, '1', hdrSize); | |
| 485 memset(&zMap[hdrSize], 'H', iCellPtr); | |
| 486 memset(&zMap[hdrSize+iCellPtr], 'P', 2*nCell); | |
| 487 } | |
| 488 for(i=0; i<nCell; i++){ | |
| 489 int cofst = iCellPtr + i*2; | |
| 490 char *zDesc; | |
| 491 i64 n; | |
| 492 | |
| 493 cofst = a[cofst]*256 + a[cofst+1]; | |
| 494 n = describeCell(a[0], &a[cofst-hdrSize], showCellContent, &zDesc); | |
| 495 if( showMap ){ | |
| 496 char zBuf[30]; | |
| 497 memset(&zMap[cofst], '*', (size_t)n); | |
| 498 zMap[cofst] = '['; | |
| 499 zMap[cofst+n-1] = ']'; | |
| 500 sprintf(zBuf, "%d", i); | |
| 501 j = (int)strlen(zBuf); | |
| 502 if( j<=n-2 ) memcpy(&zMap[cofst+1], zBuf, j); | |
| 503 } | |
| 504 printf(" %03x: cell[%d] %s\n", cofst, i, zDesc); | |
| 505 } | |
| 506 if( showMap ){ | |
| 507 for(i=0; i<pagesize; i+=64){ | |
| 508 printf(" %03x: %.64s\n", i, &zMap[i]); | |
| 509 } | |
| 510 free(zMap); | |
| 511 } | |
| 512 } | |
| 513 | |
| 514 int main(int argc, char **argv){ | |
| 515 struct stat sbuf; | |
| 516 unsigned char zPgSz[4]; | |
| 517 if( argc<2 ){ | |
| 518 fprintf(stderr,"Usage: %s FILENAME ?PAGE? ...\n", argv[0]); | |
| 519 exit(1); | |
| 520 } | |
| 521 fd = open(argv[1], O_RDONLY); | |
| 522 if( fd<0 ){ | |
| 523 fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]); | |
| 524 exit(1); | |
| 525 } | |
| 526 zPgSz[0] = 0; | |
| 527 zPgSz[1] = 0; | |
| 528 lseek(fd, 8, SEEK_SET); | |
| 529 read(fd, zPgSz, 4); | |
| 530 pagesize = zPgSz[1]*65536 + zPgSz[2]*256 + zPgSz[3]; | |
| 531 if( pagesize==0 ) pagesize = 1024; | |
| 532 printf("Pagesize: %d\n", pagesize); | |
| 533 fstat(fd, &sbuf); | |
| 534 if( sbuf.st_size<32 ){ | |
| 535 printf("file too small to be a WAL\n"); | |
| 536 return 0; | |
| 537 } | |
| 538 mxFrame = (sbuf.st_size - 32)/(pagesize + 24); | |
| 539 printf("Available pages: 1..%d\n", mxFrame); | |
| 540 if( argc==2 ){ | |
| 541 int i; | |
| 542 Cksum x; | |
| 543 print_wal_header(&x); | |
| 544 for(i=1; i<=mxFrame; i++){ | |
| 545 print_oneline_frame(i, &x); | |
| 546 } | |
| 547 }else{ | |
| 548 int i; | |
| 549 for(i=2; i<argc; i++){ | |
| 550 int iStart, iEnd; | |
| 551 char *zLeft; | |
| 552 if( strcmp(argv[i], "header")==0 ){ | |
| 553 print_wal_header(0); | |
| 554 continue; | |
| 555 } | |
| 556 if( !ISDIGIT(argv[i][0]) ){ | |
| 557 fprintf(stderr, "%s: unknown option: [%s]\n", argv[0], argv[i]); | |
| 558 continue; | |
| 559 } | |
| 560 iStart = strtol(argv[i], &zLeft, 0); | |
| 561 if( zLeft && strcmp(zLeft,"..end")==0 ){ | |
| 562 iEnd = mxFrame; | |
| 563 }else if( zLeft && zLeft[0]=='.' && zLeft[1]=='.' ){ | |
| 564 iEnd = strtol(&zLeft[2], 0, 0); | |
| 565 }else if( zLeft && zLeft[0]=='b' ){ | |
| 566 int ofst, nByte, hdrSize; | |
| 567 unsigned char *a; | |
| 568 if( iStart==1 ){ | |
| 569 hdrSize = 100; | |
| 570 ofst = hdrSize = 100; | |
| 571 nByte = pagesize-100; | |
| 572 }else{ | |
| 573 hdrSize = 0; | |
| 574 ofst = (iStart-1)*pagesize; | |
| 575 nByte = pagesize; | |
| 576 } | |
| 577 ofst = 32 + hdrSize + (iStart-1)*(pagesize+24) + 24; | |
| 578 a = getContent(ofst, nByte); | |
| 579 decode_btree_page(a, iStart, hdrSize, zLeft+1); | |
| 580 free(a); | |
| 581 continue; | |
| 582 }else{ | |
| 583 iEnd = iStart; | |
| 584 } | |
| 585 if( iStart<1 || iEnd<iStart || iEnd>mxFrame ){ | |
| 586 fprintf(stderr, | |
| 587 "Page argument should be LOWER?..UPPER?. Range 1 to %d\n", | |
| 588 mxFrame); | |
| 589 exit(1); | |
| 590 } | |
| 591 while( iStart<=iEnd ){ | |
| 592 print_frame(iStart); | |
| 593 iStart++; | |
| 594 } | |
| 595 } | |
| 596 } | |
| 597 close(fd); | |
| 598 return 0; | |
| 599 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
