dnix-tools/dnix-traverse/dnix-traverse.cpp

/*

  compile using : c++ dnix-traverse.cpp -o dnix-traverse

  Program to list and extract files from a DNIX FS. Should also be able to write to a DNIX file system. Possibly even add boot code and other things.

 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <limits.h>     /* PATH_MAX */

#include <errno.h>

typedef unsigned int daddr_t;
typedef int dnix_time_t;
typedef int dnix_ino_t;

#pragma pack(1)

//#define daddr_t dnix_daddr_t
#define time_t dnix_time_t
#define ino_t dnix_ino_t

#include "../dnix-headers/diskpar.h"
#include "../dnix-headers/inode.h"
#include "../dnix-headers/sysfile.h"
#include "../dnix-headers/dir.h"

#undef ino_t
//#undef daddr_t
#undef time_t
//#define daddr_t daddr_t
#define time_t time_t

#include <sys/stat.h>   /* mkdir(2) */

#define swap32(num) (((num>>24)&0xff) | ((num<<8)&0xff0000) | ((num>>8)&0xff00) | ((num<<24)&0xff000000)) 

#define swap16(num) (((num >> 8) & 0xff) | ((num << 8) & 0xff00))

class DnixFs {
  struct sysfptr dnixPartitionInfo;
  struct sysfile sysfile;
  FILE * image;
 public:
  DnixFs();
  void init( FILE * image );
  bool readInode (int inumber, struct dinode * inode);
};


bool DnixFs:: readInode (int inumber, struct dinode * inode) {
  struct dinode dinode;
  char buffer[26];
  struct tm * tm_info;
  time_t tim;
  int i;
  printf ("inumber  %04X\n", inumber);
  printf ("insiz %04X\n", sysfile.s_insiz);
  printf ("inadr %04X\n", sysfile.s_inadr);
  printf ("Address to read inode from %04lX\n", (inumber-1) * (sizeof dinode) + sysfile.s_inadr);
  if (((inumber-1) * (sizeof dinode) + sysfile.s_inadr) > sysfile.s_insiz) {
    printf ("******************* invalid inode address. Refusing. It is outide valid range.\n");
    return false;
  }
  fseek (image, (inumber-1) * (sizeof dinode) + sysfile.s_inadr, SEEK_SET);
  fread ( (void * ) &dinode, sizeof dinode, 1, image);

  
  inode->di_mode = swap16(dinode.di_mode);
  inode->di_nlink = swap16(dinode.di_nlink);
  inode->di_uid = swap16(dinode.di_uid);
  inode->di_gid = swap16(dinode.di_gid);
  inode->di_size = swap32(dinode.di_size);
  inode->di_atime = swap32(dinode.di_atime);
  inode->di_atime = swap32(dinode.di_atime);
  inode->di_mtime = swap32(dinode.di_mtime);
  inode->di_ctime = swap32(dinode.di_ctime);
  memcpy((void *) inode->di_addr, (void *) dinode.di_addr, 40);
  //for (i=0; i<40; i++) {
  //  printf ("di_addr[%d] = %02X  %02X\n",  i, inode->di_addr[i], dinode.di_addr[i]);
  //}

  printf("mode and type of file %04X\n", inode->di_mode);
  printf("number of links to file %d\n", inode->di_nlink);
  printf("owner's user id %d\n", inode->di_uid);
  printf("owner's group id %d\n", inode->di_gid);
  printf("number of bytes in file %d\n", inode->di_size);

  tim = inode->di_atime;
  tm_info = localtime((time_t *) ( &tim));
  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);

  printf("time last accessed %s\n", buffer);

  tim = inode->di_mtime;
  tm_info = localtime((time_t *) ( &tim));
  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);

  printf("time last modified %s\n", buffer);
  tim = inode->di_ctime;
  tm_info = localtime((time_t *) ( &tim));
  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);

  printf("time inode last modified %s\n", buffer);
  return true;

}


void DnixFs::init(FILE * img) {
  char buffer[26];
  struct tm * tm_info;
  daddr_t superblock_address;
  struct sysfile s;
  time_t tim;
  image = img;
  // Read the partition info
  
  fseek (image, SYSFPTR, SEEK_SET);
  fread ( (void * ) &dnixPartitionInfo, 512, 1, image);
  tim = swap32(dnixPartitionInfo.timestamp);
  tm_info = localtime((time_t *) ( &tim));
  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);
  superblock_address = swap32(dnixPartitionInfo.vdsp);
  printf ("Pointer to volume descriptor block: %08X\n", superblock_address);
  printf ("1:s complement of previous item: %08X\n", swap32(dnixPartitionInfo.vdspn));
  printf ("Volume clean flag: %08X\n", swap32(dnixPartitionInfo.cleanfl));
  printf ("Timestamp %s\n", buffer);
  
  fseek (image, superblock_address, SEEK_SET);
  fread ( (void *) &s, sizeof sysfile, 1, image);
  memcpy ( (void *) &sysfile, (void *) &s, sizeof sysfile);
  
  sysfile.s_bmadr = swap32(s.s_bmadr);
  sysfile.s_inadr = swap32(s.s_inadr);
  sysfile.s_rtadr = swap32(s.s_rtadr);
  sysfile.s_swadr = swap32(s.s_swadr);
  sysfile.s_vlsiz = swap32(s.s_vlsiz);
  sysfile.s_bmsiz = swap32(s.s_bmsiz);
  sysfile.s_swsiz = swap32(s.s_swsiz);
  sysfile.s_bksiz = swap32(s.s_bksiz);
  sysfile.s_disiz = swap32(s.s_disiz);
  sysfile.s_insiz = swap32(s.s_insiz);
  sysfile.s_time = swap32(s.s_time); 
  
  printf ("Bitmap pointer: %08X\n", sysfile.s_bmadr);
  printf ("Inode list pointer: %08X\n", sysfile.s_inadr);
  printf ("Root file pointer: %08X\n", sysfile.s_rtadr);
  printf ("Swap area: %08X\n", sysfile.s_swadr);
  printf ("Volume size: %d\n", sysfile.s_vlsiz);
  printf ("Bitmap size: %d\n", sysfile.s_bmsiz);
  printf ("Swap area size: %d\n", sysfile.s_swsiz);
  printf ("Block size: %d\n", sysfile.s_bksiz);
  printf ("Size of a directory entry: %d\n", sysfile.s_disiz);
  printf ("Default size of inode list: %08X\n", sysfile.s_insiz);

  tim = sysfile.s_time;
  
  tm_info = localtime((time_t *) ( &tim));
  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);
  printf ("Time initiated: %s\n", buffer);
}

// Read a file - block number as specified  - store in buf


class DnixFile {
  struct dinode ino;
  FILE * image;
  char indir_level_one [2048];
  int  indir_level_one_block_no;
  char indir_level_two [2048];
  int  indir_level_two_block_no;
  char indir_level_three [2048];
  int  indir_level_three_block_no;
public:
  void init( FILE * image, struct dinode * inode );
  void readFileBlock( int block_no, void * buf );
};


void DnixFile::init(FILE * img, struct dinode * inode) {
  memcpy (&ino, inode, sizeof (struct dinode));
  image = img;
}

void DnixFile::readFileBlock ( int block_no, void * buf ) {
  long disk_address;
  int ret;
  printf("block_no=%d\n",block_no );
  if (block_no<11) {
    // direct blocks
    disk_address = ((((long)(0xff& ino.di_addr[block_no*3])) <<16 ) | (((long)(0xff & ino.di_addr[block_no*3 + 1])) <<8 ) | (ino.di_addr[block_no*3 + 2] & 0xff))<<8;
    printf ("diskaddress=%08lX\n", disk_address);
  } else if ((block_no > 10) && (block_no < 692)) {
    // address of first indirect block is in block 11.
    disk_address = ((((long)(0xff& ino.di_addr[30])) <<16 ) | (((long)(0xff & ino.di_addr[31])) <<8 ) | (ino.di_addr[32] & 0xff))<<8;
    if (disk_address != indir_level_one_block_no) {
      fseek (image, disk_address, SEEK_SET);
      fread (indir_level_one, 2048, 1, image);
    }
    disk_address = ((((long)(0xff& indir_level_one[(block_no-10)*3])) <<16 ) | (((long)(0xff & indir_level_one[(block_no-10)*3 + 1])) <<8 ) | (indir_level_one[(block_no-10)*3 + 2] & 0xff))<<8;

    // First level of indirect block
  } else if ((block_no > 693) && (block_no < 465816)) {
    
    // Second level of indirect block
    disk_address = ((((long)(0xff& ino.di_addr[33])) <<16 ) | (((long)(0xff & ino.di_addr[34])) <<8 ) | (ino.di_addr[35] & 0xff))<<8;
    if (disk_address != indir_level_two_block_no) {
      fseek (image, disk_address, SEEK_SET);
      fread (indir_level_two, 2048, 1, image);
      indir_level_two_block_no = disk_address;
    }
    //disk_address = ((((long)(0xff& indir_level_two[(block_no-10)*3])) <<16 ) | (((long)(0xff & indir_level_one[(block_no-10)*3 + 1])) <<8 ) | (indir_level_one[(block_no-10)*3 + 2] & 0xff))<<8;
    //disk_address = indir_level_two[((block_no-693)/682)*3] * 65536 + indir_level_two[((block_no-693)/682)*3 + 1]*256 + indir_level_two[((block_no-693)/682)*3 + 2];
    if (disk_address != indir_level_one_block_no) {
      fseek (image, disk_address, SEEK_SET);
      fread (indir_level_one, 2048, 1, image);
      indir_level_one_block_no = disk_address;
    }
    disk_address = indir_level_one[(block_no-10)*3] * 65536 + indir_level_one[(block_no-10)*3 + 1]*256 + indir_level_one[(block_no-10)*3 + 2];

  } else {
    // Third level of indirect block 
    disk_address = ino.di_addr[36] * 65536 + ino.di_addr[37]*256 + ino.di_addr[38];
    if (disk_address != indir_level_one_block_no) {
      fseek (image, disk_address, SEEK_SET);
      fread (indir_level_one, 2048, 1, image);
    }
    disk_address = ino.di_addr[(block_no-10)*3] * 65536 + ino.di_addr[(block_no-10)*3 + 1]*256 + ino.di_addr[(block_no-10)*3 + 2];

  }
  printf ("before fseek\n");
  ret = fseek (image, disk_address, SEEK_SET);
  printf ("fseek ret=%d\n", ret);
  ret = fread (buf, 2048, 1, image);
  printf ("fread ret=%d\n", ret);
}


DnixFs::DnixFs() {
}


int mkdir_p(const char *path)
{
  /* Adapted from http://stackoverflow.com/a/2336245/119527 */
  const size_t len = strlen(path);
  char _path[PATH_MAX];
  char *p; 

  errno = 0;

  /* Copy string so its mutable */
  if (len > sizeof(_path)-1) {
    errno = ENAMETOOLONG;
    return -1; 
  }   
  strcpy(_path, path);

  /* Iterate the string */
  for (p = _path + 1; *p; p++) {
    if (*p == '/') {
      /* Temporarily truncate */
      *p = '\0';

      if (mkdir(_path, S_IRWXU) != 0) {
	if (errno != EEXIST)
	  return -1; 
      }

      *p = '/';
    }
  }   

  if (mkdir(_path, S_IRWXU) != 0) {
    if (errno != EEXIST)
      return -1; 
  }   

  return 0;
}



void readDir(int inumber, FILE * image_file, class DnixFs * dnixFs, char * path) {
  char p [1024];
  const char * slash = "/";
  struct direct * dir;
  class DnixFile * file = new class DnixFile;
  int size;
  FILE *output;
  int block_no;
  int dir_cnt;
  bool ret;
  struct dinode inode;
  printf("Processing path=%s\n", path);
  ret = dnixFs->readInode(inumber, &inode);
  if (!ret) return;
  dir = (struct direct *) malloc (2048);
  file->init(image_file, &inode);
  size = inode.di_size;
  printf ("size=%d\n", size);
  if (inode.di_mode & 0x4000) {
    mkdir_p(path);
    // Directory
    // Allocate memory
    block_no = 0;
    do {
      file->readFileBlock(block_no, (void * ) dir);
      // process all the entries in the directory
      dir_cnt=0;
      do {
	printf ("inode: %d name: %s \n", swap16(dir[dir_cnt].d_ino),  dir[dir_cnt].d_name);
	if (((strncmp(dir[dir_cnt].d_name,".",1)!=0) && (strncmp(dir[dir_cnt].d_name,"..",2)!=0)) || (strlen(dir[dir_cnt].d_name) > 2)) {
	  memset(p,0,sizeof p);
	  strcpy(p, path);
	  strcat(p, slash);
	  strncat(p, dir[dir_cnt].d_name,14);
	  readDir(swap16(dir[dir_cnt].d_ino), image_file, dnixFs, p);
	}
	dir_cnt++;
	printf("dir_cnt=%d\n", dir_cnt);
      } while ((dir_cnt < 128) && (swap16(dir[dir_cnt].d_ino) != 0)); 
      size -= 2048;
      block_no ++;
    } while (size > 0 && swap16(dir[255].d_ino) !=0 );
  } else {    
    // Ordinary file
    output = fopen (path, "w");
    chmod (path, inode.di_mode & 07777);
    chown (path, inode.di_gid, inode.di_uid);
    do {
      file->readFileBlock(block_no, (void * ) dir);
      if (size >= 2048) {
	fwrite(dir, 1, 2048, output);
      } else {
	fwrite(dir, 1, size, output);
      }
      size -= 2048;
      block_no ++;
    } while (size > 0);
    fclose(output);
  }
}


int main (int argc, char ** argv) {
  FILE * image_file;
  int opt;
  class DnixFs dnixFs;
  while ((opt = getopt(argc, argv, "d:")) != -1) {
    switch (opt) {
    case 'd':
      image_file = fopen (optarg, "r");
      if (image_file == NULL) {
	perror ("Failure opening file.");
	exit(EXIT_FAILURE);
      }
      break;
    default: /* '?' */
      fprintf(stderr, "Usage: %s [-d disk-image-file]\n", argv[0]);
      exit(EXIT_FAILURE);
    }
  }

  dnixFs.init(image_file);
  readDir(INOROOT, image_file, &dnixFs, (char *) ".");
}