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