static APIRET getSetAllocInfo(ServerData * pServerData,
struct fsinfo * pfsinfo)
{
PFSALLOCATE pfsalloc;
if (pfsinfo->fsFlag == INFO_RETRIEVE) {
if (pfsinfo->cbData < sizeof(FSALLOCATE))
return ERROR_BUFFER_OVERFLOW;
pfsinfo->cbData = sizeof(FSALLOCATE);
pfsalloc = (PFSALLOCATE) pServerData->pData;
pfsalloc->idFileSystem = 0;
pfsalloc->cSectorUnit = 1;
pfsalloc->cUnitAvail = 0;
if (pfsinfo->pVolData->high_sierra)
{
struct hs_primary_descriptor *hpd = (struct hs_primary_descriptor *) &pfsinfo->pVolData->ipd;
pfsalloc->cUnit = isonum_733((unsigned char *)&(hpd->volume_space_size));
pfsalloc->cbSector = isonum_723(hpd->logical_block_size);
}
else
{
pfsalloc->cUnit = isonum_733((unsigned char *)&(pfsinfo->pVolData->ipd.volume_space_size));
pfsalloc->cbSector = isonum_723(pfsinfo->pVolData->ipd.logical_block_size);
}
return NO_ERROR;
} else {
logMsg(L_EVIL, "cannot set FSALLOCATE");
return ERROR_NOT_SUPPORTED;
}
}
void K3b::Iso9660::createSimplePrimaryDesc( struct iso_primary_descriptor* desc )
{
d->primaryDesc.volumeId = QString::fromLocal8Bit( desc->volume_id, 32 ).trimmed();
d->primaryDesc.systemId = QString::fromLocal8Bit( desc->system_id, 32 ).trimmed();
d->primaryDesc.volumeSetId = QString::fromLocal8Bit( desc->volume_set_id, 128 ).trimmed();
d->primaryDesc.publisherId = QString::fromLocal8Bit( desc->publisher_id, 128 ).trimmed();
d->primaryDesc.preparerId = QString::fromLocal8Bit( desc->preparer_id, 128 ).trimmed();
d->primaryDesc.applicationId = QString::fromLocal8Bit( desc->application_id, 128 ).trimmed();
d->primaryDesc.volumeSetSize = isonum_723(desc->volume_set_size);
d->primaryDesc.volumeSetNumber = isonum_723(desc->volume_set_size);
d->primaryDesc.logicalBlockSize = isonum_723(desc->logical_block_size);
d->primaryDesc.volumeSpaceSize = isonum_733(desc->volume_space_size);
}
/*
* Make a mount point from a volume descriptor
*/
static int
iso_makemp(struct iso_mnt *isomp, struct buf *bp, int *ea_len)
{
struct iso_primary_descriptor *pri;
int logical_block_size;
struct iso_directory_record *rootp;
pri = (struct iso_primary_descriptor *)bp->b_data;
logical_block_size = isonum_723 (pri->logical_block_size);
if (logical_block_size < DEV_BSIZE || logical_block_size > MAXBSIZE
|| (logical_block_size & (logical_block_size - 1)) != 0)
return -1;
rootp = (struct iso_directory_record *)pri->root_directory_record;
isomp->logical_block_size = logical_block_size;
isomp->volume_space_size = isonum_733 (pri->volume_space_size);
memcpy(isomp->root, rootp, sizeof(isomp->root));
isomp->root_extent = isonum_733 (rootp->extent);
isomp->root_size = isonum_733 (rootp->size);
isomp->im_joliet_level = 0;
isomp->im_bmask = logical_block_size - 1;
isomp->im_bshift = 0;
while ((1 << isomp->im_bshift) < isomp->logical_block_size)
isomp->im_bshift++;
if (ea_len != NULL)
*ea_len = isonum_711(rootp->ext_attr_length);
return 0;
}
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");
}
int
cd9660_match(ib_params *params)
{
int rv, blocksize;
struct iso_primary_descriptor ipd;
assert(params != NULL);
assert(params->fstype != NULL);
assert(params->fsfd != -1);
rv = pread(params->fsfd, &ipd, sizeof(ipd),
ISO_DEFAULT_BLOCK_SIZE * 16);
if (rv == -1) {
warn("Reading primary descriptor in `%s'", params->filesystem);
return 0;
} else if (rv != sizeof(ipd)) {
warnx("Reading primary descriptor in `%s': short read",
params->filesystem);
return 0;
}
if (ipd.type[0] != ISO_VD_PRIMARY ||
strncmp(ipd.id, ISO_STANDARD_ID, sizeof(ipd.id)) != 0 ||
ipd.version[0] != 1) {
warnx("Filesystem `%s' is not ISO9660 format",
params->filesystem);
return 0;
}
blocksize = isonum_723((char *)ipd.logical_block_size);
if (blocksize != ISO_DEFAULT_BLOCK_SIZE) {
warnx("Invalid blocksize %d in `%s'",
blocksize, params->filesystem);
return 0;
}
params->fstype->blocksize = blocksize;
params->fstype->needswap = 0;
return 1;
}
static void isosize(int argc, char *filenamep, int xflag, long divisor)
{
int fd, nsecs, ssize;
struct iso_primary_descriptor ipd;
if ((fd = open(filenamep, O_RDONLY)) < 0)
err(EXIT_FAILURE, _("cannot open %s"), filenamep);
if (is_iso(fd))
warnx(_("%s: might not be an ISO filesystem"), filenamep);
if (lseek(fd, 16 << 11, 0) == (off_t) - 1)
err(EXIT_FAILURE, _("seek error on %s"), filenamep);
if (read(fd, &ipd, sizeof(ipd)) <= 0)
err(EXIT_FAILURE, _("read error on %s"), filenamep);
nsecs = isonum_733(ipd.volume_space_size, xflag);
/* isonum_723 returns nowadays always 2048 */
ssize = isonum_723(ipd.logical_block_size, xflag);
if (1 < argc)
printf("%s: ", filenamep);
if (xflag) {
printf(_("sector count: %d, sector size: %d\n"), nsecs, ssize);
} else {
long long product = nsecs;
if (divisor == 0)
printf("%lld\n", product * ssize);
else if (divisor == ssize)
printf("%d\n", nsecs);
else
printf("%lld\n", (product * ssize) / divisor);
}
close(fd);
}
static int
cd9660_open(const char *path, struct open_file *f)
{
struct file *fp = NULL;
void *buf;
struct iso_primary_descriptor *vd;
size_t buf_size, read, dsize, off;
daddr_t bno, boff;
struct iso_directory_record rec;
struct iso_directory_record *dp = NULL;
int rc, first, use_rrip, lenskip;
/* First find the volume descriptor */
buf = malloc(buf_size = ISO_DEFAULT_BLOCK_SIZE);
vd = buf;
for (bno = 16;; bno++) {
twiddle(1);
rc = f->f_dev->dv_strategy(f->f_devdata, F_READ, cdb2devb(bno),
ISO_DEFAULT_BLOCK_SIZE, buf, &read);
if (rc)
goto out;
if (read != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
rc = EINVAL;
if (bcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
goto out;
if (isonum_711(vd->type) == ISO_VD_END)
goto out;
if (isonum_711(vd->type) == ISO_VD_PRIMARY)
break;
}
if (isonum_723(vd->logical_block_size) != ISO_DEFAULT_BLOCK_SIZE)
goto out;
rec = *(struct iso_directory_record *) vd->root_directory_record;
if (*path == '/') path++; /* eat leading '/' */
first = 1;
use_rrip = 0;
while (*path) {
bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
dsize = isonum_733(rec.size);
off = 0;
boff = 0;
while (off < dsize) {
if ((off % ISO_DEFAULT_BLOCK_SIZE) == 0) {
twiddle(1);
rc = f->f_dev->dv_strategy
(f->f_devdata, F_READ,
cdb2devb(bno + boff),
ISO_DEFAULT_BLOCK_SIZE,
buf, &read);
if (rc)
goto out;
if (read != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
boff++;
dp = (struct iso_directory_record *) buf;
}
if (isonum_711(dp->length) == 0) {
/* skip to next block, if any */
off = boff * ISO_DEFAULT_BLOCK_SIZE;
continue;
}
/* See if RRIP is in use. */
if (first)
use_rrip = rrip_check(f, dp, &lenskip);
if (dirmatch(f, path, dp, use_rrip,
first ? 0 : lenskip)) {
first = 0;
break;
} else
first = 0;
dp = (struct iso_directory_record *)
((char *) dp + isonum_711(dp->length));
/* If the new block has zero length, it is padding. */
if (isonum_711(dp->length) == 0) {
/* Skip to next block, if any. */
off = boff * ISO_DEFAULT_BLOCK_SIZE;
continue;
}
off += isonum_711(dp->length);
}
if (off >= dsize) {
rc = ENOENT;
goto out;
}
rec = *dp;
while (*path && *path != '/') /* look for next component */
path++;
if (*path) path++; /* skip '/' */
}
/* allocate file system specific data structure */
fp = malloc(sizeof(struct file));
bzero(fp, sizeof(struct file));
f->f_fsdata = (void *)fp;
if ((isonum_711(rec.flags) & 2) != 0) {
fp->f_flags = F_ISDIR;
}
if (first) {
fp->f_flags |= F_ROOTDIR;
/* Check for Rock Ridge since we didn't in the loop above. */
bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
twiddle(1);
rc = f->f_dev->dv_strategy(f->f_devdata, F_READ, cdb2devb(bno),
ISO_DEFAULT_BLOCK_SIZE, buf, &read);
if (rc)
goto out;
if (read != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
dp = (struct iso_directory_record *)buf;
use_rrip = rrip_check(f, dp, &lenskip);
}
if (use_rrip) {
fp->f_flags |= F_RR;
fp->f_susp_skip = lenskip;
}
fp->f_off = 0;
fp->f_bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
fp->f_size = isonum_733(rec.size);
free(buf);
return 0;
out:
if (fp)
free(fp);
free(buf);
return rc;
}
int
cd9660_open(const char *path, struct open_file *f)
{
struct file *fp = 0;
void *buf;
struct iso_primary_descriptor *vd;
size_t buf_size, nread, psize, dsize;
daddr_t bno;
int parent, ent;
struct ptable_ent *pp;
struct iso_directory_record *dp = 0;
int rc;
/* First find the volume descriptor */
buf_size = ISO_DEFAULT_BLOCK_SIZE;
buf = alloc(buf_size);
vd = buf;
for (bno = 16;; bno++) {
#if !defined(LIBSA_NO_TWIDDLE)
twiddle();
#endif
rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ, cdb2devb(bno),
ISO_DEFAULT_BLOCK_SIZE, buf, &nread);
if (rc)
goto out;
if (nread != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
rc = EINVAL;
if (memcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
goto out;
if (isonum_711(vd->type) == ISO_VD_END)
goto out;
if (isonum_711(vd->type) == ISO_VD_PRIMARY)
break;
}
if (isonum_723(vd->logical_block_size) != ISO_DEFAULT_BLOCK_SIZE)
goto out;
/* Now get the path table and lookup the directory of the file */
bno = isonum_732(vd->type_m_path_table);
psize = isonum_733(vd->path_table_size);
if (psize > ISO_DEFAULT_BLOCK_SIZE) {
dealloc(buf, ISO_DEFAULT_BLOCK_SIZE);
buf = alloc(buf_size = roundup(psize, ISO_DEFAULT_BLOCK_SIZE));
}
#if !defined(LIBSA_NO_TWIDDLE)
twiddle();
#endif
rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ, cdb2devb(bno),
buf_size, buf, &nread);
if (rc)
goto out;
if (nread != buf_size) {
rc = EIO;
goto out;
}
parent = 1;
pp = (struct ptable_ent *)buf;
ent = 1;
bno = isonum_732(pp->block) + isonum_711(pp->extlen);
rc = ENOENT;
/*
* Remove extra separators
*/
while (*path == '/')
path++;
while (*path) {
if ((char *)pp >= (char *)buf + psize)
break;
if (isonum_722(pp->parent) != parent)
break;
if (!pnmatch(path, pp)) {
pp = (struct ptable_ent *)((char *)pp + PTSIZE(pp));
ent++;
continue;
}
path += isonum_711(pp->namlen) + 1;
parent = ent;
bno = isonum_732(pp->block) + isonum_711(pp->extlen);
while ((char *)pp < (char *)buf + psize) {
if (isonum_722(pp->parent) == parent)
break;
pp = (struct ptable_ent *)((char *)pp + PTSIZE(pp));
ent++;
}
}
/*
* Now bno has the start of the directory that supposedly
* contains the file
*/
bno--;
dsize = 1; /* Something stupid, but > 0 XXX */
for (psize = 0; psize < dsize;) {
if (!(psize % ISO_DEFAULT_BLOCK_SIZE)) {
bno++;
#if !defined(LIBSA_NO_TWIDDLE)
twiddle();
#endif
rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
cdb2devb(bno),
ISO_DEFAULT_BLOCK_SIZE,
buf, &nread);
if (rc)
goto out;
if (nread != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
dp = (struct iso_directory_record *)buf;
}
if (!isonum_711(dp->length)) {
if ((void *)dp == buf)
psize += ISO_DEFAULT_BLOCK_SIZE;
else
psize = roundup(psize, ISO_DEFAULT_BLOCK_SIZE);
continue;
}
if (dsize == 1)
dsize = isonum_733(dp->size);
if (dirmatch(path, dp))
break;
psize += isonum_711(dp->length);
dp = (struct iso_directory_record *)
((char *)dp + isonum_711(dp->length));
}
if (psize >= dsize) {
rc = ENOENT;
goto out;
}
/* allocate file system specific data structure */
fp = alloc(sizeof(struct file));
memset(fp, 0, sizeof(struct file));
f->f_fsdata = (void *)fp;
fp->off = 0;
fp->bno = isonum_733(dp->extent);
fp->size = isonum_733(dp->size);
dealloc(buf, buf_size);
return 0;
out:
if (fp)
dealloc(fp, sizeof(struct file));
dealloc(buf, buf_size);
return rc;
}
static int
cd9660_findfile(int disk, const char *path, int *startp, int *lenp)
{
void *buf;
struct iso_primary_descriptor *vd;
size_t buf_size, read, dsize, off;
daddr_t bno, boff;
struct iso_directory_record rec;
struct iso_directory_record *dp = 0;
int rc = 0;
/* First find the volume descriptor */
buf = malloc(buf_size = ISO_DEFAULT_BLOCK_SIZE);
vd = buf;
for (bno = 16;; bno++) {
read = pread(disk, buf, ISO_DEFAULT_BLOCK_SIZE, cdb2off(bno));
if (read != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
rc = EINVAL;
if (bcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
goto out;
if (isonum_711(vd->type) == ISO_VD_END)
goto out;
if (isonum_711(vd->type) == ISO_VD_PRIMARY)
break;
}
if (isonum_723(vd->logical_block_size) != ISO_DEFAULT_BLOCK_SIZE) {
rc = EINVAL;
goto out;
}
rec = *(struct iso_directory_record *) vd->root_directory_record;
if (*path == '/') path++; /* eat leading '/' */
while (*path) {
bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
dsize = isonum_733(rec.size);
off = 0;
boff = 0;
while (off < dsize) {
if ((off % ISO_DEFAULT_BLOCK_SIZE) == 0) {
read = pread(disk, buf,
ISO_DEFAULT_BLOCK_SIZE,
cdb2off(bno + boff));
if (read != ISO_DEFAULT_BLOCK_SIZE) {
rc = EIO;
goto out;
}
boff++;
dp = (struct iso_directory_record *) buf;
}
if (isonum_711(dp->length) == 0) {
/* skip to next block, if any */
off = boff * ISO_DEFAULT_BLOCK_SIZE;
continue;
}
if (dirmatch(path, dp))
break;
dp = (struct iso_directory_record *)
((char *) dp + isonum_711(dp->length));
off += isonum_711(dp->length);
}
if (off == dsize) {
rc = ENOENT;
goto out;
}
rec = *dp;
while (*path && *path != '/') /* look for next component */
path++;
if (*path) path++; /* skip '/' */
}
*startp = cdb2off(isonum_733(rec.extent)
+ isonum_711(rec.ext_attr_length));
*lenp = isonum_733(rec.size);
rc = 0;
out:
free(buf);
return rc;
}
struct super_block *isofs_read_super(struct super_block *s,void *data,
int silent)
{
struct buffer_head *bh=NULL;
int iso_blknum;
unsigned int blocksize_bits;
int high_sierra;
kdev_t dev = s->s_dev;
unsigned int vol_desc_start;
int orig_zonesize;
char *p;
int joliet_level = 0;
struct iso_volume_descriptor *vdp;
struct hs_volume_descriptor *hdp;
struct iso_primary_descriptor *pri = NULL;
struct iso_supplementary_descriptor *sec = NULL;
struct hs_primary_descriptor *h_pri = NULL;
struct iso_directory_record *rootp;
struct iso9660_options opt;
MOD_INC_USE_COUNT;
if (!parse_options((char *) data,&opt)) {
s->s_dev = 0;
MOD_DEC_USE_COUNT;
return NULL;
}
#if 0
printk("map = %c\n", opt.map);
printk("rock = %c\n", opt.rock);
printk("joliet = %c\n", opt.joliet);
printk("check = %c\n", opt.check);
printk("cruft = %c\n", opt.cruft);
printk("unhide = %c\n", opt.unhide);
printk("conversion = %c\n", opt.conversion);
printk("blocksize = %d\n", opt.blocksize);
printk("gid = %d\n", opt.gid);
printk("uid = %d\n", opt.uid);
#endif
blocksize_bits = 0;
{
int i = opt.blocksize;
while (i != 1){
blocksize_bits++;
i >>=1;
}
}
set_blocksize(dev, opt.blocksize);
lock_super(s);
s->u.isofs_sb.s_high_sierra = high_sierra = 0; /* default is iso9660 */
vol_desc_start = isofs_get_last_session(dev);
for (iso_blknum = vol_desc_start+16;
iso_blknum < vol_desc_start+100; iso_blknum++)
{
int b = iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits);
if (!(bh = bread(dev,b,opt.blocksize))) {
s->s_dev = 0;
printk("isofs_read_super: bread failed, dev "
"%s iso_blknum %d block %d\n",
kdevname(dev), iso_blknum, b);
unlock_super(s);
MOD_DEC_USE_COUNT;
return NULL;
}
vdp = (struct iso_volume_descriptor *)bh->b_data;
hdp = (struct hs_volume_descriptor *)bh->b_data;
if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
goto out;
if (isonum_711 (hdp->type) == ISO_VD_END)
goto out;
s->u.isofs_sb.s_high_sierra = 1;
high_sierra = 1;
opt.rock = 'n';
h_pri = (struct hs_primary_descriptor *)vdp;
break;
}
if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
if (isonum_711 (vdp->type) == ISO_VD_END)
break;
if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) {
if (pri == NULL) {
pri = (struct iso_primary_descriptor *)vdp;
}
} else if (isonum_711 (vdp->type) == ISO_VD_SUPPLEMENTARY) {
sec = (struct iso_supplementary_descriptor *)vdp;
if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
if (opt.joliet == 'y') {
if (sec->escape[2] == 0x40) {
joliet_level = 1;
} else if (sec->escape[2] == 0x43) {
joliet_level = 2;
} else if (sec->escape[2] == 0x45) {
joliet_level = 3;
}
printk("ISO9660 Extensions: Microsoft Joliet Level %d\n",
joliet_level);
}
break;
} else {
/* Unknown supplementary volume descriptor */
sec = NULL;
}
}
/* Just skip any volume descriptors we don't recognize */
}
brelse(bh);
}
if ((pri == NULL) && (sec == NULL) && (h_pri == NULL)) {
if (!silent)
printk("Unable to identify CD-ROM format.\n");
s->s_dev = 0;
unlock_super(s);
MOD_DEC_USE_COUNT;
return NULL;
}
s->u.isofs_sb.s_joliet_level = joliet_level;
if (joliet_level && opt.rock == 'n') {
/* This is the case of Joliet with the norock mount flag.
* A disc with both Joliet and Rock Ridge is handled later
*/
pri = (struct iso_primary_descriptor *) sec;
}
if(high_sierra){
rootp = (struct iso_directory_record *) h_pri->root_directory_record;
#ifndef IGNORE_WRONG_MULTI_VOLUME_SPECS
if (isonum_723 (h_pri->volume_set_size) != 1) {
printk("Multi-volume disks not supported.\n");
goto out;
}
#endif IGNORE_WRONG_MULTI_VOLUME_SPECS
s->u.isofs_sb.s_nzones = isonum_733 (h_pri->volume_space_size);
s->u.isofs_sb.s_log_zone_size = isonum_723 (h_pri->logical_block_size);
s->u.isofs_sb.s_max_size = isonum_733(h_pri->volume_space_size);
} else {
rootp = (struct iso_directory_record *) pri->root_directory_record;
#ifndef IGNORE_WRONG_MULTI_VOLUME_SPECS
if (isonum_723 (pri->volume_set_size) != 1) {
printk("Multi-volume disks not supported.\n");
goto out;
}
#endif IGNORE_WRONG_MULTI_VOLUME_SPECS
s->u.isofs_sb.s_nzones = isonum_733 (pri->volume_space_size);
s->u.isofs_sb.s_log_zone_size = isonum_723 (pri->logical_block_size);
s->u.isofs_sb.s_max_size = isonum_733(pri->volume_space_size);
}
s->u.isofs_sb.s_ninodes = 0; /* No way to figure this out easily */
/* RDE: convert log zone size to bit shift */
orig_zonesize = s -> u.isofs_sb.s_log_zone_size;
switch (s -> u.isofs_sb.s_log_zone_size)
{ case 512: s -> u.isofs_sb.s_log_zone_size = 9; break;
case 1024: s -> u.isofs_sb.s_log_zone_size = 10; break;
case 2048: s -> u.isofs_sb.s_log_zone_size = 11; break;
default:
printk("Bad logical zone size %ld\n", s -> u.isofs_sb.s_log_zone_size);
goto out;
}
s->s_magic = ISOFS_SUPER_MAGIC;
/* The CDROM is read-only, has no nodes (devices) on it, and since
all of the files appear to be owned by root, we really do not want
to allow suid. (suid or devices will not show up unless we have
Rock Ridge extensions) */
s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
brelse(bh);
/* RDE: data zone now byte offset! */
s->u.isofs_sb.s_firstdatazone = ((isonum_733 (rootp->extent) +
isonum_711 (rootp->ext_attr_length))
<< s -> u.isofs_sb.s_log_zone_size);
printk(KERN_DEBUG "Max size:%ld Log zone size:%ld\n",
s->u.isofs_sb.s_max_size,
1UL << s->u.isofs_sb.s_log_zone_size);
printk(KERN_DEBUG "First datazone:%ld Root inode number %ld\n",
s->u.isofs_sb.s_firstdatazone >> s -> u.isofs_sb.s_log_zone_size,
s->u.isofs_sb.s_firstdatazone);
if(high_sierra) printk(KERN_DEBUG "Disc in High Sierra format.\n");
unlock_super(s);
/* set up enough so that it can read an inode */
/*
* Force the blocksize to 512 for 512 byte sectors. The file
* read primitives really get it wrong in a bad way if we don't
* do this.
*/
if( orig_zonesize < opt.blocksize )
{
opt.blocksize = orig_zonesize;
blocksize_bits = 0;
{
int i = opt.blocksize;
while (i != 1){
blocksize_bits++;
i >>=1;
}
}
set_blocksize(dev, opt.blocksize);
printk(KERN_DEBUG "Forcing new log zone size:%d\n", opt.blocksize);
}
void isofs_read_inode(struct inode * inode)
{
unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
struct buffer_head * bh;
struct iso_directory_record * raw_inode;
unsigned char *pnt = NULL;
void *cpnt = NULL;
int high_sierra;
int block;
int i;
block = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
if (!(bh=bread(inode->i_dev,block, bufsize))) {
printk("unable to read i-node block");
goto fail;
}
pnt = ((unsigned char *) bh->b_data
+ (inode->i_ino & (bufsize - 1)));
raw_inode = ((struct iso_directory_record *) pnt);
high_sierra = inode->i_sb->u.isofs_sb.s_high_sierra;
if ((inode->i_ino & (bufsize - 1)) + *pnt > bufsize){
int frag1, offset;
offset = (inode->i_ino & (bufsize - 1));
frag1 = bufsize - offset;
cpnt = kmalloc(*pnt,GFP_KERNEL);
if (cpnt == NULL) {
printk(KERN_INFO "NoMem ISO inode %lu\n",inode->i_ino);
brelse(bh);
goto fail;
}
memcpy(cpnt, bh->b_data + offset, frag1);
brelse(bh);
if (!(bh = bread(inode->i_dev,++block, bufsize))) {
kfree(cpnt);
printk("unable to read i-node block");
goto fail;
}
offset += *pnt - bufsize;
memcpy((char *)cpnt+frag1, bh->b_data, offset);
pnt = ((unsigned char *) cpnt);
raw_inode = ((struct iso_directory_record *) pnt);
}
inode->i_mode = S_IRUGO; /* Everybody gets to read the file. */
inode->i_nlink = 1;
if (raw_inode->flags[-high_sierra] & 2) {
inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
inode->i_nlink = 1; /* Set to 1. We know there are 2, but
the find utility tries to optimize
if it is 2, and it screws up. It is
easier to give 1 which tells find to
do it the hard way. */
} else {
inode->i_mode = S_IRUGO; /* Everybody gets to read the file. */
inode->i_nlink = 1;
inode->i_mode |= S_IFREG;
/* If there are no periods in the name, then set the execute permission bit */
for(i=0; i< raw_inode->name_len[0]; i++)
if(raw_inode->name[i]=='.' || raw_inode->name[i]==';')
break;
if(i == raw_inode->name_len[0] || raw_inode->name[i] == ';')
inode->i_mode |= S_IXUGO; /* execute permission */
}
inode->i_uid = inode->i_sb->u.isofs_sb.s_uid;
inode->i_gid = inode->i_sb->u.isofs_sb.s_gid;
inode->i_size = isonum_733 (raw_inode->size);
/* There are defective discs out there - we do this to protect
ourselves. A cdrom will never contain more than 700Mb */
if((inode->i_size < 0 || inode->i_size > 700000000) &&
inode->i_sb->u.isofs_sb.s_cruft == 'n') {
printk("Warning: defective cdrom. Enabling \"cruft\" mount option.\n");
inode->i_sb->u.isofs_sb.s_cruft = 'y';
}
/* Some dipshit decided to store some other bit of information in the high
byte of the file length. Catch this and holler. WARNING: this will make
it impossible for a file to be > 16Mb on the CDROM!!!*/
if(inode->i_sb->u.isofs_sb.s_cruft == 'y' &&
inode->i_size & 0xff000000){
/* printk("Illegal format on cdrom. Pester manufacturer.\n"); */
inode->i_size &= 0x00ffffff;
}
if (raw_inode->interleave[0]) {
printk("Interleaved files not (yet) supported.\n");
inode->i_size = 0;
}
/* I have no idea what file_unit_size is used for, so
we will flag it for now */
if(raw_inode->file_unit_size[0] != 0){
printk("File unit size != 0 for ISO file (%ld).\n",inode->i_ino);
}
/* I have no idea what other flag bits are used for, so
we will flag it for now */
if((raw_inode->flags[-high_sierra] & ~2)!= 0){
printk("Unusual flag settings for ISO file (%ld %x).\n",
inode->i_ino, raw_inode->flags[-high_sierra]);
}
#ifdef DEBUG
printk("Get inode %d: %d %d: %d\n",inode->i_ino, block,
((int)pnt) & 0x3ff, inode->i_size);
#endif
inode->i_mtime = inode->i_atime = inode->i_ctime =
iso_date(raw_inode->date, high_sierra);
inode->u.isofs_i.i_first_extent =
(isonum_733 (raw_inode->extent) +
isonum_711 (raw_inode->ext_attr_length)) <<
(ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS(inode));
inode->u.isofs_i.i_backlink = 0xffffffff; /* Will be used for previous directory */
switch (inode->i_sb->u.isofs_sb.s_conversion){
case 'a':
inode->u.isofs_i.i_file_format = ISOFS_FILE_UNKNOWN; /* File type */
break;
case 'b':
inode->u.isofs_i.i_file_format = ISOFS_FILE_BINARY; /* File type */
break;
case 't':
inode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT; /* File type */
break;
case 'm':
inode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT_M; /* File type */
break;
}
/* Now test for possible Rock Ridge extensions which will override some of
these numbers in the inode structure. */
if (!high_sierra)
parse_rock_ridge_inode(raw_inode, inode);
#ifdef DEBUG
printk("Inode: %x extent: %x\n",inode->i_ino, inode->u.isofs_i.i_first_extent);
#endif
brelse(bh);
inode->i_op = NULL;
/* A volume number of 0 is nonsense. Disable checking if we see
this */
if (inode->i_sb->u.isofs_sb.s_cruft == 'n' &&
isonum_723 (raw_inode->volume_sequence_number) == 0) {
printk("Warning: defective cdrom. Enabling \"cruft\" mount option.\n");
inode->i_sb->u.isofs_sb.s_cruft = 'y';
}
if (inode->i_sb->u.isofs_sb.s_cruft != 'y' &&
isonum_723 (raw_inode->volume_sequence_number) != 1) {
printk("Multi volume CD somehow got mounted.\n");
} else {
if (S_ISREG(inode->i_mode))
inode->i_op = &isofs_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &isofs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &isofs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
}
if (cpnt) {
kfree (cpnt);
cpnt = NULL;
}
return;
fail:
/* With a data error we return this information */
inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
inode->u.isofs_i.i_first_extent = 0;
inode->u.isofs_i.i_backlink = 0xffffffff;
inode->i_size = 0;
inode->i_nlink = 1;
inode->i_uid = inode->i_gid = 0;
inode->i_mode = S_IFREG; /*Regular file, no one gets to read*/
inode->i_op = NULL;
return;
}
struct super_block *isofs_read_super(struct super_block *s,void *data,
int silent)
{
struct buffer_head *bh;
int iso_blknum;
unsigned int blocksize_bits;
int high_sierra;
int dev=s->s_dev;
struct iso_volume_descriptor *vdp;
struct hs_volume_descriptor *hdp;
struct iso_primary_descriptor *pri = NULL;
struct hs_primary_descriptor *h_pri = NULL;
struct iso_directory_record *rootp;
struct iso9660_options opt;
if (!parse_options((char *) data,&opt)) {
s->s_dev = 0;
return NULL;
}
#if 0
printk("map = %c\n", opt.map);
printk("rock = %c\n", opt.rock);
printk("cruft = %c\n", opt.cruft);
printk("conversion = %c\n", opt.conversion);
printk("blocksize = %d\n", opt.blocksize);
printk("gid = %d\n", opt.gid);
printk("uid = %d\n", opt.uid);
#endif
blocksize_bits = 0;
{
int i = opt.blocksize;
while (i != 1){
blocksize_bits++;
i >>=1;
};
};
set_blocksize(dev, opt.blocksize);
lock_super(s);
s->u.isofs_sb.s_high_sierra = high_sierra = 0; /* default is iso9660 */
for (iso_blknum = 16; iso_blknum < 100; iso_blknum++) {
if (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), opt.blocksize))) {
s->s_dev=0;
printk("isofs_read_super: bread failed, dev 0x%x iso_blknum %d\n",
dev, iso_blknum);
unlock_super(s);
return NULL;
}
vdp = (struct iso_volume_descriptor *)bh->b_data;
hdp = (struct hs_volume_descriptor *)bh->b_data;
if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
goto out;
if (isonum_711 (hdp->type) == ISO_VD_END)
goto out;
s->u.isofs_sb.s_high_sierra = 1;
high_sierra = 1;
opt.rock = 'n';
h_pri = (struct hs_primary_descriptor *)vdp;
break;
};
if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
if (isonum_711 (vdp->type) != ISO_VD_PRIMARY)
goto out;
if (isonum_711 (vdp->type) == ISO_VD_END)
goto out;
pri = (struct iso_primary_descriptor *)vdp;
break;
};
brelse(bh);
}
if(iso_blknum == 100) {
if (!silent)
printk("Unable to identify CD-ROM format.\n");
s->s_dev = 0;
unlock_super(s);
return NULL;
};
if(high_sierra){
rootp = (struct iso_directory_record *) h_pri->root_directory_record;
if (isonum_723 (h_pri->volume_set_size) != 1) {
printk("Multi-volume disks not (yet) supported.\n");
goto out;
};
s->u.isofs_sb.s_nzones = isonum_733 (h_pri->volume_space_size);
s->u.isofs_sb.s_log_zone_size = isonum_723 (h_pri->logical_block_size);
s->u.isofs_sb.s_max_size = isonum_733(h_pri->volume_space_size);
} else {
rootp = (struct iso_directory_record *) pri->root_directory_record;
if (isonum_723 (pri->volume_set_size) != 1) {
printk("Multi-volume disks not (yet) supported.\n");
goto out;
};
s->u.isofs_sb.s_nzones = isonum_733 (pri->volume_space_size);
s->u.isofs_sb.s_log_zone_size = isonum_723 (pri->logical_block_size);
s->u.isofs_sb.s_max_size = isonum_733(pri->volume_space_size);
}
s->u.isofs_sb.s_ninodes = 0; /* No way to figure this out easily */
s->u.isofs_sb.s_firstdatazone = isonum_733( rootp->extent) <<
(ISOFS_BLOCK_BITS - blocksize_bits);
s->s_magic = ISOFS_SUPER_MAGIC;
/* The CDROM is read-only, has no nodes (devices) on it, and since
all of the files appear to be owned by root, we really do not want
to allow suid. (suid or devices will not show up unless we have
Rock Ridge extensions) */
s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
if(s->u.isofs_sb.s_log_zone_size != (1 << ISOFS_BLOCK_BITS)) {
printk("1 <<Block bits != Block size\n");
goto out;
};
brelse(bh);
printk("Max size:%ld Log zone size:%ld\n",
s->u.isofs_sb.s_max_size,
s->u.isofs_sb.s_log_zone_size);
printk("First datazone:%ld Root inode number %d\n",
s->u.isofs_sb.s_firstdatazone,
isonum_733 (rootp->extent) << ISOFS_BLOCK_BITS);
if(high_sierra) printk("Disc in High Sierra format.\n");
unlock_super(s);
/* set up enough so that it can read an inode */
s->s_dev = dev;
s->s_op = &isofs_sops;
s->u.isofs_sb.s_mapping = opt.map;
s->u.isofs_sb.s_rock = (opt.rock == 'y' ? 1 : 0);
s->u.isofs_sb.s_conversion = opt.conversion;
s->u.isofs_sb.s_cruft = opt.cruft;
s->u.isofs_sb.s_uid = opt.uid;
s->u.isofs_sb.s_gid = opt.gid;
s->s_blocksize = opt.blocksize;
s->s_blocksize_bits = blocksize_bits;
s->s_mounted = iget(s, isonum_733 (rootp->extent) << ISOFS_BLOCK_BITS);
unlock_super(s);
if (!(s->s_mounted)) {
s->s_dev=0;
printk("get root inode failed\n");
return NULL;
}
if(!check_disk_change(s->s_dev)) return s;
out: /* Kick out for various error conditions */
brelse(bh);
s->s_dev = 0;
unlock_super(s);
return NULL;
}
int
cd9660_findstage2(ib_params *params, uint32_t *maxblk, ib_block *blocks)
{
uint8_t buf[ISO_DEFAULT_BLOCK_SIZE];
char name[MAXNAMLEN];
char *ofwboot;
off_t loc;
int rv, blocksize, found, i;
struct iso_primary_descriptor ipd;
struct iso_directory_record *idr;
assert(params != NULL);
assert(params->stage2 != NULL);
assert(maxblk != NULL);
assert(blocks != NULL);
#if 0
if (params->flags & IB_STAGE2START)
return hardcode_stage2(params, maxblk, blocks);
#endif
/* The secondary bootstrap must be clearly in /. */
strlcpy(name, params->stage2, MAXNAMLEN);
ofwboot = name;
if (ofwboot[0] == '/')
ofwboot++;
if (strchr(ofwboot, '/') != NULL) {
warnx("The secondary bootstrap `%s' must be in / "
"on filesystem `%s'", params->stage2, params->filesystem);
return 0;
}
if (strchr(ofwboot, '.') == NULL) {
/*
* XXX should fix isofncmp()?
*/
strlcat(ofwboot, ".", MAXNAMLEN);
}
rv = pread(params->fsfd, &ipd, sizeof(ipd),
ISO_DEFAULT_BLOCK_SIZE * 16);
if (rv == -1) {
warn("Reading primary descriptor in `%s'", params->filesystem);
return 0;
} else if (rv != sizeof(ipd)) {
warnx("Reading primary descriptor in `%s': short read",
params->filesystem);
return 0;
}
blocksize = isonum_723((char *)ipd.logical_block_size);
idr = (void *)ipd.root_directory_record;
loc = (off_t)isonum_733(idr->extent) * blocksize;
rv = pread(params->fsfd, buf, blocksize, loc);
if (rv == -1) {
warn("Reading root directory record in `%s'",
params->filesystem);
return 0;
} else if (rv != sizeof(ipd)) {
warnx("Reading root directory record in `%s': short read",
params->filesystem);
return 0;
}
found = 0;
for (i = 0; i < blocksize - sizeof(struct iso_directory_record);
i += (u_char)idr->length[0]) {
idr = (void *)&buf[i];
#ifdef DEBUG
printf("i = %d, idr->length[0] = %3d\n",
i, (u_char)idr->length[0]);
#endif
/* check end of entries */
if (idr->length[0] == 0) {
#ifdef DEBUG
printf("end of entries\n");
#endif
break;
}
if (idr->flags[0] & 2) {
/* skip directory entries */
#ifdef DEBUG
printf("skip directory entry\n");
#endif
continue;
}
if (idr->name_len[0] == 1 &&
(idr->name[0] == 0 || idr->name[0] == 1)) {
/* skip "." and ".." */
#ifdef DEBUG
printf("skip dot dot\n");
#endif
continue;
}
#ifdef DEBUG
{
int j;
printf("filename:");
for (j = 0; j < isonum_711(idr->name_len); j++)
printf("%c", idr->name[j]);
printf("\n");
}
#endif
if (isofncmp(ofwboot, strlen(ofwboot),
idr->name, isonum_711(idr->name_len), 0) == 0) {
found = 1;
/* ISO filesystem always has contiguous file blocks */
blocks[0].block = (int64_t)isonum_733(idr->extent);
/* XXX bootxx assumes blocksize is 512 */
blocks[0].block *= blocksize / 512;
blocks[0].blocksize =
roundup(isonum_733(idr->size), blocksize);
*maxblk = 1;
#ifdef DEBUG
printf("block = %ld, blocksize = %ld\n",
(long)blocks[0].block, blocks[0].blocksize);
#endif
break;
}
}
if (found == 0) {
warnx("Can't find secondary bootstrap `%s' in filesystem `%s'",
params->stage2, params->filesystem);
return 0;
}
return 1;
}
