mirror of
https://git.savannah.gnu.org/git/grub.git
synced 2026-10-22 07:12:39 +00:00
jeroen
50396703ad
* stage2/char_io.c (grub_memcmp): Define for stage1.5 too. * stage2/fsys_iso9660.c (iso9660_mount): Use memcmp() instead of __builtin_memcmp(). (iso9660_dir): Likewise.
443 lines
11 KiB
C
443 lines
11 KiB
C
/*
|
|
* ISO 9660 filesystem backend for GRUB (GRand Unified Bootloader)
|
|
* including Rock Ridge Extensions support
|
|
*
|
|
* Copyright (C) 1998, 1999 Kousuke Takai <tak@kmc.kyoto-u.ac.jp>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 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; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
/*
|
|
* References:
|
|
* linux/fs/isofs/rock.[ch]
|
|
* mkisofs-1.11.1/diag/isoinfo.c
|
|
* mkisofs-1.11.1/iso9660.h
|
|
* (all are written by Eric Youngdale)
|
|
*
|
|
* Modifications by:
|
|
* Leonid Lisovskiy <lly@pisem.net> 2003
|
|
*/
|
|
|
|
#ifdef FSYS_ISO9660
|
|
|
|
#include "shared.h"
|
|
#include "filesys.h"
|
|
#include "iso9660.h"
|
|
|
|
/* iso9660 super-block data in memory */
|
|
struct iso_sb_info {
|
|
unsigned long vol_sector;
|
|
|
|
};
|
|
|
|
/* iso fs inode data in memory */
|
|
struct iso_inode_info {
|
|
unsigned long file_start;
|
|
};
|
|
|
|
#define ISO_SUPER \
|
|
((struct iso_sb_info *)(FSYS_BUF))
|
|
#define INODE \
|
|
((struct iso_inode_info *)(FSYS_BUF+sizeof(struct iso_sb_info)))
|
|
#define PRIMDESC ((struct iso_primary_descriptor *)(FSYS_BUF + 2048))
|
|
#define DIRREC ((struct iso_directory_record *)(FSYS_BUF + 4096))
|
|
#define RRCONT_BUF ((unsigned char *)(FSYS_BUF + 6144))
|
|
#define NAME_BUF ((unsigned char *)(FSYS_BUF + 8192))
|
|
|
|
|
|
static inline unsigned long
|
|
log2 (unsigned long word)
|
|
{
|
|
asm volatile ("bsfl %1,%0"
|
|
: "=r" (word)
|
|
: "r" (word));
|
|
return word;
|
|
}
|
|
|
|
static int
|
|
iso9660_devread (int sector, int byte_offset, int byte_len, char *buf)
|
|
{
|
|
unsigned short sector_size_lg2 = log2(buf_geom.sector_size);
|
|
|
|
/*
|
|
* We have to use own devread() function since BIOS return wrong geometry
|
|
*/
|
|
if (sector < 0)
|
|
{
|
|
errnum = ERR_OUTSIDE_PART;
|
|
return 0;
|
|
}
|
|
if (byte_len <= 0)
|
|
return 1;
|
|
|
|
sector += (byte_offset >> sector_size_lg2);
|
|
byte_offset &= (buf_geom.sector_size - 1);
|
|
asm volatile ("shl%L0 %1,%0"
|
|
: "=r"(sector)
|
|
: "Ic"((int8_t)(ISO_SECTOR_BITS - sector_size_lg2)),
|
|
"0"(sector));
|
|
|
|
#if !defined(STAGE1_5)
|
|
if (disk_read_hook && debug)
|
|
printf ("<%d, %d, %d>", sector, byte_offset, byte_len);
|
|
#endif /* !STAGE1_5 */
|
|
|
|
return rawread(current_drive, part_start + sector, byte_offset, byte_len, buf);
|
|
}
|
|
|
|
int
|
|
iso9660_mount (void)
|
|
{
|
|
unsigned int sector;
|
|
|
|
/*
|
|
* Because there is no defined slice type ID for ISO-9660 filesystem,
|
|
* this test will pass only either (1) if entire disk is used, or
|
|
* (2) if current partition is BSD style sub-partition whose ID is
|
|
* ISO-9660.
|
|
*/
|
|
if ((current_partition != 0xFFFFFF)
|
|
&& !IS_PC_SLICE_TYPE_BSD_WITH_FS(current_slice, FS_ISO9660))
|
|
return 0;
|
|
|
|
/*
|
|
* Currently, only FIRST session of MultiSession disks are supported !!!
|
|
*/
|
|
for (sector = 16 ; sector < 32 ; sector++)
|
|
{
|
|
if (!iso9660_devread(sector, 0, sizeof(*PRIMDESC), (char *)PRIMDESC))
|
|
break;
|
|
/* check ISO_VD_PRIMARY and ISO_STANDARD_ID */
|
|
if (PRIMDESC->type.l == ISO_VD_PRIMARY
|
|
&& !memcmp(PRIMDESC->id, ISO_STANDARD_ID, sizeof(PRIMDESC->id)))
|
|
{
|
|
ISO_SUPER->vol_sector = sector;
|
|
INODE->file_start = 0;
|
|
fsmax = PRIMDESC->volume_space_size.l;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
iso9660_dir (char *dirname)
|
|
{
|
|
struct iso_directory_record *idr;
|
|
RR_ptr_t rr_ptr;
|
|
struct rock_ridge *ce_ptr;
|
|
unsigned int pathlen;
|
|
int size;
|
|
unsigned int extent;
|
|
unsigned char file_type;
|
|
unsigned int rr_len;
|
|
unsigned char rr_flag;
|
|
|
|
idr = &PRIMDESC->root_directory_record;
|
|
INODE->file_start = 0;
|
|
|
|
do
|
|
{
|
|
while (*dirname == '/') /* skip leading slashes */
|
|
dirname++;
|
|
/* pathlen = strcspn(dirname, "/\n\t "); */
|
|
for (pathlen = 0 ;
|
|
dirname[pathlen]
|
|
&& !isspace(dirname[pathlen]) && dirname[pathlen] != '/' ;
|
|
pathlen++)
|
|
;
|
|
|
|
size = idr->size.l;
|
|
extent = idr->extent.l;
|
|
|
|
while (size > 0)
|
|
{
|
|
if (!iso9660_devread(extent, 0, ISO_SECTOR_SIZE, (char *)DIRREC))
|
|
{
|
|
errnum = ERR_FSYS_CORRUPT;
|
|
return 0;
|
|
}
|
|
extent++;
|
|
|
|
idr = (struct iso_directory_record *)DIRREC;
|
|
for (; idr->length.l > 0;
|
|
idr = (struct iso_directory_record *)((char *)idr + idr->length.l) )
|
|
{
|
|
const char *name = idr->name;
|
|
unsigned int name_len = idr->name_len.l;
|
|
|
|
file_type = (idr->flags.l & 2) ? ISO_DIRECTORY : ISO_REGULAR;
|
|
if (name_len == 1)
|
|
{
|
|
if ((name[0] == 0) || /* self */
|
|
(name[0] == 1)) /* parent */
|
|
continue;
|
|
}
|
|
if (name_len > 2 && CHECK2(name + name_len - 2, ';', '1'))
|
|
{
|
|
name_len -= 2; /* truncate trailing file version */
|
|
if (name_len > 1 && name[name_len - 1] == '.')
|
|
name_len--; /* truncate trailing dot */
|
|
}
|
|
|
|
/*
|
|
* Parse Rock-Ridge extension
|
|
*/
|
|
rr_len = (idr->length.l - idr->name_len.l
|
|
- sizeof(struct iso_directory_record)
|
|
+ sizeof(idr->name));
|
|
rr_ptr.ptr = ((unsigned char *)idr + idr->name_len.l
|
|
+ sizeof(struct iso_directory_record)
|
|
- sizeof(idr->name));
|
|
if (rr_ptr.i & 1)
|
|
rr_ptr.i++, rr_len--;
|
|
ce_ptr = NULL;
|
|
rr_flag = RR_FLAG_NM | RR_FLAG_PX /*| RR_FLAG_SL*/;
|
|
|
|
while (rr_len >= 4)
|
|
{
|
|
if (rr_ptr.rr->version != 1)
|
|
{
|
|
#ifndef STAGE1_5
|
|
if (debug)
|
|
printf(
|
|
"Non-supported version (%d) RockRidge chunk "
|
|
"`%c%c'\n", rr_ptr.rr->version,
|
|
rr_ptr.rr->signature & 0xFF,
|
|
rr_ptr.rr->signature >> 8);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
switch (rr_ptr.rr->signature)
|
|
{
|
|
case RRMAGIC('R', 'R'):
|
|
if ( rr_ptr.rr->len >= (4+sizeof(struct RR)))
|
|
rr_flag &= rr_ptr.rr->u.rr.flags.l;
|
|
break;
|
|
case RRMAGIC('N', 'M'):
|
|
name = rr_ptr.rr->u.nm.name;
|
|
name_len = rr_ptr.rr->len - (4+sizeof(struct NM));
|
|
rr_flag &= ~RR_FLAG_NM;
|
|
break;
|
|
case RRMAGIC('P', 'X'):
|
|
if (rr_ptr.rr->len >= (4+sizeof(struct PX)))
|
|
{
|
|
file_type = ((rr_ptr.rr->u.px.mode.l & POSIX_S_IFMT)
|
|
== POSIX_S_IFREG
|
|
? ISO_REGULAR
|
|
: ((rr_ptr.rr->u.px.mode.l & POSIX_S_IFMT)
|
|
== POSIX_S_IFDIR
|
|
? ISO_DIRECTORY : ISO_OTHER));
|
|
rr_flag &= ~RR_FLAG_PX;
|
|
}
|
|
break;
|
|
case RRMAGIC('C', 'E'):
|
|
if (rr_ptr.rr->len >= (4+sizeof(struct CE)))
|
|
ce_ptr = rr_ptr.rr;
|
|
break;
|
|
#if 0 // RockRidge symlinks are not supported yet
|
|
case RRMAGIC('S', 'L'):
|
|
{
|
|
int slen;
|
|
unsigned char rootflag, prevflag;
|
|
char *rpnt = NAME_BUF+1024;
|
|
struct SL_component *slp;
|
|
|
|
slen = rr_ptr.rr->len - (4+1);
|
|
slp = &rr_ptr.rr->u.sl.link;
|
|
while (slen > 1)
|
|
{
|
|
rootflag = 0;
|
|
switch (slp->flags.l)
|
|
{
|
|
case 0:
|
|
memcpy(rpnt, slp->text, slp->len);
|
|
rpnt += slp->len;
|
|
break;
|
|
case 4:
|
|
*rpnt++ = '.';
|
|
/* fallthru */
|
|
case 2:
|
|
*rpnt++ = '.';
|
|
break;
|
|
case 8:
|
|
rootflag = 1;
|
|
*rpnt++ = '/';
|
|
break;
|
|
default:
|
|
printf("Symlink component flag not implemented (%d)\n",
|
|
slp->flags.l);
|
|
slen = 0;
|
|
break;
|
|
}
|
|
slen -= slp->len + 2;
|
|
prevflag = slp->flags.l;
|
|
slp = (struct SL_component *) ((char *) slp + slp->len + 2);
|
|
|
|
if (slen < 2)
|
|
{
|
|
/*
|
|
* If there is another SL record, and this component
|
|
* record isn't continued, then add a slash.
|
|
*/
|
|
if ((!rootflag) && (rr_ptr.rr->u.sl.flags.l & 1) && !(prevflag & 1))
|
|
*rpnt++='/';
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* If this component record isn't continued, then append a '/'.
|
|
*/
|
|
if (!rootflag && !(prevflag & 1))
|
|
*rpnt++ = '/';
|
|
}
|
|
*rpnt++ = '\0';
|
|
grub_putstr(NAME_BUF+1024);// debug print!
|
|
}
|
|
rr_flag &= ~RR_FLAG_SL;
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (!rr_flag)
|
|
/*
|
|
* There is no more extension we expects...
|
|
*/
|
|
break;
|
|
|
|
rr_len -= rr_ptr.rr->len;
|
|
rr_ptr.ptr += rr_ptr.rr->len;
|
|
if (rr_len < 4 && ce_ptr != NULL)
|
|
{
|
|
/* preserve name before loading new extent. */
|
|
if( RRCONT_BUF <= (unsigned char *)name
|
|
&& (unsigned char *)name < RRCONT_BUF + ISO_SECTOR_SIZE )
|
|
{
|
|
memcpy(NAME_BUF, name, name_len);
|
|
name = NAME_BUF;
|
|
}
|
|
rr_ptr.ptr = RRCONT_BUF + ce_ptr->u.ce.offset.l;
|
|
rr_len = ce_ptr->u.ce.size.l;
|
|
if (!iso9660_devread(ce_ptr->u.ce.extent.l, 0, ISO_SECTOR_SIZE, RRCONT_BUF))
|
|
{
|
|
errnum = 0; /* this is not fatal. */
|
|
break;
|
|
}
|
|
ce_ptr = NULL;
|
|
}
|
|
} /* rr_len >= 4 */
|
|
|
|
filemax = MAXINT;
|
|
if (name_len >= pathlen
|
|
&& !memcmp(name, dirname, pathlen))
|
|
{
|
|
if (dirname[pathlen] == '/' || !print_possibilities)
|
|
{
|
|
/*
|
|
* DIRNAME is directory component of pathname,
|
|
* or we are to open a file.
|
|
*/
|
|
if (pathlen == name_len)
|
|
{
|
|
if (dirname[pathlen] == '/')
|
|
{
|
|
if (file_type != ISO_DIRECTORY)
|
|
{
|
|
errnum = ERR_BAD_FILETYPE;
|
|
return 0;
|
|
}
|
|
goto next_dir_level;
|
|
}
|
|
if (file_type != ISO_REGULAR)
|
|
{
|
|
errnum = ERR_BAD_FILETYPE;
|
|
return 0;
|
|
}
|
|
INODE->file_start = idr->extent.l;
|
|
filepos = 0;
|
|
filemax = idr->size.l;
|
|
return 1;
|
|
}
|
|
}
|
|
else /* Completion */
|
|
{
|
|
#ifndef STAGE1_5
|
|
if (print_possibilities > 0)
|
|
print_possibilities = -print_possibilities;
|
|
memcpy(NAME_BUF, name, name_len);
|
|
NAME_BUF[name_len] = '\0';
|
|
print_a_completion (NAME_BUF);
|
|
#endif
|
|
}
|
|
}
|
|
} /* for */
|
|
|
|
size -= ISO_SECTOR_SIZE;
|
|
} /* size>0 */
|
|
|
|
if (dirname[pathlen] == '/' || print_possibilities >= 0)
|
|
{
|
|
errnum = ERR_FILE_NOT_FOUND;
|
|
return 0;
|
|
}
|
|
|
|
next_dir_level:
|
|
dirname += pathlen;
|
|
|
|
} while (*dirname == '/');
|
|
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
iso9660_read (char *buf, int len)
|
|
{
|
|
int sector, blkoffset, size, ret;
|
|
|
|
if (INODE->file_start == 0)
|
|
return 0;
|
|
|
|
ret = 0;
|
|
blkoffset = filepos & (ISO_SECTOR_SIZE - 1);
|
|
sector = filepos >> ISO_SECTOR_BITS;
|
|
while (len > 0)
|
|
{
|
|
size = ISO_SECTOR_SIZE - blkoffset;
|
|
if (size > len)
|
|
size = len;
|
|
|
|
disk_read_func = disk_read_hook;
|
|
|
|
if (!iso9660_devread(INODE->file_start + sector, blkoffset, size, buf))
|
|
return 0;
|
|
|
|
disk_read_func = NULL;
|
|
|
|
len -= size;
|
|
buf += size;
|
|
ret += size;
|
|
filepos += size;
|
|
sector++;
|
|
blkoffset = 0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif /* FSYS_ISO9660 */
|