summaryrefslogtreecommitdiff
path: root/genisoimage/diag/isoinfo.c
diff options
context:
space:
mode:
Diffstat (limited to 'genisoimage/diag/isoinfo.c')
-rw-r--r--genisoimage/diag/isoinfo.c1321
1 files changed, 1321 insertions, 0 deletions
diff --git a/genisoimage/diag/isoinfo.c b/genisoimage/diag/isoinfo.c
new file mode 100644
index 0000000..55396c2
--- /dev/null
+++ b/genisoimage/diag/isoinfo.c
@@ -0,0 +1,1321 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)isoinfo.c 1.50 05/05/15 joerg */
+/*
+ * File isodump.c - dump iso9660 directory information.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * Simple program to dump contents of iso9660 image in more usable format.
+ *
+ * Usage:
+ * To list contents of image (with or without RR):
+ * isoinfo -l [-R] -i imagefile
+ * To extract file from image:
+ * isoinfo -i imagefile -x xtractfile > outfile
+ * To generate a "find" like list of files:
+ * isoinfo -f -i imagefile
+ */
+
+#include <mconfig.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <strdefs.h>
+
+#include <stdio.h>
+#include <utypes.h>
+#include <standard.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <statdefs.h>
+#include <fctldefs.h>
+#include <schily.h>
+
+#include "../iso9660.h"
+#include "../scsi.h"
+#include "../../wodim/defaults.h"
+
+#include <unls.h>
+
+#if defined(__CYGWIN32__) || defined(__EMX__) || defined(__DJGPP__)
+#include <io.h> /* for setmode() prototype */
+#endif
+
+/*
+ * Make sure we have a definition for this. If not, take a very conservative
+ * guess.
+ * POSIX requires the max pathname component lenght to be defined in limits.h
+ * If variable, it may be undefined. If undefined, there should be
+ * a definition for _POSIX_NAME_MAX in limits.h or in unistd.h
+ * As _POSIX_NAME_MAX is defined to 14, we cannot use it.
+ * XXX Eric's wrong comment:
+ * XXX From what I can tell SunOS is the only one with this trouble.
+ */
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifndef NAME_MAX
+#ifdef FILENAME_MAX
+#define NAME_MAX FILENAME_MAX
+#else
+#define NAME_MAX 256
+#endif
+#endif
+
+#ifndef PATH_MAX
+#ifdef FILENAME_MAX
+#define PATH_MAX FILENAME_MAX
+#else
+#define PATH_MAX 1024
+#endif
+#endif
+
+/*
+ * 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
+
+#ifndef S_ISLNK
+#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
+#endif
+#ifndef S_ISSOCK
+#ifdef S_IFSOCK
+# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
+#else
+# define S_ISSOCK(m) (0)
+#endif
+#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 use_rock = 0;
+int use_joliet = 0;
+int do_listing = 0;
+int do_find = 0;
+int do_sectors = 0;
+int do_pathtab = 0;
+int do_pvd = 0;
+BOOL debug = FALSE;
+char *xtract = 0;
+int su_version = 0;
+int aa_version = 0;
+int ucs_level = 0;
+
+struct stat fstat_buf;
+int found_rr;
+char name_buf[256];
+char xname[2048];
+unsigned char date_buf[9];
+/*
+ * Use sector_offset != 0 (-N #) if we have an image file
+ * of a single session and we need to list the directory contents.
+ * This is the session block (sector) number of the start
+ * of the session when it would be on disk.
+ */
+unsigned int sector_offset = 0;
+
+unsigned char buffer[2048];
+
+struct unls_table *unls;
+
+#define PAGE sizeof (buffer)
+
+#define ISODCL(from, to) (to - from + 1)
+
+
+int isonum_721(char * p);
+int isonum_723(char * p);
+int isonum_731(char * p);
+int isonum_732(char * p);
+int isonum_733(unsigned char * p);
+void printchars(char *s, int n);
+char *sdate(char *dp);
+void dump_pathtab(int block, int size);
+int parse_rr(unsigned char * pnt, int len, int cont_flag);
+void find_rr(struct iso_directory_record * idr, Uchar **pntp, int *lenp);
+int dump_rr(struct iso_directory_record * idr);
+void dump_stat(struct iso_directory_record * idr, int extent);
+void extract_file(struct iso_directory_record * idr);
+void parse_dir(char * rootname, int extent, int len);
+void usage(int excode);
+
+static void printf_bootinfo(FILE *f, int bootcat_offset);
+static char *arch_name(int val);
+static char *boot_name(int val);
+static char *bootmedia_name(int val);
+
+
+int
+isonum_721(char *p)
+{
+ return ((p[0] & 0xff)
+ | ((p[1] & 0xff) << 8));
+}
+
+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));
+}
+
+int
+isonum_731(char *p)
+{
+ return ((p[0] & 0xff)
+ | ((p[1] & 0xff) << 8)
+ | ((p[2] & 0xff) << 16)
+ | ((p[3] & 0xff) << 24));
+}
+
+int
+isonum_732(char *p)
+{
+ return ((p[3] & 0xff)
+ | ((p[2] & 0xff) << 8)
+ | ((p[1] & 0xff) << 16)
+ | ((p[0] & 0xff) << 24));
+}
+
+int
+isonum_733(unsigned char *p)
+{
+ return (isonum_731((char *)p));
+}
+
+void
+printchars(char *s, int n)
+{
+ int i;
+ char *p;
+
+ for (; n > 0 && *s; n--) {
+ if (*s == ' ') {
+ p = s;
+ i = n;
+ while (--i >= 0 && *p++ == ' ')
+ ;
+ if (i <= 0)
+ break;
+ }
+ putchar(*s++);
+ }
+}
+
+/*
+ * Print date info from PVD
+ */
+char *
+sdate(char *dp)
+{
+ static char d[30];
+
+ sprintf(d, "%4.4s %2.2s %2.2s %2.2s:%2.2s:%2.2s.%2.2s",
+ &dp[0], /* Year */
+ &dp[4], /* Month */
+ &dp[6], /* Monthday */
+ &dp[8], /* Hour */
+ &dp[10], /* Minute */
+ &dp[12], /* Seconds */
+ &dp[14]); /* Hunreds of a Seconds */
+
+ /*
+ * dp[16] contains minute offset from Greenwich
+ * Positive values are to the east of Greenwich.
+ */
+ return (d);
+}
+
+void
+dump_pathtab(int block, int size)
+{
+ unsigned char *buf;
+ int offset;
+ int idx;
+ int extent;
+ int pindex;
+ int j;
+ int len;
+ int jlen;
+ char namebuf[255];
+ unsigned char uh, ul, uc, *up;
+
+
+ printf("Path table starts at block %d, size %d\n", block, size);
+
+ buf = (unsigned char *) malloc(ISO_ROUND_UP(size));
+
+#ifdef USE_SCG
+ readsecs(block - sector_offset, buf, ISO_BLOCKS(size));
+#else
+ lseek(fileno(infile), ((off_t)(block - sector_offset)) << 11, SEEK_SET);
+ read(fileno(infile), buf, size);
+#endif
+
+ offset = 0;
+ idx = 1;
+ while (offset < size) {
+ len = buf[offset];
+ extent = isonum_731((char *)buf + offset + 2);
+ pindex = isonum_721((char *)buf + offset + 6);
+ switch (ucs_level) {
+ case 3:
+ case 2:
+ case 1:
+ jlen = len/2;
+ namebuf[0] = '\0';
+ for (j = 0; j < jlen; j++) {
+ uh = buf[offset + 8 + j*2];
+ ul = buf[offset + 8 + j*2+1];
+
+ up = unls->unls_uni2cs[uh];
+
+ if (up == NULL)
+ uc = '\0';
+ else
+ uc = up[ul];
+
+ namebuf[j] = uc ? uc : '_';
+ }
+ printf("%4d: %4d %x %.*s\n",
+ idx, pindex, extent, jlen, namebuf);
+ break;
+ case 0:
+ printf("%4d: %4d %x %.*s\n",
+ idx, pindex, extent, len, buf + offset + 8);
+ }
+
+ idx++;
+ offset += 8 + len;
+ if (offset & 1)
+ offset++;
+ }
+
+ free(buf);
+}
+
+int
+parse_rr(unsigned char *pnt, int len, int cont_flag)
+{
+ int slen;
+ int xlen;
+ int ncount;
+ int extent;
+ int cont_extent, cont_offset, cont_size;
+ int flag1, flag2;
+ unsigned char *pnts;
+ char symlinkname[1024];
+ int goof;
+
+ symlinkname[0] = 0;
+
+ cont_extent = cont_offset = cont_size = 0;
+
+ ncount = 0;
+ flag1 = flag2 = 0;
+ while (len >= 4) {
+ if (pnt[3] != 1 && pnt[3] != 2) {
+ printf("**BAD RRVERSION (%d)\n", pnt[3]);
+ return (0); /* JS ??? Is this right ??? */
+ }
+ ncount++;
+ if (pnt[0] == 'R' && pnt[1] == 'R') flag1 = pnt[4] & 0xff;
+ if (strncmp((char *)pnt, "PX", 2) == 0) flag2 |= 1; /* POSIX attributes */
+ if (strncmp((char *)pnt, "PN", 2) == 0) flag2 |= 2; /* POSIX device number */
+ if (strncmp((char *)pnt, "SL", 2) == 0) flag2 |= 4; /* Symlink */
+ if (strncmp((char *)pnt, "NM", 2) == 0) flag2 |= 8; /* Alternate Name */
+ if (strncmp((char *)pnt, "CL", 2) == 0) flag2 |= 16; /* Child link */
+ if (strncmp((char *)pnt, "PL", 2) == 0) flag2 |= 32; /* Parent link */
+ if (strncmp((char *)pnt, "RE", 2) == 0) flag2 |= 64; /* Relocated Direcotry */
+ if (strncmp((char *)pnt, "TF", 2) == 0) flag2 |= 128; /* Time stamp */
+ if (strncmp((char *)pnt, "SP", 2) == 0) {
+ flag2 |= 1024; /* SUSP record */
+ su_version = pnt[3] & 0xff;
+ }
+ if (strncmp((char *)pnt, "AA", 2) == 0) {
+ flag2 |= 2048; /* Apple Signature record */
+ aa_version = pnt[3] & 0xff;
+ }
+
+ if (strncmp((char *)pnt, "PX", 2) == 0) { /* POSIX attributes */
+ fstat_buf.st_mode = isonum_733(pnt+4);
+ fstat_buf.st_nlink = isonum_733(pnt+12);
+ fstat_buf.st_uid = isonum_733(pnt+20);
+ fstat_buf.st_gid = isonum_733(pnt+28);
+ }
+
+ if (strncmp((char *)pnt, "NM", 2) == 0) { /* Alternate Name */
+ int l = strlen(name_buf);
+
+ if (!found_rr)
+ l = 0;
+ strncpy(&name_buf[l], (char *)(pnt+5), pnt[2] - 5);
+ name_buf[l + pnt[2] - 5] = 0;
+ found_rr = 1;
+ }
+
+ if (strncmp((char *)pnt, "CE", 2) == 0) { /* Continuation Area */
+ cont_extent = isonum_733(pnt+4);
+ cont_offset = isonum_733(pnt+12);
+ cont_size = isonum_733(pnt+20);
+ }
+
+ if (strncmp((char *)pnt, "PL", 2) == 0 || strncmp((char *)pnt, "CL", 2) == 0) {
+ extent = isonum_733(pnt+4);
+ }
+
+ if (strncmp((char *)pnt, "SL", 2) == 0) { /* Symlink */
+ int cflag;
+
+ cflag = pnt[4];
+ pnts = pnt+5;
+ slen = pnt[2] - 5;
+ while (slen >= 1) {
+ switch (pnts[0] & 0xfe) {
+ case 0:
+ strncat(symlinkname, (char *)(pnts+2), pnts[1]);
+ symlinkname[pnts[1]] = 0;
+ break;
+ case 2:
+ strcat(symlinkname, ".");
+ break;
+ case 4:
+ strcat(symlinkname, "..");
+ break;
+ case 8:
+ strcat(symlinkname, "/");
+ break;
+ case 16:
+ strcat(symlinkname, "/mnt");
+ printf("Warning - mount point requested");
+ break;
+ case 32:
+ strcat(symlinkname, "kafka");
+ printf("Warning - host_name requested");
+ break;
+ default:
+ printf("Reserved bit setting in symlink");
+ goof++;
+ break;
+ }
+ if ((pnts[0] & 0xfe) && pnts[1] != 0) {
+ printf("Incorrect length in symlink component");
+ }
+ if (xname[0] == 0) strcpy(xname, "-> ");
+ strcat(xname, symlinkname);
+ symlinkname[0] = 0;
+ xlen = strlen(xname);
+ if ((pnts[0] & 1) == 0 && xname[xlen-1] != '/') strcat(xname, "/");
+
+ slen -= (pnts[1] + 2);
+ pnts += (pnts[1] + 2);
+ }
+ symlinkname[0] = 0;
+ }
+
+ len -= pnt[2];
+ pnt += pnt[2];
+ if (len <= 3 && cont_extent) {
+ unsigned char sector[2048];
+
+#ifdef USE_SCG
+ readsecs(cont_extent - sector_offset, sector, ISO_BLOCKS(sizeof (sector)));
+#else
+ lseek(fileno(infile), ((off_t)(cont_extent - sector_offset)) << 11, SEEK_SET);
+ read(fileno(infile), sector, sizeof (sector));
+#endif
+ flag2 |= parse_rr(&sector[cont_offset], cont_size, 1);
+ }
+ }
+ /*
+ * for symbolic links, strip out the last '/'
+ */
+ if (xname[0] != 0 && xname[strlen(xname)-1] == '/') {
+ xname[strlen(xname)-1] = '\0';
+ }
+ return (flag2);
+}
+
+void
+find_rr(struct iso_directory_record *idr, Uchar **pntp, int *lenp)
+{
+ struct iso_xa_dir_record *xadp;
+ int len;
+ unsigned char * pnt;
+
+ len = idr->length[0] & 0xff;
+ len -= offsetof(struct iso_directory_record, name[0]);
+ len -= idr->name_len[0];
+
+ pnt = (unsigned char *) idr;
+ pnt += offsetof(struct iso_directory_record, name[0]);
+ pnt += idr->name_len[0];
+ if ((idr->name_len[0] & 1) == 0) {
+ pnt++;
+ len--;
+ }
+ if (len >= 14) {
+ xadp = (struct iso_xa_dir_record *)pnt;
+
+ if (xadp->signature[0] == 'X' && xadp->signature[1] == 'A' &&
+ xadp->reserved[0] == '\0') {
+ len -= 14;
+ pnt += 14;
+ }
+ }
+ *pntp = pnt;
+ *lenp = len;
+}
+
+int
+dump_rr(struct iso_directory_record *idr)
+{
+ int len;
+ unsigned char * pnt;
+
+ find_rr(idr, &pnt, &len);
+ return (parse_rr(pnt, len, 0));
+}
+
+struct todo
+{
+ struct todo *next;
+ char *name;
+ int extent;
+ int length;
+};
+
+struct todo *todo_idr = NULL;
+
+char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
+ "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+void
+dump_stat(struct iso_directory_record *idr, int extent)
+{
+ int i;
+ char outline[80];
+
+ memset(outline, ' ', sizeof (outline));
+
+ if (S_ISREG(fstat_buf.st_mode))
+ outline[0] = '-';
+ else if (S_ISDIR(fstat_buf.st_mode))
+ outline[0] = 'd';
+ else if (S_ISLNK(fstat_buf.st_mode))
+ outline[0] = 'l';
+ else if (S_ISCHR(fstat_buf.st_mode))
+ outline[0] = 'c';
+ else if (S_ISBLK(fstat_buf.st_mode))
+ outline[0] = 'b';
+ else if (S_ISFIFO(fstat_buf.st_mode))
+ outline[0] = 'f';
+ else if (S_ISSOCK(fstat_buf.st_mode))
+ outline[0] = 's';
+ else
+ outline[0] = '?';
+
+ memset(outline+1, '-', 9);
+ if (fstat_buf.st_mode & S_IRUSR)
+ outline[1] = 'r';
+ if (fstat_buf.st_mode & S_IWUSR)
+ outline[2] = 'w';
+ if (fstat_buf.st_mode & S_IXUSR)
+ outline[3] = 'x';
+
+ if (fstat_buf.st_mode & S_IRGRP)
+ outline[4] = 'r';
+ if (fstat_buf.st_mode & S_IWGRP)
+ outline[5] = 'w';
+ if (fstat_buf.st_mode & S_IXGRP)
+ outline[6] = 'x';
+
+ if (fstat_buf.st_mode & S_IROTH)
+ outline[7] = 'r';
+ if (fstat_buf.st_mode & S_IWOTH)
+ outline[8] = 'w';
+ if (fstat_buf.st_mode & S_IXOTH)
+ outline[9] = 'x';
+
+ /*
+ * XXX This is totally ugly code from Eric.
+ * XXX If one field is wider than expected then it is truncated.
+ */
+ sprintf(outline+11, "%3ld", (long)fstat_buf.st_nlink);
+ sprintf(outline+15, "%4lo", (unsigned long)fstat_buf.st_uid);
+ sprintf(outline+20, "%4lo", (unsigned long)fstat_buf.st_gid);
+ sprintf(outline+30, "%10lld", (Llong)fstat_buf.st_size);
+
+ if (do_sectors == 0) {
+ sprintf(outline+30, "%10lld", (Llong)fstat_buf.st_size);
+ } else {
+ sprintf(outline+30, "%10lld", (Llong)((fstat_buf.st_size+PAGE-1)/PAGE));
+ }
+
+ if (date_buf[1] >= 1 && date_buf[1] <= 12) {
+ memcpy(outline+41, months[date_buf[1]-1], 3);
+ }
+
+ sprintf(outline+45, "%2d", date_buf[2]);
+ outline[63] = 0;
+ sprintf(outline+48, "%4d", date_buf[0]+1900);
+
+ sprintf(outline+53, "[%7d", extent); /* XXX up to 20 GB */
+ sprintf(outline+61, " %02X]", idr->flags[0]);
+
+ for (i = 0; i < 66; i++) {
+ if (outline[i] == 0) outline[i] = ' ';
+ }
+ outline[66] = 0;
+ printf("%s %s %s\n", outline, name_buf, xname);
+}
+
+void
+extract_file(struct iso_directory_record *idr)
+{
+ int extent, len, tlen;
+ unsigned char buff[2048];
+
+#if defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__EMX__) || defined(__DJGPP__)
+ setmode(fileno(stdout), O_BINARY);
+#endif
+
+ extent = isonum_733((unsigned char *)idr->extent);
+ len = isonum_733((unsigned char *)idr->size);
+
+ while (len > 0) {
+#ifdef USE_SCG
+ readsecs(extent - sector_offset, buff, ISO_BLOCKS(sizeof (buff)));
+ tlen = (len > sizeof (buff) ? sizeof (buff) : len);
+#else
+ lseek(fileno(infile), ((off_t)(extent - sector_offset)) << 11, SEEK_SET);
+ tlen = (len > sizeof (buff) ? sizeof (buff) : len);
+ read(fileno(infile), buff, tlen);
+#endif
+ len -= tlen;
+ extent++;
+ write(STDOUT_FILENO, buff, tlen); /* FIXME: check return value */
+ }
+}
+
+void
+parse_dir(char *rootname, int extent, int len)
+{
+ char testname[PATH_MAX+1];
+ struct todo *td;
+ int i;
+ struct iso_directory_record * idr;
+ unsigned char uh, ul, uc, *up;
+
+
+ if (do_listing)
+ printf("\nDirectory listing of %s\n", rootname);
+
+ while (len > 0) {
+#ifdef USE_SCG
+ readsecs(extent - sector_offset, buffer, ISO_BLOCKS(sizeof (buffer)));
+#else
+ lseek(fileno(infile), ((off_t)(extent - sector_offset)) << 11, SEEK_SET);
+ read(fileno(infile), buffer, sizeof (buffer));
+#endif
+ len -= sizeof (buffer);
+ extent++;
+ i = 0;
+ while (1 == 1) {
+ idr = (struct iso_directory_record *) &buffer[i];
+ if (idr->length[0] == 0) break;
+ memset(&fstat_buf, 0, sizeof (fstat_buf));
+ found_rr = 0;
+ name_buf[0] = xname[0] = 0;
+ fstat_buf.st_size = (off_t)(unsigned)isonum_733((unsigned char *)idr->size);
+ if (idr->flags[0] & 2)
+ fstat_buf.st_mode |= S_IFDIR;
+ else
+ fstat_buf.st_mode |= S_IFREG;
+ if (idr->name_len[0] == 1 && idr->name[0] == 0)
+ strcpy(name_buf, ".");
+ else if (idr->name_len[0] == 1 && idr->name[0] == 1)
+ strcpy(name_buf, "..");
+ else {
+ switch (ucs_level) {
+ case 3:
+ case 2:
+ case 1:
+ /*
+ * Unicode name. Convert as best we can.
+ */
+ {
+ int j;
+
+ name_buf[0] = '\0';
+ for (j = 0; j < (int)idr->name_len[0] / 2; j++) {
+ uh = idr->name[j*2];
+ ul = idr->name[j*2+1];
+
+ up = unls->unls_uni2cs[uh];
+
+ if (up == NULL)
+ uc = '\0';
+ else
+ uc = up[ul];
+
+ name_buf[j] = uc ? uc : '_';
+ }
+ name_buf[idr->name_len[0]/2] = '\0';
+ }
+ break;
+ case 0:
+ /*
+ * Normal non-Unicode name.
+ */
+ strncpy(name_buf, idr->name, idr->name_len[0]);
+ name_buf[idr->name_len[0]] = 0;
+ break;
+ default:
+ /*
+ * Don't know how to do these yet. Maybe they are the same
+ * as one of the above.
+ */
+ exit(1);
+ }
+ }
+ memcpy(date_buf, idr->date, 9);
+ if (use_rock)
+ dump_rr(idr);
+ if ((idr->flags[0] & 2) != 0 &&
+ (idr->name_len[0] != 1 ||
+ (idr->name[0] != 0 && idr->name[0] != 1))) {
+ /*
+ * Add this directory to the todo list.
+ */
+ td = todo_idr;
+ if (td != NULL) {
+ while (td->next != NULL)
+ td = td->next;
+ td->next = (struct todo *) malloc(sizeof (*td));
+ td = td->next;
+ } else {
+ todo_idr = td = (struct todo *) malloc(sizeof (*td));
+ }
+ td->next = NULL;
+ td->extent = isonum_733((unsigned char *)idr->extent);
+ td->length = isonum_733((unsigned char *)idr->size);
+ td->name = (char *) malloc(strlen(rootname)
+ + strlen(name_buf) + 2);
+ strcpy(td->name, rootname);
+ strcat(td->name, name_buf);
+ strcat(td->name, "/");
+ } else {
+ strcpy(testname, rootname);
+ strcat(testname, name_buf);
+ if (xtract && strcmp(xtract, testname) == 0) {
+ extract_file(idr);
+ }
+ }
+ if (do_find &&
+ (idr->name_len[0] != 1 ||
+ (idr->name[0] != 0 && idr->name[0] != 1))) {
+ strcpy(testname, rootname);
+ strcat(testname, name_buf);
+ printf("%s\n", testname);
+ }
+ if (do_listing)
+ dump_stat(idr, isonum_733((unsigned char *)idr->extent));
+ i += buffer[i];
+ if (i > 2048 - offsetof(struct iso_directory_record, name[0])) break;
+ }
+ }
+}
+
+void
+usage(int excode)
+{
+ errmsgno(EX_BAD, "Usage: %s [options] -i filename\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-debug Print additional debug info\n");
+ fprintf(stderr, "\t-d Print information from the primary volume descriptor\n");
+ fprintf(stderr, "\t-f Generate output similar to 'find . -print'\n");
+ fprintf(stderr, "\t-J Print information from Joliet extensions\n");
+ fprintf(stderr, "\t-j charset Use charset to display Joliet file names\n");
+ fprintf(stderr, "\t-l Generate output similar to 'ls -lR'\n");
+ fprintf(stderr, "\t-p Print Path Table\n");
+ fprintf(stderr, "\t-R Print information from Rock Ridge extensions\n");
+ fprintf(stderr, "\t-s Print file size infos in multiples of sector size (%ld bytes).\n", (long)PAGE);
+ fprintf(stderr, "\t-N sector Sector number where ISO image should start on CD\n");
+ fprintf(stderr, "\t-T sector Sector number where actual session starts on CD\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, "\t-x pathname Extract specified file to stdout\n");
+ exit(excode);
+}
+
+int
+main(int argc, char *argv[])
+{
+ int cac;
+ char * const *cav;
+ int c;
+ char * filename = NULL;
+ char * devname = NULL;
+ /*
+ * Use toc_offset != 0 (-T #) if we have a complete multi-session
+ * disc that we want/need to play with.
+ * Here we specify the offset where we want to
+ * start searching for the TOC.
+ */
+ int toc_offset = 0;
+ int extent;
+ struct todo * td;
+ struct iso_primary_descriptor ipd;
+ struct iso_primary_descriptor jpd;
+ struct eltorito_boot_descriptor bpd;
+ struct iso_directory_record * idr;
+ char *charset = NULL;
+ char *opts = "help,h,version,debug,d,p,i*,dev*,J,R,l,x*,f,s,N#l,T#l,j*";
+ BOOL help = FALSE;
+ BOOL prvers = FALSE;
+ BOOL found_eltorito = FALSE;
+ int bootcat_offset = 0;
+
+
+ save_args(argc, argv);
+
+ cac = argc - 1;
+ cav = argv + 1;
+ if (getallargs(&cac, &cav, opts,
+ &help, &help, &prvers, &debug,
+ &do_pvd, &do_pathtab,
+ &filename, &devname,
+ &use_joliet, &use_rock,
+ &do_listing,
+ &xtract,
+ &do_find, &do_sectors,
+ &sector_offset, &toc_offset,
+ &charset) < 0) {
+ errmsgno(EX_BAD, "Bad Option: '%s'\n", cav[0]);
+ usage(EX_BAD);
+ }
+ if (help)
+ usage(0);
+ if (prvers) {
+ printf("isoinfo %s (%s)\n", CDRKIT_VERSION, HOST_SYSTEM);
+ exit(0);
+ }
+ cac = argc - 1;
+ cav = argv + 1;
+ if (getfiles(&cac, &cav, opts) != 0) {
+ errmsgno(EX_BAD, "Bad Argument: '%s'\n", cav[0]);
+ usage(EX_BAD);
+ }
+
+ init_unls(); /* Initialize UNICODE tables */
+ init_unls_file(charset);
+ if (charset == NULL) {
+#if (defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__DJGPP__)) && !defined(IS_CYGWIN_1)
+ unls = load_unls("cp437");
+#else
+ unls = load_unls("iso8859-1");
+#endif
+ } else {
+ if (strcmp(charset, "default") == 0)
+ unls = load_unls_default();
+ else
+ unls = load_unls(charset);
+ }
+ if (unls == NULL) { /* Unknown charset specified */
+ fprintf(stderr, "Unknown charset: %s\nKnown charsets are:\n",
+ charset);
+ list_unls(); /* List all known charset names */
+ exit(1);
+ }
+
+ 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("Unable to open %s\n", filename);
+#else
+ fprintf(stderr, "Unable to open %s\n", filename);
+ exit(1);
+#endif
+ }
+
+ /*
+ * Absolute sector offset, so don't subtract sector_offset here.
+ */
+#ifdef USE_SCG
+ readsecs(16 + toc_offset, &ipd, ISO_BLOCKS(sizeof (ipd)));
+#else
+ lseek(fileno(infile), ((off_t)(16 + toc_offset)) <<11, SEEK_SET);
+ read(fileno(infile), &ipd, sizeof (ipd));
+#endif
+ idr = (struct iso_directory_record *)ipd.root_directory_record;
+ if (do_pvd) {
+ /*
+ * High sierra:
+ *
+ * DESC TYPE == 1 (VD_SFS) offset 8 len 1
+ * STR ID == "CDROM" offset 9 len 5
+ * STD_VER == 1 offset 14 len 1
+ */
+ if ((((char *)&ipd)[8] == 1) &&
+ (strncmp(&((char *)&ipd)[9], "CDROM", 5) == 0) &&
+ (((char *)&ipd)[14] == 1)) {
+ printf("CD-ROM is in High Sierra format\n");
+ exit(0);
+ }
+ /*
+ * ISO 9660:
+ *
+ * DESC TYPE == 1 (VD_PVD) offset 0 len 1
+ * STR ID == "CD001" offset 1 len 5
+ * STD_VER == 1 offset 6 len 1
+ */
+ if ((ipd.type[0] != ISO_VD_PRIMARY) ||
+ (strncmp(ipd.id, ISO_STANDARD_ID, sizeof (ipd.id)) != 0) ||
+ (ipd.version[0] != 1)) {
+ printf("CD-ROM is NOT in ISO 9660 format\n");
+ exit(1);
+ }
+
+ printf("CD-ROM is in ISO 9660 format\n");
+ printf("System id: ");
+ printchars(ipd.system_id, 32);
+ putchar('\n');
+ printf("Volume id: ");
+ printchars(ipd.volume_id, 32);
+ putchar('\n');
+
+ printf("Volume set id: ");
+ printchars(ipd.volume_set_id, 128);
+ putchar('\n');
+ printf("Publisher id: ");
+ printchars(ipd.publisher_id, 128);
+ putchar('\n');
+ printf("Data preparer id: ");
+ printchars(ipd.preparer_id, 128);
+ putchar('\n');
+ printf("Application id: ");
+ printchars(ipd.application_id, 128);
+ putchar('\n');
+
+ printf("Copyright File id: ");
+ printchars(ipd.copyright_file_id, 37);
+ putchar('\n');
+ printf("Abstract File id: ");
+ printchars(ipd.abstract_file_id, 37);
+ putchar('\n');
+ printf("Bibliographic File id: ");
+ printchars(ipd.bibliographic_file_id, 37);
+ putchar('\n');
+
+ printf("Volume set size is: %d\n", isonum_723(ipd.volume_set_size));
+ printf("Volume set sequence number is: %d\n", isonum_723(ipd.volume_sequence_number));
+ printf("Logical block size is: %d\n", isonum_723(ipd.logical_block_size));
+ printf("Volume size is: %d\n", isonum_733((unsigned char *)ipd.volume_space_size));
+ if (debug) {
+ int dextent;
+ int dlen;
+
+ dextent = isonum_733((unsigned char *)idr->extent);
+ dlen = isonum_733((unsigned char *)idr->size);
+ printf("Root directory extent: %d size: %d\n",
+ dextent, dlen);
+ printf("Path table size is: %d\n",
+ isonum_733((unsigned char *)ipd.path_table_size));
+ printf("L Path table start: %d\n",
+ isonum_731(ipd.type_l_path_table));
+ printf("L Path opt table start: %d\n",
+ isonum_731(ipd.opt_type_l_path_table));
+ printf("M Path table start: %d\n",
+ isonum_732(ipd.type_m_path_table));
+ printf("M Path opt table start: %d\n",
+ isonum_732(ipd.opt_type_m_path_table));
+ printf("Creation Date: %s\n",
+ sdate(ipd.creation_date));
+ printf("Modification Date: %s\n",
+ sdate(ipd.modification_date));
+ printf("Expiration Date: %s\n",
+ sdate(ipd.expiration_date));
+ printf("Effective Date: %s\n",
+ sdate(ipd.effective_date));
+ printf("File structure version: %d\n",
+ ipd.file_structure_version[0]);
+ }
+ {
+ int block = 16;
+ movebytes(&ipd, &jpd, sizeof (ipd));
+ while ((Uchar)jpd.type[0] != ISO_VD_END) {
+
+ if (debug && (Uchar) jpd.type[0] == ISO_VD_SUPPLEMENTARY)
+ fprintf(stderr, "Joliet escape sequence 0: '%c' 1: '%c' 2: '%c' 3: '%c'\n",
+ jpd.escape_sequences[0],
+ jpd.escape_sequences[1],
+ jpd.escape_sequences[2],
+ jpd.escape_sequences[3]);
+ /*
+ * If Joliet UCS escape sequence found, we may be wrong
+ */
+ if (jpd.escape_sequences[0] == '%' &&
+ jpd.escape_sequences[1] == '/' &&
+ (jpd.escape_sequences[3] == '\0' ||
+ jpd.escape_sequences[3] == ' ') &&
+ (jpd.escape_sequences[2] == '@' ||
+ jpd.escape_sequences[2] == 'C' ||
+ jpd.escape_sequences[2] == 'E')) {
+
+ if (jpd.version[0] == 1)
+ goto nextblock;
+ }
+ if (jpd.type[0] == 0) {
+ movebytes(&jpd, &bpd, sizeof (bpd));
+ if (strncmp(bpd.system_id, EL_TORITO_ID, sizeof (EL_TORITO_ID)) == 0) {
+ bootcat_offset = (Uchar)bpd.bootcat_ptr[0] +
+ (Uchar)bpd.bootcat_ptr[1] * 256 +
+ (Uchar)bpd.bootcat_ptr[2] * 65536 +
+ (Uchar)bpd.bootcat_ptr[3] * 16777216;
+ found_eltorito = TRUE;
+ printf("El Torito VD version %d found, boot catalog is in sector %d\n",
+ bpd.version[0],
+ bootcat_offset);
+ }
+ }
+ if (jpd.version[0] == 2) {
+ printf("CD-ROM uses ISO 9660:1999 relaxed format\n");
+ break;
+ }
+
+ nextblock:
+ block++;
+#ifdef USE_SCG
+ readsecs(block + toc_offset, &jpd, ISO_BLOCKS(sizeof (jpd)));
+#else
+ lseek(fileno(infile), ((off_t)(block + toc_offset)) <<11, SEEK_SET);
+ read(fileno(infile), &jpd, sizeof (jpd));
+#endif
+ }
+ }
+ }
+ /*
+ * ISO 9660:
+ *
+ * DESC TYPE == 1 (VD_PVD) offset 0 len 1
+ * STR ID == "CD001" offset 1 len 5
+ * STD_VER == 1 offset 6 len 1
+ */
+ if ((ipd.type[0] != ISO_VD_PRIMARY) ||
+ (strncmp(ipd.id, ISO_STANDARD_ID, sizeof (ipd.id)) != 0) ||
+ (ipd.version[0] != 1)) {
+ printf("CD-ROM is NOT in ISO 9660 format\n");
+ exit(1);
+ }
+
+ if (use_joliet || do_pvd) {
+ int block = 16;
+ movebytes(&ipd, &jpd, sizeof (ipd));
+ while ((unsigned char) jpd.type[0] != ISO_VD_END) {
+ if (debug && (unsigned char) jpd.type[0] == ISO_VD_SUPPLEMENTARY)
+ fprintf(stderr, "Joliet escape sequence 0: '%c' 1: '%c' 2: '%c' 3: '%c'\n",
+ jpd.escape_sequences[0],
+ jpd.escape_sequences[1],
+ jpd.escape_sequences[2],
+ jpd.escape_sequences[3]);
+ /*
+ * Find the UCS escape sequence.
+ */
+ if (jpd.escape_sequences[0] == '%' &&
+ jpd.escape_sequences[1] == '/' &&
+ (jpd.escape_sequences[3] == '\0' ||
+ jpd.escape_sequences[3] == ' ') &&
+ (jpd.escape_sequences[2] == '@' ||
+ jpd.escape_sequences[2] == 'C' ||
+ jpd.escape_sequences[2] == 'E')) {
+ break;
+ }
+
+ block++;
+#ifdef USE_SCG
+ readsecs(block + toc_offset, &jpd, ISO_BLOCKS(sizeof (jpd)));
+#else
+ lseek(fileno(infile),
+ ((off_t)(block + toc_offset)) <<11, SEEK_SET);
+ read(fileno(infile), &jpd, sizeof (jpd));
+#endif
+ }
+
+ if (use_joliet && ((unsigned char) jpd.type[0] == ISO_VD_END)) {
+#ifdef USE_LIBSCHILY
+ comerrno(EX_BAD, "Unable to find Joliet SVD\n");
+#else
+ fprintf(stderr, "Unable to find Joliet SVD\n");
+ exit(1);
+#endif
+ }
+
+ switch (jpd.escape_sequences[2]) {
+ case '@':
+ ucs_level = 1;
+ break;
+ case 'C':
+ ucs_level = 2;
+ break;
+ case 'E':
+ ucs_level = 3;
+ break;
+ }
+
+ if (ucs_level > 3) {
+#ifdef USE_LIBSCHILY
+ comerrno(EX_BAD,
+ "Don't know what ucs_level == %d means\n",
+ ucs_level);
+#else
+ fprintf(stderr,
+ "Don't know what ucs_level == %d means\n",
+ ucs_level);
+ exit(1);
+#endif
+ }
+ if (jpd.escape_sequences[3] == ' ')
+ errmsgno(EX_BAD,
+ "Warning: Joliet escape sequence uses illegal space at offset 3\n");
+ }
+
+ if (do_pvd) {
+ if (ucs_level > 0)
+ printf("Joliet with UCS level %d found\n", ucs_level);
+ else
+ printf("NO Joliet present\n");
+
+ extent = isonum_733((unsigned char *)idr->extent);
+
+#ifdef USE_SCG
+ readsecs(extent - sector_offset, buffer, ISO_BLOCKS(sizeof (buffer)));
+#else
+ lseek(fileno(infile),
+ ((off_t)(extent - sector_offset)) <<11, SEEK_SET);
+ read(fileno(infile), buffer, sizeof (buffer));
+#endif
+ idr = (struct iso_directory_record *) buffer;
+ if ((c = dump_rr(idr)) != 0) {
+/* printf("RR %X %d\n", c, c);*/
+ if (c & 1024) {
+ printf(
+ "Rock Ridge signatures version %d found\n",
+ su_version);
+ } else {
+ printf(
+ "Bad Rock Ridge signatures found (SU record missing)\n");
+ }
+ /*
+ * This is currently a no op!
+ * We need to check the first plain file instead of
+ * the '.' entry in the root directory.
+ */
+ if (c & 2048) {
+ printf("Apple signatures version %d found\n",
+ aa_version);
+ }
+ } else {
+ printf("NO Rock Ridge present\n");
+ }
+ if (found_eltorito)
+ printf_bootinfo(infile, bootcat_offset);
+ exit(0);
+ }
+
+ if (use_joliet)
+ idr = (struct iso_directory_record *)jpd.root_directory_record;
+
+ if (do_pathtab) {
+ if (use_joliet) {
+ dump_pathtab(isonum_731(jpd.type_l_path_table),
+ isonum_733((unsigned char *)jpd.path_table_size));
+ } else {
+ dump_pathtab(isonum_731(ipd.type_l_path_table),
+ isonum_733((unsigned char *)ipd.path_table_size));
+ }
+ }
+
+ parse_dir("/", isonum_733((unsigned char *)idr->extent),
+ isonum_733((unsigned char *)idr->size));
+ td = todo_idr;
+ while (td) {
+ parse_dir(td->name, td->extent, td->length);
+ td = td->next;
+ }
+
+ if (infile != NULL)
+ fclose(infile);
+ return (0);
+}
+
+#include <intcvt.h>
+
+static void
+printf_bootinfo(FILE *f, int bootcat_offset)
+{
+ struct eltorito_validation_entry *evp;
+ struct eltorito_defaultboot_entry *ebe;
+
+#ifdef USE_SCG
+ readsecs(bootcat_offset, buffer, ISO_BLOCKS(sizeof (buffer)));
+#else
+ lseek(fileno(f), ((off_t)bootcat_offset) <<11, SEEK_SET);
+ read(fileno(f), buffer, sizeof (buffer));
+#endif
+
+ evp = (struct eltorito_validation_entry *)buffer;
+ ebe = (struct eltorito_defaultboot_entry *)&buffer[32];
+
+ printf("Eltorito validation header:\n");
+ printf(" Hid %d\n", (Uchar)evp->headerid[0]);
+ printf(" Arch %d (%s)\n", (Uchar)evp->arch[0], arch_name((Uchar)evp->arch[0]));
+ printf(" ID '%.23s'\n", evp->id);
+ printf(" Key %X %X\n", (Uchar)evp->key1[0], (Uchar)evp->key2[0]);
+
+ printf(" Eltorito defaultboot header:\n");
+ printf(" Bootid %X (%s)\n", (Uchar)ebe->boot_id[0], boot_name((Uchar)ebe->boot_id[0]));
+ printf(" Boot media %X (%s)\n", (Uchar)ebe->boot_media[0], bootmedia_name((Uchar)ebe->boot_media[0]));
+ printf(" Load segment %X\n", la_to_2_byte(ebe->loadseg));
+ printf(" Sys type %X\n", (Uchar)ebe->sys_type[0]);
+ printf(" Nsect %X\n", la_to_2_byte(ebe->nsect));
+ printf(" Bootoff %lX %ld\n", la_to_4_byte(ebe->bootoff), la_to_4_byte(ebe->bootoff));
+
+}
+
+static char *
+arch_name(int val)
+{
+ switch (val) {
+
+ case EL_TORITO_ARCH_x86:
+ return ("x86");
+ case EL_TORITO_ARCH_PPC:
+ return ("PPC");
+ case EL_TORITO_ARCH_MAC:
+ return ("MAC");
+ default:
+ return ("Unknown Arch");
+ }
+}
+
+static char *
+boot_name(int val)
+{
+ switch (val) {
+
+ case EL_TORITO_BOOTABLE:
+ return ("bootable");
+ case EL_TORITO_NOT_BOOTABLE:
+ return ("not bootable");
+ default:
+ return ("Illegal");
+ }
+}
+
+static char *
+bootmedia_name(int val)
+{
+ switch (val) {
+
+ case EL_TORITO_MEDIA_NOEMUL:
+ return ("No Emulation Boot");
+ case EL_TORITO_MEDIA_12FLOP:
+ return ("1200 Floppy");
+ case EL_TORITO_MEDIA_144FLOP:
+ return ("1.44MB Floppy");
+ case EL_TORITO_MEDIA_288FLOP:
+ return ("2.88MB Floppy");
+ case EL_TORITO_MEDIA_HD:
+ return ("Hard Disk Emulation");
+ default:
+ return ("Illegal Bootmedia");
+ }
+}