开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
isovfy.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：17k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

isovfy.c：源码内容
  1. /*
  2.  * File isovfy.c - verify consistency of iso9660 filesystem.
  3.  *
  5.    Written by Eric Youngdale (1993).
  7.    Copyright 1993 Yggdrasil Computing, Incorporated
  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 2, or (at your option)
  12.    any later version.
  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  19.    You should have received a copy of the GNU General Public License
  20.    along with this program; if not, write to the Free Software
  21.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23. static char rcsid[] ="$Id: isovfy.c,v 1.5 1999/03/02 03:41:36 eric Exp $";
  25. #include "../config.h"
  27. #include <stdxlib.h>
  28. #include <unixstd.h>
  29. #include <strdefs.h>
  31. #include <stdio.h>
  32. #include <standard.h>
  33. #include <signal.h>
  35. FILE * infile;
  36. int blocksize;
  38. #define PAGE sizeof(buffer)
  40. #define ISODCL(from, to) (to - from + 1)
  42. struct iso_primary_descriptor {
  43. unsigned char type [ISODCL (  1,   1)]; /* 711 */
  44. unsigned char id [ISODCL (  2,   6)];
  45. unsigned char version [ISODCL (  7,   7)]; /* 711 */
  46. unsigned char unused1 [ISODCL (  8,   8)];
  47. unsigned char system_id [ISODCL (  9,  40)]; /* aunsigned chars */
  48. unsigned char volume_id [ISODCL ( 41,  72)]; /* dunsigned chars */
  49. unsigned char unused2 [ISODCL ( 73,  80)];
  50. unsigned char volume_space_size [ISODCL ( 81,  88)]; /* 733 */
  51. unsigned char unused3 [ISODCL ( 89, 120)];
  52. unsigned char volume_set_size [ISODCL (121, 124)]; /* 723 */
  53. unsigned char volume_sequence_number [ISODCL (125, 128)]; /* 723 */
  54. unsigned char logical_block_size [ISODCL (129, 132)]; /* 723 */
  55. unsigned char path_table_size [ISODCL (133, 140)]; /* 733 */
  56. unsigned char type_l_path_table [ISODCL (141, 144)]; /* 731 */
  57. unsigned char opt_type_l_path_table [ISODCL (145, 148)]; /* 731 */
  58. unsigned char type_m_path_table [ISODCL (149, 152)]; /* 732 */
  59. unsigned char opt_type_m_path_table [ISODCL (153, 156)]; /* 732 */
  60. unsigned char root_directory_record [ISODCL (157, 190)]; /* 9.1 */
  61. unsigned char volume_set_id [ISODCL (191, 318)]; /* dunsigned chars */
  62. unsigned char publisher_id [ISODCL (319, 446)]; /* achars */
  63. unsigned char preparer_id [ISODCL (447, 574)]; /* achars */
  64. unsigned char application_id [ISODCL (575, 702)]; /* achars */
  65. unsigned char copyright_file_id [ISODCL (703, 739)]; /* 7.5 dchars */
  66. unsigned char abstract_file_id [ISODCL (740, 776)]; /* 7.5 dchars */
  67. unsigned char bibliographic_file_id [ISODCL (777, 813)]; /* 7.5 dchars */
  68. unsigned char creation_date [ISODCL (814, 830)]; /* 8.4.26.1 */
  69. unsigned char modification_date [ISODCL (831, 847)]; /* 8.4.26.1 */
  70. unsigned char expiration_date [ISODCL (848, 864)]; /* 8.4.26.1 */
  71. unsigned char effective_date [ISODCL (865, 881)]; /* 8.4.26.1 */
  72. unsigned char file_structure_version [ISODCL (882, 882)]; /* 711 */
  73. unsigned char unused4 [ISODCL (883, 883)];
  74. unsigned char application_data [ISODCL (884, 1395)];
  75. unsigned char unused5 [ISODCL (1396, 2048)];
  76. };
  78. struct iso_directory_record {
  79. unsigned char length [ISODCL (1, 1)]; /* 711 */
  80. unsigned char ext_attr_length [ISODCL (2, 2)]; /* 711 */
  81. unsigned char extent [ISODCL (3, 10)]; /* 733 */
  82. unsigned char size [ISODCL (11, 18)]; /* 733 */
  83. unsigned char date [ISODCL (19, 25)]; /* 7 by 711 */
  84. unsigned char flags [ISODCL (26, 26)];
  85. unsigned char file_unit_size [ISODCL (27, 27)]; /* 711 */
  86. unsigned char interleave [ISODCL (28, 28)]; /* 711 */
  87. unsigned char volume_sequence_number [ISODCL (29, 32)]; /* 723 */
  88. unsigned char name_len [ISODCL (33, 33)]; /* 711 */
  89. unsigned char name [38];
  90. };
  92. int isonum_721 __PR((char * p));
  93. int isonum_723 __PR((char * p));
  94. int isonum_711 __PR((char * p));
  95. int isonum_731 __PR((char * p));
  96. int isonum_722 __PR((char * p));
  97. int isonum_732 __PR((char * p));
  98. int isonum_733 __PR((unsigned char * p));
  99. int parse_rr __PR((unsigned char * pnt, int len, int cont_flag));
  100. int dump_rr __PR((struct iso_directory_record * idr));
  101. void check_tree __PR((int file_addr, int file_size, int parent_addr));
  102. void check_path_tables __PR((int typel_extent, int typem_extent, int path_table_size));
  103. void usage __PR((int excode));
  104. int main __PR((int argc, char *argv[]));
  106. int
  107. isonum_721 (p)
  108. char *p;
  109. {
  110. return ((p[0] & 0xff) | ((p[1] & 0xff) << 8));
  111. }
  113. int
  114. isonum_723 (p)
  115. char *p;
  116. {
  117. #if 0
  118. if (p[0] != p[3] || p[1] != p[2]) {
  119. #ifdef USE_LIBSCHILY
  120. comerrno(EX_BAD, "invalid format 7.2.3 numbern");
  121. #else
  122. fprintf (stderr, "invalid format 7.2.3 numbern");
  123. exit (1);
  124. #endif
  125. }
  126. #endif
  127. return (isonum_721 (p));
  128. }
  130. int
  131. isonum_711 (p)
  132. char *p;
  133. {
  134. return (*p & 0xff);
  135. }
  137. int
  138. isonum_731 (p)
  139. char *p;
  140. {
  141. return ((p[0] & 0xff)
  142. | ((p[1] & 0xff) << 8)
  143. | ((p[2] & 0xff) << 16)
  144. | ((p[3] & 0xff) << 24));
  145. }
  147. int
  148. isonum_722(p)
  149. char *p;
  150. {
  151. return ((p[1] & 0xff)
  152. | ((p[0] & 0xff) << 8));
  153. }
  155. int
  156. isonum_732 (p)
  157. char *p;
  158. {
  159. return ((p[3] & 0xff)
  160. | ((p[2] & 0xff) << 8)
  161. | ((p[1] & 0xff) << 16)
  162. | ((p[0] & 0xff) << 24));
  163. }
  165. int
  166. isonum_733 (p)
  167. unsigned char *p;
  168. {
  169. return (isonum_731 ((char *)p));
  170. }
  172. char lbuffer[1024];
  173. int iline;
  174. int rr_goof;
  177. int parse_rr(pnt, len, cont_flag)
  178. unsigned char *pnt;
  179. int len;
  180. int cont_flag;
  181. {
  182. int slen;
  183. int ncount;
  184. int flag1, flag2;
  185. int extent;
  186. unsigned char *pnts;
  187. int cont_extent, cont_offset, cont_size;
  188. char symlinkname[1024];
  189. sprintf(lbuffer+iline," RRlen=%d ", len);
  190. iline += strlen(lbuffer+iline);
  192. cont_extent = cont_offset = cont_size = 0;
  194. symlinkname[0] = 0;
  196. ncount = 0;
  197. flag1 = flag2 = 0;
  198. while(len >= 4){
  199. if(ncount) sprintf(lbuffer+iline,",");
  200. else sprintf(lbuffer+iline,"[");
  201. iline += strlen(lbuffer + iline);
  202. sprintf(lbuffer+iline,"%c%c", pnt[0], pnt[1]);
  203. iline += strlen(lbuffer + iline);
  204. if(pnt[0] < 'A' || pnt[0] > 'Z' || pnt[1] < 'A' || 
  205.    pnt[1] > 'Z') {
  206. sprintf(lbuffer+iline,"**BAD SUSP %d %d]", 
  207.  pnt[0], pnt[1]);
  208. rr_goof++;
  209. iline += strlen(lbuffer + iline);
  210. return flag2;
  211. };
  213. if(pnt[3] != 1 && pnt[3] != 2) {
  214. sprintf(lbuffer+iline, "**BAD RRVERSION (%d)n", pnt[3]);
  215. rr_goof++;
  216. iline += strlen(lbuffer + iline);
  217. return flag2;
  218. };
  219. ncount++;
  220. if(pnt[0] == 'R' && pnt[1] == 'R') flag1 = pnt[4] & 0xff;
  221. if(strncmp((char *)pnt, "PX", 2) == 0) flag2 |= 1;
  222. if(strncmp((char *)pnt, "PN", 2) == 0) flag2 |= 2;
  223. if(strncmp((char *)pnt, "SL", 2) == 0) flag2 |= 4;
  224. if(strncmp((char *)pnt, "NM", 2) == 0) flag2 |= 8;
  225. if(strncmp((char *)pnt, "CL", 2) == 0) flag2 |= 16;
  226. if(strncmp((char *)pnt, "PL", 2) == 0) flag2 |= 32;
  227. if(strncmp((char *)pnt, "RE", 2) == 0) flag2 |= 64;
  228. if(strncmp((char *)pnt, "TF", 2) == 0) flag2 |= 128;
  230. if(strncmp((char *)pnt, "CE", 2) == 0) {
  231. cont_extent = isonum_733(pnt+4);
  232. cont_offset = isonum_733(pnt+12);
  233. cont_size = isonum_733(pnt+20);
  234. sprintf(lbuffer+iline, "=[%x,%x,%d]",
  235.  cont_extent, cont_offset, cont_size);
  236. iline += strlen(lbuffer + iline);
  237.       };
  239. if(strncmp((char *)pnt, "PL", 2) == 0 || strncmp((char *)pnt, "CL", 2) == 0) {
  240. extent = isonum_733(pnt+4);
  241.         sprintf(lbuffer+iline,"=%x", extent);
  242. iline += strlen(lbuffer + iline);
  243. if(extent == 0) rr_goof++;
  244. };
  245. if(strncmp((char *)pnt, "SL", 2) == 0) {
  246. pnts = pnt+5;
  247. slen = pnt[2] - 5;
  248. while(slen >= 1){
  249. switch(pnts[0] & 0xfe){
  250. case 0:
  251. strncat(symlinkname, (char *)(pnts+2), pnts[1]);
  252. break;
  253. case 2:
  254. strcat (symlinkname, ".");
  255. break;
  256. case 4:
  257. strcat (symlinkname, "..");
  258. break;
  259. case 8:
  260. strcat (symlinkname, "/");
  261. break;
  262. case 16:
  263. strcat(symlinkname,"/mnt");
  264. sprintf(lbuffer+iline,"Warning - mount point requested");
  265. iline += strlen(lbuffer + iline);
  266. break;
  267. case 32:
  268. strcat(symlinkname,"kafka");
  269. sprintf(lbuffer+iline,"Warning - host_name requested");
  270. iline += strlen(lbuffer + iline);
  271. break;
  272. default:
  273. sprintf(lbuffer+iline,"Reserved bit setting in symlink");
  274. rr_goof++;
  275. iline += strlen(lbuffer + iline);
  276. break;
  277. };
  278. if((pnts[0] & 0xfe) && pnts[1] != 0) {
  279. sprintf(lbuffer+iline,"Incorrect length in symlink component");
  280. iline += strlen(lbuffer + iline);
  281. };
  282. if((pnts[0] & 1) == 0)
  283.   strcat(symlinkname,"/");
  284. slen -= (pnts[1] + 2);
  285. pnts += (pnts[1] + 2);
  287.        };
  288. if(symlinkname[0] != 0) {
  289.   sprintf(lbuffer+iline,"=%s", symlinkname);
  290.   iline += strlen(lbuffer + iline);
  291.   symlinkname[0] = 0;
  292. }
  293. };
  295. len -= pnt[2];
  296. pnt += pnt[2];
  297. if(len <= 3 && cont_extent) {
  298.   unsigned char sector[2048];
  299.   lseek(fileno(infile), cont_extent * blocksize, 0);
  300.   read(fileno(infile), sector, sizeof(sector));
  301.   flag2 |= parse_rr(&sector[cont_offset], cont_size, 1);
  302. };
  303. };
  304. if(ncount) 
  305.   {
  306.     sprintf(lbuffer+iline,"]");
  307.     iline += strlen(lbuffer + iline);
  308.   }
  309. if (!cont_flag && flag1 && flag1 != flag2) 
  310.   {
  311.     sprintf(lbuffer+iline,"Flag %x != %x", flag1, flag2);
  312.     rr_goof++;
  313.     iline += strlen(lbuffer + iline);
  314.   }
  315. return flag2;
  316. }
  318. int 
  319. dump_rr(idr)
  320. struct iso_directory_record *idr;
  321. {
  322. int len;
  323. char * pnt;
  325. len = idr->length[0] & 0xff;
  326. len -= (sizeof(struct iso_directory_record) - sizeof(idr->name));
  327. len -= idr->name_len[0];
  328. pnt = (char *) idr;
  329. pnt += (sizeof(struct iso_directory_record) - sizeof(idr->name));
  330. pnt += idr->name_len[0];
  332. if((idr->name_len[0] & 1) == 0){
  333. pnt++;
  334. len--;
  335. };
  337. rr_goof = 0;
  338. parse_rr((unsigned char *)pnt, len, 0);
  339. return rr_goof;
  340. }
  343. int dir_count = 0;
  344. int dir_size_count = 0;
  345. int ngoof = 0;
  347. void
  348. check_tree(file_addr, file_size, parent_addr)
  349. int file_addr;
  350. int file_size;
  351. int parent_addr;
  352. {
  353.   unsigned char buffer[2048];
  354.   unsigned int k;
  355.   int rflag = 0;
  356.   int i, i1, j, goof;
  357.   int extent, size;
  358.   int orig_file_addr, parent_file_addr;
  359.   struct iso_directory_record * idr;
  361.   i1 = 0;
  363.   orig_file_addr = file_addr / blocksize;  /* Actual extent of this directory */
  364.   parent_file_addr = parent_addr / blocksize;
  366.   if((dir_count % 100) == 0) printf("[%d %d]n", dir_count, dir_size_count);
  367. #if 0
  368.   printf("Starting directory %d %d %dn", file_addr, file_size, parent_addr);
  369. #endif
  371.   dir_count++;
  372.   dir_size_count += file_size / blocksize;
  374.   if(file_size & 0x3ff) printf("********Directory has unusual sizen");
  376.   for(k=0; k < (file_size / sizeof(buffer)); k++){
  377.   lseek(fileno(infile), file_addr, 0);
  378.   read(fileno(infile), buffer, sizeof(buffer));
  379.   i = 0;
  380.   while(1==1){
  381.   goof = iline=0;
  382.   idr = (struct iso_directory_record *) &buffer[i];
  383.   if(idr->length[0] == 0) break;
  384.   sprintf(&lbuffer[iline],"%3d ", idr->length[0]);
  385.   iline += strlen(lbuffer + iline);
  386.   extent = isonum_733(idr->extent);
  387.   size = isonum_733(idr->size);
  388.   sprintf(&lbuffer[iline],"%5x ", extent);
  389.   iline += strlen(lbuffer + iline);
  390.   sprintf(&lbuffer[iline],"%8d ", size);
  391.   iline += strlen(lbuffer + iline);
  392.   sprintf (&lbuffer[iline], "%c", (idr->flags[0] & 2) ? '*' : ' '); 
  393.   iline += strlen(lbuffer + iline);
  395.   if(idr->name_len[0] > 33)
  396.     {
  397.       sprintf(&lbuffer[iline],"File name length=(%d)",
  398.       idr->name_len[0]);
  399.       goof++;
  400.       iline += strlen(lbuffer + iline);
  401.     }
  402.   else if(idr->name_len[0] == 1 && idr->name[0] == 0) {
  403.   sprintf(&lbuffer[iline],".             ");
  404.   iline += strlen(lbuffer + iline);
  405.   rflag = 0;
  406.   if(orig_file_addr !=isonum_733(idr->extent) + isonum_711((char *) idr->ext_attr_length))
  407.     {
  408.       sprintf(&lbuffer[iline],"***** Directory has null extent.");
  409.       goof++;
  410.       iline += strlen(lbuffer + iline);
  411.     }
  412.   if(i1)
  413.     {
  414.       sprintf(&lbuffer[iline],"***** . not  first entry.");
  415.       rr_goof++;
  416.       iline += strlen(lbuffer + iline);
  417.     }
  418.   } else if(idr->name_len[0] == 1 && idr->name[0] == 1) {
  419.   sprintf(&lbuffer[iline],"..            ");
  420.   iline += strlen(lbuffer + iline);
  421.   rflag = 0;
  422.   if(parent_file_addr !=isonum_733(idr->extent) + isonum_711((char *) idr->ext_attr_length))
  423.     {
  424.       sprintf(&lbuffer[iline],"***** Directory has null extent.");
  425.       goof++;
  426.       iline += strlen(lbuffer + iline);
  427.     }
  428.   if(i1 != 1)
  429.     {
  430.       sprintf(&lbuffer[iline],"***** .. not second entry.");
  431.       rr_goof++;
  432.       iline += strlen(lbuffer + iline);
  433.     }
  434.   
  435.   } else {
  436.           if(i1 < 2) 
  437.     {
  438.       sprintf(&lbuffer[iline]," Improper sorting.");
  439.       rr_goof++;
  440.     }
  441.   for(j=0; j<idr->name_len[0]; j++) 
  442.     {
  443.       sprintf(&lbuffer[iline],"%c", idr->name[j]);
  444.     }
  445.   for(j=0; j<14 - (int) idr->name_len[0]; j++) 
  446.     {
  447.       sprintf(&lbuffer[iline]," ");
  448.       iline += strlen(lbuffer + iline);
  449.     }
  450.   rflag = 1;
  451.   };
  453.   if(size && extent == 0) 
  454.     {
  455.       sprintf(&lbuffer[iline],"****Extent==0, size != 0");
  456.       goof++;
  457.       iline += strlen(lbuffer + iline);
  458.     }
  459. #if 0
  460.   /* This is apparently legal. */
  461.   if(size == 0 && extent) 
  462.     {
  463.       sprintf(&lbuffer[iline],"****Extent!=0, size == 0");
  464.       goof++;
  465.       iline += strlen(lbuffer + iline);
  466.     }
  467. #endif
  469.   if(idr->flags[0] & 0xf5)
  470.     {
  471.   sprintf(&lbuffer[iline],"Flags=(%x) ", idr->flags[0]);
  472.   goof++;
  473.   iline += strlen(lbuffer + iline);
  474.     }
  475.   if(idr->interleave[0])
  476.     {
  477.   sprintf(&lbuffer[iline],"Interleave=(%d) ", idr->interleave[0]);
  478.   goof++;
  479.   iline += strlen(lbuffer + iline);
  480.     }
  482.   if(idr->file_unit_size[0])
  483.     {
  484. sprintf(&lbuffer[iline],"File unit size=(%d) ", idr->file_unit_size[0]);
  485. goof++;
  486. iline += strlen(lbuffer + iline);
  487.     }
  490.   if(idr->volume_sequence_number[0] != 1)
  491.     {
  492.       sprintf(&lbuffer[iline],"Volume sequence number=(%d) ", idr->volume_sequence_number[0]);
  493.       goof++;
  494.       iline += strlen(lbuffer + iline);
  495.     }
  497.   goof += dump_rr(idr);
  498.   sprintf(&lbuffer[iline],"n");
  499.   iline += strlen(lbuffer + iline);
  502.   if(goof){
  503.           ngoof++;
  504.   lbuffer[iline++] = 0;
  505.   printf("%x: %s", orig_file_addr, lbuffer);
  506.   };
  510.   if(rflag && (idr->flags[0] & 2)) check_tree((isonum_733(idr->extent) + isonum_711((char *)idr->ext_attr_length)) * blocksize,
  511.    isonum_733(idr->size),
  512.    orig_file_addr * blocksize);
  513.   i += buffer[i];
  514.   i1++;
  515.   if (i > 2048 - sizeof(struct iso_directory_record)) break;
  516.   };
  517.   file_addr += sizeof(buffer);
  518.   };
  519.   fflush(stdout);
  520. }
  523. /* This function simply dumps the contents of the path tables.  No
  524.    consistency checking takes place, although this would proably be a good
  525.    idea. */
  527. struct path_table_info{
  528.   char * name;
  529.   unsigned int extent;
  530.   unsigned short index;
  531.   unsigned short parent;
  532. };
  534. void
  535. check_path_tables(typel_extent, typem_extent, path_table_size)
  536. int typel_extent;
  537. int typem_extent;
  538. int path_table_size;
  539. {
  540.   int count;
  541.   int j;
  542.   char * pnt;
  543.   char * typel, *typem;
  545.   /* Now read in the path tables */
  547.   typel = (char *) malloc(path_table_size);
  548.   lseek(fileno(infile), typel_extent * blocksize, 0);
  549.   read(fileno(infile), typel, path_table_size);
  551.   typem = (char *) malloc(path_table_size);
  552.   lseek(fileno(infile), typem_extent * blocksize, 0);
  553.   read(fileno(infile), typem, path_table_size);
  555.   j = path_table_size;
  556.   pnt = typel;
  557.   count = 1;
  558.   while(j){
  559.   int namelen, extent, idx;
  560.   char name[32];
  561.   namelen = *pnt++; pnt++;
  562.   extent = isonum_731(pnt); pnt += 4;
  563.   idx = isonum_721(pnt); pnt+= 2;
  564.   j -= 8+namelen;
  565.   memset(name, 0, sizeof(name));
  567.   strncpy(name, pnt, namelen);
  568.   pnt += namelen;
  569.   if(j & 1) { j--; pnt++;};
  570.   printf("%4.4d %4.4d %8.8x %sn",count++, idx, extent, name);
  571.   };
  573.   j = path_table_size;
  574.   pnt = typem;
  575.   count = 1;
  576.   while(j){
  577.   int namelen, extent, idx;
  578.   char name[32];
  579.   namelen = *pnt++; pnt++;
  580.   extent = isonum_732(pnt); pnt += 4;
  581.   idx = isonum_722(pnt); pnt+= 2;
  582.   j -= 8+namelen;
  583.   memset(name, 0, sizeof(name));
  585.   strncpy(name, pnt, namelen);
  586.   pnt += namelen;
  587.   if(j & 1) { j--; pnt++;};
  588.   printf("%4.4d %4.4d %8.8x %sn", count++, idx, extent, name);
  589.   };
  591. }
  593. void
  594. usage(excode)
  595. int excode;
  596. {
  597. errmsgno(EX_BAD, "Usage: %s [options] imagen",
  598.                 get_progname());
  600. error("Options:n");
  601. exit(excode);
  602. }
  604. int
  605. main(argc, argv)
  606. int argc;
  607. char *argv[];
  608. {
  609.   int file_addr, file_size;
  610.   struct iso_primary_descriptor ipd;
  611.   struct iso_directory_record * idr;
  612.   int typel_extent, typem_extent;
  613.   int path_table_size;
  615. save_args(argc, argv);
  617.   if(argc < 2)
  618. usage(EX_BAD);
  619.   infile = fopen(argv[1],"rb");
  620.   if (infile == NULL) {
  621. #ifdef USE_LIBSCHILY
  622. comerr("Cannot open '%s'.n", argv[1]);
  623. #else
  624. printf("Cannot open '%s'.n", argv[1]);
  625. exit(1);
  626. #endif
  627.   }
  630.   file_addr = 32768;
  631.   lseek(fileno(infile), file_addr, 0);
  632.   read(fileno(infile), &ipd, sizeof(ipd));
  634.   idr = (struct iso_directory_record *)ipd.root_directory_record;
  636.   blocksize = isonum_723((char *)ipd.logical_block_size);
  637.   if( blocksize != 512 && blocksize != 1024 && blocksize != 2048 )
  638.     {
  639.       blocksize = 2048;
  640.     }
  642.   file_addr = isonum_733(idr->extent) + isonum_711((char *)idr->ext_attr_length);
  643.   file_size = isonum_733(idr->size);
  645.   printf("Root at extent %x, %d bytesn", file_addr, file_size);
  646.   file_addr = file_addr * blocksize;
  648.   check_tree(file_addr, file_size, file_addr);
  650.   typel_extent = isonum_731((char *)ipd.type_l_path_table);
  651.   typem_extent = isonum_732((char *)ipd.type_m_path_table);
  652.   path_table_size = isonum_733(ipd.path_table_size);
  654.   /* Enable this to get the dump of the path tables */
  655. #if 0
  656.   check_path_tables(typel_extent, typem_extent, path_table_size);
  657. #endif
  659.   fclose(infile);
  661.   if(!ngoof) printf("No errors foundn");
  662.   return (0);
  663. }