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

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

SCSI/ASPI

开发平台：

MultiPlatform

isoinfo.c：源码内容
  1. /*
  2.  * File isodump.c - dump iso9660 directory information.
  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: isoinfo.c,v 1.6 1999/03/02 03:41:36 eric Exp $";
  25. /*
  26.  * Simple program to dump contents of iso9660 image in more usable format.
  27.  *
  28.  * Usage:
  29.  * To list contents of image (with or without RR):
  30.  * isoinfo -l [-R] -i imagefile
  31.  * To extract file from image:
  32.  * isoinfo -i imagefile -x xtractfile > outfile
  33.  * To generate a "find" like list of files:
  34.  * isoinfo -f -i imagefile
  35.  */
  37. #include "../config.h"
  39. #include <stdxlib.h>
  40. #include <unixstd.h>
  41. #include <strdefs.h>
  43. #include <stdio.h>
  44. #include <standard.h>
  45. #include <signal.h>
  46. #include <sys/stat.h>
  47. #include <statdefs.h>
  49. #include "../iso9660.h"
  51. #ifdef __SVR4
  52. #include <stdlib.h>
  53. #else
  54. extern int optind;
  55. extern char *optarg;
  56. /* extern int getopt (int __argc, char **__argv, char *__optstring); */
  57. #endif
  59. #ifndef S_ISLNK
  60. #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
  61. #endif
  62. #ifndef S_ISSOCK
  63. # ifdef S_IFSOCK
  64. #   define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
  65. # else
  66. #   define S_ISSOCK(m) (0)
  67. # endif
  68. #endif
  70. FILE * infile;
  71. int use_rock = 0;
  72. int use_joliet = 0;
  73. int do_listing = 0;
  74. int do_find = 0;
  75. int do_pathtab = 0;
  76. int do_pvd = 0;
  77. char * xtract = 0;
  78. int ucs_level = 0;
  80. struct stat fstat_buf;
  81. char name_buf[256];
  82. char xname[256];
  83. unsigned char date_buf[9];
  84. unsigned int sector_offset = 0;
  86. unsigned char buffer[2048];
  88. #define PAGE sizeof(buffer)
  90. #define ISODCL(from, to) (to - from + 1)
  93. int isonum_721 __PR((char * p));
  94. int isonum_723 __PR((char * p));
  95. int isonum_731 __PR((char * p));
  96. int isonum_733 __PR((unsigned char * p));
  97. void dump_pathtab __PR((int block, int size));
  98. int parse_rr __PR((unsigned char * pnt, int len, int cont_flag));
  99. void dump_rr __PR((struct iso_directory_record * idr));
  100. void dump_stat __PR((int extent));
  101. void extract_file __PR((struct iso_directory_record * idr));
  102. void parse_dir __PR((char * rootname, int extent, int len));
  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)
  111. | ((p[1] & 0xff) << 8));
  112. }
  114. int
  115. isonum_723 (p)
  116. char * p;
  117. {
  118. #if 0
  119. if (p[0] != p[3] || p[1] != p[2]) {
  120. #ifdef USE_LIBSCHILY
  121. comerrno(EX_BAD, "invalid format 7.2.3 numbern");
  122. #else
  123. fprintf (stderr, "invalid format 7.2.3 numbern");
  124. exit (1);
  125. #endif
  126. }
  127. #endif
  128. return (isonum_721 (p));
  129. }
  131. int
  132. isonum_731 (p)
  133. char *p;
  134. {
  135. return ((p[0] & 0xff)
  136. | ((p[1] & 0xff) << 8)
  137. | ((p[2] & 0xff) << 16)
  138. | ((p[3] & 0xff) << 24));
  139. }
  142. int
  143. isonum_733 (p)
  144. unsigned char *p;
  145. {
  146. return (isonum_731 ((char *)p));
  147. }
  149. void
  150. printchars(s, n)
  151. char *s;
  152. int n;
  153. {
  154. int i;
  155. char *p;
  157. for (;n > 0 && *s; n--) {
  158. if (*s == ' ') {
  159. p = s;
  160. i = n;
  161. while (--i >= 0 && *p++ == ' ')
  162. ;
  163. if (i <= 0)
  164. break;
  165. }
  166. putchar(*s++);
  167. }
  168. }
  170. void
  171. dump_pathtab(block, size)
  172. int block;
  173. int size;
  174. {
  175.     char * buf;
  176.     int    offset;
  177.     int    idx;
  178.     int    extent;
  179.     int    pindex;
  180.     int    j;
  181.     int    len;
  182.     char   namebuf[255];
  184.     printf("Path table starts at block %d, size %dn", block, size);
  185.     
  186.     buf = (char *) malloc(size);
  187.     
  188.     lseek(fileno(infile), (block - sector_offset) << 11, 0);
  189.     read(fileno(infile), buf, size);
  190.     
  191.     offset = 0;
  192.     idx = 1;
  193.     while(offset < size)
  194.     {
  195. len    = buf[offset];
  196. extent = isonum_731(buf + offset + 2);
  197. pindex  = isonum_721(buf + offset + 6);
  198. switch( ucs_level )
  199. {
  200. case 3:
  201. case 2:
  202. case 1:
  203.     for(j=0; j < len; j++)
  204.     {
  205. namebuf[j] = buf[offset + 8 + j*2+1];
  206.     }
  207.     printf("%4d: %4d %x %sn", idx, pindex, extent, namebuf);
  208.     break;
  209. case 0:
  210.     printf("%4d: %4d %x %sn", idx, pindex, extent, buf + offset + 8);
  211. }
  213. idx++;
  214. offset += 8 + len;
  215. if( offset & 1) offset++;
  216.     }
  218.     free(buf);
  219. }
  221. int parse_rr(pnt, len, cont_flag)
  222. unsigned char *pnt;
  223. int len;
  224. int cont_flag;
  225. {
  226. int slen;
  227. int ncount;
  228. int extent;
  229. int cont_extent, cont_offset, cont_size;
  230. int flag1, flag2;
  231. unsigned char *pnts;
  232. char symlinkname[1024];
  233. int goof;
  235. symlinkname[0] = 0;
  237. cont_extent = cont_offset = cont_size = 0;
  239. ncount = 0;
  240. flag1 = flag2 = 0;
  241. while(len >= 4){
  242. if(pnt[3] != 1 && pnt[3] != 2) {
  243.   printf("**BAD RRVERSION (%d)n", pnt[3]);
  244.   return 0; /* JS ??? Is this right ??? */
  245. };
  246. ncount++;
  247. if(pnt[0] == 'R' && pnt[1] == 'R') flag1 = pnt[4] & 0xff;
  248. if(strncmp((char *)pnt, "PX", 2) == 0) flag2 |= 1; /* POSIX attributes */
  249. if(strncmp((char *)pnt, "PN", 2) == 0) flag2 |= 2; /* POSIX devive number */
  250. if(strncmp((char *)pnt, "SL", 2) == 0) flag2 |= 4; /* Symlink */
  251. if(strncmp((char *)pnt, "NM", 2) == 0) flag2 |= 8; /* Alternate Name */
  252. if(strncmp((char *)pnt, "CL", 2) == 0) flag2 |= 16; /* Child link */
  253. if(strncmp((char *)pnt, "PL", 2) == 0) flag2 |= 32; /* Parent link */
  254. if(strncmp((char *)pnt, "RE", 2) == 0) flag2 |= 64; /* Relocated Direcotry */
  255. if(strncmp((char *)pnt, "TF", 2) == 0) flag2 |= 128; /* Time stamp */
  257. if(strncmp((char *)pnt, "PX", 2) == 0) { /* POSIX attributes */
  258. fstat_buf.st_mode = isonum_733(pnt+4);
  259. fstat_buf.st_nlink = isonum_733(pnt+12);
  260. fstat_buf.st_uid = isonum_733(pnt+20);
  261. fstat_buf.st_gid = isonum_733(pnt+28);
  262. };
  264. if(strncmp((char *)pnt, "NM", 2) == 0) { /* Alternate Name */
  265.   strncpy(name_buf, (char *)(pnt+5), pnt[2] - 5);
  266.   name_buf[pnt[2] - 5] = 0;
  267. }
  269. if(strncmp((char *)pnt, "CE", 2) == 0) { /* Continuation Area */
  270. cont_extent = isonum_733(pnt+4);
  271. cont_offset = isonum_733(pnt+12);
  272. cont_size = isonum_733(pnt+20);
  273. };
  275. if(strncmp((char *)pnt, "PL", 2) == 0 || strncmp((char *)pnt, "CL", 2) == 0) {
  276. extent = isonum_733(pnt+4);
  277. };
  279. if(strncmp((char *)pnt, "SL", 2) == 0) { /* Symlink */
  280.         int cflag;
  282. cflag = pnt[4];
  283. pnts = pnt+5;
  284. slen = pnt[2] - 5;
  285. while(slen >= 1){
  286. switch(pnts[0] & 0xfe){
  287. case 0:
  288. strncat(symlinkname, (char *)(pnts+2), pnts[1]);
  289. break;
  290. case 2:
  291. strcat (symlinkname, ".");
  292. break;
  293. case 4:
  294. strcat (symlinkname, "..");
  295. break;
  296. case 8:
  297. if((pnts[0] & 1) == 0)strcat (symlinkname, "/");
  298. break;
  299. case 16:
  300. strcat(symlinkname,"/mnt");
  301. printf("Warning - mount point requested");
  302. break;
  303. case 32:
  304. strcat(symlinkname,"kafka");
  305. printf("Warning - host_name requested");
  306. break;
  307. default:
  308. printf("Reserved bit setting in symlink");
  309. goof++;
  310. break;
  311. };
  312. if((pnts[0] & 0xfe) && pnts[1] != 0) {
  313. printf("Incorrect length in symlink component");
  314. };
  315. if((pnts[0] & 1) == 0) strcat(symlinkname,"/");
  317. slen -= (pnts[1] + 2);
  318. pnts += (pnts[1] + 2);
  319. if(xname[0] == 0) strcpy(xname, "-> ");
  320. strcat(xname, symlinkname);
  321.        };
  322. symlinkname[0] = 0;
  323. };
  325. len -= pnt[2];
  326. pnt += pnt[2];
  327. if(len <= 3 && cont_extent) {
  328.   unsigned char sector[2048];
  329.   lseek(fileno(infile), (cont_extent - sector_offset) << 11, 0);
  330.   read(fileno(infile), sector, sizeof(sector));
  331.   flag2 |= parse_rr(&sector[cont_offset], cont_size, 1);
  332. };
  333. };
  334. return flag2;
  335. }
  337. void
  338. dump_rr(idr)
  339. struct iso_directory_record *idr;
  340. {
  341. int len;
  342. unsigned char * pnt;
  344. len = idr->length[0] & 0xff;
  345. len -= sizeof(struct iso_directory_record);
  346. len += sizeof(idr->name);
  347. len -= idr->name_len[0];
  348. pnt = (unsigned char *) idr;
  349. pnt += sizeof(struct iso_directory_record);
  350. pnt -= sizeof(idr->name);
  351. pnt += idr->name_len[0];
  352. if((idr->name_len[0] & 1) == 0){
  353. pnt++;
  354. len--;
  355. };
  356. parse_rr(pnt, len, 0);
  357. }
  359. struct todo
  360. {
  361.   struct todo * next;
  362.   char * name;
  363.   int extent;
  364.   int length;
  365. };
  367. struct todo * todo_idr = NULL;
  369. char * months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
  370.        "Aug", "Sep", "Oct", "Nov", "Dec"};
  372. void
  373. dump_stat(extent)
  374. int extent;
  375. {
  376.   int i;
  377.   char outline[80];
  379.   memset(outline, ' ', sizeof(outline));
  381.   if(S_ISREG(fstat_buf.st_mode))
  382.     outline[0] = '-';
  383.   else   if(S_ISDIR(fstat_buf.st_mode))
  384.     outline[0] = 'd';
  385.   else   if(S_ISLNK(fstat_buf.st_mode))
  386.     outline[0] = 'l';
  387.   else   if(S_ISCHR(fstat_buf.st_mode))
  388.     outline[0] = 'c';
  389.   else   if(S_ISBLK(fstat_buf.st_mode))
  390.     outline[0] = 'b';
  391.   else   if(S_ISFIFO(fstat_buf.st_mode))
  392.     outline[0] = 'f';
  393.   else   if(S_ISSOCK(fstat_buf.st_mode))
  394.     outline[0] = 's';
  395.   else
  396.     outline[0] = '?';
  398.   memset(outline+1, '-', 9);
  399.   if( fstat_buf.st_mode & S_IRUSR )
  400.     outline[1] = 'r';
  401.   if( fstat_buf.st_mode & S_IWUSR )
  402.     outline[2] = 'w';
  403.   if( fstat_buf.st_mode & S_IXUSR )
  404.     outline[3] = 'x';
  406.   if( fstat_buf.st_mode & S_IRGRP )
  407.     outline[4] = 'r';
  408.   if( fstat_buf.st_mode & S_IWGRP )
  409.     outline[5] = 'w';
  410.   if( fstat_buf.st_mode & S_IXGRP )
  411.     outline[6] = 'x';
  413.   if( fstat_buf.st_mode & S_IROTH )
  414.     outline[7] = 'r';
  415.   if( fstat_buf.st_mode & S_IWOTH )
  416.     outline[8] = 'w';
  417.   if( fstat_buf.st_mode & S_IXOTH )
  418.     outline[9] = 'x';
  420.   sprintf(outline+11, "%3ld", (long)fstat_buf.st_nlink);
  421.   sprintf(outline+15, "%4lo", (unsigned long)fstat_buf.st_uid);
  422.   sprintf(outline+20, "%4lo", (unsigned long)fstat_buf.st_gid);
  423.   sprintf(outline+33, "%8ld", (long)fstat_buf.st_size);
  425.   if( date_buf[1] >= 1 && date_buf[1] <= 12 )
  426.     {
  427.       memcpy(outline+42, months[date_buf[1]-1], 3);
  428.     }
  430.   sprintf(outline+46, "%2d", date_buf[2]);
  431.   sprintf(outline+49, "%4d", date_buf[0]+1900);
  433.   sprintf(outline+54, "[%6d]", extent);
  435.   for(i=0; i<63; i++)
  436.     if(outline[i] == 0) outline[i] = ' ';
  437.   outline[63] = 0;
  439.   printf("%s %s %sn", outline, name_buf, xname);
  440. }
  442. void
  443. extract_file(idr)
  444. struct iso_directory_record *idr;
  445. {
  446.   int extent, len, tlen;
  447.   unsigned char buff[2048];
  449.   extent = isonum_733((unsigned char *)idr->extent);
  450.   len = isonum_733((unsigned char *)idr->size);
  452.   while(len > 0)
  453.     {
  454.       lseek(fileno(infile), (extent - sector_offset) << 11, 0);
  455.       tlen = (len > sizeof(buff) ? sizeof(buff) : len);
  456.       read(fileno(infile), buff, tlen);
  457.       len -= tlen;
  458.       extent++;
  459.       write(1, buff, tlen);
  460.     }
  461. }
  463. void
  464. parse_dir(rootname, extent, len)
  465. char *rootname;
  466. int extent;
  467. int len;
  468. {
  469.   char testname[256];
  470.   struct todo * td;
  471.   int i;
  472.   struct iso_directory_record * idr;
  475.   if( do_listing)
  476.     printf("nDirectory listing of %sn", rootname);
  478.   while(len > 0 )
  479.     {
  480.       lseek(fileno(infile), (extent - sector_offset) << 11, 0);
  481.       read(fileno(infile), buffer, sizeof(buffer));
  482.       len -= sizeof(buffer);
  483.       extent++;
  484.       i = 0;
  485.       while(1==1){
  486. idr = (struct iso_directory_record *) &buffer[i];
  487. if(idr->length[0] == 0) break;
  488. memset(&fstat_buf, 0, sizeof(fstat_buf));
  489. name_buf[0] = xname[0] = 0;
  490. fstat_buf.st_size = isonum_733((unsigned char *)idr->size);
  491. if( idr->flags[0] & 2)
  492.   fstat_buf.st_mode |= S_IFDIR;
  493. else
  494.   fstat_buf.st_mode |= S_IFREG;
  495. if(idr->name_len[0] == 1 && idr->name[0] == 0)
  496.   strcpy(name_buf, ".");
  497. else if(idr->name_len[0] == 1 && idr->name[0] == 1)
  498.   strcpy(name_buf, "..");
  499. else {
  500.   switch(ucs_level)
  501.     {
  502.     case 3:
  503.     case 2:
  504.     case 1:
  505.       /*
  506.        * Unicode name.  Convert as best we can.
  507.        */
  508.       {
  509. int j;
  511. for(j=0; j < idr->name_len[0] / 2; j++)
  512.   {
  513.     name_buf[j] = idr->name[j*2+1];
  514.   }
  515. name_buf[idr->name_len[0]/2] = '';
  516.       }
  517.       break;
  518.     case 0:
  519.       /*
  520.        * Normal non-Unicode name.
  521.        */
  522.       strncpy(name_buf, idr->name, idr->name_len[0]);
  523.       name_buf[idr->name_len[0]] = 0;
  524.       break;
  525.     default:
  526.       /*
  527.        * Don't know how to do these yet.  Maybe they are the same
  528.        * as one of the above.
  529.        */
  530.       exit(1);
  531.     }
  532. };
  533. memcpy(date_buf, idr->date, 9);
  534. if(use_rock) dump_rr(idr);
  535. if(   (idr->flags[0] & 2) != 0
  536.    && (idr->name_len[0] != 1
  537.        || (idr->name[0] != 0 && idr->name[0] != 1)))
  538.   {
  539.     /*
  540.      * Add this directory to the todo list.
  541.      */
  542.     td = todo_idr;
  543.     if( td != NULL ) 
  544.       {
  545. while(td->next != NULL) td = td->next;
  546. td->next = (struct todo *) malloc(sizeof(*td));
  547. td = td->next;
  548.       }
  549.     else
  550.       {
  551. todo_idr = td = (struct todo *) malloc(sizeof(*td));
  552.       }
  553.     td->next = NULL;
  554.     td->extent = isonum_733((unsigned char *)idr->extent);
  555.     td->length = isonum_733((unsigned char *)idr->size);
  556.     td->name = (char *) malloc(strlen(rootname) 
  557.        + strlen(name_buf) + 2);
  558.     strcpy(td->name, rootname);
  559.     strcat(td->name, name_buf);
  560.     strcat(td->name, "/");
  561.   }
  562. else
  563.   {
  564.     strcpy(testname, rootname);
  565.     strcat(testname, name_buf);
  566.     if(xtract && strcmp(xtract, testname) == 0)
  567.       {
  568. extract_file(idr);
  569.       }
  570.   }
  571. if(   do_find
  572.    && (idr->name_len[0] != 1
  573.        || (idr->name[0] != 0 && idr->name[0] != 1)))
  574.   {
  575.     strcpy(testname, rootname);
  576.     strcat(testname, name_buf);
  577.     printf("%sn", testname);
  578.   }
  579. if(do_listing)
  580.   dump_stat(isonum_733((unsigned char *)idr->extent));
  581. i += buffer[i];
  582. if (i > 2048 - sizeof(struct iso_directory_record)) break;
  583.       }
  584.     }
  585. }
  587. void
  588. usage(excode)
  589. int excode;
  590. {
  591. errmsgno(EX_BAD, "Usage: %s [options]n",
  592.                 get_progname());
  594. error("Options:n");
  595. error("t-h Print this helpn");
  596. error("t-d Print information from the primary volume descriptorn");
  597. error("t-f Generate output similar to 'find .  -print'n");
  598. error("t-J Print information from from Joliet extensionsn");
  599. error("t-l Generate output similar to 'ls -lR'n");
  600. error("t-p Print Path Tablen");
  601. error("t-R Print information from from Rock Ridge extensionsn");
  602. error("t-N sector Sector number where ISO image should start on CDn");
  603. error("t-T sector Sector number where actual session starts on CDn");
  604. error("t-i filename Filename to read ISO-9660 image fromn");
  605. error("t-x pathname Extract specified file to stdoutn");
  606. exit(excode);
  607. }
  609. int
  610. main(argc, argv)
  611. int argc;
  612. char *argv[];
  613. {
  614.   int c;
  615.   char * filename = NULL;
  616.   int toc_offset = 0;
  617.   struct todo * td;
  618.   struct iso_primary_descriptor ipd;
  619.   struct iso_directory_record * idr;
  621. save_args(argc, argv);
  623.   if(argc < 2)
  624. usage(EX_BAD);
  625.   while ((c = getopt(argc, argv, "hdpi:JRlx:fN:T:")) != EOF)
  626.     switch (c)
  627.       {
  628.       case 'h':
  629. usage(0);
  630. break;
  631.       case 'd':
  632. do_pvd++;
  633. break;
  634.       case 'f':
  635. do_find++;
  636. break;
  637.       case 'p':
  638. do_pathtab++;
  639. break;
  640.       case 'R':
  641. use_rock++;
  642. break;
  643.       case 'J':
  644. use_joliet++;
  645. break;
  646.       case 'l':
  647. do_listing++;
  648. break;
  649.       case 'T':
  650. /*
  651.  * This is used if we have a complete multi-session
  652.  * disc that we want/need to play with.
  653.  * Here we specify the offset where we want to
  654.  * start searching for the TOC.
  655.  */
  656. toc_offset = atol(optarg);
  657. break;
  658.       case 'N':
  659. /*
  660.  * Use this if we have an image of a single session
  661.  * and we need to list the directory contents.
  662.  * This is the session block number of the start
  663.  * of the session.
  664.  */
  665. sector_offset = atol(optarg);
  666. break;
  667.       case 'i':
  668. filename = optarg;
  669. break;
  670.       case 'x':
  671. xtract = optarg;
  672. break;
  673.       default:
  674. usage(EX_BAD);
  675.       }
  676.   
  677.   if( filename == NULL )
  678.   {
  679. #ifdef USE_LIBSCHILY
  680. comerrno(EX_BAD, "Error - file not specifiedn");
  681. #else
  682. fprintf(stderr, "Error - file not specifiedn");
  683.    exit(1);
  684. #endif
  685.   }
  687.   infile = fopen(filename,"rb");
  689.   if( infile == NULL )
  690.   {
  691. #ifdef USE_LIBSCHILY
  692. comerr("Unable to open file %sn", filename);
  693. #else
  694. fprintf(stderr,"Unable to open file %sn", filename);
  695. exit(1);
  696. #endif
  697.   }
  699.   /*
  700.    * Absolute sector offset, so don't subtract sector_offset here.
  701.    */
  702.   lseek(fileno(infile), (16 + toc_offset) <<11, 0);
  703.   read(fileno(infile), &ipd, sizeof(ipd));
  704.   if (do_pvd) {
  705. printf("CD-ROM is in ISO 9660 formatn");
  706. printf("System id: ");
  707. printchars(ipd.system_id, 32);
  708. putchar('n');
  709. printf("Volume id: ");
  710. printchars(ipd.volume_id, 32);
  711. putchar('n');
  713. printf("Volume set id: ");
  714. printchars(ipd.volume_set_id, 128);
  715. putchar('n');
  716. printf("Publisher id: ");
  717. printchars(ipd.publisher_id, 128);
  718. putchar('n');
  719. printf("Data preparer id: ");
  720. printchars(ipd.preparer_id, 128);
  721. putchar('n');
  722. printf("Application id: ");
  723. printchars(ipd.application_id, 128);
  724. putchar('n');
  726. printf("Copyright File id: ");
  727. printchars(ipd.copyright_file_id, 37);
  728. putchar('n');
  729. printf("Abstract File id: ");
  730. printchars(ipd.abstract_file_id, 37);
  731. putchar('n');
  732. printf("Bibliographic File id: ");
  733. printchars(ipd.bibliographic_file_id, 37);
  734. putchar('n');
  736. printf("Volume set size is: %dn", isonum_723(ipd.volume_set_size));
  737. printf("Volume set seqence number is: %dn", isonum_723(ipd.volume_sequence_number));
  738. printf("Logical block size is: %dn", isonum_723(ipd.logical_block_size));
  739. printf("Volume size is: %dn", isonum_733((unsigned char *)ipd.volume_space_size));
  741. exit(0);
  742.   }
  744.   if( use_joliet )
  745.     {
  746.       int block = 16;
  747.       while( (unsigned char) ipd.type[0] != ISO_VD_END )
  748. {
  749.   /*
  750.    * Find the UCS escape sequence.
  751.    */
  752.   if(    ipd.escape_sequences[0] == '%'
  753.       && ipd.escape_sequences[1] == '/'
  754.       && ipd.escape_sequences[3] == ''
  755.       && (    ipd.escape_sequences[2] == '@'
  756.    || ipd.escape_sequences[2] == 'C'
  757.    || ipd.escape_sequences[2] == 'E') )
  758.     {
  759.       break;
  760.     }
  762.   block++;
  763.   lseek(fileno(infile), (block + toc_offset) <<11, 0);
  764.   read(fileno(infile), &ipd, sizeof(ipd));
  765. }
  767.       if( (unsigned char) ipd.type[0] == ISO_VD_END )
  768. {
  769. #ifdef USE_LIBSCHILY
  770.   comerrno(EX_BAD, "Unable to find Joliet SVDn");
  771. #else
  772.   fprintf(stderr, "Unable to find Joliet SVDn");
  773.   exit(1);
  774. #endif
  775. }
  777.       switch(ipd.escape_sequences[2])
  778. {
  779. case '@':
  780.   ucs_level = 1;
  781.   break;
  782. case 'C':
  783.   ucs_level = 2;
  784.   break;
  785. case 'E':
  786.   ucs_level = 3;
  787.   break;
  788. }
  790.       if( ucs_level > 3 )
  791. {
  792. #ifdef USE_LIBSCHILY
  793.   comerrno(EX_BAD, "Don't know what ucs_level == %d meansn", ucs_level);
  794. #else
  795.   fprintf(stderr, "Don't know what ucs_level == %d meansn", ucs_level);
  796.   exit(1);
  797. #endif
  798. }
  799.     }
  801.   idr = (struct iso_directory_record *)ipd.root_directory_record;
  803.   if( do_pathtab )
  804.     {
  805.       dump_pathtab(isonum_731(ipd.type_l_path_table), 
  806.    isonum_733((unsigned char *)ipd.path_table_size));
  807.     }
  809.   parse_dir("/", isonum_733((unsigned char *)idr->extent), isonum_733((unsigned char *)idr->size));
  810.   td = todo_idr;
  811.   while(td)
  812.     {
  813.       parse_dir(td->name, td->extent, td->length);
  814.       td = td->next;
  815.     }
  817.   fclose(infile);
  818.   return(0);
  819. }