/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
char leaf_name[NAME_MAX + 1];
if (!dir_get_leaf_name (name, leaf_name))
return false;
struct dir *parent_dir = dir_get_parent_dir (name);
if (parent_dir == NULL)
return false;
struct inode *inode;
if (!dir_lookup (parent_dir, leaf_name, &inode))
{
dir_close (parent_dir);
return false;
}
bool success;
if (!inode_is_dir(inode)) // if is file
success = dir_remove (parent_dir, leaf_name);
else
{
if (dir_is_empty (inode))
{
success = dir_remove (parent_dir, leaf_name);
}
else
success = false;
}
dir_close (parent_dir);
return success;
}
bool system::dir_remove(const string& path, const bool recursive)
{
if(recursive)
{
DIR* dir = NULL;
struct dirent* entry = NULL;
if(!(dir = opendir(path())))
return false;
while((entry = readdir(dir)))
{
if(strcmp(entry->d_name, ".") && strcmp(entry->d_name, ".."))
{
string rempath(path + (strcmp(path(-1), "/") ? "/" : "") + entry->d_name);
if(entry->d_type == DT_DIR)
if(!dir_remove(rempath, true))
break;
if(remove(rempath()) == -1)
if(errno != ENOENT && errno != ENOTDIR)
break;
}
}
closedir(dir);
}
return !rmdir(path());
}
/*
* Removes a directory entry.
*/
PUBLIC int sys_unlink(const char *path)
{
int ret; /* Return value. */
struct inode *dir; /* Working directory. */
const char *filename; /* Working file name. */
char *pathname; /* Path name. */
pathname = getname(path);
dir = inode_dname(pathname, &filename);
/* Failed to get directory. */
if (dir == NULL)
{
putname(pathname);
return (-ENOENT);
}
/* No write permissions on directory. */
if (!permission(dir->mode, dir->uid, dir->gid, curr_proc, MAY_WRITE, 0))
{
inode_put(dir);
putname(pathname);
return (-EPERM);
}
ret = dir_remove(dir, filename);
inode_put(dir);
putname(pathname);
return (ret);
}
/*! Deletes the file named NAME. Returns true if successful, false on failure.
Fails if no file named NAME exists, or if an internal memory allocation
fails. */
bool filesys_remove(const char *name) {
struct dir *dir = dir_open_root();
bool success = dir != NULL && dir_remove(dir, name);
dir_close(dir);
return success;
}
void MemoryRelease(U16 handle)
{
switch (handletable[handle].Nowhere.stored_at)
{
case NOWHERE: // MemoryRelease
break;
case MEMORY: // MemoryRelease
free(handletable[handle].Linearmem.memory);
handletable[handle].Linearmem.memory = nullptr;
handletable[handle].Linearmem.size = 0;
handletable[handle].Linearmem.stored_at = NOWHERE;
numTOTALhandles--;
break;
case DISK: // MemoryRelease
memfile[9] = (char)(handle % 10 + (int)'0');
memfile[8] = (char)((handle % 100) / 10 + (int)'0');
memfile[7] = (char)((handle % 1000) / 100 + (int)'0');
fclose(handletable[handle].Disk.file);
dir_remove(tempdir, memfile);
handletable[handle].Disk.file = nullptr;
handletable[handle].Disk.size = 0;
handletable[handle].Disk.stored_at = NOWHERE;
numTOTALhandles--;
break;
} // end of switch
}
static void dir_remove(struct dir_info *dir)
{
char *path;
/* Remove directory contents */
while (dir->first) {
struct dir_entry_info *entry;
entry = dir->first;
if (entry->type == 'd')
dir_remove(entry->entry.dir);
else if (entry->type == 'f')
file_unlink(entry);
else if (entry->type == 's')
symlink_remove(entry->entry.symlink);
else
CHECK(0); /* Invalid struct dir_entry_info */
}
/* Remove entry from parent directory */
remove_dir_entry(dir->entry);
/* Remove directory itself */
path = dir_path(dir->parent, dir->name);
CHECK(rmdir(path) != -1);
free(dir);
}
int dir_remove(const char *path)
{
assert(path);
struct stat st;
if (stat(path, &st)) {
return (-1);
}
if (!S_ISDIR(st.st_mode)) {
return (unlink(path));
}
DIR *dir;
if (!(dir = opendir(path))) {
return (-1);
}
struct dirent *saveptr;
struct dirent ent;
char *buf;
int ret = 0;
/* Please see details here: https://lwn.net/Articles/696474/ */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
while (!readdir_r(dir, &ent, &saveptr) && saveptr) {
#pragma GCC diagnostic pop
if (!strcmp(ent.d_name, ".") || !strcmp(ent.d_name, "..")) {
continue;
}
if (-1 == asprintf(&buf, "%s/%s", path, ent.d_name)) {
errno = ENOMEM;
ret = -1;
break;
}
if (dir_remove(buf)) {
ret = -1;
}
free(buf);
}
closedir(dir);
if (rmdir(path)) {
ret = -1;
}
return (ret);
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
struct dir *dir = containing_dir(name);
char* file_name = get_name(name);
bool success = dir != NULL && dir_remove (dir, file_name);
dir_close (dir);
free(file_name);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *path)
{
char *name = get_filename (path);
struct dir *dir = dir_get (path);
bool success = dir != NULL && dir_remove (dir, name);
dir_close (dir);
free (name);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
// struct dir *dir = dir_open_root ();
struct dir* dir = get_containing_dir (name);
char* filename = get_filename(name);
bool success = dir != NULL && dir_remove (dir, filename);
dir_close (dir);
free (filename);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
char * parse = parse_filename (name);
//get the correct dir
struct dir *dir = dir_lookup_rec (parse);
bool success = dir != NULL && dir_remove (dir, parse);
dir_close (dir);
return success;
}
int mwDirectory_destroy(struct mwDirectory *dir) {
int ret = 0;
g_return_val_if_fail(dir != NULL, -1);
if(MW_DIRECTORY_IS_OPEN(dir) || MW_DIRECTORY_IS_PENDING(dir)) {
ret = dir_close(dir);
}
dir_remove(dir);
return ret;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
struct thread *cur = thread_current();
struct dir *dir;
if(cur->current_directory == NULL)
dir = dir_open_root ();
else
dir = dir_open_current();
bool success = dir != NULL && dir_remove (dir, name);
dir_close (dir);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
// XXX lock_acquire();
lock_acquire(lock);
// XXX
struct dir *dir = dir_open_root ();
bool success = dir != NULL && dir_remove (dir, name);
dir_close (dir);
// XXX lock_release();
lock_release(lock);
// XXX
return success;
}
/* Creates a file named NAME with the given INITIAL_SIZE.*/
bool
filesys_create (const char *name, off_t initial_size, bool isdir)
{
if (strlen(name) == 0) return false;
block_sector_t inode_sector = 0;
struct dir *dir_ = filesys_get_dir(name);
char *name_ = filesys_get_name(name);
bool success = false;
if (strcmp (name_, "") == 0) goto done;
success = (dir_ && free_map_allocate (1, &inode_sector)
&& inode_create (inode_sector, initial_size)
&& dir_add (dir_, name_, inode_sector, isdir));
struct inode *ninode = NULL;
struct dir *ndir = NULL;
bool success1 = true;
if (success && isdir){
success1 = ((ninode = inode_open (inode_sector))
&& (ndir = dir_open (ninode))
&& dir_add (ndir, ".", inode_sector, true)
&& dir_add (ndir, "..",inode_get_inumber (dir_get_inode (dir_)), true));
}
if (inode_sector != 0 && !success)
free_map_release (inode_sector, 1);
if (success && !success1) {
success = false;
printf("Failure: create dir: %s\n", name);
dir_remove (dir_, name_);
}
done:
dir_close (dir_);
free(name_);
if (!ndir && ninode){
inode_close(ninode);
} else if (ndir) {
dir_close(ndir);
}
return success;
}
/* Deletes the file named NAME. */
bool
filesys_remove (const char *name)
{
bool result = false;
if (strlen(name) == 0){
return false;
} else {
struct dir* dir_ = filesys_get_dir(name);
char* name_ = filesys_get_name(name);
if (strlen(name_) != 0) {
result = dir_ != NULL && dir_remove (dir_, name_);
}
dir_close (dir_);
free(name_);
return result;
}
}
/* Randomly select something to do with a directory entry */
static void operate_on_entry(struct dir_entry_info *entry)
{
/* If shrinking, 1 time in 50, remove a directory */
if (entry->type == 'd') {
if (shrink && tests_random_no(50) == 0) {
dir_remove(entry->entry.dir);
return;
}
operate_on_dir(entry->entry.dir);
}
/* If shrinking, 1 time in 10, remove a file */
if (entry->type == 'f') {
if (shrink && tests_random_no(10) == 0) {
file_delete(entry->entry.file);
return;
}
operate_on_file(entry->entry.file);
}
}
bool Desktop::remove_icon(DesktopIcon *di, bool real_delete) {
bool ret = true;
if(real_delete) {
if(di->get_icon_type() == DESKTOP_ICON_TYPE_FOLDER) {
if(!dir_empty(di->get_path())) {
alert(_("This folder is not empty. Recursive removal of not empty folders is not yet supported"));
return false;
}
ret = dir_remove(di->get_path());
} else {
ret = file_remove(di->get_path());
}
}
remove(di);
redraw();
return ret;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *path)
{
struct dir *dir = NULL;
bool success = false;
char *name = malloc (NAME_MAX + 1);
if (name == NULL)
goto done;
if (!dir_follow_path (thread_current ()->cwd, path, &dir, name))
goto done;
if (dir == NULL)
goto done;
success = dir_remove (dir, name);
done:
dir_close (dir);
free (name);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
char s[100];
char *save_ptr;
memcpy(s,name,strlen(name)+1);
// printf("name len :%d %s\n",strlen(name),name);
char *file_name = get_file_name(name);
// printf("name len :%d\n",strlen(name));
if( strtok_r(s,"/",&save_ptr) ==NULL&&strlen(name)>0 )
{
/// printf("aaa\n");
return false;
}
struct dir *dir = get_directory (name);
bool success = dir != NULL && dir_remove (dir, file_name);
dir_close (dir);
free(file_name);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
//struct dir *dir = dir_open_root ();
/* Start of Project 4 */
struct dir *dir = dir_from_path (name);
char* file_name = retrieve_file_name (name);
bool success = false;
if (dir != NULL)
success = dir_remove (dir, file_name);
else
success = false;
//bool success = dir != NULL && dir_remove (dir, file_name);
free(file_name);
/* End of Project 4 */
dir_close (dir);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
struct dir *dir;
char parsed_name[NAME_MAX + 1];
if (*name == NULL || (strlen (name) > NAME_MAX) || !strcmp (name, "/"))
{
return false;
}
bool success = parse_path (name, &dir, parsed_name);
if (!success)
{
return success;
}
success = dir != NULL && dir_remove (dir, parsed_name);
dir_close (dir);
return success;
}
static void
process__final_step (NautilusCacheRemoveData *ncrd)
{
char *sub_dir;
if (! ncrd->recursive || ncrd->interrupted) {
nautilus_cache_data_free (ncrd);
return;
}
ncrd->dirs = g_list_concat (ncrd->pld->dirs, ncrd->dirs);
ncrd->pld->dirs = NULL;
path_list_data_free (ncrd->pld);
ncrd->pld = NULL;
if (ncrd->dirs == NULL) {
if (ncrd->clear_all) {
const GList *scan = ncrd->visited_dirs;
for (; scan; scan = scan->next) {
char *dir = scan->data;
dir_remove (dir);
}
}
nautilus_cache_data_free (ncrd);
return;
}
sub_dir = (char*) ncrd->dirs->data;
ncrd->dirs = g_list_remove_link (ncrd->dirs, ncrd->dirs);
ncrd->visited_dirs = g_list_prepend (ncrd->visited_dirs,
g_strdup (sub_dir));
visit_dir_async (sub_dir, ncrd);
g_free (sub_dir);
}
static void dir_remove(struct dir_info *dir)
{
char *path;
struct dir_entry_info *entry;
struct dir_entry_info **prev;
int found;
/* Remove directory contents */
while (dir->first) {
struct dir_entry_info *entry;
entry = dir->first;
if (entry->type == 'd')
dir_remove(entry->entry.dir);
else if (entry->type == 'f')
file_delete(entry->entry.file);
else
CHECK(0); /* Invalid struct dir_entry_info */
}
/* Remove entry from parent directory */
found = 0;
prev = &dir->parent->first;
for (entry = dir->parent->first; entry; entry = entry->next) {
if (entry->type == 'd' && entry->entry.dir == dir) {
dir->parent->number_of_entries -= 1;
*prev = entry->next;
free(entry);
found = 1;
break;
}
prev = &entry->next;
}
CHECK(found); /* Check the file is in the parent directory */
/* Remove directory itself */
path = dir_path(dir->parent, dir->name);
CHECK(rmdir(path) != -1);
}
/* Randomly select something to do with a directory entry */
static void operate_on_entry(struct dir_entry_info *entry)
{
/* 1 time in 1000 rename */
if (tests_random_no(1000) == 0) {
rename_entry(entry);
return;
}
if (entry->type == 's') {
symlink_check(entry->entry.symlink);
/* If shrinking, 1 time in 50, remove a symlink */
if (shrink && tests_random_no(50) == 0)
symlink_remove(entry->entry.symlink);
return;
}
if (entry->type == 'd') {
/* If shrinking, 1 time in 50, remove a directory */
if (shrink && tests_random_no(50) == 0) {
dir_remove(entry->entry.dir);
return;
}
operate_on_dir(entry->entry.dir);
}
if (entry->type == 'f') {
/* If shrinking, 1 time in 10, remove a file */
if (shrink && tests_random_no(10) == 0) {
file_delete(entry->entry.file);
return;
}
/* If not growing, 1 time in 10, unlink a file with links > 1 */
if (!grow && entry->entry.file->link_count > 1 &&
tests_random_no(10) == 0) {
file_unlink_file(entry->entry.file);
return;
}
operate_on_file(entry->entry.file);
}
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
char *cp_name;
char *file_name;
if(strcmp(name,"/")==0)
return false;
cp_name = malloc( sizeof(char) * (strlen(name)+1) );
file_name = malloc( sizeof(char) * (strlen(name)+1) );
if(cp_name == NULL || file_name == NULL)
return false;
strlcpy(cp_name, name, strlen(name)+1);
struct dir *dir = parse_path (cp_name, file_name);
bool success = dir != NULL && dir_remove (dir, file_name);
dir_close (dir);
free(file_name);
free(cp_name);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
struct dir *dir = get_containing_dir(name);
char *file_name = get_filename(name);
// Get dir
struct dir* dir = get_containing_dir(name);
// Get file name
char* file_name = get_filename(name);
>>>>>>> Stashed changes
bool success = dir != NULL && dir_remove (dir, file_name);
dir_close (dir);
free(file_name);
return success;
}
/* Formats the file system. */
static void
do_format (void)
{
printf ("Formatting file system...");
free_map_create ();
if (!dir_create (ROOT_DIR_SECTOR, 16))
PANIC ("root directory creation failed");
free_map_close ();
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
bool success = false;
struct inode *inode = NULL;
struct dir *search_dir = get_cwd(name);
struct dir *parent_dir = NULL;
if (search_dir == NULL) {
return false;
}
parent_dir = dir_reopen(search_dir);
char *part = malloc(NAME_MAX + 1);
if (part == NULL) {
return false;
}
memset(part, 0, NAME_MAX + 1);
int retrieved_next_part;
for (retrieved_next_part = get_next_part(part, &name); retrieved_next_part > 0;
retrieved_next_part = get_next_part(part, &name)) {
if (dir_lookup (search_dir, part, &inode)) {
dir_close(parent_dir);
parent_dir = dir_reopen(search_dir);
if (parent_dir == NULL) {
dir_close(search_dir);
free(part);
return false;
}
if (!inode_is_dir(inode)) {
break;
} else {
dir_close(search_dir);
search_dir = dir_open(inode);
if (search_dir == NULL) {
dir_close(parent_dir);
free(part);
return false;
}
}
} else {
inode = NULL;
break;
}
}
if (inode == NULL || get_next_part(part, &name) != 0) {
if (inode != NULL && !inode_is_dir(inode)) {
inode_close(inode);
}
dir_close(parent_dir);
dir_close(search_dir);
free(part);
return false;
}
if (parent_dir == NULL || search_dir == NULL) {
dir_close(search_dir);
dir_close(parent_dir);
free(part);
return false;
}
if (inode_is_dir(inode)) {
char buffer[NAME_MAX + 1];
if (inode_is_open(inode) || dir_readdir(search_dir, buffer)) {
success = false;
} else {
inode_close(inode);
success = dir_remove (parent_dir, part);
}
} else {
inode_close(inode);
success = dir_remove(parent_dir, part);
}
dir_close(search_dir);
dir_close(parent_dir);
free(part);
return success;
}
/* Deletes the file named NAME.
Returns true if successful, false on failure.
Fails if no file named NAME exists,
or if an internal memory allocation fails. */
bool
filesys_remove (const char *name)
{
char name_copy[MAX_FULL_PATH];
char *file_name = NULL;
char *token = NULL, *save_ptr = NULL;
struct dir *dir = NULL;
/* Null name not allowed. */
if (name[0] == '\0')
{
return false;
}
/* Open parent directory. */
dir = recursive_dir_open (name);
/* extract only file name from full path. */
strlcpy (name_copy, name, strlen (name) + 1);
for (token = strtok_r (name_copy, "/", &save_ptr); token != NULL;
token = strtok_r (NULL, "/", &save_ptr))
{
file_name = token;
}
if (!file_name)
{
dir_close (dir);
return false;
}
/* Check for and prevent simultaneous accesses. */
struct list_elem *e;
block_sector_t parent_dir_sector = inode_get_inumber (dir_get_inode (dir));
lock_acquire (&cur_name_list_lock);
for (e = list_begin (&cur_name_list);
e != list_end (&cur_name_list);
e = list_next (e))
{
struct cur_name_list_entry *cur_name_list_entry = NULL;
cur_name_list_entry = list_entry (e, struct cur_name_list_entry, elem);
if ((cur_name_list_entry->parent_dir_sector == parent_dir_sector)
&& (!strcmp (file_name, cur_name_list_entry->file_name)))
{
dir_close (dir);
return false;
}
}
struct cur_name_list_entry *name_entry = NULL;
name_entry = malloc (sizeof (struct cur_name_list_entry));
if (name_entry == NULL)
{
dir_close (dir);
lock_release (&cur_name_list_lock);
return false;
}
strlcpy (name_entry->file_name, file_name, strlen (file_name) + 1);
name_entry->parent_dir_sector = parent_dir_sector;
list_push_back (&cur_name_list, &name_entry->elem);
lock_release (&cur_name_list_lock);
/* Remove dirctory entry of file. */
bool success = dir != NULL && dir_remove (dir, file_name);
dir_close (dir);
lock_acquire (&cur_name_list_lock);
list_remove (&name_entry->elem);
lock_release (&cur_name_list_lock);
free (name_entry);
return success;
}
