/* 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; }