/** * ntfs_dir.c - devoptab directory routines for NTFS-based devices. * * Copyright (c) 2010 Dimok * Copyright (c) 2009 Rhys "Shareese" Koedijk * Copyright (c) 2006 Michael "Chishm" Chisholm * * This program/include file 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/include file 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef HAVE_STDLIB_H #include <stdlib.h> #endif #ifdef HAVE_SYS_STATVFS_H #include <sys/statvfs.h> #endif #ifdef HAVE_SYS_STAT_H #include <sys/stat.h> #endif #ifdef HAVE_ERRNO_H #include <errno.h> #endif #ifdef HAVE_STRING_H #include <string.h> #endif #include "ntfsinternal.h" #include "ntfsdir.h" #include "device.h" #include <sys/dir.h> #define STATE(x) ((ntfs_dir_state*)(x)->dirStruct) void ntfsCloseDir (ntfs_dir_state *dir) { // Sanity check if (!dir || !dir->vd) return; // Free the directory entries (if any) while (dir->first) { ntfs_dir_entry *next = dir->first->next; ntfs_free(dir->first->name); ntfs_free(dir->first); dir->first = next; } // Close the directory (if open) if (dir->ni) ntfsCloseEntry(dir->vd, dir->ni); // Reset the directory state dir->ni = NULL; dir->first = NULL; dir->current = NULL; return; } int ntfs_stat_r (struct _reent *r, const char *path, struct stat *st) { // Short circuit cases were we don't actually have to do anything if (!st || !path) return 0; ntfs_log_trace("path %s, st %p\n", path, st); ntfs_vd *vd = NULL; ntfs_inode *ni = NULL; // Get the volume descriptor for this path vd = ntfsGetVolume(path); if (!vd) { r->_errno = ENODEV; return -1; } if(strcmp(path, ".") == 0 || strcmp(path, "..") == 0) { memset(st, 0, sizeof(struct stat)); st->st_mode = S_IFDIR; return 0; } // Lock ntfsLock(vd); // Find the entry ni = ntfsOpenEntry(vd, path); if (!ni) { r->_errno = errno; ntfsUnlock(vd); return -1; } // Get the entry stats int ret = ntfsStat(vd, ni, st); if (ret) r->_errno = errno; // Close the entry ntfsCloseEntry(vd, ni); ntfsUnlock(vd); return 0; } int ntfs_link_r (struct _reent *r, const char *existing, const char *newLink) { ntfs_log_trace("existing %s, newLink %s\n", existing, newLink); ntfs_vd *vd = NULL; ntfs_inode *ni = NULL; // Get the volume descriptor for this path vd = ntfsGetVolume(existing); if (!vd) { r->_errno = ENODEV; return -1; } // Lock ntfsLock(vd); // Create a symbolic link between the two paths ni = ntfsCreate(vd, existing, S_IFLNK, newLink); if (!ni) { ntfsUnlock(vd); r->_errno = errno; return -1; } // Close the symbolic link ntfsCloseEntry(vd, ni); // Unlock ntfsUnlock(vd); return 0; } int ntfs_unlink_r (struct _reent *r, const char *name) { ntfs_log_trace("name %s\n", name); // Unlink the entry int ret = ntfsUnlink(ntfsGetVolume(name), name); if (ret) r->_errno = errno; return ret; } int ntfs_chdir_r (struct _reent *r, const char *name) { ntfs_log_trace("name %s\n", name); ntfs_vd *vd = NULL; ntfs_inode *ni = NULL; // Get the volume descriptor for this path vd = ntfsGetVolume(name); if (!vd) { r->_errno = ENODEV; return -1; } // Lock ntfsLock(vd); // Find the directory ni = ntfsOpenEntry(vd, name); if (!ni) { ntfsUnlock(vd); r->_errno = ENOENT; return -1; } // Ensure that this directory is indeed a directory if (!(ni->mrec->flags && MFT_RECORD_IS_DIRECTORY)) { ntfsCloseEntry(vd, ni); ntfsUnlock(vd); r->_errno = ENOTDIR; return -1; } // Close the old current directory (if any) if (vd->cwd_ni) ntfsCloseEntry(vd, vd->cwd_ni); // Set the new current directory vd->cwd_ni = ni; // Unlock ntfsUnlock(vd); return 0; } int ntfs_rename_r (struct _reent *r, const char *oldName, const char *newName) { ntfs_log_trace("oldName %s, newName %s\n", oldName, newName); ntfs_vd *vd = NULL; ntfs_inode *ni = NULL; // Get the volume descriptor for this path vd = ntfsGetVolume(oldName); if (!vd) { r->_errno = ENODEV; return -1; } // Lock ntfsLock(vd); // You cannot rename between devices if(vd != ntfsGetVolume(newName)) { ntfsUnlock(vd); r->_errno = EXDEV; return -1; } // Check that there is no existing entry with the new name ni = ntfsOpenEntry(vd, newName); if (ni) { ntfsCloseEntry(vd, ni); ntfsUnlock(vd); r->_errno = EEXIST; return -1; } // Link the old entry with the new one if (ntfsLink(vd, oldName, newName)) { ntfsUnlock(vd); return -1; } // Unlink the old entry if (ntfsUnlink(vd, oldName)) { if (ntfsUnlink(vd, newName)) { ntfsUnlock(vd); return -1; } ntfsUnlock(vd); return -1; } // Unlock ntfsUnlock(vd); return 0; } int ntfs_mkdir_r (struct _reent *r, const char *path, int mode) { ntfs_log_trace("path %s, mode %i\n", path, mode); ntfs_vd *vd = NULL; ntfs_inode *ni = NULL; // Get the volume descriptor for this path vd = ntfsGetVolume(path); if (!vd) { r->_errno = ENODEV; return -1; } // Lock ntfsLock(vd); // Create the directory ni = ntfsCreate(vd, path, S_IFDIR, NULL); if (!ni) { ntfsUnlock(vd); r->_errno = errno; return -1; } // Close the directory ntfsCloseEntry(vd, ni); // Unlock ntfsUnlock(vd); return 0; } int ntfs_statvfs_r (struct _reent *r, const char *path, struct statvfs *buf) { ntfs_log_trace("path %s, buf %p\n", path, buf); ntfs_vd *vd = NULL; s64 size; int delta_bits; // Get the volume descriptor for this path vd = ntfsGetVolume(path); if (!vd) { r->_errno = ENODEV; return -1; } // Short circuit cases were we don't actually have to do anything if (!buf) return 0; // Lock ntfsLock(vd); // Zero out the stat buffer memset(buf, 0, sizeof(struct statvfs)); if(ntfs_volume_get_free_space(vd->vol) < 0) { ntfsUnlock(vd); return -1; } // File system block size buf->f_bsize = vd->vol->cluster_size; // Fundamental file system block size buf->f_frsize = vd->vol->cluster_size; // Total number of blocks on file system in units of f_frsize buf->f_blocks = vd->vol->nr_clusters; // Free blocks available for all and for non-privileged processes size = MAX(vd->vol->free_clusters, 0); buf->f_bfree = buf->f_bavail = size; // Free inodes on the free space delta_bits = vd->vol->cluster_size_bits - vd->vol->mft_record_size_bits; if (delta_bits >= 0) size <<= delta_bits; else size >>= -delta_bits; // Number of inodes at this point in time buf->f_files = (vd->vol->mftbmp_na->allocated_size << 3) + size; // Free inodes available for all and for non-privileged processes size += vd->vol->free_mft_records; buf->f_ffree = buf->f_favail = MAX(size, 0); // File system id buf->f_fsid = vd->id; // Bit mask of f_flag values. buf->f_flag = (NVolReadOnly(vd->vol) ? ST_RDONLY : 0); // Maximum length of filenames buf->f_namemax = NTFS_MAX_NAME_LEN; // Unlock ntfsUnlock(vd); return 0; } /** * PRIVATE: Callback for directory walking */ int ntfs_readdir_filler (DIR_ITER *dirState, const ntfschar *name, const int name_len, const int name_type, const s64 pos, const MFT_REF mref, const unsigned dt_type) { ntfs_dir_state *dir = STATE(dirState); ntfs_dir_entry *entry = NULL; char *entry_name = NULL; // Sanity check if (!dir || !dir->vd) { errno = EINVAL; return -1; } // Ignore DOS file names if (name_type == FILE_NAME_DOS) { return 0; } // Preliminary check that this entry can be enumerated (as described by the volume descriptor) if (MREF(mref) == FILE_root || MREF(mref) >= FILE_first_user || dir->vd->showSystemFiles) { // Convert the entry name to our current local if (ntfsUnicodeToLocal(name, name_len, &entry_name, 0) < 0) { return -1; } if(dir->first && dir->first->mref == FILE_root && MREF(mref) == FILE_root && strcmp(entry_name, "..") == 0) { return 0; } // If this is not the parent or self directory reference if ((strcmp(entry_name, ".") != 0) && (strcmp(entry_name, "..") != 0)) { // Open the entry ntfs_inode *ni = ntfs_pathname_to_inode(dir->vd->vol, dir->ni, entry_name); if (!ni) return -1; // Double check that this entry can be emuerated (as described by the volume descriptor) if (((ni->flags & FILE_ATTR_HIDDEN) && !dir->vd->showHiddenFiles) || ((ni->flags & FILE_ATTR_SYSTEM) && !dir->vd->showSystemFiles)) { ntfs_inode_close(ni); return 0; } // Close the entry ntfs_inode_close(ni); } // Allocate a new directory entry entry = (ntfs_dir_entry *) ntfs_alloc(sizeof(ntfs_dir_entry)); if (!entry) return -1; // Setup the entry entry->name = entry_name; entry->next = NULL; entry->mref = MREF(mref); // Link the entry to the directory if (!dir->first) { dir->first = entry; } else { ntfs_dir_entry *last = dir->first; while (last->next) last = last->next; last->next = entry; } } return 0; } DIR_ITER *ntfs_diropen_r (struct _reent *r, DIR_ITER *dirState, const char *path) { ntfs_log_trace("dirState %p, path %s\n", dirState, path); ntfs_dir_state* dir = STATE(dirState); s64 position = 0; // Get the volume descriptor for this path dir->vd = ntfsGetVolume(path); if (!dir->vd) { r->_errno = ENODEV; return NULL; } // Lock ntfsLock(dir->vd); // Find the directory dir->ni = ntfsOpenEntry(dir->vd, path); if (!dir->ni) { ntfsUnlock(dir->vd); r->_errno = ENOENT; return NULL; } // Ensure that this directory is indeed a directory if (!(dir->ni->mrec->flags && MFT_RECORD_IS_DIRECTORY)) { ntfsCloseEntry(dir->vd, dir->ni); ntfsUnlock(dir->vd); r->_errno = ENOTDIR; return NULL; } // Read the directory dir->first = dir->current = NULL; if (ntfs_readdir(dir->ni, &position, dirState, (ntfs_filldir_t)ntfs_readdir_filler)) { ntfsCloseDir(dir); ntfsUnlock(dir->vd); r->_errno = errno; return NULL; } // Move to the first entry in the directory dir->current = dir->first; // Update directory times ntfsUpdateTimes(dir->vd, dir->ni, NTFS_UPDATE_ATIME); // Insert the directory into the double-linked FILO list of open directories if (dir->vd->firstOpenDir) { dir->nextOpenDir = dir->vd->firstOpenDir; dir->vd->firstOpenDir->prevOpenDir = dir; } else { dir->nextOpenDir = NULL; } dir->prevOpenDir = NULL; dir->vd->cwd_ni = dir->ni; dir->vd->firstOpenDir = dir; dir->vd->openDirCount++; // Unlock ntfsUnlock(dir->vd); return dirState; } int ntfs_dirreset_r (struct _reent *r, DIR_ITER *dirState) { ntfs_log_trace("dirState %p\n", dirState); ntfs_dir_state* dir = STATE(dirState); // Sanity check if (!dir || !dir->vd || !dir->ni) { r->_errno = EBADF; return -1; } // Lock ntfsLock(dir->vd); // Move to the first entry in the directory dir->current = dir->first; // Update directory times ntfsUpdateTimes(dir->vd, dir->ni, NTFS_UPDATE_ATIME); // Unlock ntfsUnlock(dir->vd); return 0; } int ntfs_dirnext_r (struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *filestat) { ntfs_log_trace("dirState %p, filename %p, filestat %p\n", dirState, filename, filestat); ntfs_dir_state* dir = STATE(dirState); ntfs_inode *ni = NULL; // Sanity check if (!dir || !dir->vd || !dir->ni) { r->_errno = EBADF; return -1; } // Lock ntfsLock(dir->vd); // Check that there is a entry waiting to be fetched if (!dir->current) { ntfsUnlock(dir->vd); r->_errno = ENOENT; return -1; } // Fetch the current entry strcpy(filename, dir->current->name); if(filestat != NULL) { if(strcmp(dir->current->name, ".") == 0 || strcmp(dir->current->name, "..") == 0) { memset(filestat, 0, sizeof(struct stat)); filestat->st_mode = S_IFDIR; } else { ni = ntfsOpenEntry(dir->vd, dir->current->name); if (ni) { ntfsStat(dir->vd, ni, filestat); ntfsCloseEntry(dir->vd, ni); } } } // Move to the next entry in the directory dir->current = dir->current->next; // Update directory times ntfsUpdateTimes(dir->vd, dir->ni, NTFS_UPDATE_ATIME); // Unlock ntfsUnlock(dir->vd); return 0; } int ntfs_dirclose_r (struct _reent *r, DIR_ITER *dirState) { ntfs_log_trace("dirState %p\n", dirState); ntfs_dir_state* dir = STATE(dirState); // Sanity check if (!dir || !dir->vd) { r->_errno = EBADF; return -1; } // Lock ntfsLock(dir->vd); // Close the directory ntfsCloseDir(dir); // Remove the directory from the double-linked FILO list of open directories dir->vd->openDirCount--; if (dir->nextOpenDir) dir->nextOpenDir->prevOpenDir = dir->prevOpenDir; if (dir->prevOpenDir) dir->prevOpenDir->nextOpenDir = dir->nextOpenDir; else dir->vd->firstOpenDir = dir->nextOpenDir; // Unlock ntfsUnlock(dir->vd); return 0; }