int
main(int argc, const char *argv[])
{
char const *psz_fname;
iso9660_t *p_iso;
lsn_t lsn = 24;
char *psz_path = NULL;
if (argc > 1)
lsn = strtol(argv[1], (char **)NULL, 10);
if (argc > 2)
psz_fname = argv[2];
else
psz_fname = ISO9660_IMAGE;
p_iso = iso9660_open (psz_fname);
if (NULL == p_iso) {
fprintf(stderr, "Sorry, couldn't open %s as an ISO-9660 image\n",
psz_fname);
return 1;
}
iso9660_ifs_find_lsn_with_path (p_iso, lsn, &psz_path);
if (psz_path != NULL) {
printf("File at LSN %u is %s\n", lsn, psz_path);
free(psz_path);
}
iso9660_close(p_iso);
return 0;
}
void input_vfs_init()
{
/*************************************
VFS management
*************************************/
device_init(&bd_dev);
bd_dev.addr[0] = 0x68200000;
error_t err = block_ramdisk_init(&bd_dev,NULL);//, (void*) 0x68200000);
//#if defined(CONFIG_VFS_LIBC_STREAM)
printf(" -- INPUT VFS INIT -- VFS Initialization\n");
struct vfs_fs_s *root_fs;
//fat_open(&bd_dev,&root_fs);
err = iso9660_open(&root_fs,&bd_dev);
struct vfs_node_s *root_node;
vfs_create_root(root_fs, &root_node);
/*
if (vfs_init(&bd_dev, VFS_VFAT_TYPE, 20, 20, NULL) != 0){
printf("\033[1A -- INPUT VFS INIT -- Aborted : problem during the initialization\n");
abort();
}
printf("\033[1A -- INPUT VFS INIT -- VFS Initialized\033[K\n");
*/
//#endif
}
int
main(int argc, const char *argv[])
{
CdioList_t *entlist;
CdioListNode_t *entnode;
iso9660_t *p_iso = iso9660_open (ISO9660_IMAGE);
if (NULL == p_iso) {
fprintf(stderr, "Sorry, couldn't open ISO 9660 image %s\n", ISO9660_IMAGE);
return 1;
}
entlist = iso9660_ifs_readdir (p_iso, "/");
/* Iterate over the list of nodes that iso9660_ifs_readdir gives */
_CDIO_LIST_FOREACH (entnode, entlist)
{
char filename[4096];
iso9660_stat_t *p_statbuf =
(iso9660_stat_t *) _cdio_list_node_data (entnode);
iso9660_name_translate(p_statbuf->filename, filename);
printf ("/%s\n", filename);
}
int
main(int argc, const char *argv[])
{
CdioList_t *p_entlist;
CdioListNode_t *p_entnode;
char const *psz_fname;
iso9660_t *p_iso;
const char *psz_path="/";
if (argc > 1)
psz_fname = argv[1];
else
psz_fname = ISO9660_IMAGE;
p_iso = iso9660_open (psz_fname);
if (NULL == p_iso) {
fprintf(stderr, "Sorry, couldn't open %s as an ISO-9660 image\n",
psz_fname);
return 1;
}
/* Show basic CD info from the Primary Volume Descriptor. */
{
char *psz_str = NULL;
print_vd_info("Application", iso9660_ifs_get_application_id);
print_vd_info("Preparer ", iso9660_ifs_get_preparer_id);
print_vd_info("Publisher ", iso9660_ifs_get_publisher_id);
print_vd_info("System ", iso9660_ifs_get_system_id);
print_vd_info("Volume ", iso9660_ifs_get_volume_id);
print_vd_info("Volume Set ", iso9660_ifs_get_volumeset_id);
}
p_entlist = iso9660_ifs_readdir (p_iso, psz_path);
/* Iterate over the list of nodes that iso9660_ifs_readdir gives */
if (p_entlist) {
_CDIO_LIST_FOREACH (p_entnode, p_entlist)
{
char filename[4096];
iso9660_stat_t *p_statbuf =
(iso9660_stat_t *) _cdio_list_node_data (p_entnode);
iso9660_name_translate(p_statbuf->filename, filename);
printf ("%s [LSN %6d] %8u %s%s\n",
_STAT_DIR == p_statbuf->type ? "d" : "-",
p_statbuf->lsn, p_statbuf->size, psz_path, filename);
}
_cdio_list_free (p_entlist, true);
}
static file_desc_t *
open_path( fs_ops_t *fs, const char *path )
{
iso9660_VOLUME *volume = (iso9660_VOLUME *)fs->fs_data;
iso9660_COMMON *common;
common = (iso9660_COMMON *)malloc(sizeof(*common));
if (common == NULL)
return NULL;
common->dir = iso9660_opendir(volume, path);
if (common->dir == NULL) {
common->file = iso9660_open(volume, path);
if (common->file == NULL) {
free(common);
return NULL;
}
common->type = FILE;
return (file_desc_t *)common;
}
common->type = DIR;
return (file_desc_t *)common;
}
int DVDRipper::open_disc() {
off64_t disc_len;
int total_blocks;
if ((fd = open(path, flags)) < 0) {
printf("failed to open input/output file\n");
return 1;
}
/* figure out how big the ISO image is */
if ((disc_len = lseek64(fd, 0, SEEK_END)) < 0) {
perror("lseek64 failed");
return 1;
}
if (lseek64(fd, 0, SEEK_SET) < 0) {
perror("lseek64 failed");
return 1;
}
total_blocks = disc_len / DVDCSS_BLOCK_SIZE;
if (disc_len != (long long) total_blocks * DVDCSS_BLOCK_SIZE) {
printf("partial block?????\n");
return 1;
}
printf("total_blocks = %d\n", total_blocks);
start_blocks.push_back(total_blocks);
/* find locations where have to rekey CSS */
if ((p_iso = iso9660_open(path)) == NULL) {
printf("couldn't open %s as ISO\n", path);
return 1;
}
return 0;
}
int64_t ExtractISOFile(const char* iso, const char* iso_file, const char* dest_file)
{
size_t i;
ssize_t read_size;
int64_t file_length, r = 0;
char buf[UDF_BLOCKSIZE];
DWORD buf_size, wr_size;
BOOL s;
iso9660_t* p_iso = NULL;
udf_t* p_udf = NULL;
udf_dirent_t *p_udf_root = NULL, *p_udf_file = NULL;
iso9660_stat_t *p_statbuf = NULL;
lsn_t lsn;
HANDLE file_handle = INVALID_HANDLE_VALUE;
file_handle = CreateFileU(dest_file, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (file_handle == INVALID_HANDLE_VALUE) {
uprintf(" Unable to create file %s: %s\n", dest_file, WindowsErrorString());
goto out;
}
/* First try to open as UDF - fallback to ISO if it failed */
p_udf = udf_open(iso);
if (p_udf == NULL)
goto try_iso;
p_udf_root = udf_get_root(p_udf, true, 0);
if (p_udf_root == NULL) {
uprintf("Couldn't locate UDF root directory\n");
goto out;
}
p_udf_file = udf_fopen(p_udf_root, iso_file);
if (!p_udf_file) {
uprintf("Couldn't locate file %s in ISO image\n", iso_file);
goto out;
}
file_length = udf_get_file_length(p_udf_file);
while (file_length > 0) {
memset(buf, 0, UDF_BLOCKSIZE);
read_size = udf_read_block(p_udf_file, buf, 1);
if (read_size < 0) {
uprintf("Error reading UDF file %s\n", iso_file);
goto out;
}
buf_size = (DWORD)MIN(file_length, read_size);
s = WriteFile(file_handle, buf, buf_size, &wr_size, NULL);
if ((!s) || (buf_size != wr_size)) {
uprintf(" Error writing file %s: %s\n", dest_file, WindowsErrorString());
goto out;
}
file_length -= read_size;
r += read_size;
}
goto out;
try_iso:
p_iso = iso9660_open(iso);
if (p_iso == NULL) {
uprintf("Unable to open image '%s'.\n", iso);
goto out;
}
p_statbuf = iso9660_ifs_stat_translate(p_iso, iso_file);
if (p_statbuf == NULL) {
uprintf("Could not get ISO-9660 file information for file %s\n", iso_file);
goto out;
}
file_length = p_statbuf->size;
for (i = 0; file_length > 0; i++) {
memset(buf, 0, ISO_BLOCKSIZE);
lsn = p_statbuf->lsn + (lsn_t)i;
if (iso9660_iso_seek_read(p_iso, buf, lsn, 1) != ISO_BLOCKSIZE) {
uprintf(" Error reading ISO9660 file %s at LSN %lu\n", iso_file, (long unsigned int)lsn);
goto out;
}
buf_size = (DWORD)MIN(file_length, ISO_BLOCKSIZE);
s = WriteFile(file_handle, buf, buf_size, &wr_size, NULL);
if ((!s) || (buf_size != wr_size)) {
uprintf(" Error writing file %s: %s\n", dest_file, WindowsErrorString());
goto out;
}
file_length -= ISO_BLOCKSIZE;
r += ISO_BLOCKSIZE;
}
out:
safe_closehandle(file_handle);
if (p_statbuf != NULL)
safe_free(p_statbuf->rr.psz_symlink);
safe_free(p_statbuf);
if (p_udf_root != NULL)
udf_dirent_free(p_udf_root);
if (p_udf_file != NULL)
udf_dirent_free(p_udf_file);
if (p_iso != NULL)
iso9660_close(p_iso);
if (p_udf != NULL)
udf_close(p_udf);
return r;
}
TSK_FS_INFO *
tsk_fs_open(TSK_IMG_INFO * img_info, TSK_OFF_T offset,
const TSK_TCHAR * type)
{
/* We will try different file systems ...
* We need to try all of them in case more than one matches
*/
if (type == NULL) {
TSK_FS_INFO *fs_info, *fs_set = NULL;
char *set = NULL;
if (tsk_verbose)
tsk_fprintf(stderr,
"fsopen: Auto detection mode at offset %" PRIuOFF "\n",
offset);
if ((fs_info =
ntfs_open(img_info, offset, TSK_FS_INFO_TYPE_NTFS_AUTO,
1)) != NULL) {
set = "NTFS";
fs_set = fs_info;
}
else {
tsk_error_reset();
}
if ((fs_info =
fatfs_open(img_info, offset, TSK_FS_INFO_TYPE_FAT_AUTO,
1)) != NULL) {
if (set == NULL) {
set = "FAT";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "FAT or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
if ((fs_info =
ext2fs_open(img_info, offset, TSK_FS_INFO_TYPE_EXT_AUTO,
1)) != NULL) {
if (set == NULL) {
set = "EXT2/3";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "EXT2/3 or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
if ((fs_info =
ffs_open(img_info, offset,
TSK_FS_INFO_TYPE_FFS_AUTO)) != NULL) {
if (set == NULL) {
set = "UFS";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "UFS or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
#if TSK_USE_HFS
if ((fs_info =
hfs_open(img_info, offset, TSK_FS_INFO_TYPE_HFS,
1)) != NULL) {
if (set == NULL) {
set = "HFS";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "HFS or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
#endif
if ((fs_info =
iso9660_open(img_info, offset, TSK_FS_INFO_TYPE_ISO9660,
1)) != NULL) {
if (set != NULL) {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "ISO9660 or %s", set);
return NULL;
}
fs_set = fs_info;
}
else {
tsk_error_reset();
}
if (fs_set == NULL) {
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
tsk_errstr[0] = '\0';
tsk_errstr2[0] = '\0';
return NULL;
}
return fs_set;
}
else {
uint8_t ftype;
ftype = tsk_fs_parse_type(type);
switch (ftype & TSK_FS_INFO_TYPE_FS_MASK) {
case TSK_FS_INFO_TYPE_FFS_TYPE:
return ffs_open(img_info, offset, ftype);
case TSK_FS_INFO_TYPE_EXT_TYPE:
return ext2fs_open(img_info, offset, ftype, 0);
case TSK_FS_INFO_TYPE_FAT_TYPE:
return fatfs_open(img_info, offset, ftype, 0);
case TSK_FS_INFO_TYPE_NTFS_TYPE:
return ntfs_open(img_info, offset, ftype, 0);
case TSK_FS_INFO_TYPE_ISO9660_TYPE:
return iso9660_open(img_info, offset, ftype, 0);
#if 0
case TSK_FS_INFO_TYPE_HFS_TYPE:
return hfs_open(img_info, offset, ftype, 0);
#endif
case TSK_FS_INFO_TYPE_RAW_TYPE:
return rawfs_open(img_info, offset);
case TSK_FS_INFO_TYPE_SWAP_TYPE:
return swapfs_open(img_info, offset);
case TSK_FS_INFO_TYPE_UNSUPP:
default:
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNSUPTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "%s", type);
return NULL;
}
}
}
/**
* \ingroup fslib
* Tries to process data in a disk image at a given offset as a file system.
* Returns a structure that can be used for analysis and reporting.
*
* @param a_img_info Disk image to analyze
* @param a_offset Byte offset to start analyzing from
* @param a_ftype Type of file system (or autodetect)
*
* @return NULL on error
*/
TSK_FS_INFO *
tsk_fs_open_img(TSK_IMG_INFO * a_img_info, TSK_OFF_T a_offset,
TSK_FS_TYPE_ENUM a_ftype)
{
if (a_img_info == NULL) {
tsk_error_reset();
tsk_errno = TSK_ERR_FS_ARG;
snprintf(tsk_errstr, TSK_ERRSTR_L,
"tsk_fs_open_img: Null image handle");
return NULL;
}
/* We will try different file systems ...
* We need to try all of them in case more than one matches
*/
if (a_ftype == TSK_FS_TYPE_DETECT) {
TSK_FS_INFO *fs_info, *fs_set = NULL;
char *set = NULL;
if (tsk_verbose)
tsk_fprintf(stderr,
"fsopen: Auto detection mode at offset %" PRIuOFF "\n",
a_offset);
if ((fs_info =
ntfs_open(a_img_info, a_offset, TSK_FS_TYPE_NTFS_DETECT,
1)) != NULL) {
set = "NTFS";
fs_set = fs_info;
}
else {
tsk_error_reset();
}
if ((fs_info =
fatfs_open(a_img_info, a_offset, TSK_FS_TYPE_FAT_DETECT,
1)) != NULL) {
if (set == NULL) {
set = "FAT";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "FAT or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
if ((fs_info =
ext2fs_open(a_img_info, a_offset, TSK_FS_TYPE_EXT_DETECT,
1)) != NULL) {
if (set == NULL) {
set = "EXT2/3";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "EXT2/3 or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
if ((fs_info =
ffs_open(a_img_info, a_offset,
TSK_FS_TYPE_FFS_DETECT)) != NULL) {
if (set == NULL) {
set = "UFS";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "UFS or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
#if TSK_USE_HFS
if ((fs_info =
hfs_open(a_img_info, a_offset, TSK_FS_TYPE_HFS_DETECT,
1)) != NULL) {
if (set == NULL) {
set = "HFS";
fs_set = fs_info;
}
else {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "HFS or %s", set);
return NULL;
}
}
else {
tsk_error_reset();
}
#endif
if ((fs_info =
iso9660_open(a_img_info, a_offset,
TSK_FS_TYPE_ISO9660_DETECT, 1)) != NULL) {
if (set != NULL) {
fs_set->close(fs_set);
fs_info->close(fs_info);
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "ISO9660 or %s", set);
return NULL;
}
fs_set = fs_info;
}
else {
tsk_error_reset();
}
if (fs_set == NULL) {
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNKTYPE;
tsk_errstr[0] = '\0';
tsk_errstr2[0] = '\0';
return NULL;
}
return fs_set;
}
else {
if (TSK_FS_TYPE_ISNTFS(a_ftype))
return ntfs_open(a_img_info, a_offset, a_ftype, 0);
else if (TSK_FS_TYPE_ISFAT(a_ftype))
return fatfs_open(a_img_info, a_offset, a_ftype, 0);
else if (TSK_FS_TYPE_ISFFS(a_ftype))
return ffs_open(a_img_info, a_offset, a_ftype);
else if (TSK_FS_TYPE_ISEXT(a_ftype))
return ext2fs_open(a_img_info, a_offset, a_ftype, 0);
else if (TSK_FS_TYPE_ISHFS(a_ftype))
return hfs_open(a_img_info, a_offset, a_ftype, 0);
else if (TSK_FS_TYPE_ISISO9660(a_ftype))
return iso9660_open(a_img_info, a_offset, a_ftype, 0);
else if (TSK_FS_TYPE_ISRAW(a_ftype))
return rawfs_open(a_img_info, a_offset);
else if (TSK_FS_TYPE_ISSWAP(a_ftype))
return swapfs_open(a_img_info, a_offset);
else {
tsk_error_reset();
tsk_errno = TSK_ERR_FS_UNSUPTYPE;
snprintf(tsk_errstr, TSK_ERRSTR_L, "%X", (int) a_ftype);
return NULL;
}
}
}
int
main(int argc, const char *argv[])
{
iso9660_stat_t *p_statbuf;
FILE *p_outfd;
int i;
iso9660_t *p_iso = iso9660_open (ISO9660_IMAGE);
if (NULL == p_iso) {
fprintf(stderr, "Sorry, couldn't open ISO 9660 image %s\n", ISO9660_IMAGE);
return 1;
}
p_statbuf = iso9660_ifs_stat_translate (p_iso, LOCAL_FILENAME);
if (NULL == p_statbuf)
{
fprintf(stderr,
"Could not get ISO-9660 file information for file %s\n",
LOCAL_FILENAME);
iso9660_close(p_iso);
return 2;
}
if (!(p_outfd = fopen (LOCAL_FILENAME, "wb")))
{
perror ("fopen()");
free(p_statbuf);
iso9660_close(p_iso);
return 3;
}
/* Copy the blocks from the ISO-9660 filesystem to the local filesystem. */
for (i = 0; i < p_statbuf->size; i += ISO_BLOCKSIZE)
{
char buf[ISO_BLOCKSIZE];
memset (buf, 0, ISO_BLOCKSIZE);
if ( ISO_BLOCKSIZE != iso9660_iso_seek_read (p_iso, buf, p_statbuf->lsn
+ (i / ISO_BLOCKSIZE),
1) )
{
fprintf(stderr, "Error reading ISO 9660 file at lsn %lu\n",
(long unsigned int) p_statbuf->lsn + (i / ISO_BLOCKSIZE));
my_exit(4);
}
fwrite (buf, ISO_BLOCKSIZE, 1, p_outfd);
if (ferror (p_outfd))
{
perror ("fwrite()");
my_exit(5);
}
}
fflush (p_outfd);
/* Make sure the file size has the exact same byte size. Without the
truncate below, the file will a multiple of ISO_BLOCKSIZE.
*/
if (ftruncate (fileno (p_outfd), p_statbuf->size))
perror ("ftruncate()");
printf("Extraction of file 'copying' from %s successful.\n", ISO9660_IMAGE);
my_exit(0);
}
uint32_t GetInstallWimVersion(const char* iso)
{
char *wim_path = NULL, *p, buf[UDF_BLOCKSIZE] = { 0 };
uint32_t* wim_header = (uint32_t*)buf, r = 0xffffffff;
iso9660_t* p_iso = NULL;
udf_t* p_udf = NULL;
udf_dirent_t *p_udf_root = NULL, *p_udf_file = NULL;
iso9660_stat_t *p_statbuf = NULL;
wim_path = safe_strdup(&img_report.install_wim_path[2]);
if (wim_path == NULL)
goto out;
// UDF indiscriminately accepts slash or backslash delimiters,
// but ISO-9660 requires slash
for (p = wim_path; *p != 0; p++)
if (*p == '\\') *p = '/';
// First try to open as UDF - fallback to ISO if it failed
p_udf = udf_open(iso);
if (p_udf == NULL)
goto try_iso;
p_udf_root = udf_get_root(p_udf, true, 0);
if (p_udf_root == NULL) {
uprintf("Could not locate UDF root directory\n");
goto out;
}
p_udf_file = udf_fopen(p_udf_root, wim_path);
if (!p_udf_file) {
uprintf("Could not locate file %s in ISO image\n", wim_path);
goto out;
}
if (udf_read_block(p_udf_file, buf, 1) != UDF_BLOCKSIZE) {
uprintf("Error reading UDF file %s\n", wim_path);
goto out;
}
r = wim_header[3];
goto out;
try_iso:
p_iso = iso9660_open(iso);
if (p_iso == NULL) {
uprintf("Unable to open image '%s'.\n", iso);
goto out;
}
p_statbuf = iso9660_ifs_stat_translate(p_iso, wim_path);
if (p_statbuf == NULL) {
uprintf("Could not get ISO-9660 file information for file %s\n", wim_path);
goto out;
}
if (iso9660_iso_seek_read(p_iso, buf, p_statbuf->lsn, 1) != ISO_BLOCKSIZE) {
uprintf("Error reading ISO9660 file %s at LSN %lu\n", wim_path, (long unsigned int)p_statbuf->lsn);
goto out;
}
r = wim_header[3];
out:
if (p_statbuf != NULL)
safe_free(p_statbuf->rr.psz_symlink);
safe_free(p_statbuf);
if (p_udf_root != NULL)
udf_dirent_free(p_udf_root);
if (p_udf_file != NULL)
udf_dirent_free(p_udf_file);
if (p_iso != NULL)
iso9660_close(p_iso);
if (p_udf != NULL)
udf_close(p_udf);
safe_free(wim_path);
return bswap_uint32(r);
}
int
main(int argc, const char *argv[])
{
iso9660_stat_t *p_statbuf;
FILE *p_outfd;
int i;
char const *psz_image;
char const *psz_fname;
iso9660_t *p_iso;
if (argc > 3) {
printf("usage %s [ISO9660-image.ISO [filename]]\n", argv[0]);
printf("Extracts filename from ISO-9660-image.ISO\n");
return 1;
}
if (argc > 1)
psz_image = argv[1];
else
psz_image = ISO9660_IMAGE;
if (argc > 2)
psz_fname = argv[2];
else
psz_fname = LOCAL_FILENAME;
p_iso = iso9660_open (psz_image);
if (NULL == p_iso) {
fprintf(stderr, "Sorry, couldn't open ISO 9660 image %s\n", psz_image);
return 1;
}
p_statbuf = iso9660_ifs_stat_translate (p_iso, psz_fname);
if (NULL == p_statbuf)
{
fprintf(stderr,
"Could not get ISO-9660 file information for file %s\n",
psz_fname);
iso9660_close(p_iso);
return 2;
}
if (!(p_outfd = fopen (psz_fname, "wb")))
{
perror ("fopen()");
free(p_statbuf);
iso9660_close(p_iso);
return 3;
}
/* Copy the blocks from the ISO-9660 filesystem to the local filesystem. */
{
const unsigned int i_blocks = CEILING(p_statbuf->size, ISO_BLOCKSIZE);
for (i = 0; i < i_blocks ; i++)
{
char buf[ISO_BLOCKSIZE];
const lsn_t lsn = p_statbuf->lsn + i;
memset (buf, 0, ISO_BLOCKSIZE);
if ( ISO_BLOCKSIZE != iso9660_iso_seek_read (p_iso, buf, lsn, 1) )
{
fprintf(stderr, "Error reading ISO 9660 file %s at LSN %lu\n",
psz_fname, (long unsigned int) lsn);
my_exit(4);
}
fwrite (buf, ISO_BLOCKSIZE, 1, p_outfd);
if (ferror (p_outfd))
{
perror ("fwrite()");
my_exit(5);
}
}
}
fflush (p_outfd);
/* Make sure the file size has the exact same byte size. Without the
truncate below, the file will a multiple of ISO_BLOCKSIZE.
*/
if (ftruncate (fileno (p_outfd), p_statbuf->size))
perror ("ftruncate()");
printf("Extraction of file '%s' from %s successful.\n",
psz_fname, psz_image);
my_exit(0);
}
/**
* \ingroup fslib
* Tries to process data in a disk image at a given offset as a file system.
* Returns a structure that can be used for analysis and reporting.
*
* @param a_img_info Disk image to analyze
* @param a_offset Byte offset to start analyzing from
* @param a_ftype Type of file system (or autodetect)
*
* @return NULL on error
*/
TSK_FS_INFO *
tsk_fs_open_img(TSK_IMG_INFO * a_img_info, TSK_OFF_T a_offset,
TSK_FS_TYPE_ENUM a_ftype)
{
TSK_FS_INFO *fs_info;
const struct {
char* name;
TSK_FS_INFO* (*open)(TSK_IMG_INFO*, TSK_OFF_T,
TSK_FS_TYPE_ENUM, uint8_t);
TSK_FS_TYPE_ENUM type;
} FS_OPENERS[] = {
{ "NTFS", ntfs_open, TSK_FS_TYPE_NTFS_DETECT },
{ "FAT", fatfs_open, TSK_FS_TYPE_FAT_DETECT },
{ "EXT2/3/4", ext2fs_open, TSK_FS_TYPE_EXT_DETECT },
{ "UFS", ffs_open, TSK_FS_TYPE_FFS_DETECT },
{ "YAFFS2", yaffs2_open, TSK_FS_TYPE_YAFFS2_DETECT },
#if TSK_USE_HFS
{ "HFS", hfs_open, TSK_FS_TYPE_HFS_DETECT },
#endif
{ "ISO9660", iso9660_open, TSK_FS_TYPE_ISO9660_DETECT }
};
if (a_img_info == NULL) {
tsk_error_reset();
tsk_error_set_errno(TSK_ERR_FS_ARG);
tsk_error_set_errstr("tsk_fs_open_img: Null image handle");
return NULL;
}
/* We will try different file systems ...
* We need to try all of them in case more than one matches
*/
if (a_ftype == TSK_FS_TYPE_DETECT) {
unsigned long i;
const char *name_first = "";
TSK_FS_INFO *fs_first = NULL;
if (tsk_verbose)
tsk_fprintf(stderr,
"fsopen: Auto detection mode at offset %" PRIuOFF "\n",
a_offset);
for (i = 0; i < sizeof(FS_OPENERS)/sizeof(FS_OPENERS[0]); ++i) {
if ((fs_info = FS_OPENERS[i].open(
a_img_info, a_offset, FS_OPENERS[i].type, 1)) != NULL) {
// fs opens as type i
if (fs_first == NULL) {
// first success opening fs
name_first = FS_OPENERS[i].name;
fs_first = fs_info;
}
else {
// second success opening fs, which means we
// cannot autodetect the fs type and must give up
fs_first->close(fs_first);
fs_info->close(fs_info);
tsk_error_reset();
tsk_error_set_errno(TSK_ERR_FS_UNKTYPE);
tsk_error_set_errstr(
"%s or %s", FS_OPENERS[i].name, name_first);
return NULL;
}
}
else {
// fs does not open as type i
tsk_error_reset();
}
}
if (fs_first == NULL) {
tsk_error_reset();
tsk_error_set_errno(TSK_ERR_FS_UNKTYPE);
}
return fs_first;
}
else if (TSK_FS_TYPE_ISNTFS(a_ftype)) {
return ntfs_open(a_img_info, a_offset, a_ftype, 0);
}
else if (TSK_FS_TYPE_ISFAT(a_ftype)) {
return fatfs_open(a_img_info, a_offset, a_ftype, 0);
}
else if (TSK_FS_TYPE_ISFFS(a_ftype)) {
return ffs_open(a_img_info, a_offset, a_ftype, 0);
}
else if (TSK_FS_TYPE_ISEXT(a_ftype)) {
return ext2fs_open(a_img_info, a_offset, a_ftype, 0);
}
else if (TSK_FS_TYPE_ISHFS(a_ftype)) {
return hfs_open(a_img_info, a_offset, a_ftype, 0);
}
else if (TSK_FS_TYPE_ISISO9660(a_ftype)) {
return iso9660_open(a_img_info, a_offset, a_ftype, 0);
}
else if (TSK_FS_TYPE_ISRAW(a_ftype)) {
return rawfs_open(a_img_info, a_offset);
}
else if (TSK_FS_TYPE_ISSWAP(a_ftype)) {
return swapfs_open(a_img_info, a_offset);
}
else if (TSK_FS_TYPE_ISYAFFS2(a_ftype)) {
return yaffs2_open(a_img_info, a_offset, a_ftype, 0);
}
tsk_error_reset();
tsk_error_set_errno(TSK_ERR_FS_UNSUPTYPE);
tsk_error_set_errstr("%X", (int) a_ftype);
return NULL;
}
