1 /*
2 * This file has been modified for the cdrkit suite.
3 *
4 * The behaviour and appearence of the program code below can differ to a major
5 * extent from the version distributed by the original author(s).
6 *
7 * For details, see Changelog file distributed with the cdrkit package. If you
8 * received this file from another source then ask the distributing person for
9 * a log of modifications.
10 *
11 */
12
13 /* @(#)isoinfo.c 1.50 05/05/15 joerg */
14 /*
15 * File isodump.c - dump iso9660 directory information.
16 *
17 *
18 * Written by Eric Youngdale (1993).
19 *
20 * Copyright 1993 Yggdrasil Computing, Incorporated
21 * Copyright (c) 1999-2004 J. Schilling
22 *
23 * This program is free software; you can redistribute it and/or modify
24 * it under the terms of the GNU General Public License version 2
25 * as published by the Free Software Foundation.
26 *
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
31 *
32 * You should have received a copy of the GNU General Public License along with
33 * this program; see the file COPYING. If not, write to the Free Software
34 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
35 */
36
37 /*
38 * Simple program to dump contents of iso9660 image in more usable format.
39 *
40 * Usage:
41 * To list contents of image (with or without RR):
42 * isoinfo -l [-R] -i imagefile
43 * To extract file from image:
44 * isoinfo -i imagefile -x xtractfile > outfile
45 * To generate a "find" like list of files:
46 * isoinfo -f -i imagefile
47 */
48
49 #include <mconfig.h>
50 #include <stdxlib.h>
51 #include <unixstd.h>
52 #include <strdefs.h>
53
54 #include <stdio.h>
55 #include <utypes.h>
56 #include <standard.h>
57 #include <signal.h>
58 #include <sys/stat.h>
59 #include <statdefs.h>
60 #include <fctldefs.h>
61 #include <schily.h>
62
63 #include "../iso9660.h"
64 #include "../scsi.h"
65 #include "../../wodim/defaults.h"
66
67 #include <unls.h>
68
69 #if defined(__CYGWIN32__) || defined(__EMX__) || defined(__DJGPP__)
70 #include <io.h> /* for setmode() prototype */
71 #endif
72
73 /*
74 * Make sure we have a definition for this. If not, take a very conservative
75 * guess.
76 * POSIX requires the max pathname component lenght to be defined in limits.h
77 * If variable, it may be undefined. If undefined, there should be
78 * a definition for _POSIX_NAME_MAX in limits.h or in unistd.h
79 * As _POSIX_NAME_MAX is defined to 14, we cannot use it.
80 * XXX Eric's wrong comment:
81 * XXX From what I can tell SunOS is the only one with this trouble.
82 */
83 #ifdef HAVE_LIMITS_H
84 #include <limits.h>
85 #endif
86 #ifndef NAME_MAX
87 #ifdef FILENAME_MAX
88 #define NAME_MAX FILENAME_MAX
89 #else
90 #define NAME_MAX 256
91 #endif
92 #endif
93
94 #ifndef PATH_MAX
95 #ifdef FILENAME_MAX
96 #define PATH_MAX FILENAME_MAX
97 #else
98 #define PATH_MAX 1024
99 #endif
100 #endif
101
102 /*
103 * XXX JS: Some structures have odd lengths!
104 * Some compilers (e.g. on Sun3/mc68020) padd the structures to even length.
105 * For this reason, we cannot use sizeof (struct iso_path_table) or
106 * sizeof (struct iso_directory_record) to compute on disk sizes.
107 * Instead, we use offsetof(..., name) and add the name size.
108 * See iso9660.h
109 */
110 #ifndef offsetof
111 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
112 #endif
113
114 #ifndef S_ISLNK
115 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
116 #endif
117 #ifndef S_ISSOCK
118 #ifdef S_IFSOCK
119 # define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
120 #else
121 # define S_ISSOCK(m) (0)
122 #endif
123 #endif
124
125 /*
126 * Note: always use these macros to avoid problems.
127 *
128 * ISO_ROUND_UP(X) may cause an integer overflow and thus give
129 * incorrect results. So avoid it if possible.
130 *
131 * ISO_BLOCKS(X) is overflow safe. Prefer this when ever it is possible.
132 */
133 #define SECTOR_SIZE (2048)
134 #define ISO_ROUND_UP(X) (((X) + (SECTOR_SIZE - 1)) & ~(SECTOR_SIZE - 1))
135 #define ISO_BLOCKS(X) (((X) / SECTOR_SIZE) + (((X)%SECTOR_SIZE)?1:0))
136
137 #define infile in_image
138 FILE *infile = NULL;
139 int use_rock = 0;
140 int use_joliet = 0;
141 int do_listing = 0;
142 int do_find = 0;
143 int do_sectors = 0;
144 int do_pathtab = 0;
145 int do_pvd = 0;
146 BOOL debug = FALSE;
147 char *xtract = 0;
148 int su_version = 0;
149 int aa_version = 0;
150 int ucs_level = 0;
151
152 struct stat fstat_buf;
153 int found_rr;
154 char name_buf[256];
155 char xname[2048];
156 unsigned char date_buf[9];
157 /*
158 * Use sector_offset != 0 (-N #) if we have an image file
159 * of a single session and we need to list the directory contents.
160 * This is the session block (sector) number of the start
161 * of the session when it would be on disk.
162 */
163 unsigned int sector_offset = 0;
164
165 unsigned char buffer[2048];
166
167 struct unls_table *unls;
168
169 #define PAGE sizeof (buffer)
170
171 #define ISODCL(from, to) (to - from + 1)
172
173
174 int isonum_721(char * p);
175 int isonum_723(char * p);
176 int isonum_731(char * p);
177 int isonum_732(char * p);
178 int isonum_733(unsigned char * p);
179 void printchars(char *s, int n);
180 char *sdate(char *dp);
181 void dump_pathtab(int block, int size);
182 int parse_rr(unsigned char * pnt, int len, int cont_flag);
183 void find_rr(struct iso_directory_record * idr, Uchar **pntp, int *lenp);
184 int dump_rr(struct iso_directory_record * idr);
185 void dump_stat(struct iso_directory_record * idr, int extent);
186 void extract_file(struct iso_directory_record * idr);
187 void parse_dir(char * rootname, int extent, int len);
188 void usage(int excode);
189
190 static void printf_bootinfo(FILE *f, int bootcat_offset);
191 static char *arch_name(int val);
192 static char *boot_name(int val);
193 static char *bootmedia_name(int val);
194
195
196 int
isonum_721(char * p)197 isonum_721(char *p)
198 {
199 return ((p[0] & 0xff)
200 | ((p[1] & 0xff) << 8));
201 }
202
203 int
isonum_723(char * p)204 isonum_723(char *p)
205 {
206 #if 0
207 if (p[0] != p[3] || p[1] != p[2]) {
208 #ifdef USE_LIBSCHILY
209 comerrno(EX_BAD, "invalid format 7.2.3 number\n");
210 #else
211 fprintf(stderr, "invalid format 7.2.3 number\n");
212 exit(1);
213 #endif
214 }
215 #endif
216 return (isonum_721(p));
217 }
218
219 int
isonum_731(char * p)220 isonum_731(char *p)
221 {
222 return ((p[0] & 0xff)
223 | ((p[1] & 0xff) << 8)
224 | ((p[2] & 0xff) << 16)
225 | ((p[3] & 0xff) << 24));
226 }
227
228 int
isonum_732(char * p)229 isonum_732(char *p)
230 {
231 return ((p[3] & 0xff)
232 | ((p[2] & 0xff) << 8)
233 | ((p[1] & 0xff) << 16)
234 | ((p[0] & 0xff) << 24));
235 }
236
237 int
isonum_733(unsigned char * p)238 isonum_733(unsigned char *p)
239 {
240 return (isonum_731((char *)p));
241 }
242
243 void
printchars(char * s,int n)244 printchars(char *s, int n)
245 {
246 int i;
247 char *p;
248
249 for (; n > 0 && *s; n--) {
250 if (*s == ' ') {
251 p = s;
252 i = n;
253 while (--i >= 0 && *p++ == ' ')
254 ;
255 if (i <= 0)
256 break;
257 }
258 putchar(*s++);
259 }
260 }
261
262 /*
263 * Print date info from PVD
264 */
265 char *
sdate(char * dp)266 sdate(char *dp)
267 {
268 static char d[30];
269
270 sprintf(d, "%4.4s %2.2s %2.2s %2.2s:%2.2s:%2.2s.%2.2s",
271 &dp[0], /* Year */
272 &dp[4], /* Month */
273 &dp[6], /* Monthday */
274 &dp[8], /* Hour */
275 &dp[10], /* Minute */
276 &dp[12], /* Seconds */
277 &dp[14]); /* Hunreds of a Seconds */
278
279 /*
280 * dp[16] contains minute offset from Greenwich
281 * Positive values are to the east of Greenwich.
282 */
283 return (d);
284 }
285
286 void
dump_pathtab(int block,int size)287 dump_pathtab(int block, int size)
288 {
289 unsigned char *buf;
290 int offset;
291 int idx;
292 int extent;
293 int pindex;
294 int j;
295 int len;
296 int jlen;
297 char namebuf[255];
298 unsigned char uh, ul, uc, *up;
299
300
301 printf("Path table starts at block %d, size %d\n", block, size);
302
303 buf = (unsigned char *) malloc(ISO_ROUND_UP(size));
304
305 #ifdef USE_SCG
306 readsecs(block - sector_offset, buf, ISO_BLOCKS(size));
307 #else
308 lseek(fileno(infile), ((off_t)(block - sector_offset)) << 11, SEEK_SET);
309 read(fileno(infile), buf, size);
310 #endif
311
312 offset = 0;
313 idx = 1;
314 while (offset < size) {
315 len = buf[offset];
316 extent = isonum_731((char *)buf + offset + 2);
317 pindex = isonum_721((char *)buf + offset + 6);
318 switch (ucs_level) {
319 case 3:
320 case 2:
321 case 1:
322 jlen = len/2;
323 namebuf[0] = '\0';
324 for (j = 0; j < jlen; j++) {
325 uh = buf[offset + 8 + j*2];
326 ul = buf[offset + 8 + j*2+1];
327
328 up = unls->unls_uni2cs[uh];
329
330 if (up == NULL)
331 uc = '\0';
332 else
333 uc = up[ul];
334
335 namebuf[j] = uc ? uc : '_';
336 }
337 printf("%4d: %4d %x %.*s\n",
338 idx, pindex, extent, jlen, namebuf);
339 break;
340 case 0:
341 printf("%4d: %4d %x %.*s\n",
342 idx, pindex, extent, len, buf + offset + 8);
343 }
344
345 idx++;
346 offset += 8 + len;
347 if (offset & 1)
348 offset++;
349 }
350
351 free(buf);
352 }
353
354 int
parse_rr(unsigned char * pnt,int len,int cont_flag)355 parse_rr(unsigned char *pnt, int len, int cont_flag)
356 {
357 int slen;
358 int xlen;
359 int ncount;
360 int extent;
361 int cont_extent, cont_offset, cont_size;
362 int flag1, flag2;
363 unsigned char *pnts;
364 char symlinkname[1024];
365 int goof;
366
367 symlinkname[0] = 0;
368
369 cont_extent = cont_offset = cont_size = 0;
370
371 ncount = 0;
372 flag1 = flag2 = 0;
373 while (len >= 4) {
374 if (pnt[3] != 1 && pnt[3] != 2) {
375 printf("**BAD RRVERSION (%d)\n", pnt[3]);
376 return (0); /* JS ??? Is this right ??? */
377 }
378 ncount++;
379 if (pnt[0] == 'R' && pnt[1] == 'R') flag1 = pnt[4] & 0xff;
380 if (strncmp((char *)pnt, "PX", 2) == 0) flag2 |= 1; /* POSIX attributes */
381 if (strncmp((char *)pnt, "PN", 2) == 0) flag2 |= 2; /* POSIX device number */
382 if (strncmp((char *)pnt, "SL", 2) == 0) flag2 |= 4; /* Symlink */
383 if (strncmp((char *)pnt, "NM", 2) == 0) flag2 |= 8; /* Alternate Name */
384 if (strncmp((char *)pnt, "CL", 2) == 0) flag2 |= 16; /* Child link */
385 if (strncmp((char *)pnt, "PL", 2) == 0) flag2 |= 32; /* Parent link */
386 if (strncmp((char *)pnt, "RE", 2) == 0) flag2 |= 64; /* Relocated Direcotry */
387 if (strncmp((char *)pnt, "TF", 2) == 0) flag2 |= 128; /* Time stamp */
388 if (strncmp((char *)pnt, "SP", 2) == 0) {
389 flag2 |= 1024; /* SUSP record */
390 su_version = pnt[3] & 0xff;
391 }
392 if (strncmp((char *)pnt, "AA", 2) == 0) {
393 flag2 |= 2048; /* Apple Signature record */
394 aa_version = pnt[3] & 0xff;
395 }
396
397 if (strncmp((char *)pnt, "PX", 2) == 0) { /* POSIX attributes */
398 fstat_buf.st_mode = isonum_733(pnt+4);
399 fstat_buf.st_nlink = isonum_733(pnt+12);
400 fstat_buf.st_uid = isonum_733(pnt+20);
401 fstat_buf.st_gid = isonum_733(pnt+28);
402 }
403
404 if (strncmp((char *)pnt, "NM", 2) == 0) { /* Alternate Name */
405 int l = strlen(name_buf);
406
407 if (!found_rr)
408 l = 0;
409 strncpy(&name_buf[l], (char *)(pnt+5), pnt[2] - 5);
410 name_buf[l + pnt[2] - 5] = 0;
411 found_rr = 1;
412 }
413
414 if (strncmp((char *)pnt, "CE", 2) == 0) { /* Continuation Area */
415 cont_extent = isonum_733(pnt+4);
416 cont_offset = isonum_733(pnt+12);
417 cont_size = isonum_733(pnt+20);
418 }
419
420 if (strncmp((char *)pnt, "PL", 2) == 0 || strncmp((char *)pnt, "CL", 2) == 0) {
421 extent = isonum_733(pnt+4);
422 }
423
424 if (strncmp((char *)pnt, "SL", 2) == 0) { /* Symlink */
425 int cflag;
426
427 cflag = pnt[4];
428 pnts = pnt+5;
429 slen = pnt[2] - 5;
430 while (slen >= 1) {
431 switch (pnts[0] & 0xfe) {
432 case 0:
433 strncat(symlinkname, (char *)(pnts+2), pnts[1]);
434 symlinkname[pnts[1]] = 0;
435 break;
436 case 2:
437 strcat(symlinkname, ".");
438 break;
439 case 4:
440 strcat(symlinkname, "..");
441 break;
442 case 8:
443 strcat(symlinkname, "/");
444 break;
445 case 16:
446 strcat(symlinkname, "/mnt");
447 printf("Warning - mount point requested");
448 break;
449 case 32:
450 strcat(symlinkname, "kafka");
451 printf("Warning - host_name requested");
452 break;
453 default:
454 printf("Reserved bit setting in symlink");
455 goof++;
456 break;
457 }
458 if ((pnts[0] & 0xfe) && pnts[1] != 0) {
459 printf("Incorrect length in symlink component");
460 }
461 if (xname[0] == 0) strcpy(xname, "-> ");
462 strcat(xname, symlinkname);
463 symlinkname[0] = 0;
464 xlen = strlen(xname);
465 if ((pnts[0] & 1) == 0 && xname[xlen-1] != '/') strcat(xname, "/");
466
467 slen -= (pnts[1] + 2);
468 pnts += (pnts[1] + 2);
469 }
470 symlinkname[0] = 0;
471 }
472
473 len -= pnt[2];
474 pnt += pnt[2];
475 if (len <= 3 && cont_extent) {
476 unsigned char sector[2048];
477
478 #ifdef USE_SCG
479 readsecs(cont_extent - sector_offset, sector, ISO_BLOCKS(sizeof (sector)));
480 #else
481 lseek(fileno(infile), ((off_t)(cont_extent - sector_offset)) << 11, SEEK_SET);
482 read(fileno(infile), sector, sizeof (sector));
483 #endif
484 flag2 |= parse_rr(§or[cont_offset], cont_size, 1);
485 }
486 }
487 /*
488 * for symbolic links, strip out the last '/'
489 */
490 if (xname[0] != 0 && xname[strlen(xname)-1] == '/') {
491 xname[strlen(xname)-1] = '\0';
492 }
493 return (flag2);
494 }
495
496 void
find_rr(struct iso_directory_record * idr,Uchar ** pntp,int * lenp)497 find_rr(struct iso_directory_record *idr, Uchar **pntp, int *lenp)
498 {
499 struct iso_xa_dir_record *xadp;
500 int len;
501 unsigned char * pnt;
502
503 len = idr->length[0] & 0xff;
504 len -= offsetof(struct iso_directory_record, name[0]);
505 len -= idr->name_len[0];
506
507 pnt = (unsigned char *) idr;
508 pnt += offsetof(struct iso_directory_record, name[0]);
509 pnt += idr->name_len[0];
510 if ((idr->name_len[0] & 1) == 0) {
511 pnt++;
512 len--;
513 }
514 if (len >= 14) {
515 xadp = (struct iso_xa_dir_record *)pnt;
516
517 if (xadp->signature[0] == 'X' && xadp->signature[1] == 'A' &&
518 xadp->reserved[0] == '\0') {
519 len -= 14;
520 pnt += 14;
521 }
522 }
523 *pntp = pnt;
524 *lenp = len;
525 }
526
527 int
dump_rr(struct iso_directory_record * idr)528 dump_rr(struct iso_directory_record *idr)
529 {
530 int len;
531 unsigned char * pnt;
532
533 find_rr(idr, &pnt, &len);
534 return (parse_rr(pnt, len, 0));
535 }
536
537 struct todo
538 {
539 struct todo *next;
540 char *name;
541 int extent;
542 int length;
543 };
544
545 struct todo *todo_idr = NULL;
546
547 char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
548 "Aug", "Sep", "Oct", "Nov", "Dec"};
549
550 void
dump_stat(struct iso_directory_record * idr,int extent)551 dump_stat(struct iso_directory_record *idr, int extent)
552 {
553 int i;
554 char outline[80];
555
556 memset(outline, ' ', sizeof (outline));
557
558 if (S_ISREG(fstat_buf.st_mode))
559 outline[0] = '-';
560 else if (S_ISDIR(fstat_buf.st_mode))
561 outline[0] = 'd';
562 else if (S_ISLNK(fstat_buf.st_mode))
563 outline[0] = 'l';
564 else if (S_ISCHR(fstat_buf.st_mode))
565 outline[0] = 'c';
566 else if (S_ISBLK(fstat_buf.st_mode))
567 outline[0] = 'b';
568 else if (S_ISFIFO(fstat_buf.st_mode))
569 outline[0] = 'f';
570 else if (S_ISSOCK(fstat_buf.st_mode))
571 outline[0] = 's';
572 else
573 outline[0] = '?';
574
575 memset(outline+1, '-', 9);
576 if (fstat_buf.st_mode & S_IRUSR)
577 outline[1] = 'r';
578 if (fstat_buf.st_mode & S_IWUSR)
579 outline[2] = 'w';
580 if (fstat_buf.st_mode & S_IXUSR)
581 outline[3] = 'x';
582
583 if (fstat_buf.st_mode & S_IRGRP)
584 outline[4] = 'r';
585 if (fstat_buf.st_mode & S_IWGRP)
586 outline[5] = 'w';
587 if (fstat_buf.st_mode & S_IXGRP)
588 outline[6] = 'x';
589
590 if (fstat_buf.st_mode & S_IROTH)
591 outline[7] = 'r';
592 if (fstat_buf.st_mode & S_IWOTH)
593 outline[8] = 'w';
594 if (fstat_buf.st_mode & S_IXOTH)
595 outline[9] = 'x';
596
597 /*
598 * XXX This is totally ugly code from Eric.
599 * XXX If one field is wider than expected then it is truncated.
600 */
601 sprintf(outline+11, "%3ld", (long)fstat_buf.st_nlink);
602 sprintf(outline+15, "%4lo", (unsigned long)fstat_buf.st_uid);
603 sprintf(outline+20, "%4lo", (unsigned long)fstat_buf.st_gid);
604 sprintf(outline+30, "%10lld", (Llong)fstat_buf.st_size);
605
606 if (do_sectors == 0) {
607 sprintf(outline+30, "%10lld", (Llong)fstat_buf.st_size);
608 } else {
609 sprintf(outline+30, "%10lld", (Llong)((fstat_buf.st_size+PAGE-1)/PAGE));
610 }
611
612 if (date_buf[1] >= 1 && date_buf[1] <= 12) {
613 memcpy(outline+41, months[date_buf[1]-1], 3);
614 }
615
616 sprintf(outline+45, "%2d", date_buf[2]);
617 outline[63] = 0;
618 sprintf(outline+48, "%4d", date_buf[0]+1900);
619
620 sprintf(outline+53, "[%7d", extent); /* XXX up to 20 GB */
621 sprintf(outline+61, " %02X]", idr->flags[0]);
622
623 for (i = 0; i < 66; i++) {
624 if (outline[i] == 0) outline[i] = ' ';
625 }
626 outline[66] = 0;
627 printf("%s %s %s\n", outline, name_buf, xname);
628 }
629
630 void
extract_file(struct iso_directory_record * idr)631 extract_file(struct iso_directory_record *idr)
632 {
633 int extent, len, tlen;
634 unsigned char buff[2048];
635
636 #if defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__EMX__) || defined(__DJGPP__)
637 setmode(fileno(stdout), O_BINARY);
638 #endif
639
640 extent = isonum_733((unsigned char *)idr->extent);
641 len = isonum_733((unsigned char *)idr->size);
642
643 while (len > 0) {
644 #ifdef USE_SCG
645 readsecs(extent - sector_offset, buff, ISO_BLOCKS(sizeof (buff)));
646 tlen = (len > sizeof (buff) ? sizeof (buff) : len);
647 #else
648 lseek(fileno(infile), ((off_t)(extent - sector_offset)) << 11, SEEK_SET);
649 tlen = (len > sizeof (buff) ? sizeof (buff) : len);
650 read(fileno(infile), buff, tlen);
651 #endif
652 len -= tlen;
653 extent++;
654 write(STDOUT_FILENO, buff, tlen); /* FIXME: check return value */
655 }
656 }
657
658 void
parse_dir(char * rootname,int extent,int len)659 parse_dir(char *rootname, int extent, int len)
660 {
661 char testname[PATH_MAX+1];
662 struct todo *td;
663 int i;
664 struct iso_directory_record * idr;
665 unsigned char uh, ul, uc, *up;
666
667
668 if (do_listing)
669 printf("\nDirectory listing of %s\n", rootname);
670
671 while (len > 0) {
672 #ifdef USE_SCG
673 readsecs(extent - sector_offset, buffer, ISO_BLOCKS(sizeof (buffer)));
674 #else
675 lseek(fileno(infile), ((off_t)(extent - sector_offset)) << 11, SEEK_SET);
676 read(fileno(infile), buffer, sizeof (buffer));
677 #endif
678 len -= sizeof (buffer);
679 extent++;
680 i = 0;
681 while (1 == 1) {
682 idr = (struct iso_directory_record *) &buffer[i];
683 if (idr->length[0] == 0) break;
684 memset(&fstat_buf, 0, sizeof (fstat_buf));
685 found_rr = 0;
686 name_buf[0] = xname[0] = 0;
687 fstat_buf.st_size = (off_t)(unsigned)isonum_733((unsigned char *)idr->size);
688 if (idr->flags[0] & 2)
689 fstat_buf.st_mode |= S_IFDIR;
690 else
691 fstat_buf.st_mode |= S_IFREG;
692 if (idr->name_len[0] == 1 && idr->name[0] == 0)
693 strcpy(name_buf, ".");
694 else if (idr->name_len[0] == 1 && idr->name[0] == 1)
695 strcpy(name_buf, "..");
696 else {
697 switch (ucs_level) {
698 case 3:
699 case 2:
700 case 1:
701 /*
702 * Unicode name. Convert as best we can.
703 */
704 {
705 int j;
706
707 name_buf[0] = '\0';
708 for (j = 0; j < (int)idr->name_len[0] / 2; j++) {
709 uh = idr->name[j*2];
710 ul = idr->name[j*2+1];
711
712 up = unls->unls_uni2cs[uh];
713
714 if (up == NULL)
715 uc = '\0';
716 else
717 uc = up[ul];
718
719 name_buf[j] = uc ? uc : '_';
720 }
721 name_buf[idr->name_len[0]/2] = '\0';
722 }
723 break;
724 case 0:
725 /*
726 * Normal non-Unicode name.
727 */
728 strncpy(name_buf, idr->name, idr->name_len[0]);
729 name_buf[idr->name_len[0]] = 0;
730 break;
731 default:
732 /*
733 * Don't know how to do these yet. Maybe they are the same
734 * as one of the above.
735 */
736 exit(1);
737 }
738 }
739 memcpy(date_buf, idr->date, 9);
740 if (use_rock)
741 dump_rr(idr);
742 if ((idr->flags[0] & 2) != 0 &&
743 (idr->name_len[0] != 1 ||
744 (idr->name[0] != 0 && idr->name[0] != 1))) {
745 /*
746 * Add this directory to the todo list.
747 */
748 td = todo_idr;
749 if (td != NULL) {
750 while (td->next != NULL)
751 td = td->next;
752 td->next = (struct todo *) malloc(sizeof (*td));
753 td = td->next;
754 } else {
755 todo_idr = td = (struct todo *) malloc(sizeof (*td));
756 }
757 td->next = NULL;
758 td->extent = isonum_733((unsigned char *)idr->extent);
759 td->length = isonum_733((unsigned char *)idr->size);
760 td->name = (char *) malloc(strlen(rootname)
761 + strlen(name_buf) + 2);
762 strcpy(td->name, rootname);
763 strcat(td->name, name_buf);
764 strcat(td->name, "/");
765 } else {
766 strcpy(testname, rootname);
767 strcat(testname, name_buf);
768 if (xtract && strcmp(xtract, testname) == 0) {
769 extract_file(idr);
770 }
771 }
772 if (do_find &&
773 (idr->name_len[0] != 1 ||
774 (idr->name[0] != 0 && idr->name[0] != 1))) {
775 strcpy(testname, rootname);
776 strcat(testname, name_buf);
777 printf("%s\n", testname);
778 }
779 if (do_listing)
780 dump_stat(idr, isonum_733((unsigned char *)idr->extent));
781 i += buffer[i];
782 if (i > 2048 - offsetof(struct iso_directory_record, name[0])) break;
783 }
784 }
785 }
786
787 void
usage(int excode)788 usage(int excode)
789 {
790 errmsgno(EX_BAD, "Usage: %s [options] -i filename\n", get_progname());
791
792 fprintf(stderr, "Options:\n");
793 fprintf(stderr, "\t-help,-h Print this help\n");
794 fprintf(stderr, "\t-version Print version info and exit\n");
795 fprintf(stderr, "\t-debug Print additional debug info\n");
796 fprintf(stderr, "\t-d Print information from the primary volume descriptor\n");
797 fprintf(stderr, "\t-f Generate output similar to 'find . -print'\n");
798 fprintf(stderr, "\t-J Print information from Joliet extensions\n");
799 fprintf(stderr, "\t-j charset Use charset to display Joliet file names\n");
800 fprintf(stderr, "\t-l Generate output similar to 'ls -lR'\n");
801 fprintf(stderr, "\t-p Print Path Table\n");
802 fprintf(stderr, "\t-R Print information from Rock Ridge extensions\n");
803 fprintf(stderr, "\t-s Print file size infos in multiples of sector size (%ld bytes).\n", (long)PAGE);
804 fprintf(stderr, "\t-N sector Sector number where ISO image should start on CD\n");
805 fprintf(stderr, "\t-T sector Sector number where actual session starts on CD\n");
806 fprintf(stderr, "\t-i filename Filename to read ISO-9660 image from\n");
807 fprintf(stderr, "\tdev=target SCSI target to use as CD/DVD-Recorder\n");
808 fprintf(stderr, "\t-x pathname Extract specified file to stdout\n");
809 exit(excode);
810 }
811
812 int
main(int argc,char * argv[])813 main(int argc, char *argv[])
814 {
815 int cac;
816 char * const *cav;
817 int c;
818 char * filename = NULL;
819 char * devname = NULL;
820 /*
821 * Use toc_offset != 0 (-T #) if we have a complete multi-session
822 * disc that we want/need to play with.
823 * Here we specify the offset where we want to
824 * start searching for the TOC.
825 */
826 int toc_offset = 0;
827 int extent;
828 struct todo * td;
829 struct iso_primary_descriptor ipd;
830 struct iso_primary_descriptor jpd;
831 struct eltorito_boot_descriptor bpd;
832 struct iso_directory_record * idr;
833 char *charset = NULL;
834 char *opts = "help,h,version,debug,d,p,i*,dev*,J,R,l,x*,f,s,N#l,T#l,j*";
835 BOOL help = FALSE;
836 BOOL prvers = FALSE;
837 BOOL found_eltorito = FALSE;
838 int bootcat_offset = 0;
839
840
841 save_args(argc, argv);
842
843 cac = argc - 1;
844 cav = argv + 1;
845 if (getallargs(&cac, &cav, opts,
846 &help, &help, &prvers, &debug,
847 &do_pvd, &do_pathtab,
848 &filename, &devname,
849 &use_joliet, &use_rock,
850 &do_listing,
851 &xtract,
852 &do_find, &do_sectors,
853 §or_offset, &toc_offset,
854 &charset) < 0) {
855 errmsgno(EX_BAD, "Bad Option: '%s'\n", cav[0]);
856 usage(EX_BAD);
857 }
858 if (help)
859 usage(0);
860 if (prvers) {
861 printf("isoinfo %s (%s)\n", CDRKIT_VERSION, HOST_SYSTEM);
862 exit(0);
863 }
864 cac = argc - 1;
865 cav = argv + 1;
866 if (getfiles(&cac, &cav, opts) != 0) {
867 errmsgno(EX_BAD, "Bad Argument: '%s'\n", cav[0]);
868 usage(EX_BAD);
869 }
870
871 init_unls(); /* Initialize UNICODE tables */
872 init_unls_file(charset);
873 if (charset == NULL) {
874 #if (defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__DJGPP__)) && !defined(IS_CYGWIN_1)
875 unls = load_unls("cp437");
876 #else
877 unls = load_unls("iso8859-1");
878 #endif
879 } else {
880 if (strcmp(charset, "default") == 0)
881 unls = load_unls_default();
882 else
883 unls = load_unls(charset);
884 }
885 if (unls == NULL) { /* Unknown charset specified */
886 fprintf(stderr, "Unknown charset: %s\nKnown charsets are:\n",
887 charset);
888 list_unls(); /* List all known charset names */
889 exit(1);
890 }
891
892 if (filename != NULL && devname != NULL) {
893 errmsgno(EX_BAD, "Only one of -i or dev= allowed\n");
894 usage(EX_BAD);
895 }
896 #ifdef USE_SCG
897 if (filename == NULL && devname == NULL)
898 cdr_defaults(&devname, NULL, NULL, NULL);
899 #endif
900 if (filename == NULL && devname == NULL) {
901 #ifdef USE_LIBSCHILY
902 errmsgno(EX_BAD, "ISO-9660 image not specified\n");
903 #else
904 fprintf(stderr, "ISO-9660 image not specified\n");
905 #endif
906 usage(EX_BAD);
907 }
908
909 if (filename != NULL)
910 infile = fopen(filename, "rb");
911 else
912 filename = devname;
913
914 if (infile != NULL) {
915 /* EMPTY */;
916 #ifdef USE_SCG
917 } else if (scsidev_open(filename) < 0) {
918 #else
919 } else {
920 #endif
921 #ifdef USE_LIBSCHILY
922 comerr("Unable to open %s\n", filename);
923 #else
924 fprintf(stderr, "Unable to open %s\n", filename);
925 exit(1);
926 #endif
927 }
928
929 /*
930 * Absolute sector offset, so don't subtract sector_offset here.
931 */
932 #ifdef USE_SCG
933 readsecs(16 + toc_offset, &ipd, ISO_BLOCKS(sizeof (ipd)));
934 #else
935 lseek(fileno(infile), ((off_t)(16 + toc_offset)) <<11, SEEK_SET);
936 read(fileno(infile), &ipd, sizeof (ipd));
937 #endif
938 idr = (struct iso_directory_record *)ipd.root_directory_record;
939 if (do_pvd) {
940 /*
941 * High sierra:
942 *
943 * DESC TYPE == 1 (VD_SFS) offset 8 len 1
944 * STR ID == "CDROM" offset 9 len 5
945 * STD_VER == 1 offset 14 len 1
946 */
947 if ((((char *)&ipd)[8] == 1) &&
948 (strncmp(&((char *)&ipd)[9], "CDROM", 5) == 0) &&
949 (((char *)&ipd)[14] == 1)) {
950 printf("CD-ROM is in High Sierra format\n");
951 exit(0);
952 }
953 /*
954 * ISO 9660:
955 *
956 * DESC TYPE == 1 (VD_PVD) offset 0 len 1
957 * STR ID == "CD001" offset 1 len 5
958 * STD_VER == 1 offset 6 len 1
959 */
960 if ((ipd.type[0] != ISO_VD_PRIMARY) ||
961 (strncmp(ipd.id, ISO_STANDARD_ID, sizeof (ipd.id)) != 0) ||
962 (ipd.version[0] != 1)) {
963 printf("CD-ROM is NOT in ISO 9660 format\n");
964 exit(1);
965 }
966
967 printf("CD-ROM is in ISO 9660 format\n");
968 printf("System id: ");
969 printchars(ipd.system_id, 32);
970 putchar('\n');
971 printf("Volume id: ");
972 printchars(ipd.volume_id, 32);
973 putchar('\n');
974
975 printf("Volume set id: ");
976 printchars(ipd.volume_set_id, 128);
977 putchar('\n');
978 printf("Publisher id: ");
979 printchars(ipd.publisher_id, 128);
980 putchar('\n');
981 printf("Data preparer id: ");
982 printchars(ipd.preparer_id, 128);
983 putchar('\n');
984 printf("Application id: ");
985 printchars(ipd.application_id, 128);
986 putchar('\n');
987
988 printf("Copyright File id: ");
989 printchars(ipd.copyright_file_id, 37);
990 putchar('\n');
991 printf("Abstract File id: ");
992 printchars(ipd.abstract_file_id, 37);
993 putchar('\n');
994 printf("Bibliographic File id: ");
995 printchars(ipd.bibliographic_file_id, 37);
996 putchar('\n');
997
998 printf("Volume set size is: %d\n", isonum_723(ipd.volume_set_size));
999 printf("Volume set sequence number is: %d\n", isonum_723(ipd.volume_sequence_number));
1000 printf("Logical block size is: %d\n", isonum_723(ipd.logical_block_size));
1001 printf("Volume size is: %d\n", isonum_733((unsigned char *)ipd.volume_space_size));
1002 if (debug) {
1003 int dextent;
1004 int dlen;
1005
1006 dextent = isonum_733((unsigned char *)idr->extent);
1007 dlen = isonum_733((unsigned char *)idr->size);
1008 printf("Root directory extent: %d size: %d\n",
1009 dextent, dlen);
1010 printf("Path table size is: %d\n",
1011 isonum_733((unsigned char *)ipd.path_table_size));
1012 printf("L Path table start: %d\n",
1013 isonum_731(ipd.type_l_path_table));
1014 printf("L Path opt table start: %d\n",
1015 isonum_731(ipd.opt_type_l_path_table));
1016 printf("M Path table start: %d\n",
1017 isonum_732(ipd.type_m_path_table));
1018 printf("M Path opt table start: %d\n",
1019 isonum_732(ipd.opt_type_m_path_table));
1020 printf("Creation Date: %s\n",
1021 sdate(ipd.creation_date));
1022 printf("Modification Date: %s\n",
1023 sdate(ipd.modification_date));
1024 printf("Expiration Date: %s\n",
1025 sdate(ipd.expiration_date));
1026 printf("Effective Date: %s\n",
1027 sdate(ipd.effective_date));
1028 printf("File structure version: %d\n",
1029 ipd.file_structure_version[0]);
1030 }
1031 {
1032 int block = 16;
1033 movebytes(&ipd, &jpd, sizeof (ipd));
1034 while ((Uchar)jpd.type[0] != ISO_VD_END) {
1035
1036 if (debug && (Uchar) jpd.type[0] == ISO_VD_SUPPLEMENTARY)
1037 fprintf(stderr, "Joliet escape sequence 0: '%c' 1: '%c' 2: '%c' 3: '%c'\n",
1038 jpd.escape_sequences[0],
1039 jpd.escape_sequences[1],
1040 jpd.escape_sequences[2],
1041 jpd.escape_sequences[3]);
1042 /*
1043 * If Joliet UCS escape sequence found, we may be wrong
1044 */
1045 if (jpd.escape_sequences[0] == '%' &&
1046 jpd.escape_sequences[1] == '/' &&
1047 (jpd.escape_sequences[3] == '\0' ||
1048 jpd.escape_sequences[3] == ' ') &&
1049 (jpd.escape_sequences[2] == '@' ||
1050 jpd.escape_sequences[2] == 'C' ||
1051 jpd.escape_sequences[2] == 'E')) {
1052
1053 if (jpd.version[0] == 1)
1054 goto nextblock;
1055 }
1056 if (jpd.type[0] == 0) {
1057 movebytes(&jpd, &bpd, sizeof (bpd));
1058 if (strncmp(bpd.system_id, EL_TORITO_ID, sizeof (EL_TORITO_ID)) == 0) {
1059 bootcat_offset = (Uchar)bpd.bootcat_ptr[0] +
1060 (Uchar)bpd.bootcat_ptr[1] * 256 +
1061 (Uchar)bpd.bootcat_ptr[2] * 65536 +
1062 (Uchar)bpd.bootcat_ptr[3] * 16777216;
1063 found_eltorito = TRUE;
1064 printf("El Torito VD version %d found, boot catalog is in sector %d\n",
1065 bpd.version[0],
1066 bootcat_offset);
1067 }
1068 }
1069 if (jpd.version[0] == 2) {
1070 printf("CD-ROM uses ISO 9660:1999 relaxed format\n");
1071 break;
1072 }
1073
1074 nextblock:
1075 block++;
1076 #ifdef USE_SCG
1077 readsecs(block + toc_offset, &jpd, ISO_BLOCKS(sizeof (jpd)));
1078 #else
1079 lseek(fileno(infile), ((off_t)(block + toc_offset)) <<11, SEEK_SET);
1080 read(fileno(infile), &jpd, sizeof (jpd));
1081 #endif
1082 }
1083 }
1084 }
1085 /*
1086 * ISO 9660:
1087 *
1088 * DESC TYPE == 1 (VD_PVD) offset 0 len 1
1089 * STR ID == "CD001" offset 1 len 5
1090 * STD_VER == 1 offset 6 len 1
1091 */
1092 if ((ipd.type[0] != ISO_VD_PRIMARY) ||
1093 (strncmp(ipd.id, ISO_STANDARD_ID, sizeof (ipd.id)) != 0) ||
1094 (ipd.version[0] != 1)) {
1095 printf("CD-ROM is NOT in ISO 9660 format\n");
1096 exit(1);
1097 }
1098
1099 if (use_joliet || do_pvd) {
1100 int block = 16;
1101 movebytes(&ipd, &jpd, sizeof (ipd));
1102 while ((unsigned char) jpd.type[0] != ISO_VD_END) {
1103 if (debug && (unsigned char) jpd.type[0] == ISO_VD_SUPPLEMENTARY)
1104 fprintf(stderr, "Joliet escape sequence 0: '%c' 1: '%c' 2: '%c' 3: '%c'\n",
1105 jpd.escape_sequences[0],
1106 jpd.escape_sequences[1],
1107 jpd.escape_sequences[2],
1108 jpd.escape_sequences[3]);
1109 /*
1110 * Find the UCS escape sequence.
1111 */
1112 if (jpd.escape_sequences[0] == '%' &&
1113 jpd.escape_sequences[1] == '/' &&
1114 (jpd.escape_sequences[3] == '\0' ||
1115 jpd.escape_sequences[3] == ' ') &&
1116 (jpd.escape_sequences[2] == '@' ||
1117 jpd.escape_sequences[2] == 'C' ||
1118 jpd.escape_sequences[2] == 'E')) {
1119 break;
1120 }
1121
1122 block++;
1123 #ifdef USE_SCG
1124 readsecs(block + toc_offset, &jpd, ISO_BLOCKS(sizeof (jpd)));
1125 #else
1126 lseek(fileno(infile),
1127 ((off_t)(block + toc_offset)) <<11, SEEK_SET);
1128 read(fileno(infile), &jpd, sizeof (jpd));
1129 #endif
1130 }
1131
1132 if (use_joliet && ((unsigned char) jpd.type[0] == ISO_VD_END)) {
1133 #ifdef USE_LIBSCHILY
1134 comerrno(EX_BAD, "Unable to find Joliet SVD\n");
1135 #else
1136 fprintf(stderr, "Unable to find Joliet SVD\n");
1137 exit(1);
1138 #endif
1139 }
1140
1141 switch (jpd.escape_sequences[2]) {
1142 case '@':
1143 ucs_level = 1;
1144 break;
1145 case 'C':
1146 ucs_level = 2;
1147 break;
1148 case 'E':
1149 ucs_level = 3;
1150 break;
1151 }
1152
1153 if (ucs_level > 3) {
1154 #ifdef USE_LIBSCHILY
1155 comerrno(EX_BAD,
1156 "Don't know what ucs_level == %d means\n",
1157 ucs_level);
1158 #else
1159 fprintf(stderr,
1160 "Don't know what ucs_level == %d means\n",
1161 ucs_level);
1162 exit(1);
1163 #endif
1164 }
1165 if (jpd.escape_sequences[3] == ' ')
1166 errmsgno(EX_BAD,
1167 "Warning: Joliet escape sequence uses illegal space at offset 3\n");
1168 }
1169
1170 if (do_pvd) {
1171 if (ucs_level > 0)
1172 printf("Joliet with UCS level %d found\n", ucs_level);
1173 else
1174 printf("NO Joliet present\n");
1175
1176 extent = isonum_733((unsigned char *)idr->extent);
1177
1178 #ifdef USE_SCG
1179 readsecs(extent - sector_offset, buffer, ISO_BLOCKS(sizeof (buffer)));
1180 #else
1181 lseek(fileno(infile),
1182 ((off_t)(extent - sector_offset)) <<11, SEEK_SET);
1183 read(fileno(infile), buffer, sizeof (buffer));
1184 #endif
1185 idr = (struct iso_directory_record *) buffer;
1186 if ((c = dump_rr(idr)) != 0) {
1187 /* printf("RR %X %d\n", c, c);*/
1188 if (c & 1024) {
1189 printf(
1190 "Rock Ridge signatures version %d found\n",
1191 su_version);
1192 } else {
1193 printf(
1194 "Bad Rock Ridge signatures found (SU record missing)\n");
1195 }
1196 /*
1197 * This is currently a no op!
1198 * We need to check the first plain file instead of
1199 * the '.' entry in the root directory.
1200 */
1201 if (c & 2048) {
1202 printf("Apple signatures version %d found\n",
1203 aa_version);
1204 }
1205 } else {
1206 printf("NO Rock Ridge present\n");
1207 }
1208 if (found_eltorito)
1209 printf_bootinfo(infile, bootcat_offset);
1210 exit(0);
1211 }
1212
1213 if (use_joliet)
1214 idr = (struct iso_directory_record *)jpd.root_directory_record;
1215
1216 if (do_pathtab) {
1217 if (use_joliet) {
1218 dump_pathtab(isonum_731(jpd.type_l_path_table),
1219 isonum_733((unsigned char *)jpd.path_table_size));
1220 } else {
1221 dump_pathtab(isonum_731(ipd.type_l_path_table),
1222 isonum_733((unsigned char *)ipd.path_table_size));
1223 }
1224 }
1225
1226 parse_dir("/", isonum_733((unsigned char *)idr->extent),
1227 isonum_733((unsigned char *)idr->size));
1228 td = todo_idr;
1229 while (td) {
1230 parse_dir(td->name, td->extent, td->length);
1231 td = td->next;
1232 }
1233
1234 if (infile != NULL)
1235 fclose(infile);
1236 return (0);
1237 }
1238
1239 #include <intcvt.h>
1240
1241 static void
printf_bootinfo(FILE * f,int bootcat_offset)1242 printf_bootinfo(FILE *f, int bootcat_offset)
1243 {
1244 struct eltorito_validation_entry *evp;
1245 struct eltorito_defaultboot_entry *ebe;
1246
1247 #ifdef USE_SCG
1248 readsecs(bootcat_offset, buffer, ISO_BLOCKS(sizeof (buffer)));
1249 #else
1250 lseek(fileno(f), ((off_t)bootcat_offset) <<11, SEEK_SET);
1251 read(fileno(f), buffer, sizeof (buffer));
1252 #endif
1253
1254 evp = (struct eltorito_validation_entry *)buffer;
1255 ebe = (struct eltorito_defaultboot_entry *)&buffer[32];
1256
1257 printf("Eltorito validation header:\n");
1258 printf(" Hid %d\n", (Uchar)evp->headerid[0]);
1259 printf(" Arch %d (%s)\n", (Uchar)evp->arch[0], arch_name((Uchar)evp->arch[0]));
1260 printf(" ID '%.23s'\n", evp->id);
1261 printf(" Key %X %X\n", (Uchar)evp->key1[0], (Uchar)evp->key2[0]);
1262
1263 printf(" Eltorito defaultboot header:\n");
1264 printf(" Bootid %X (%s)\n", (Uchar)ebe->boot_id[0], boot_name((Uchar)ebe->boot_id[0]));
1265 printf(" Boot media %X (%s)\n", (Uchar)ebe->boot_media[0], bootmedia_name((Uchar)ebe->boot_media[0]));
1266 printf(" Load segment %X\n", la_to_2_byte(ebe->loadseg));
1267 printf(" Sys type %X\n", (Uchar)ebe->sys_type[0]);
1268 printf(" Nsect %X\n", la_to_2_byte(ebe->nsect));
1269 printf(" Bootoff %lX %ld\n", la_to_4_byte(ebe->bootoff), la_to_4_byte(ebe->bootoff));
1270
1271 }
1272
1273 static char *
arch_name(int val)1274 arch_name(int val)
1275 {
1276 switch (val) {
1277
1278 case EL_TORITO_ARCH_x86:
1279 return ("x86");
1280 case EL_TORITO_ARCH_PPC:
1281 return ("PPC");
1282 case EL_TORITO_ARCH_MAC:
1283 return ("MAC");
1284 default:
1285 return ("Unknown Arch");
1286 }
1287 }
1288
1289 static char *
boot_name(int val)1290 boot_name(int val)
1291 {
1292 switch (val) {
1293
1294 case EL_TORITO_BOOTABLE:
1295 return ("bootable");
1296 case EL_TORITO_NOT_BOOTABLE:
1297 return ("not bootable");
1298 default:
1299 return ("Illegal");
1300 }
1301 }
1302
1303 static char *
bootmedia_name(int val)1304 bootmedia_name(int val)
1305 {
1306 switch (val) {
1307
1308 case EL_TORITO_MEDIA_NOEMUL:
1309 return ("No Emulation Boot");
1310 case EL_TORITO_MEDIA_12FLOP:
1311 return ("1200 Floppy");
1312 case EL_TORITO_MEDIA_144FLOP:
1313 return ("1.44MB Floppy");
1314 case EL_TORITO_MEDIA_288FLOP:
1315 return ("2.88MB Floppy");
1316 case EL_TORITO_MEDIA_HD:
1317 return ("Hard Disk Emulation");
1318 default:
1319 return ("Illegal Bootmedia");
1320 }
1321 }
1322