check.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6 #include "omfs.h"
   7 #include "dirscan.h"
   8 #include "check.h"
   9 #include "crc.h"
  10 #include "fix.h"
  11 #include "bits.h"
  12 #include "io.h"
  13
  14 /*
  15  * TODO:
  16  *
  17  * - check hash table index
  18  * - clear extents from free bitmap and make sure free bitmap is null
  19  * - sanity check block size, sys block size, mirrors, etc
  20  * - check that extent count is valid
  21  * - check that terminator matches
  22  * - make sure file sizes match up
  23  */
  24
  25 int check_crc(u8 *blk)
  26 {
  27         u16 crc;
  28         size_t hdr_size = sizeof(struct omfs_header);
  29         struct omfs_inode *oi;
  30
  31         oi = (struct omfs_inode *) blk;
  32
  33         crc = crc_ccitt_msb(0, blk + hdr_size,
  34                 swap_be32(oi->head.body_size));
  35
  36         return (crc == swap_be16(oi->head.crc));
  37 }
  38
  39 int check_header(u8 *blk)
  40 {
  41         int i;
  42         int xor;
  43         struct omfs_inode *oi;
  44
  45         oi = (struct omfs_inode *) blk;
  46
  47         xor = blk[0];
  48         for (i = 1; i < OMFS_XOR_COUNT; i++)
  49                 xor ^= blk[i];
  50
  51         return (xor == oi->head.check_xor);
  52 }
  53
  54 int check_sanity(check_context_t *ctx)
  55 {
  56         omfs_inode_t *inode = ctx->current_inode;
  57         if (inode->head.body_size > ctx->omfs_info->super->sys_blocksize)
  58                 return 0;
  59         // check device size here too.
  60         return 1;
  61 }
  62
  63 int check_inode(check_context_t *ctx)
  64 {
  65         int ret = 1;
  66         omfs_inode_t *inode = ctx->current_inode;
  67         if (!check_sanity(ctx))
  68         {
  69                 fix_problem(E_INSANE, ctx);
  70                 return 0;
  71         }
  72         if (!check_header(inode->data))
  73         {
  74                 fix_problem(E_HEADER_XOR, ctx);
  75         }
  76         if (!check_crc(inode->data))
  77         {
  78                 fix_problem(E_HEADER_CRC, ctx);
  79         }
  80         if (inode->head.self != ctx->block)
  81         {
  82                 fix_problem(E_SELF_PTR, ctx);
  83                 ret = 0;
  84         }
  85         if (inode->parent != ctx->parent)
  86         {
  87                 fix_problem(E_PARENT_PTR, ctx);
  88                 ret = 0;
  89         }
  90         if (omfs_compute_hash(ctx->omfs_info, inode->name) != ctx->hash)
  91         {
  92                 fix_problem(E_HASH_WRONG, ctx);
  93                 ret = 0;
  94         }
  95         if (ctx->bitmap && !test_bit(ctx->bitmap, inode->head.self))
  96         {
  97                 fix_problem(E_BIT_CLEAR, ctx);
  98                 ret = 0;
  99         }
 100         clear_bit(ctx->bitmap, inode->head.self);
 101         if (inode->type == OMFS_FILE)
 102         {
 103                 // TODO check its extents here
 104         }
 105
 106         return ret;
 107 }
 108
 109 int check_fs(FILE *fp)
 110 {
 111         check_context_t ctx;
 112         omfs_super_t super;
 113         omfs_root_t root;
 114         omfs_info_t info = {
 115                 .dev = fp,
 116                 .super = &super,
 117                 .root = &root
 118         };
 119
 120         if (omfs_read_super(fp, &super))
 121         {
 122                 fix_problem(E_READ_SUPER, 0);
 123                 return 0;
 124         }
 125         if (omfs_read_root_block(fp, &super, &root))
 126         {
 127                 fix_problem(E_READ_ROOT, 0);
 128                 return 0;
 129         }
 130
 131         dirscan_entry_t *entry;
 132         ctx.omfs_info = &info;
 133         ctx.bitmap = omfs_get_bitmap(&info);
 134
 135         dirscan_t *scan = dirscan_begin(&info);
 136         if (!scan)
 137         {
 138                 fix_problem(E_SCAN, 0);
 139                 return 0;
 140         }
 141
 142         while ((entry = dirscan_next(scan)))
 143         {
 144                 char *name = escape(entry->inode->name);
 145                 printf("inode: %*c%s %llx %d %llx %llx\n",
 146                         entry->level*2, ' ', name,
 147                         entry->inode->head.self, entry->hindex,
 148                         entry->parent, entry->block);
 149                 free(name);
 150
 151                 ctx.current_inode = entry->inode;
 152                 ctx.block = entry->block;
 153                 ctx.parent = entry->parent;
 154                 ctx.hash = entry->hindex;
 155                 check_inode(&ctx);
 156
 157                 dirscan_release_entry(entry);
 158         }
 159         dirscan_end(scan);
 160
 161         // TODO check all set bits for real inodes.  If they are there,
 162         // move them to root directory with a found-<name>
 163         if (ctx.bitmap)
 164                 free(ctx.bitmap);
 165         return 1;
 166 }