Return to showjournal.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool

Annotation of embedaddon/sqlite3/tool/showjournal.c, revision 1.1.1.1

1.1       misho       1: /*
                      2: ** A utility for printing an SQLite database journal.
                      3: */
                      4: #include <stdio.h>
                      5: #include <ctype.h>
                      6: #include <stdlib.h>
                      7: #include <string.h>
                      8: 
                      9: /*
                     10: ** state information
                     11: */
                     12: static int pageSize = 1024;
                     13: static int sectorSize = 512;
                     14: static FILE *db = 0;
                     15: static int showPageContent = 0;
                     16: static int fileSize = 0;
                     17: static unsigned cksumNonce = 0;
                     18: 
                     19: /* Report a memory allocation error */
                     20: static void out_of_memory(void){
                     21:   fprintf(stderr,"Out of memory...\n");
                     22:   exit(1);
                     23: }
                     24: 
                     25: /*
                     26: ** Read N bytes of memory starting at iOfst into space obtained
                     27: ** from malloc().
                     28: */
                     29: static char *read_content(int N, int iOfst){
                     30:   int got;
                     31:   char *pBuf = malloc(N);
                     32:   if( pBuf==0 ) out_of_memory();
                     33:   fseek(db, iOfst, SEEK_SET);
                     34:   got = fread(pBuf, 1, N, db);
                     35:   if( got<0 ){
                     36:     fprintf(stderr, "I/O error reading %d bytes from %d\n", N, iOfst);
                     37:     memset(pBuf, 0, N);
                     38:   }else if( got<N ){
                     39:     fprintf(stderr, "Short read: got only %d of %d bytes from %d\n",
                     40:                      got, N, iOfst);
                     41:     memset(&pBuf[got], 0, N-got);
                     42:   }
                     43:   return pBuf;
                     44: }
                     45: 
                     46: /* Print a line of decode output showing a 4-byte integer.
                     47: */
                     48: static unsigned print_decode_line(
                     49:   unsigned char *aData,      /* Content being decoded */
                     50:   int ofst, int nByte,       /* Start and size of decode */
                     51:   const char *zMsg           /* Message to append */
                     52: ){
                     53:   int i, j;
                     54:   unsigned val = aData[ofst];
                     55:   char zBuf[100];
                     56:   sprintf(zBuf, " %03x: %02x", ofst, aData[ofst]);
                     57:   i = strlen(zBuf);
                     58:   for(j=1; j<4; j++){
                     59:     if( j>=nByte ){
                     60:       sprintf(&zBuf[i], "   ");
                     61:     }else{
                     62:       sprintf(&zBuf[i], " %02x", aData[ofst+j]);
                     63:       val = val*256 + aData[ofst+j];
                     64:     }
                     65:     i += strlen(&zBuf[i]);
                     66:   }
                     67:   sprintf(&zBuf[i], "   %10u", val);
                     68:   printf("%s  %s\n", zBuf, zMsg);
                     69:   return val;
                     70: }
                     71: 
                     72: /*
                     73: ** Read and print a journal header.  Store key information (page size, etc)
                     74: ** in global variables.
                     75: */
                     76: static unsigned decode_journal_header(int iOfst){
                     77:   char *pHdr = read_content(64, iOfst);
                     78:   unsigned nPage;
                     79:   printf("Header at offset %d:\n", iOfst);
                     80:   print_decode_line(pHdr, 0, 4, "Header part 1 (3654616569)");
                     81:   print_decode_line(pHdr, 4, 4, "Header part 2 (547447767)");
                     82:   nPage =
                     83:   print_decode_line(pHdr, 8, 4, "page count");
                     84:   cksumNonce =
                     85:   print_decode_line(pHdr, 12, 4, "chksum nonce");
                     86:   print_decode_line(pHdr, 16, 4, "initial database size in pages");
                     87:   sectorSize =
                     88:   print_decode_line(pHdr, 20, 4, "sector size");
                     89:   pageSize =
                     90:   print_decode_line(pHdr, 24, 4, "page size");
                     91:   print_decode_line(pHdr, 28, 4, "zero");
                     92:   print_decode_line(pHdr, 32, 4, "zero");
                     93:   print_decode_line(pHdr, 36, 4, "zero");
                     94:   print_decode_line(pHdr, 40, 4, "zero");
                     95:   free(pHdr);
                     96:   return nPage;
                     97: }
                     98: 
                     99: static void print_page(int iOfst){
                    100:   unsigned char *aData;
                    101:   char zTitle[50];
                    102:   aData = read_content(pageSize+8, iOfst);
                    103:   sprintf(zTitle, "page number for page at offset %d", iOfst);
                    104:   print_decode_line(aData, 0, 4, zTitle);
                    105:   free(aData);
                    106: }
                    107: 
                    108: int main(int argc, char **argv){
                    109:   int rc;
                    110:   int nPage, cnt;
                    111:   int iOfst;
                    112:   if( argc!=2 ){
                    113:     fprintf(stderr,"Usage: %s FILENAME\n", argv[0]);
                    114:     exit(1);
                    115:   }
                    116:   db = fopen(argv[1], "rb");
                    117:   if( db==0 ){
                    118:     fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
                    119:     exit(1);
                    120:   }
                    121:   fseek(db, 0, SEEK_END);
                    122:   fileSize = ftell(db);
                    123:   printf("journal file size: %d bytes\n", fileSize);
                    124:   fseek(db, 0, SEEK_SET);
                    125:   iOfst = 0;
                    126:   while( iOfst<fileSize ){
                    127:     cnt = nPage = (int)decode_journal_header(iOfst);
                    128:     if( cnt==0 ){
                    129:       cnt = (fileSize - sectorSize)/(pageSize+8);
                    130:     }
                    131:     iOfst += sectorSize;
                    132:     while( cnt && iOfst<fileSize ){
                    133:       print_page(iOfst);
                    134:       iOfst += pageSize+8;
                    135:     }
                    136:     iOfst = (iOfst/sectorSize + 1)*sectorSize;
                    137:   }
                    138:   fclose(db);
                    139: }