/* $Id: fsw_iso9660.c 98103 2023-01-17 14:15:46Z vboxsync $ */ /** @file * fsw_iso9660.c - ISO9660 file system driver code. * * Current limitations: * - Files must be in one extent (i.e. Level 2) * - No Joliet or Rock Ridge extensions * - No interleaving * - inode number generation strategy fails on volumes > 2 GB * - No blocksizes != 2048 * - No High Sierra or anything else != 'CD001' * - No volume sets with directories pointing at other volumes * - No extended attribute records */ /* * Copyright (C) 2010-2023 Oracle and/or its affiliates. * * This file is part of VirtualBox base platform packages, as * available from https://www.virtualbox.org. * * 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, in version 3 of the * License. * * 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, see . * * The contents of this file may alternatively be used under the terms * of the Common Development and Distribution License Version 1.0 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included * in the VirtualBox distribution, in which case the provisions of the * CDDL are applicable instead of those of the GPL. * * You may elect to license modified versions of this file under the * terms and conditions of either the GPL or the CDDL or both. * * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 * --------------------------------------------------------------------------- * This code is based on: * * Copyright (c) 2006 Christoph Pfisterer * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. * * * Neither the name of Christoph Pfisterer nor the names of the * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "fsw_iso9660.h" // functions static fsw_status_t fsw_iso9660_volume_mount(struct fsw_iso9660_volume *vol); static void fsw_iso9660_volume_free(struct fsw_iso9660_volume *vol); static fsw_status_t fsw_iso9660_volume_stat(struct fsw_iso9660_volume *vol, struct fsw_volume_stat *sb); static fsw_status_t fsw_iso9660_dnode_fill(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno); static void fsw_iso9660_dnode_free(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno); static fsw_status_t fsw_iso9660_dnode_stat(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_dnode_stat *sb); static fsw_status_t fsw_iso9660_get_extent(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_extent *extent); static fsw_status_t fsw_iso9660_dir_lookup(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_string *lookup_name, struct fsw_iso9660_dnode **child_dno); static fsw_status_t fsw_iso9660_dir_read(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_shandle *shand, struct fsw_iso9660_dnode **child_dno); static fsw_status_t fsw_iso9660_read_dirrec(struct fsw_iso9660_volume *vol, struct fsw_shandle *shand, struct iso9660_dirrec_buffer *dirrec_buffer); static fsw_status_t fsw_iso9660_readlink(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_string *link); static fsw_status_t rr_find_sp(struct iso9660_dirrec *dirrec, struct fsw_rock_ridge_susp_sp **psp); static fsw_status_t rr_find_nm(struct fsw_iso9660_volume *vol, struct iso9660_dirrec *dirrec, int off, struct fsw_string *str); static fsw_status_t rr_read_ce(struct fsw_iso9660_volume *vol, union fsw_rock_ridge_susp_ce *ce, fsw_u8 *begin); // // Dispatch Table // struct fsw_fstype_table FSW_FSTYPE_TABLE_NAME(iso9660) = { { FSW_STRING_TYPE_ISO88591, 4, 4, "iso9660" }, sizeof(struct fsw_iso9660_volume), sizeof(struct fsw_iso9660_dnode), fsw_iso9660_volume_mount, fsw_iso9660_volume_free, fsw_iso9660_volume_stat, fsw_iso9660_dnode_fill, fsw_iso9660_dnode_free, fsw_iso9660_dnode_stat, fsw_iso9660_get_extent, fsw_iso9660_dir_lookup, fsw_iso9660_dir_read, fsw_iso9660_readlink, }; static fsw_status_t rr_find_sp(struct iso9660_dirrec *dirrec, struct fsw_rock_ridge_susp_sp **psp) { fsw_u8 *r; int off = 0; struct fsw_rock_ridge_susp_sp *sp; r = (fsw_u8 *)((fsw_u8 *)dirrec + sizeof(*dirrec) + dirrec->file_identifier_length); off = (int)(r - (fsw_u8 *)dirrec); while(off < dirrec->dirrec_length) { if (*r == 'S') { sp = (struct fsw_rock_ridge_susp_sp *)r; if( sp->e.sig[0] == 'S' && sp->e.sig[1] == 'P' && sp->magic[0] == 0xbe && sp->magic[1] == 0xef) { *psp = sp; return FSW_SUCCESS; } } r++; off = (int)(r - (fsw_u8 *)dirrec); } *psp = NULL; return FSW_NOT_FOUND; } static fsw_status_t rr_find_nm(struct fsw_iso9660_volume *vol, struct iso9660_dirrec *dirrec, int off, struct fsw_string *str) { fsw_u8 *r, *begin; int fCe = 0; struct fsw_rock_ridge_susp_nm *nm; int limit = dirrec->dirrec_length; begin = (fsw_u8 *)dirrec; r = (fsw_u8 *)dirrec + off; str->data = NULL; str->len = 0; str->size = 0; str->type = 0; while(off < limit) { if (r[0] == 'C' && r[1] == 'E' && r[2] == 28) { int rc; int ce_off; union fsw_rock_ridge_susp_ce *ce; if (fCe == 0) fsw_alloc_zero(ISO9660_BLOCKSIZE, (void *)&begin); fCe = 1; DEBUG((DEBUG_WARN, "%a:%d we found CE before NM or its continuation\n", __FILE__, __LINE__)); ce = (union fsw_rock_ridge_susp_ce *)r; limit = ISOINT(ce->X.len); ce_off = ISOINT(ce->X.offset); rc = rr_read_ce(vol, ce, begin); if (rc != FSW_SUCCESS) { fsw_free(begin); return rc; } begin += ce_off; r = begin; } if (r[0] == 'N' && r[1] == 'M') { nm = (struct fsw_rock_ridge_susp_nm *)r; if( nm->e.sig[0] == 'N' && nm->e.sig[1] == 'M') { int len = 0; fsw_u8 *tmp = NULL; if (nm->flags & RR_NM_CURR) { fsw_memdup(str->data, ".", 1); str->len = 1; goto done; } if (nm->flags & RR_NM_PARE) { fsw_memdup(str->data, "..", 2); str->len = 2; goto done; } len = nm->e.len - sizeof(struct fsw_rock_ridge_susp_nm) + 1; fsw_alloc_zero(str->len + len, (void **)&tmp); if (str->data != NULL) { fsw_memcpy(tmp, str->data, str->len); fsw_free(str->data); } DEBUG((DEBUG_INFO, "dst:%p src:%p len:%d\n", tmp + str->len, &nm->name[0], len)); fsw_memcpy(tmp + str->len, &nm->name[0], len); str->data = tmp; str->len += len; if ((nm->flags & RR_NM_CONT) == 0) goto done; } } r++; off = (int)(r - (fsw_u8 *)begin); } if(fCe == 1) fsw_free(begin); return FSW_NOT_FOUND; done: str->type = FSW_STRING_TYPE_ISO88591; str->size = str->len; if(fCe == 1) fsw_free(begin); return FSW_SUCCESS; } static fsw_status_t rr_read_ce(struct fsw_iso9660_volume *vol, union fsw_rock_ridge_susp_ce *ce, fsw_u8 *begin) { int rc; rc = vol->g.host_table->read_block(&vol->g, ISOINT(ce->X.block_loc), begin); if (rc != FSW_SUCCESS) return rc; return FSW_SUCCESS; } /** * Mount an ISO9660 volume. Reads the superblock and constructs the * root directory dnode. */ static fsw_status_t fsw_iso9660_volume_mount(struct fsw_iso9660_volume *vol) { fsw_status_t status; void *buffer; fsw_u32 blockno; struct iso9660_volume_descriptor *voldesc; struct iso9660_primary_volume_descriptor *pvoldesc; fsw_u32 voldesc_type; int i; struct fsw_string s; struct iso9660_dirrec rootdir; int sua_pos; char *sig; int skip; struct fsw_rock_ridge_susp_entry *entry; // read through the Volume Descriptor Set fsw_set_blocksize(vol, ISO9660_BLOCKSIZE, ISO9660_BLOCKSIZE); blockno = ISO9660_SUPERBLOCK_BLOCKNO; do { status = fsw_block_get(vol, blockno, 0, &buffer); if (status) return status; voldesc = (struct iso9660_volume_descriptor *)buffer; voldesc_type = voldesc->volume_descriptor_type; if (fsw_memeq(voldesc->standard_identifier, "CD001", 5)) { // descriptor follows ISO 9660 standard if (voldesc_type == 1 && voldesc->volume_descriptor_version == 1) { // suitable Primary Volume Descriptor found if (vol->primary_voldesc) { fsw_free(vol->primary_voldesc); vol->primary_voldesc = NULL; } status = fsw_memdup((void **)&vol->primary_voldesc, voldesc, ISO9660_BLOCKSIZE); } } else if (!fsw_memeq(voldesc->standard_identifier, "CD", 2)) { // completely alien standard identifier, stop reading voldesc_type = 255; } fsw_block_release(vol, blockno, buffer); blockno++; } while (!status && voldesc_type != 255); if (status) return status; // get information from Primary Volume Descriptor if (vol->primary_voldesc == NULL) return FSW_UNSUPPORTED; pvoldesc = vol->primary_voldesc; if (ISOINT(pvoldesc->logical_block_size) != 2048) return FSW_UNSUPPORTED; // get volume name for (i = 32; i > 0; i--) if (pvoldesc->volume_identifier[i-1] != ' ') break; s.type = FSW_STRING_TYPE_ISO88591; s.size = s.len = i; s.data = pvoldesc->volume_identifier; status = fsw_strdup_coerce(&vol->g.label, vol->g.host_string_type, &s); if (status) return status; // setup the root dnode status = fsw_dnode_create_root(vol, ISO9660_SUPERBLOCK_BLOCKNO << ISO9660_BLOCKSIZE_BITS, &vol->g.root); if (status) return status; fsw_memcpy(&vol->g.root->dirrec, &pvoldesc->root_directory, sizeof(struct iso9660_dirrec)); if ( pvoldesc->escape[0] == 0x25 && pvoldesc->escape[1] == 0x2f && ( pvoldesc->escape[2] == 0x40 || pvoldesc->escape[2] == 0x43 || pvoldesc->escape[2] == 0x45)) { FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: success (joliet!!!)\n"))); vol->fJoliet = 1; } fsw_memcpy(&rootdir, &pvoldesc->root_directory, sizeof(rootdir)); sua_pos = (sizeof(struct iso9660_dirrec)) + rootdir.file_identifier_length + (rootdir.file_identifier_length % 2) - 2; //int sua_size = rootdir.dirrec_length - rootdir.file_identifier_length; //FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: success (SUA(pos:%x, sz:%d)!!!)\n"), sua_pos, sua_size)); #if 1 status = fsw_block_get(vol, ISOINT(rootdir.extent_location), 0, &buffer); sig = (char *)buffer + sua_pos; skip = 0; entry = (struct fsw_rock_ridge_susp_entry *)sig; if ( entry->sig[0] == 'S' && entry->sig[1] == 'P') { struct fsw_rock_ridge_susp_sp *sp = (struct fsw_rock_ridge_susp_sp *)entry; if (sp->magic[0] == 0xbe && sp->magic[1] == 0xef) { vol->fRockRidge = 1; } else { FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: SP magic isn't valid\n"))); } skip = sp->skip; } #endif // release volume descriptors fsw_free(vol->primary_voldesc); vol->primary_voldesc = NULL; FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: success\n"))); return FSW_SUCCESS; } /** * Free the volume data structure. Called by the core after an unmount or after * an unsuccessful mount to release the memory used by the file system type specific * part of the volume structure. */ static void fsw_iso9660_volume_free(struct fsw_iso9660_volume *vol) { if (vol->primary_voldesc) fsw_free(vol->primary_voldesc); } /** * Get in-depth information on a volume. */ static fsw_status_t fsw_iso9660_volume_stat(struct fsw_iso9660_volume *vol, struct fsw_volume_stat *sb) { sb->total_bytes = 0; //(fsw_u64)vol->sb->s_blocks_count * vol->g.log_blocksize; sb->free_bytes = 0; return FSW_SUCCESS; } /** * Get full information on a dnode from disk. This function is called by the core * whenever it needs to access fields in the dnode structure that may not * be filled immediately upon creation of the dnode. In the case of iso9660, we * delay fetching of the inode structure until dnode_fill is called. The size and * type fields are invalid until this function has been called. */ static fsw_status_t fsw_iso9660_dnode_fill(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno) { // get info from the directory record dno->g.size = ISOINT(dno->dirrec.data_length); if (dno->dirrec.file_flags & 0x02) dno->g.type = FSW_DNODE_TYPE_DIR; else dno->g.type = FSW_DNODE_TYPE_FILE; return FSW_SUCCESS; } /** * Free the dnode data structure. Called by the core when deallocating a dnode * structure to release the memory used by the file system type specific part * of the dnode structure. */ static void fsw_iso9660_dnode_free(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno) { } /** * Get in-depth information on a dnode. The core makes sure that fsw_iso9660_dnode_fill * has been called on the dnode before this function is called. Note that some * data is not directly stored into the structure, but passed to a host-specific * callback that converts it to the host-specific format. */ static fsw_status_t fsw_iso9660_dnode_stat(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_dnode_stat *sb) { sb->used_bytes = (dno->g.size + (ISO9660_BLOCKSIZE-1)) & ~(ISO9660_BLOCKSIZE-1); /* sb->store_time_posix(sb, FSW_DNODE_STAT_CTIME, dno->raw->i_ctime); sb->store_time_posix(sb, FSW_DNODE_STAT_ATIME, dno->raw->i_atime); sb->store_time_posix(sb, FSW_DNODE_STAT_MTIME, dno->raw->i_mtime); sb->store_attr_posix(sb, dno->raw->i_mode); */ return FSW_SUCCESS; } /** * Retrieve file data mapping information. This function is called by the core when * fsw_shandle_read needs to know where on the disk the required piece of the file's * data can be found. The core makes sure that fsw_iso9660_dnode_fill has been called * on the dnode before. Our task here is to get the physical disk block number for * the requested logical block number. */ static fsw_status_t fsw_iso9660_get_extent(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_extent *extent) { // Preconditions: The caller has checked that the requested logical block // is within the file's size. The dnode has complete information, i.e. // fsw_iso9660_dnode_read_info was called successfully on it. extent->type = FSW_EXTENT_TYPE_PHYSBLOCK; extent->phys_start = ISOINT(dno->dirrec.extent_location); extent->log_start = 0; extent->log_count = (ISOINT(dno->dirrec.data_length) + (ISO9660_BLOCKSIZE-1)) >> ISO9660_BLOCKSIZE_BITS; return FSW_SUCCESS; } /** * Lookup a directory's child dnode by name. This function is called on a directory * to retrieve the directory entry with the given name. A dnode is constructed for * this entry and returned. The core makes sure that fsw_iso9660_dnode_fill has been called * and the dnode is actually a directory. */ static fsw_status_t fsw_iso9660_dir_lookup(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_string *lookup_name, struct fsw_iso9660_dnode **child_dno_out) { fsw_status_t status; struct fsw_shandle shand; struct iso9660_dirrec_buffer dirrec_buffer; struct iso9660_dirrec *dirrec = &dirrec_buffer.dirrec; // Preconditions: The caller has checked that dno is a directory node. // setup handle to read the directory status = fsw_shandle_open(dno, &shand); if (status) return status; // scan the directory for the file while (1) { // read next entry status = fsw_iso9660_read_dirrec(vol, &shand, &dirrec_buffer); if (status) goto errorexit; if (dirrec->dirrec_length == 0) { // end of directory reached status = FSW_NOT_FOUND; goto errorexit; } // skip . and .. if (dirrec->file_identifier_length == 1 && (dirrec->file_identifier[0] == 0 || dirrec->file_identifier[0] == 1)) continue; // compare name if (fsw_streq(lookup_name, &dirrec_buffer.name)) /// @todo compare case-insensitively break; } // setup a dnode for the child item status = fsw_dnode_create(dno, dirrec_buffer.ino, FSW_DNODE_TYPE_UNKNOWN, &dirrec_buffer.name, child_dno_out); if (status == FSW_SUCCESS) fsw_memcpy(&(*child_dno_out)->dirrec, dirrec, sizeof(struct iso9660_dirrec)); errorexit: fsw_shandle_close(&shand); return status; } /** * Get the next directory entry when reading a directory. This function is called during * directory iteration to retrieve the next directory entry. A dnode is constructed for * the entry and returned. The core makes sure that fsw_iso9660_dnode_fill has been called * and the dnode is actually a directory. The shandle provided by the caller is used to * record the position in the directory between calls. */ static fsw_status_t fsw_iso9660_dir_read(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_shandle *shand, struct fsw_iso9660_dnode **child_dno_out) { fsw_status_t status; struct iso9660_dirrec_buffer dirrec_buffer; struct iso9660_dirrec *dirrec = &dirrec_buffer.dirrec; // Preconditions: The caller has checked that dno is a directory node. The caller // has opened a storage handle to the directory's storage and keeps it around between // calls. /* (vasily) directory nodes are 4096 bytes that is two logical blocks so read dir operation * should read both blocks. */ while (1) { // read next entry if (shand->pos >= dno->g.size) return FSW_NOT_FOUND; // end of directory status = fsw_iso9660_read_dirrec(vol, shand, &dirrec_buffer); if (status) return status; if (dirrec->dirrec_length == 0) { // try the next block shand->pos =(shand->pos & ~(vol->g.log_blocksize - 1)) + vol->g.log_blocksize; continue; } // skip . and .. if (dirrec->file_identifier_length == 1 && (dirrec->file_identifier[0] == 0 || dirrec->file_identifier[0] == 1)) continue; break; } // setup a dnode for the child item status = fsw_dnode_create(dno, dirrec_buffer.ino, FSW_DNODE_TYPE_UNKNOWN, &dirrec_buffer.name, child_dno_out); if (status == FSW_SUCCESS) fsw_memcpy(&(*child_dno_out)->dirrec, dirrec, sizeof(struct iso9660_dirrec)); return status; } /** * Read a directory entry from the directory's raw data. This internal function is used * to read a raw iso9660 directory entry into memory. The shandle's position pointer is adjusted * to point to the next entry. */ static fsw_status_t fsw_iso9660_read_dirrec(struct fsw_iso9660_volume *vol, struct fsw_shandle *shand, struct iso9660_dirrec_buffer *dirrec_buffer) { fsw_status_t status; fsw_u32 i, buffer_size, remaining_size, name_len; struct fsw_rock_ridge_susp_sp *sp = NULL; struct iso9660_dirrec *dirrec = &dirrec_buffer->dirrec; int rc; dirrec_buffer->ino = (ISOINT(((struct fsw_iso9660_dnode *)shand->dnode)->dirrec.extent_location) << ISO9660_BLOCKSIZE_BITS) + (fsw_u32)shand->pos; // read fixed size part of directory record buffer_size = 33; status = fsw_shandle_read(shand, &buffer_size, dirrec); if (status) { DEBUG((DEBUG_INFO, "%a:%d \n", __FILE__, __LINE__)); return status; } if (buffer_size < 33 || dirrec->dirrec_length == 0) { // end of directory reached fsw_u8 *r; r = (fsw_u8 *)dirrec; DEBUG((DEBUG_INFO, "%a:%d bs:%d dl:%d\n", __FILE__, __LINE__, buffer_size, dirrec->dirrec_length)); for(i = 0; i < buffer_size; ++i) { DEBUG((DEBUG_INFO, "r[%d]:%c", i, r[i])); } dirrec->dirrec_length = 0; return FSW_SUCCESS; } if (dirrec->dirrec_length < 33 || dirrec->dirrec_length < 33 + dirrec->file_identifier_length) return FSW_VOLUME_CORRUPTED; DEBUG((DEBUG_INFO, "%a:%d, dirrec_length: %d\n", __FILE__, __LINE__, dirrec->dirrec_length)); // read variable size part of directory record buffer_size = remaining_size = dirrec->dirrec_length - 33; status = fsw_shandle_read(shand, &buffer_size, dirrec->file_identifier); if (status) return status; if (buffer_size < remaining_size) return FSW_VOLUME_CORRUPTED; if (vol->fRockRidge) { UINTN sp_off = sizeof(*dirrec) + dirrec->file_identifier_length; rc = rr_find_sp(dirrec, &sp); if ( rc == FSW_SUCCESS && sp != NULL) { sp_off = (fsw_u8 *)&sp[1] - (fsw_u8 *)dirrec + sp->skip; } rc = rr_find_nm(vol, dirrec, (int)sp_off, &dirrec_buffer->name); if (rc == FSW_SUCCESS) return FSW_SUCCESS; } // setup name name_len = dirrec->file_identifier_length; for (i = name_len - 1; i > 0; i--) { if (dirrec->file_identifier[i] == ';') { name_len = i; // cut the ISO9660 version number off break; } } if (name_len > 0 && dirrec->file_identifier[name_len-1] == '.') name_len--; // also cut the extension separator if the extension is empty dirrec_buffer->name.type = FSW_STRING_TYPE_ISO88591; dirrec_buffer->name.len = dirrec_buffer->name.size = name_len; dirrec_buffer->name.data = dirrec->file_identifier; DEBUG((DEBUG_INFO, "%a:%d: dirrec_buffer->name.data:%a\n", __FILE__, __LINE__, dirrec_buffer->name.data)); return FSW_SUCCESS; } /** * Get the target path of a symbolic link. This function is called when a symbolic * link needs to be resolved. The core makes sure that the fsw_iso9660_dnode_fill has been * called on the dnode and that it really is a symlink. * * For iso9660, the target path can be stored inline in the inode structure (in the space * otherwise occupied by the block pointers) or in the inode's data. There is no flag * indicating this, only the number of blocks entry (i_blocks) can be used as an * indication. The check used here comes from the Linux kernel. */ static fsw_status_t fsw_iso9660_readlink(struct fsw_iso9660_volume *vol, struct fsw_iso9660_dnode *dno, struct fsw_string *link_target) { fsw_status_t status; if (dno->g.size > FSW_PATH_MAX) return FSW_VOLUME_CORRUPTED; status = fsw_dnode_readlink_data(dno, link_target); return status; } // EOF