/*
* This file has been modified for the cdrkit suite.
*
* The behaviour and appearence of the program code below can differ to a major
* extent from the version distributed by the original author(s).
*
* For details, see Changelog file distributed with the cdrkit package. If you
* received this file from another source then ask the distributing person for
* a log of modifications.
*
*/
/* @(#)isovfy.c 1.26 05/05/15 joerg */
/*
* File isovfy.c - verify consistency of iso9660 filesystem.
*
*
* Written by Eric Youngdale (1993).
*
* Copyright 1993 Yggdrasil Computing, Incorporated
* Copyright (c) 1999-2004 J. Schilling
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; see the file COPYING. If not, write to the Free Software
* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <mconfig.h>
#include <stdxlib.h>
#include <unixstd.h>
#include <strdefs.h>
#include <utypes.h>
#include <stdio.h>
#include <standard.h>
#include <signal.h>
#include <schily.h>
#include "../scsi.h"
#include "../../wodim/defaults.h"
/*
* XXX JS: Some structures have odd lengths!
* Some compilers (e.g. on Sun3/mc68020) padd the structures to even length.
* For this reason, we cannot use sizeof (struct iso_path_table) or
* sizeof (struct iso_directory_record) to compute on disk sizes.
* Instead, we use offsetof(..., name) and add the name size.
* See iso9660.h
*/
#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif
/*
* Note: always use these macros to avoid problems.
*
* ISO_ROUND_UP(X) may cause an integer overflow and thus give
* incorrect results. So avoid it if possible.
*
* ISO_BLOCKS(X) is overflow safe. Prefer this when ever it is possible.
*/
#define SECTOR_SIZE (2048)
#define ISO_ROUND_UP(X) (((X) + (SECTOR_SIZE - 1)) & ~(SECTOR_SIZE - 1))
#define ISO_BLOCKS(X) (((X) / SECTOR_SIZE) + (((X)%SECTOR_SIZE)?1:0))
#define infile in_image
FILE *infile = NULL;
int blocksize;
#define PAGE sizeof (buffer)
#define ISODCL(from, to) (to - from + 1)
struct iso_primary_descriptor {
unsigned char type [ISODCL(1, 1)]; /* 711 */
unsigned char id [ISODCL(2, 6)];
unsigned char version [ISODCL(7, 7)]; /* 711 */
unsigned char unused1 [ISODCL(8, 8)];
unsigned char system_id [ISODCL(9, 40)]; /* aunsigned chars */
unsigned char volume_id [ISODCL(41, 72)]; /* dunsigned chars */
unsigned char unused2 [ISODCL(73, 80)];
unsigned char volume_space_size [ISODCL(81, 88)]; /* 733 */
unsigned char unused3 [ISODCL(89, 120)];
unsigned char volume_set_size [ISODCL(121, 124)]; /* 723 */
unsigned char volume_sequence_number [ISODCL(125, 128)]; /* 723 */
unsigned char logical_block_size [ISODCL(129, 132)]; /* 723 */
unsigned char path_table_size [ISODCL(133, 140)]; /* 733 */
unsigned char type_l_path_table [ISODCL(141, 144)]; /* 731 */
unsigned char opt_type_l_path_table [ISODCL(145, 148)]; /* 731 */
unsigned char type_m_path_table [ISODCL(149, 152)]; /* 732 */
unsigned char opt_type_m_path_table [ISODCL(153, 156)]; /* 732 */
unsigned char root_directory_record [ISODCL(157, 190)]; /* 9.1 */
unsigned char volume_set_id [ISODCL(191, 318)]; /* dunsigned chars */
unsigned char publisher_id [ISODCL(319, 446)]; /* achars */
unsigned char preparer_id [ISODCL(447, 574)]; /* achars */
unsigned char application_id [ISODCL(575, 702)]; /* achars */
unsigned char copyright_file_id [ISODCL(703, 739)]; /* 7.5 dchars */
unsigned char abstract_file_id [ISODCL(740, 776)]; /* 7.5 dchars */
unsigned char bibliographic_file_id [ISODCL(777, 813)]; /* 7.5 dchars */
unsigned char creation_date [ISODCL(814, 830)]; /* 8.4.26.1 */
unsigned char modification_date [ISODCL(831, 847)]; /* 8.4.26.1 */
unsigned char expiration_date [ISODCL(848, 864)]; /* 8.4.26.1 */
unsigned char effective_date [ISODCL(865, 881)]; /* 8.4.26.1 */
unsigned char file_structure_version [ISODCL(882, 882)]; /* 711 */
unsigned char unused4 [ISODCL(883, 883)];
unsigned char application_data [ISODCL(884, 1395)];
unsigned char unused5 [ISODCL(1396, 2048)];
};
struct iso_directory_record {
unsigned char length [ISODCL(1, 1)]; /* 711 */
unsigned char ext_attr_length [ISODCL(2, 2)]; /* 711 */
unsigned char extent [ISODCL(3, 10)]; /* 733 */
unsigned char size [ISODCL(11, 18)]; /* 733 */
unsigned char date [ISODCL(19, 25)]; /* 7 by 711 */
unsigned char flags [ISODCL(26, 26)];
unsigned char file_unit_size [ISODCL(27, 27)]; /* 711 */
unsigned char interleave [ISODCL(28, 28)]; /* 711 */
unsigned char volume_sequence_number [ISODCL(29, 32)]; /* 723 */
unsigned char name_len [ISODCL(33, 33)]; /* 711 */
unsigned char name [38];
};
static int isonum_721(char * p);
static int isonum_723(char * p);
static int isonum_711(char * p);
static int isonum_731(char * p);
static int isonum_722(char * p);
static int isonum_732(char * p);
static int isonum_733(unsigned char * p);
static int parse_rr(unsigned char * pnt, int len, int cont_flag);
static int dump_rr(struct iso_directory_record * idr);
static void check_tree(off_t file_addr, int file_size, off_t parent_addr);
static void check_path_tables(int typel_extent, int typem_extent,
int path_table_size);
static void usage(int excode);
static int
isonum_721(char *p)
{
return ((p[0] & 0xff) | ((p[1] & 0xff) << 8));
}
static int
isonum_723(char *p)
{
#if 0
if (p[0] != p[3] || p[1] != p[2]) {
#ifdef USE_LIBSCHILY
comerrno(EX_BAD, "invalid format 7.2.3 number\n");
#else
fprintf(stderr, "invalid format 7.2.3 number\n");
exit(1);
#endif
}
#endif
return (isonum_721(p));
}
static int
isonum_711(char *p)
{
return (*p & 0xff);
}
static int
isonum_731(char *p)
{
return ((p[0] & 0xff)
| ((p[1] & 0xff) << 8)
| ((p[2] & 0xff) << 16)
| ((p[3] & 0xff) << 24));
}
static int
isonum_722(char *p)
{
return ((p[1] & 0xff)
| ((p[0] & 0xff) << 8));
}
static int
isonum_732(char *p)
{
return ((p[3] & 0xff)
| ((p[2] & 0xff) << 8)
| ((p[1] & 0xff) << 16)
| ((p[0] & 0xff) << 24));
}
static int
isonum_733(unsigned char *p)
{
return (isonum_731((char *)p));
}
char lbuffer[1024];
int iline;
int rr_goof;
static int
parse_rr(unsigned char *pnt, int len, int cont_flag)
{
int slen;
int ncount;
int flag1;
int flag2;
int extent;
unsigned char *pnts;
off_t cont_extent;
int cont_offset;
int cont_size;
char symlinkname[1024];
sprintf(lbuffer+iline, " RRlen=%d ", len);
iline += strlen(lbuffer+iline);
cont_extent = (off_t)0;
cont_offset = cont_size = 0;
symlinkname[0] = 0;
ncount = 0;
flag1 = flag2 = 0;
while (len >= 4) {
if (ncount)
sprintf(lbuffer+iline, ",");
else
sprintf(lbuffer+iline, "[");
iline += strlen(lbuffer + iline);
sprintf(lbuffer+iline, "%c%c", pnt[0], pnt[1]);
iline += strlen(lbuffer + iline);
if (pnt[0] < 'A' || pnt[0] > 'Z' || pnt[1] < 'A' ||
pnt[1] > 'Z') {
sprintf(lbuffer+iline, "**BAD SUSP %d %d]",
pnt[0], pnt[1]);
rr_goof++;
iline += strlen(lbuffer + iline);
return (flag2);
}
if (pnt[3] != 1 && pnt[3] != 2) {
sprintf(lbuffer+iline, "**BAD RRVERSION (%d)\n", pnt[3]);
rr_goof++;
iline += strlen(lbuffer + iline);
return (flag2);
}
ncount++;
if (pnt[0] == 'R' && pnt[1] == 'R') flag1 = pnt[4] & 0xff;
if (strncmp((char *)pnt, "PX", 2) == 0) flag2 |= 1;
if (strncmp((char *)pnt, "PN", 2) == 0) flag2 |= 2;
if (strncmp((char *)pnt, "SL", 2) == 0) flag2 |= 4;
if (strncmp((char *)pnt, "NM", 2) == 0) flag2 |= 8;
if (strncmp((char *)pnt, "CL", 2) == 0) flag2 |= 16;
if (strncmp((char *)pnt, "PL", 2) == 0) flag2 |= 32;
if (strncmp((char *)pnt, "RE", 2) == 0) flag2 |= 64;
if (strncmp((char *)pnt, "TF", 2) == 0) flag2 |= 128;
if (strncmp((char *)pnt, "CE", 2) == 0) {
cont_extent = (off_t)isonum_733(pnt+4);
cont_offset = isonum_733(pnt+12);
cont_size = isonum_733(pnt+20);
sprintf(lbuffer+iline, "=[%x,%x,%d]",
(int)cont_extent, cont_offset, cont_size);
iline += strlen(lbuffer + iline);
}
if (strncmp((char *)pnt, "PL", 2) == 0 || strncmp((char *)pnt, "CL", 2) == 0) {
extent = isonum_733(pnt+4);
sprintf(lbuffer+iline, "=%x", extent);
iline += strlen(lbuffer + iline);
if (extent == 0)
rr_goof++;
}
if (strncmp((char *)pnt, "SL", 2) == 0) {
pnts = pnt+5;
slen = pnt[2] - 5;
while (slen >= 1) {
switch (pnts[0] & 0xfe) {
case 0:
strncat(symlinkname, (char *)(pnts+2), pnts[1]);
break;
case 2:
strcat(symlinkname, ".");
break;
case 4:
strcat(symlinkname, "..");
break;
case 8:
strcat(symlinkname, "/");
break;
case 16:
strcat(symlinkname, "/mnt");
sprintf(lbuffer+iline, "Warning - mount point requested");
iline += strlen(lbuffer + iline);
break;
case 32:
strcat(symlinkname, "kafka");
sprintf(lbuffer+iline, "Warning - host_name requested");
iline += strlen(lbuffer + iline);
break;
default:
sprintf(lbuffer+iline, "Reserved bit setting in symlink");
rr_goof++;
iline += strlen(lbuffer + iline);
break;
}
if ((pnts[0] & 0xfe) && pnts[1] != 0) {
sprintf(lbuffer+iline, "Incorrect length in symlink component");
iline += strlen(lbuffer + iline);
}
if ((pnts[0] & 1) == 0)
strcat(symlinkname, "/");
slen -= (pnts[1] + 2);
pnts += (pnts[1] + 2);
}
if (symlinkname[0] != 0) {
sprintf(lbuffer+iline, "=%s", symlinkname);
iline += strlen(lbuffer + iline);
symlinkname[0] = 0;
}
}
len -= pnt[2];
pnt += pnt[2];
if (len <= 3 && cont_extent) {
unsigned char sector[2048];
#ifdef USE_SCG
readsecs(cont_extent * blocksize / 2048, sector, ISO_BLOCKS(sizeof (sector)));
#else
lseek(fileno(infile), cont_extent * blocksize, SEEK_SET);
read(fileno(infile), sector, sizeof (sector));
#endif
flag2 |= parse_rr(§or[cont_offset], cont_size, 1);
}
}
if (ncount) {
sprintf(lbuffer+iline, "]");
iline += strlen(lbuffer + iline);
}
if (!cont_flag && flag1 && flag1 != flag2) {
sprintf(lbuffer+iline, "Flag %x != %x", flag1, flag2);
rr_goof++;
iline += strlen(lbuffer + iline);
}
return (flag2);
}
static int
dump_rr(struct iso_directory_record *idr)
{
int len;
char * pnt;
len = idr->length[0] & 0xff;
len -= offsetof(struct iso_directory_record, name[0]);
len -= idr->name_len[0];
pnt = (char *) idr;
pnt += offsetof(struct iso_directory_record, name[0]);
pnt += idr->name_len[0];
if ((idr->name_len[0] & 1) == 0) {
pnt++;
len--;
}
rr_goof = 0;
parse_rr((unsigned char *)pnt, len, 0);
return (rr_goof);
}
static int dir_count = 0;
static int dir_size_count = 0;
static int ngoof = 0;
static void
check_tree(off_t file_addr, int file_size, off_t parent_addr)
{
unsigned char buffer[2048];
unsigned int k;
int rflag = 0;
int i;
int i1;
int j;
int goof;
int extent;
int size;
off_t orig_file_addr;
off_t 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
if (sizeof (file_addr) > sizeof (long)) {
printf("Starting directory %ld %d %lld\n",
file_addr, file_size,
(Llong)parent_addr);
} else {
printf("Starting directory %ld %d %ld\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++) {
#ifdef USE_SCG
readsecs(file_addr / 2048, buffer, ISO_BLOCKS(sizeof (buffer)));
#else
lseek(fileno(infile), file_addr, SEEK_SET);
read(fileno(infile), buffer, sizeof (buffer));
#endif
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 != (off_t)(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 != (off_t)(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 < (int)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;
if (sizeof (orig_file_addr) > sizeof (long)) {
printf("%llx: %s", (Llong)orig_file_addr, lbuffer);
} else {
printf("%lx: %s", (long)orig_file_addr, lbuffer);
}
}
if (rflag && (idr->flags[0] & 2))
check_tree((off_t)(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 - offsetof(struct iso_directory_record, name[0]))
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;
};
static void
check_path_tables(int typel_extent, int typem_extent, int path_table_size)
{
int count;
int j;
char *pnt;
char *typel;
char *typem;
/* Now read in the path tables */
typel = (char *) malloc(ISO_ROUND_UP(path_table_size));
#ifdef USE_SCG
readsecs(typel_extent * blocksize / 2048, typel, ISO_BLOCKS(path_table_size));
#else
lseek(fileno(infile), (off_t)((off_t)typel_extent) * blocksize, SEEK_SET);
do{int ret;ret=read(fileno(infile), typel, path_table_size);}while(0); /* FIXME: check return value */
#endif
typem = (char *) malloc(path_table_size);
lseek(fileno(infile), (off_t)((off_t)typem_extent) * blocksize, SEEK_SET);
do{int ret;ret=read(fileno(infile), typem, path_table_size);}while(0); /* FIXME: check return value */
j = path_table_size;
pnt = typel;
count = 1;
while (j) {
int namelen;
int extent;
int 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;
int extent;
int 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);
}
}
static void
usage(int excode)
{
errmsgno(EX_BAD, "Usage: %s [options] image\n",
get_progname());
fprintf(stderr, "Options:\n");
fprintf(stderr, "\t-help, -h Print this help\n");
fprintf(stderr, "\t-version Print version info and exit\n");
fprintf(stderr, "\t-i filename Filename to read ISO-9660 image from\n");
fprintf(stderr, "\tdev=target SCSI target to use as CD/DVD-Recorder\n");
fprintf(stderr, "\nIf neither -i nor dev= are speficied, <image> is needed.\n");
exit(excode);
}
int
main(int argc, char *argv[])
{
int cac;
char * const *cav;
char *opts = "help,h,version,i*,dev*";
BOOL help = FALSE;
BOOL prvers = FALSE;
char *filename = NULL;
char *devname = NULL;
off_t file_addr;
int file_size;
struct iso_primary_descriptor ipd;
struct iso_directory_record *idr;
int typel_extent;
int typem_extent;
int path_table_size;
save_args(argc, argv);
cac = argc - 1;
cav = argv + 1;
if (getallargs(&cac, &cav, opts, &help, &help, &prvers,
&filename, &devname) < 0) {
errmsgno(EX_BAD, "Bad Option: '%s'\n", cav[0]);
usage(EX_BAD);
}
if (help)
usage(0);
if (prvers) {
printf("isovfy %s (%s)\n", CDRKIT_VERSION, HOST_SYSTEM);
exit(0);
}
cac = argc - 1;
cav = argv + 1;
if (filename == NULL && devname == NULL) {
if (getfiles(&cac, &cav, opts) != 0) {
filename = cav[0];
cac--, cav++;
}
}
if (getfiles(&cac, &cav, opts) != 0) {
errmsgno(EX_BAD, "Bad Argument: '%s'\n", cav[0]);
usage(EX_BAD);
}
if (filename != NULL && devname != NULL) {
errmsgno(EX_BAD, "Only one of -i or dev= allowed\n");
usage(EX_BAD);
}
#ifdef USE_SCG
if (filename == NULL && devname == NULL)
cdr_defaults(&devname, NULL, NULL, NULL);
#endif
if (filename == NULL && devname == NULL) {
#ifdef USE_LIBSCHILY
errmsgno(EX_BAD, "ISO-9660 image not specified\n");
#else
fprintf(stderr, "ISO-9660 image not specified\n");
#endif
usage(EX_BAD);
}
if (filename != NULL)
infile = fopen(filename, "rb");
else
filename = devname;
if (infile != NULL) {
/* EMPTY */;
#ifdef USE_SCG
} else if (scsidev_open(filename) < 0) {
#else
} else {
#endif
#ifdef USE_LIBSCHILY
comerr("Cannot open '%s'\n", filename);
#else
fprintf(stderr, "Cannot open '%s'\n", filename);
exit(1);
#endif
}
file_addr = (off_t)32768;
#ifdef USE_SCG
readsecs(file_addr / 2048, &ipd, ISO_BLOCKS(sizeof (ipd)));
#else
lseek(fileno(infile), file_addr, SEEK_SET);
read(fileno(infile), &ipd, sizeof (ipd));
#endif
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 = (off_t)isonum_733(idr->extent) + isonum_711((char *)idr->ext_attr_length);
file_size = isonum_733(idr->size);
if (sizeof (file_addr) > sizeof (long)) {
printf("Root at extent %llx, %d bytes\n", (Llong)file_addr, file_size);
} else {
printf("Root at extent %lx, %d bytes\n", (long)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
if (infile != NULL)
fclose(infile);
if (!ngoof)
printf("No errors found\n");
return (0);
}