check_path_tables(int typel_extent, int typem_extent, int path_table_size){
int file_addr;
int count;
int j;
char * pnt;
char * typel, *typem;
/* Now read in the path tables */
typel = (char *) malloc(path_table_size);
lseek(fileno(infile), typel_extent * blocksize, 0);
read(fileno(infile), typel, path_table_size);
typem = (char *) malloc(path_table_size);
lseek(fileno(infile), typem_extent * blocksize, 0);
read(fileno(infile), typem, path_table_size);
j = path_table_size;
pnt = typel;
count = 1;
while(j){
int namelen, extent, index;
char name[32];
namelen = *pnt++; pnt++;
extent = isonum_731(pnt); pnt += 4;
index = 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++, index, extent, name);
};
j = path_table_size;
pnt = typem;
count = 1;
while(j){
int namelen, extent, index;
char name[32];
namelen = *pnt++; pnt++;
extent = isonum_732(pnt); pnt += 4;
index = 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++, index, extent, name);
};
}
void KIso::addBoot(struct el_torito_boot_descriptor* bootdesc)
{
KISOFUNC;
int i;
long long size;
boot_head boot;
boot_entry *be;
QString path;
KIsoFile *entry;
path = "Catalog";
entry = new KIsoFile(this, path, dirent->permissions() & ~S_IFDIR,
dirent->date(), dirent->adate(), dirent->cdate(),
dirent->user(), dirent->group(), QString(),
(long long)isonum_731(bootdesc->boot_catalog) << (long long)11, (long long)2048);
dirent->addEntry(entry);
if (!ReadBootTable(&readf, isonum_731(bootdesc->boot_catalog), &boot, this)) {
i = 1;
be = boot.defentry;
while (be) {
size = BootImageSize(isonum_711(be->data.d_e.media),
isonum_721(be->data.d_e.seccount));
path = "Default Image";
if (i > 1) path += " (" + QString::number(i) + ')';
entry = new KIsoFile(this, path, dirent->permissions() & ~S_IFDIR,
dirent->date(), dirent->adate(), dirent->cdate(),
dirent->user(), dirent->group(), QString(),
(long long)isonum_731(be->data.d_e.start) << (long long)11, size << (long long)9);
dirent->addEntry(entry);
be = be->next;
i++;
}
FreeBootTable(&boot);
}
}
int
isonum_733 (char * p)
{
#if 0
int i;
for (i = 0; i < 4; i++) {
if (p[i] != p[7-i]) {
fprintf (stderr, "bad format 7.3.3 number\n");
exit (1);
}
}
#endif
return (isonum_731 (p));
}
void K3b::Iso9660::addBoot(struct el_torito_boot_descriptor* bootdesc)
{
int i,size;
boot_head boot;
boot_entry *be;
QString path;
K3b::Iso9660File *entry;
entry=new K3b::Iso9660File( this, "Catalog", "Catalog", dirent->permissions() & ~S_IFDIR,
dirent->date(), dirent->adate(), dirent->cdate(),
dirent->user(), dirent->group(), QString(),
isonum_731(bootdesc->boot_catalog), 2048 );
dirent->addEntry(entry);
if (!ReadBootTable(&K3b::Iso9660::read_callback,isonum_731(bootdesc->boot_catalog),&boot,this)) {
i=1;
be=boot.defentry;
while (be) {
size=BootImageSize(&K3b::Iso9660::read_callback,
isonum_711(((struct default_entry*) be->data)->media),
isonum_731(((struct default_entry*) be->data)->start),
isonum_721(((struct default_entry*) be->data)->seccount),
this);
path="Default Image";
if (i>1) path += " (" + QString::number(i) + ')';
entry=new K3b::Iso9660File( this, path, path, dirent->permissions() & ~S_IFDIR,
dirent->date(), dirent->adate(), dirent->cdate(),
dirent->user(), dirent->group(), QString(),
isonum_731(((struct default_entry*) be->data)->start), size<<9 );
dirent->addEntry(entry);
be=be->next;
i++;
}
FreeBootTable(&boot);
}
}
main(int argc, char * argv[]){
int file_addr, file_size;
char c;
int nbyte;
struct iso_primary_descriptor ipd;
struct iso_directory_record * idr;
int typel_extent, typem_extent;
int path_table_size;
int i,j;
if(argc < 2) return 0;
infile = fopen(argv[1],"rb");
file_addr = 32768;
lseek(fileno(infile), file_addr, 0);
read(fileno(infile), &ipd, sizeof(ipd));
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 = isonum_733(idr->extent) + isonum_711((char *)idr->ext_attr_length);
file_size = isonum_733(idr->size);
printf("Root at extent %x, %d bytes\n", 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
fclose(infile);
if(!ngoof) printf("No errors found\n");
}
static void
hf_probe_volume_advanced_disc_detect (int fd)
{
size_t secsz = ISO_DEFAULT_BLOCK_SIZE;
int readoff;
struct iso_primary_descriptor desc;
u_char *ptbl;
int ptbl_size, ptbl_bsize;
int ptbl_lbn;
struct iso_path_table_entry *pte;
int pte_len;
int name_len;
int off;
readoff = ISO_VOLDESC_SEC * secsz;
do
{
if (pread(fd, &desc, sizeof desc, readoff) != sizeof desc)
{
hfp_warning("volume descriptor read error");
return;
}
if (isonum_711(desc.type) == ISO_VD_END)
return;
readoff += secsz;
}
while (isonum_711(desc.type) != ISO_VD_PRIMARY);
ptbl_size = isonum_733(desc.path_table_size);
#if BYTE_ORDER == LITTLE_ENDIAN
ptbl_lbn = isonum_731(desc.type_l_path_table);
#else
ptbl_lbn = isonum_732(desc.type_m_path_table);
#endif
ptbl_bsize = (ptbl_size + secsz - 1) / secsz * secsz;
ptbl = g_malloc(ptbl_bsize);
if (ptbl == NULL)
{
hfp_warning("path table allocation failure");
return;
}
readoff = ptbl_lbn * secsz;
if (pread(fd, ptbl, ptbl_bsize, readoff) != ptbl_bsize)
{
g_free(ptbl);
hfp_warning("path table read error");
}
for (off = 0; off < ptbl_size; off += pte_len)
{
pte = (struct iso_path_table_entry *)(ptbl + off);
name_len = *pte->name_len;
pte_len = ISO_PATH_TABLE_ENTRY_SIZE + name_len + (name_len % 2);
if (*(short *)pte->parent_no != 1)
continue;
if (name_len == 8 && strncmp(pte->name, "VIDEO_TS", 8) == 0)
{
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_videodvd", TRUE, &hfp_error);
break;
}
else if (name_len == 3 && strncmp(pte->name, "VCD", 8) == 0)
{
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_vcd", TRUE, &hfp_error);
break;
}
else if (name_len == 4 && strncmp(pte->name, "SVCD", 4) == 0)
{
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_svcd", TRUE, &hfp_error);
break;
}
}
g_free(ptbl);
}
static int cdfs_read_path_table(struct cdfs *cdfs, struct iso_volume_descriptor *vd) {
struct buf *buf;
unsigned char *pt;
int ptblk;
int ptlen;
int ptpos;
int n;
// Determine size and location of path table and allocate buffer
ptlen = isonum_733(vd->path_table_size);
ptblk = isonum_731(vd->type_l_path_table);
cdfs->path_table_buffer = malloc(ptlen);
if (!cdfs->path_table_buffer) return -ENOMEM;
// Read L path table into buffer
ptpos = 0;
while (ptpos < ptlen) {
buf = get_buffer(cdfs->cache, ptblk++);
if (!buf) return -EIO;
if (ptlen - ptpos > CDFS_BLOCKSIZE) {
memcpy(cdfs->path_table_buffer + ptpos, buf->data, CDFS_BLOCKSIZE);
ptpos += CDFS_BLOCKSIZE;
} else {
memcpy(cdfs->path_table_buffer + ptpos, buf->data, ptlen - ptpos);
ptpos = ptlen;
}
release_buffer(cdfs->cache, buf);
}
// Determine number of records in pathtable
// Path table records are indexed from 1 (first entry not used)
pt = cdfs->path_table_buffer;
n = 1;
while (pt < cdfs->path_table_buffer + ptlen) {
struct iso_pathtable_record *pathrec = (struct iso_pathtable_record *) pt;
int namelen = pathrec->length;
int reclen = sizeof(struct iso_pathtable_record) + namelen + (namelen & 1);
n++;
pt += reclen;
}
cdfs->path_table_records = n;
// Allocate path table
cdfs->path_table = (struct iso_pathtable_record **) kmalloc(cdfs->path_table_records * sizeof(struct iso_pathtable_record **));
if (!cdfs->path_table) return -ENOMEM;
cdfs->path_table[0] = NULL;
// Setup pointers into path table buffer
pt = cdfs->path_table_buffer;
for (n = 1; n < cdfs->path_table_records; n++) {
struct iso_pathtable_record *pathrec = (struct iso_pathtable_record *) pt;
int namelen = pathrec->length;
int reclen = sizeof(struct iso_pathtable_record) + namelen + (namelen & 1);
cdfs->path_table[n] = pathrec;
pt += reclen;
}
return 0;
}
int
isonum_733 (unsigned char * p)
{
return (isonum_731 ((char *)p));
}
