isovfy.c

创建一个符合iso-9660标准的iso文件系统

	if((idr->name_len[0] & 1) == 0){
		pnt++;
		len--;
	};

	rr_goof = 0;
	parse_rr((unsigned char *)pnt, len, 0);
	return rr_goof;
}


int dir_count = 0;
int dir_size_count = 0;
int ngoof = 0;

void
check_tree(file_addr, file_size, parent_addr)
	int	file_addr;
	int	file_size;
	int	parent_addr;
{
  unsigned char buffer[2048];
  unsigned int k;
  int rflag = 0;
  int i, i1, j, goof;
  int extent, size;
  int orig_file_addr, parent_file_addr;
  struct iso_directory_record * idr;

  i1 = 0;

  orig_file_addr = file_addr / blocksize;  /* Actual extent of this directory */
  parent_file_addr = parent_addr / blocksize;

  if((dir_count % 100) == 0) printf("[%d %d]\n", dir_count, dir_size_count);
#if 0
  printf("Starting directory %d %d %d\n", file_addr, file_size, parent_addr);
#endif

  dir_count++;
  dir_size_count += file_size / blocksize;

  if(file_size & 0x3ff) printf("********Directory has unusual size\n");

  for(k=0; k < (file_size / sizeof(buffer)); k++){
	  lseek(fileno(infile), file_addr, 0);
	  read(fileno(infile), buffer, sizeof(buffer));
	  i = 0;
	  while(1==1){
		  goof = iline=0;
		  idr = (struct iso_directory_record *) &buffer[i];
		  if(idr->length[0] == 0) break;
		  sprintf(&lbuffer[iline],"%3d ", idr->length[0]);
		  iline += strlen(lbuffer + iline);
		  extent = isonum_733(idr->extent);
		  size = isonum_733(idr->size);
		  sprintf(&lbuffer[iline],"%5x ", extent);
		  iline += strlen(lbuffer + iline);
		  sprintf(&lbuffer[iline],"%8d ", size);
		  iline += strlen(lbuffer + iline);
		  sprintf (&lbuffer[iline], "%c", (idr->flags[0] & 2) ? '*' : ' '); 
		  iline += strlen(lbuffer + iline);

		  if(idr->name_len[0] > 33)
		    {
		      sprintf(&lbuffer[iline],"File name length=(%d)",
			      idr->name_len[0]);
		      goof++;
		      iline += strlen(lbuffer + iline);
		    }
		  else if(idr->name_len[0] == 1 && idr->name[0] == 0) {
			  sprintf(&lbuffer[iline],".             ");
			  iline += strlen(lbuffer + iline);
			  rflag = 0;
			  if(orig_file_addr !=isonum_733(idr->extent) + isonum_711((char *) idr->ext_attr_length))
			    {
			      sprintf(&lbuffer[iline],"***** Directory has null extent.");
			      goof++;
			      iline += strlen(lbuffer + iline);
			    }
			  if(i1)
			    {
			      sprintf(&lbuffer[iline],"***** . not  first entry.");
			      rr_goof++;
			      iline += strlen(lbuffer + iline);
			    }
		  } else if(idr->name_len[0] == 1 && idr->name[0] == 1) {
			  sprintf(&lbuffer[iline],"..            ");
			  iline += strlen(lbuffer + iline);
			  rflag = 0;
			  if(parent_file_addr !=isonum_733(idr->extent) + isonum_711((char *) idr->ext_attr_length))
			    {
			      sprintf(&lbuffer[iline],"***** Directory has null extent.");
			      goof++;
			      iline += strlen(lbuffer + iline);
			    }
			  if(i1 != 1)
			    {
			      sprintf(&lbuffer[iline],"***** .. not second entry.");
			      rr_goof++;
			      iline += strlen(lbuffer + iline);
			    }
			  
		  } else {
		          if(i1 < 2) 
			    {
			      sprintf(&lbuffer[iline]," Improper sorting.");
			      rr_goof++;
			    }
			  for(j=0; j<idr->name_len[0]; j++) 
			    {
			      sprintf(&lbuffer[iline],"%c", idr->name[j]);
			    }
			  for(j=0; j<14 - (int) idr->name_len[0]; j++) 
			    {
			      sprintf(&lbuffer[iline]," ");
			      iline += strlen(lbuffer + iline);
			    }
			  rflag = 1;
		  };

		  if(size && extent == 0) 
		    {
		      sprintf(&lbuffer[iline],"****Extent==0, size != 0");
		      goof++;
		      iline += strlen(lbuffer + iline);
		    }
#if 0
		  /* This is apparently legal. */
		  if(size == 0 && extent) 
		    {
		      sprintf(&lbuffer[iline],"****Extent!=0, size == 0");
		      goof++;
		      iline += strlen(lbuffer + iline);
		    }
#endif

		  if(idr->flags[0] & 0xf5)
		    {
			  sprintf(&lbuffer[iline],"Flags=(%x) ", idr->flags[0]);
			  goof++;
			  iline += strlen(lbuffer + iline);
		    }
		  if(idr->interleave[0])
		    {
			  sprintf(&lbuffer[iline],"Interleave=(%d) ", idr->interleave[0]);
			  goof++;
			  iline += strlen(lbuffer + iline);
		    }

		  if(idr->file_unit_size[0])
		    {
			sprintf(&lbuffer[iline],"File unit size=(%d) ", idr->file_unit_size[0]);
			goof++;
			iline += strlen(lbuffer + iline);
		    }


		  if(idr->volume_sequence_number[0] != 1)
		    {
		      sprintf(&lbuffer[iline],"Volume sequence number=(%d) ", idr->volume_sequence_number[0]);
		      goof++;
		      iline += strlen(lbuffer + iline);
		    }

		  goof += dump_rr(idr);
		  sprintf(&lbuffer[iline],"\n");
		  iline += strlen(lbuffer + iline);


		  if(goof){
		          ngoof++;
			  lbuffer[iline++] = 0;
			  printf("%x: %s", orig_file_addr, lbuffer);
		  };



		  if(rflag && (idr->flags[0] & 2)) check_tree((isonum_733(idr->extent) + isonum_711((char *)idr->ext_attr_length)) * blocksize,
						   isonum_733(idr->size),
						   orig_file_addr * blocksize);
		  i += buffer[i];
		  i1++;
		  if (i > 2048 - sizeof(struct iso_directory_record)) break;
	  };
	  file_addr += sizeof(buffer);
  };
  fflush(stdout);
}


/* This function simply dumps the contents of the path tables.  No
   consistency checking takes place, although this would proably be a good
   idea. */

struct path_table_info{
  char * name;
  unsigned int extent;
  unsigned short index;
  unsigned short parent;
};

void
check_path_tables(typel_extent, typem_extent, path_table_size)
	int	typel_extent;
	int	typem_extent;
	int	path_table_size;
{
  int count;
  int j;
  char * pnt;
  char * typel, *typem;

  /* Now read in the path tables */

  typel = (char *) malloc(path_table_size);
  lseek(fileno(infile), typel_extent * blocksize, 0);
  read(fileno(infile), typel, path_table_size);

  typem = (char *) malloc(path_table_size);
  lseek(fileno(infile), typem_extent * blocksize, 0);
  read(fileno(infile), typem, path_table_size);

  j = path_table_size;
  pnt = typel;
  count = 1;
  while(j){
	  int namelen, extent, idx;
	  char name[32];
	  namelen = *pnt++; pnt++;
	  extent = isonum_731(pnt); pnt += 4;
	  idx = isonum_721(pnt); pnt+= 2;
	  j -= 8+namelen;
	  memset(name, 0, sizeof(name));

	  strncpy(name, pnt, namelen);
	  pnt += namelen;
	  if(j & 1) { j--; pnt++;};
	  printf("%4.4d %4.4d %8.8x %s\n",count++, idx, extent, name);
  };

  j = path_table_size;
  pnt = typem;
  count = 1;
  while(j){
	  int namelen, extent, idx;
	  char name[32];
	  namelen = *pnt++; pnt++;
	  extent = isonum_732(pnt); pnt += 4;
	  idx = isonum_722(pnt); pnt+= 2;
	  j -= 8+namelen;
	  memset(name, 0, sizeof(name));

	  strncpy(name, pnt, namelen);
	  pnt += namelen;
	  if(j & 1) { j--; pnt++;};
	  printf("%4.4d %4.4d %8.8x %s\n", count++, idx, extent, name);
  };

}

void
usage(excode)
	int	excode;
{
	errmsgno(EX_BAD, "Usage: %s [options] image\n",
                get_progname());

	error("Options:\n");
	exit(excode);
}

int
main(argc, argv)
	int	argc;
	char	*argv[];
{
  int file_addr, file_size;
  struct iso_primary_descriptor ipd;
  struct iso_directory_record * idr;
  int typel_extent, typem_extent;
  int path_table_size;

	save_args(argc, argv);

  if(argc < 2)
	usage(EX_BAD);
  infile = fopen(argv[1],"rb");
  if (infile == NULL) {
#ifdef	USE_LIBSCHILY
	comerr("Cannot open '%s'.\n", argv[1]);
#else
	printf("Cannot open '%s'.\n", argv[1]);
	exit(1);
#endif
  }


  file_addr = 32768;
  lseek(fileno(infile), file_addr, 0);
  read(fileno(infile), &ipd, sizeof(ipd));

  idr = (struct iso_directory_record *)ipd.root_directory_record;

  blocksize = isonum_723((char *)ipd.logical_block_size);
  if( blocksize != 512 && blocksize != 1024 && blocksize != 2048 )
    {
      blocksize = 2048;
    }

  file_addr = isonum_733(idr->extent) + isonum_711((char *)idr->ext_attr_length);
  file_size = isonum_733(idr->size);

  printf("Root at extent %x, %d bytes\n", file_addr, file_size);
  file_addr = file_addr * blocksize;

  check_tree(file_addr, file_size, file_addr);

  typel_extent = isonum_731((char *)ipd.type_l_path_table);
  typem_extent = isonum_732((char *)ipd.type_m_path_table);
  path_table_size = isonum_733(ipd.path_table_size);

  /* Enable this to get the dump of the path tables */
#if 0
  check_path_tables(typel_extent, typem_extent, path_table_size);
#endif

  fclose(infile);

  if(!ngoof) printf("No errors found\n");
  return (0);
}