/*
* Rename a file.
*/
int fs_rename(const char *path, const char *newpath) {
fprintf(stderr, "fs_rename(fpath=\"%s\", newpath=\"%s\")\n", path, newpath);
s3context_t *ctx = GET_PRIVATE_DATA;
char* s3bucket = (char*)ctx;
FILE* f = NULL;
s3dirent_t* more_dirs = NULL;
ssize_t size = s3fs_get_object(s3bucket, path, (uint8_t**)&f, 0, 0);
if (size<0) {
printf("This object does not exist\n");
return -ENOENT;
}
s3fs_remove_object(s3bucket,path);
s3fs_put_object(s3bucket, path, (uint8_t*)f, sizeof(f));
char* copy_path_1 = strdup(path);
char* copy_path_2 = strdup(path);
char* directory = dirname(copy_path_1);
char* base = basename(copy_path_2);
char* copy_new_path = strdup(newpath);
char* newbase = basename(copy_new_path);
size = s3fs_get_object(s3bucket, directory, (uint8_t**)&more_dirs, 0, 0);
if (size < 0) {
return -EIO;
}
int entries = size/sizeof(s3dirent_t);
printf("ENTRIES = %d\n", entries);
int i=0;
for(;i<entries;i++) {
if ( strcasecmp(more_dirs[i].name,base) == 0) {
more_dirs[i].name = newbase;
}
}
s3fs_put_object(s3bucket, directory, (uint8_t*)more_dirs, sizeof(more_dirs));
return -EIO;
}
/*
* Remove a file.
*/
int fs_unlink(const char *path) {
fprintf(stderr, "fs_unlink(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
char* cpy_path_1 = strdup(path);
char* cpy_path_2 = strdup(path);
char* d = dirname(cpy_path_1);
char* b = basename(cpy_path_2);
char* s3bucket = (char*)ctx;
s3dirent_t* dirs_rem = NULL;
ssize_t size = s3fs_get_object(s3bucket, d, (uint8_t**)&dirs_rem, 0, 0);
if (size<0) {
return -EIO; // directory does not exist
}
int entries = size/sizeof(s3dirent_t);
s3dirent_t arr[entries-1];
int i=0;
int k=0;
for (;i<entries;i++) {
if (strcasecmp(dirs_rem[i].name,b) != 0) {
arr[k] = dirs_rem[i];
k++;
}
}
s3fs_put_object(s3bucket, d, (uint8_t*)&arr, ((sizeof(s3dirent_t))*(entries-1)));
s3fs_remove_object(s3bucket, path);
return 0;
}
/* STEP 1
* Remove a directory.
*/
int fs_rmdir(const char *path) {
char * dir_name = dirname(strdup(path));
char * base_name = basename(strdup(path));
ssize_t ret_val = 0;
uint8_t * buffer = NULL;
fprintf(stderr, "fs_rmdir(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
ret_val = s3fs_get_object(ctx->s3bucket, path, &buffer, 0, 0);
if (0 > ret_val) {
return -ENOENT;
}
free(buffer);
if (sizeof(s3dirent_t) != ret_val) {
// more than one entry, I chose to use EINVAL here
return -EINVAL;
}
if (0 != s3fs_remove_object(ctx->s3bucket, path)) {
return -EIO;
}
ret_val = s3fs_get_object(ctx->s3bucket, dir_name, &buffer, 0, 0);
if (0 > ret_val) {
// no parent
return -EIO;
}
// make room for all entries but the deleted directory
s3dirent_t * new_parent_dir = (s3dirent_t *)malloc(ret_val - sizeof(s3dirent_t));
s3dirent_t * entries = (s3dirent_t *)buffer;
int dirent_count = ret_val / sizeof(s3dirent_t);
int i = 0;
int copy_index = 0;
for (; i < dirent_count; i++) {
if (0 != strncmp(entries[i].name, base_name, 256) && (copy_index < (dirent_count - 1))) {
memcpy(&new_parent_dir[copy_index], &entries[i], sizeof(s3dirent_t));
copy_index++;
}
}
ret_val = s3fs_put_object(ctx->s3bucket, dir_name, (uint8_t *)new_parent_dir, (dirent_count - 1) * sizeof(s3dirent_t));
if (-1 == ret_val) {
free(new_parent_dir);
return -EIO;
}
free(new_parent_dir);
return 0;
}
/*
* Remove a directory.
*/
int fs_rmdir(const char *path) {
fprintf(stderr, "fs_rmdir(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
char* s3bucket = (char*)ctx;
s3dirent_t* dirs_r = NULL;
ssize_t s = s3fs_get_object(s3bucket, path, (uint8_t**)&dirs_r, 0, 0);
if (s<0) {
free(dirs_r);
return -EIO; // directory does not exist
}
int e = s/sizeof(s3dirent_t);
if (e>1)
{
free(dirs_r);
return -EIO; // there is more than one thing in this
}
char* cpy_path_1 = strdup(path);
char* cpy_path_2 = strdup(path);
char* d = dirname(cpy_path_1);
char* b = basename(cpy_path_2);
s3dirent_t* dirs_rem = NULL;
ssize_t size = s3fs_get_object(s3bucket, d, (uint8_t**)&dirs_rem, 0, 0);
if (size<0) {
free(dirs_r);
return -EIO; // directory does not exist
}
int entries = size/sizeof(s3dirent_t);
printf("NUM ENTRIES IN REMOVE IS %d\n", entries);
s3dirent_t arr[entries-1];
int i=0;
int k=0;
for (;i<entries;i++) {
printf("NAME? in remove %s\n", dirs_rem[i].name);
printf("base name is %s\n", b);
if (strcasecmp(dirs_rem[i].name,b) != 0) {
printf("NOT THE SAME!\n");
arr[k] = dirs_rem[i];
k++;
}
}
printf("ADDING TO NEW ARR IN REM\n");
s3fs_put_object(s3bucket, d, (uint8_t*)&arr, ((sizeof(s3dirent_t))*(entries-1)));
printf("REMOVING OBJECT (PATH) %s\n", path);
s3fs_remove_object(s3bucket, path);
free(dirs_r);
return 0;
}
/*
* Remove a file.
*/
int fs_unlink(const char *path) {
fprintf(stderr, "fs_unlink(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
ssize_t dir_size;
int i = 0, j = 0;
uint8_t *dir;
if(fs_open(path, (struct fuse_file_info *)NULL) != 0) {
fprintf(stderr, "INVALID PATH\n");
return -ENOENT;
}
char *temp_path1 = strdup(path), *temp_path2 = strdup(path);
char *dir_name = strdup(dirname(temp_path1)), *base_name = strdup(basename(temp_path2));
free(temp_path1); free(temp_path2);
dir_size=s3fs_get_object(ctx->s3bucket, dir_name, &dir, 0, 0);
s3dirent_t* direct = (s3dirent_t*)dir;
for(;i<dir_size/sizeof(s3dirent_t);i++) {
if(!strcmp(direct[i].name, base_name)) {
i++; break;
}
}
for(;i<dir_size/sizeof(s3dirent_t);i++) {
j = i-1;
direct[j] = direct[i];
}
s3dirent_t* new_dir;
ssize_t new_dir_size;
new_dir = malloc(dir_size - sizeof(s3dirent_t));
memcpy(new_dir, direct, dir_size - sizeof(s3dirent_t));
new_dir_size = dir_size - sizeof(s3dirent_t);
printf("dir_size: %d new_dir_size: %d\n", dir_size, new_dir_size);
printf("updated directory from file remove path: %s\n",dir_name);
if(s3fs_put_object(ctx->s3bucket, dir_name, (uint8_t*)new_dir, new_dir_size)!= new_dir_size) {
fprintf(stderr, "SOMETHING WENT WRONG WHILE PUTTING TO S3: fs_unlink\n");
free(new_dir); free(direct); free(base_name); free(dir_name);
return -EIO;
}
if(s3fs_remove_object(ctx->s3bucket, path) != 0) {
fprintf(stderr, "ERROR WHILE TRYING TO DELTE FILE: fs_unlink");
free(new_dir); free(direct); free(base_name); free(dir_name);
return -EIO;
}
free(new_dir); free(direct); free(base_name); free(dir_name);
return 0;
}
/*
* Rename a file.
*/
int fs_rename(const char *path, const char *newpath) {
char * dir_name = dirname(strdup(path));
char * base_name = basename(strdup(path));
char * new_dir_name = dirname(strdup(newpath));
char * new_base_name = basename(strdup(newpath));
ssize_t ret_val = 0;
uint8_t * buffer = NULL;
uint8_t * _unused_buffer = NULL;
fprintf(stderr, "fs_rename(fpath=\"%s\", newpath=\"%s\")\n", path, newpath);
s3context_t *ctx = GET_PRIVATE_DATA;
size_t path_len = strlen(path);
char * file_content_key = (char *)malloc(path_len + 2); // no point of multiplying by sizeof(char)
// since the below code assumes ANSI anyways
file_content_key[0] = '~';
memcpy(&file_content_key[1], path, path_len);
file_content_key[path_len + 1] = '\0';
size_t new_path_len = strlen(newpath);
char * new_file_content_key = (char *)malloc(new_path_len + 2); // no point of multiplying by sizeof(char)
// since the below code assumes ANSI anyways
new_file_content_key[0] = '~';
memcpy(&new_file_content_key[1], newpath, new_path_len);
new_file_content_key[new_path_len + 1] = '\0';
ret_val = s3fs_get_object(ctx->s3bucket, file_content_key, &buffer, 0, 0);
if (0 > ret_val) {
free(file_content_key);
free(new_file_content_key);
return -ENOENT;
}
// check if new file doesnt already exist, if it does return error
if (0 <= s3fs_get_object(ctx->s3bucket, new_file_content_key, &_unused_buffer, 0, 0)) {
free(buffer);
free(_unused_buffer);
free(new_file_content_key);
free(file_content_key);
return -EEXIST;
}
free(_unused_buffer);
if (0 != s3fs_remove_object(ctx->s3bucket, file_content_key)) {
free(buffer);
free(new_file_content_key);
free(file_content_key);
return -EIO;
}
free(file_content_key);
ret_val = s3fs_put_object(ctx->s3bucket, new_file_content_key, buffer, ret_val);
free(buffer);
free(new_file_content_key);
// get and remove the original entry
ret_val = s3fs_get_object(ctx->s3bucket, dir_name, &buffer, 0, 0);
s3dirent_t * entries = (s3dirent_t *)buffer;
s3dirent_t * file_entry = (s3dirent_t *)malloc(sizeof(s3dirent_t));
s3dirent_t * new_parent_dir = (s3dirent_t *)malloc(ret_val - sizeof(s3dirent_t));
int dirent_count = ret_val / sizeof(s3dirent_t);
int i = 0, copy_index = 0;
for (; i < dirent_count; i++) {
if (0 == strncmp(entries[i].name, base_name, 256)) {
// save the file entry so that could add it to the new path
memcpy(file_entry, &entries[i], sizeof(s3dirent_t));
} else {
memcpy(&new_parent_dir[copy_index], &entries[i], sizeof(s3dirent_t));
copy_index++;
}
}
free(buffer);
if (1 != (i - copy_index)) {
free(new_parent_dir);
free(file_entry);
return -EIO;
}
if (0 > s3fs_put_object(ctx->s3bucket, dir_name, (uint8_t *)new_parent_dir, (ret_val - sizeof(s3dirent_t)))) {
free(new_parent_dir);
free(file_entry);
return -EIO;
}
free(new_parent_dir);
// rename in parent
ret_val = s3fs_get_object(ctx->s3bucket, new_dir_name, &buffer, 0, 0);
if (0 > ret_val) {
free(file_entry);
return -EIO;
}
dirent_count = ret_val / sizeof(s3dirent_t);
new_parent_dir = (s3dirent_t *)malloc(ret_val + sizeof(s3dirent_t));
memcpy(new_parent_dir, buffer, ret_val);
free(buffer);
time_t current_time = time(NULL);
memset(file_entry->name, 0, 256);
strcpy(file_entry->name, new_base_name);
file_entry->atime = current_time;
file_entry->mtime = current_time;
// add the entry
memcpy(&new_parent_dir[dirent_count], file_entry, sizeof(s3dirent_t));
if (0 > s3fs_put_object(ctx->s3bucket, new_dir_name, (uint8_t *)new_parent_dir, (ret_val + sizeof(s3dirent_t)))) {
free(new_parent_dir);
free(file_entry);
return -EIO;
}
free(new_parent_dir);
free(file_entry);
return 0;
}
/*
* Remove a file.
*/
int fs_unlink(const char *path) {
char * dir_name = dirname(strdup(path));
char * base_name = basename(strdup(path));
ssize_t ret_val = 0;
uint8_t * buffer = NULL;
fprintf(stderr, "fs_unlink(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
size_t path_len = strlen(path);
char * file_content_key = (char *)malloc(path_len + 2); // no point of multiplying by sizeof(char)
// since the below code assumes ANSI anyways
file_content_key[0] = '~';
memcpy(&file_content_key[1], path, path_len);
file_content_key[path_len + 1] = '\0';
ret_val = s3fs_get_object(ctx->s3bucket, file_content_key, &buffer, 0, 0);
if (0 > ret_val) {
free(file_content_key);
return -ENOENT;
}
free(buffer);
if (0 != s3fs_remove_object(ctx->s3bucket, file_content_key)) {
free(file_content_key);
return -EIO;
}
free(file_content_key);
// remove the entry
ret_val = s3fs_get_object(ctx->s3bucket, dir_name, &buffer, 0, 0);
s3dirent_t * entries = (s3dirent_t *)buffer;
s3dirent_t * new_parent_dir = (s3dirent_t *)malloc(ret_val - sizeof(s3dirent_t));
int dirent_count = ret_val / sizeof(s3dirent_t);
int i = 0, copy_index = 0;
for (; i < dirent_count; i++) {
if (0 != strncmp(entries[i].name, base_name, 256)) {
memcpy(&new_parent_dir[copy_index], &entries[i], sizeof(s3dirent_t));
copy_index++;
}
}
free(buffer);
if (1 != (i - copy_index)) {
free(new_parent_dir);
return -EIO;
}
if (0 > s3fs_put_object(ctx->s3bucket, dir_name, (uint8_t *)new_parent_dir, (ret_val - sizeof(s3dirent_t)))) {
free(new_parent_dir);
return -EIO;
}
free(new_parent_dir);
return 0;
}
/*
* Remove a file.
*/
int fs_unlink(const char *path) {
//sommers code
fprintf(stderr, "fs_unlink(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
//our code
char* directoryPath = strdup(path);
char* directoryName = strdup(path);
directoryPath = strdup(dirname(directoryPath)); //get path and malloc
directoryName = strdup(basename(directoryName)); //get name and malloc
printf("%s","directory path: ");
printf("%s\n",directoryPath);
printf("%s","directory name: ");
printf("%s\n",directoryName);
printf("%s", "removing directory from following path: ");
printf("%s\n",path);
if (s3fs_remove_object(ctx->s3bucket, path) == -1) {
fprintf(stderr, "remove directory failed");
return -EIO;
}
s3dirent_t * dirParent = NULL;
if (s3fs_get_object(ctx->s3bucket, directoryPath, (uint8_t **)&dirParent, 0,0)<0) //if not a real directory
{
fprintf(stderr, "path is not valid");
return -EIO;
}
int i = 0;
int j = 0;
printf("%s\n","testing 100");
printf("%s\n",dirParent[i].name);
s3dirent_t dirParentNew[sizeof(dirParent)-1];
while(strcmp((dirParent[i].type),"U")!=0) {
printf("%s\n",dirParent[i].name);
if(strcmp(dirParent[i].name, directoryName)!=0) {
dirParentNew[j] = dirParent[i];
printf("%s","name of what is being moved back: ");
printf("%s\n",dirParentNew[j].name);
j++;
}
i++;
}
//at the last element
if (strcmp((dirParent[i].type),"U")==0) {
if(strcmp(dirParent[i].name, directoryName)!=0) {
//strcpy(dirParent[i].type,"U");
dirParentNew[j] = dirParent[i];
strcpy(dirParentNew[j].type,"U");
}
else { //not going to add the last thing;
strcpy(dirParentNew[j].type,"U");
}
}
printf("%s\n","contents of newParentDir");
i=0;
while(strcmp((dirParent[i].type),"U")!=0) {
printf("%s","name: ");
printf("%s\n",dirParentNew[i].name);
printf("%s","type: ");
printf("%s\n",dirParentNew[i].type);
i++;
}
//re-upload new parent directory
printf("%s\n","uploading parent directory to following path:");
printf("%s\n",directoryPath);
printf("%s", "size of direparentnew: ");
printf("%d\n", sizeof(dirParentNew));
if ((s3fs_put_object(ctx->s3bucket, directoryPath, (const uint8_t *)&dirParentNew, sizeof(dirParentNew)))!=sizeof(dirParentNew)) {
fprintf(stderr, "failed to add the new directory");
return -EIO;
}
return 0;
}
/*
* Rename a file.
*/
int fs_rename(const char *path, const char *newpath) {
//sommers code
fprintf(stderr, "fs_rename(fpath=\"%s\", newpath=\"%s\")\n", path, newpath);
s3context_t *ctx = GET_PRIVATE_DATA;
//our code
FILE *fp = NULL;
char* directoryPath = strdup(path);
char* directoryName = strdup(path);
char* newDirectoryName = strdup(path);
directoryPath = strdup(dirname(directoryPath)); //get path and malloc
directoryName = strdup(basename(directoryName)); //get name and malloc
newDirectoryName = strdup(basename(newDirectoryName)); //get name and malloc
if (s3fs_get_object(ctx->s3bucket, path, (uint8_t **)&fp, 0,0)<0) //if not a real directory
{
fprintf(stderr, "failed to read file");
return -EIO;
}
if (s3fs_remove_object(ctx->s3bucket, path) == -1) {
fprintf(stderr, "remove directory failed");
return -EIO;
}
if ((s3fs_put_object(ctx->s3bucket, newpath, (const uint8_t *)&fp, sizeof(fp)))!=sizeof(fp)) {
fprintf(stderr, "failed to reupload to new path");
return -EIO;
}
//update parent directory
s3dirent_t * dirParent = NULL;
if (s3fs_get_object(ctx->s3bucket, directoryPath, (uint8_t **)&dirParent, 0,0)<0) //if not a real directory
{
fprintf(stderr, "path is not valid");
return -EIO;
}
int i = 0;
printf("%s\n","testing 100");
printf("%s\n",dirParent[i].name);
while(strcmp((dirParent[i].type),"U")!=0) {
if(strcmp(dirParent[i].name, directoryName)==0) {
strcpy(dirParent[i].name, newDirectoryName);
}
i++;
}
//re-upload new parent directory
printf("%s\n","uploading parent directory to following path:");
printf("%s\n",directoryPath);
printf("%s", "size of direparentnew: ");
printf("%d\n", sizeof(dirParent));
if ((s3fs_put_object(ctx->s3bucket, newpath, (const uint8_t *)&dirParent, sizeof(dirParent)))!=sizeof(dirParent)) {
fprintf(stderr, "failed to add the new directory");
return -EIO;
}
}
/*
* Write data to an open file
*
* Write should return exactly the number of bytes requested
* except on error.
*/
int fs_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
fprintf(stderr, "fs_write(path=\"%s\", buf=%p, size=%d, offset=%d)\n",
path, buf, (int)size, (int)offset);
s3context_t *ctx = GET_PRIVATE_DATA;
if(!strcmp(path, "/")) {
fprintf(stderr,"CANNOT WRITE TO A DIRECTORY ESPECIALLY ROOT: fs_write\n");
return -EPERM;
}
uint8_t* file = NULL;
ssize_t file_size;
printf("before grab the file\n");
if((file_size=s3fs_get_object(ctx->s3bucket, path, &file, 0, 0))<0) {
fprintf(stderr, "INVALID PATH: fs_write\n");
return -ENOENT;
}
printf("grabbed file\n");
ssize_t new_size;
char *file_data = (char *)file;
printf("strdup file data\n");
if(file_size <= offset + size) {
new_size = offset + size - file_size;
file_data = realloc(file_data, sizeof(char)*new_size);
}else {
new_size = file_size;
}
printf("after assigning new size/ realloc\n");
int i = offset;
for(;i<new_size;i++) {
file_data[i] = buf[i];
}
printf("after transfering data\n");
if(s3fs_remove_object(ctx->s3bucket, path)!=0) {
fprintf(stderr, "object not removed correctly\n");
free(file_data); return -EIO;
}
if(s3fs_put_object(ctx->s3bucket, path, (uint8_t *)file_data, new_size) != new_size) {
fprintf(stderr,"WRITTEN FILE DID NOT PUT BACK CORRECTLY: fs_write\n");
free(file_data);
return -EIO;
}
free(file_data);
uint8_t *file_entry = NULL;
ssize_t file_entry_size;
char *temp_path = strdup(path), *temp_path1 = strdup(path);
char *dir_name = strdup(dirname(temp_path)), *base_name = strdup(basename(temp_path1));
free(temp_path); free(temp_path1);
if((file_entry_size = s3fs_get_object(ctx->s3bucket, dir_name, &file_entry, 0, 0))< 0) {
fprintf(stderr, "COULD NOT UPDATE FILE ENTRY AFTER WRITE: fs_write\n");
free(dir_name); free(base_name);
return -EIO;
}
printf("after grabbed directory to update entry size meta\n");
s3dirent_t *update_file_entry = (s3dirent_t *)file_entry;
printf("update size: %d\n",new_size);
printf("base name: %s\n",base_name);
for(i=0;i<file_entry_size/sizeof(s3dirent_t);i++) {
printf("directory entry names: %s\n",update_file_entry[i].name);
if(!strcmp(update_file_entry[i].name, base_name)) {
update_file_entry[i].metadata.st_size = new_size;
printf("st_size of direct entry: %d \n",update_file_entry[i].metadata.st_size);
}
}
if(s3fs_remove_object(ctx->s3bucket, dir_name)!=0) {
fprintf(stderr,"could not remove object\n");
free(dir_name); free(base_name);free(update_file_entry);
return -EIO;
}
if(s3fs_put_object(ctx->s3bucket, dir_name, (uint8_t *)update_file_entry, file_entry_size)!=file_entry_size) {
fprintf(stderr, "COULD NOT PUT UPDATED DIRECTORY ENTRY BACK: fs_write\n");
free(dir_name); free(base_name); free(update_file_entry);
return -EIO;
}
printf("yay wrote to a file\n");
return new_size;
}
/*
* Rename a file.
*/
int fs_rename(const char *path, const char *newpath) {
fprintf(stderr, "fs_rename(fpath=\"%s\", newpath=\"%s\")\n", path, newpath);
s3context_t *ctx = GET_PRIVATE_DATA;
ssize_t dir_size, dir_size1;
uint8_t *dir = NULL, *dir1 = NULL;
char type;
int i = 0, j = NULL;
char *temp_path = strdup(path), *temp_path1 = strdup(path), *temp_new_path1 = strdup(newpath), *temp_new_path2=strdup(newpath);
char* dir_name = strdup(dirname(temp_path)), *base_name = strdup(basename(temp_path1));
char *new_dir_name=strdup(dirname(temp_new_path1)), *new_base_name = strdup(basename(temp_new_path2));
char *temp_new_path3=strdup(newpath);
free(temp_path); free(temp_path1); free(temp_new_path1); free(temp_new_path2);
if(!strcmp("/", path)) {
fprintf(stderr,"CANNOT RENAME ROOT DIRECTORY: fs_rename\n");
free(dir_name); free(base_name); free(new_dir_name); free(new_base_name);
return -EPERM;
}
if((dir_size1=s3fs_get_object(ctx->s3bucket, path, &dir1, 0, 0))>=0) {
printf("PATH TO REMOVE IN FS_RENAME DIRECTORY: %s\n",path);
if((dir_size=s3fs_get_object(ctx->s3bucket, dir_name, &dir, 0, 0))<0) {
fprintf(stderr, "INVALID PATH: fs_rename\n");
free(base_name); free(dir_name); free(new_dir_name); free(new_base_name);free(temp_new_path3);free(dir1);
return -ENOENT;
}
s3dirent_t *dirent = (s3dirent_t*)dir;
for(;i<dir_size/sizeof(s3dirent_t);i++) {
if(!strcmp(dirent[i].name, base_name)) {
j = i;
}else if(!strcmp(dirent[i].name, new_base_name)) {
fprintf(stderr, "FILE NAME ALREADY USED: fs_rename\n");
free(base_name); free(dir_name); free(new_dir_name); free(new_base_name); free(dirent);free(temp_new_path3);
free(dir1);
return -EEXIST;
}
}
if(j==NULL) {
fprintf(stderr, "INVALID PATH: fs_rename\n");
free(base_name); free(dir_name); free(new_dir_name); free(new_base_name);free(temp_new_path3);free(dir1);
return -ENOENT;
}
strcpy(dirent[j].name,new_base_name);
if(s3fs_put_object(ctx->s3bucket, new_dir_name, (uint8_t *)dirent, dir_size)!=dir_size) {
fprintf(stderr, "ERROR WHILE PUTTING UPDATED DIRECTORY TO S3: fs_rename\n");
free(base_name); free(dir_name); free(new_dir_name); free(new_base_name); free(dirent);
free(temp_new_path3); free(dir1);
return -EIO;
}
if(s3fs_remove_object(ctx->s3bucket, path)!=0) {
fprintf(stderr, "ERROR WHILE ERASING ORIGINAL DIRECTORY TO RENAME: fs_rename\n");
free(dirent); free(base_name); free(dir_name); free(new_dir_name); free(new_base_name);free(temp_new_path3);
free(dir1);
return -EIO;
}
if(s3fs_put_object(ctx->s3bucket, newpath, dir1, dir_size1)!=dir_size1) {
fprintf(stderr, "ERROR WHILE PUTTING RENAMED OBJECT BACK: fs_rename\n");
free(dirent); free(base_name); free(dir_name); free(new_dir_name); free(new_base_name);free(temp_new_path3);
free(dir1);
return -EIO;
}
free(dirent); free(base_name); free(dir_name); free(new_dir_name); free(new_base_name);free(temp_new_path3);
free(dir1);
return 0;
}else {
fprintf(stderr, "INVALID PATH:fs_rename\n");
free(base_name); free(dir_name); free(new_dir_name); free(new_base_name); free(temp_new_path3);
return -ENOENT;
}
}
/*
* Remove a directory.
*/
int fs_rmdir(const char *path) {
fprintf(stderr, "fs_rmdir(path=\"%s\")\n", path);
s3context_t *ctx = GET_PRIVATE_DATA;
uint8_t *dir = NULL;
char *temp_path = strdup(path), *temp_path1 = strdup(path), *temp_path2 = strdup(path);
char* dir_name = strdup(dirname(temp_path)), *base_name = strdup(basename(temp_path1));
printf("DIR_NAME: %s , BASE_NAME: %s\n",dir_name, base_name);
ssize_t dir_size;
if((dir_size = s3fs_get_object(ctx->s3bucket, temp_path2, &dir, 0, 0)) < 0){
fprintf(stderr, "INVALID DIRECTORY: fs_rmdir\n");
free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
return -ENOENT;
}
printf("after getting dir to remove\n");
s3dirent_t *directory = (s3dirent_t *)dir;
if(dir_size/sizeof(s3dirent_t) > 1) {
fprintf(stderr, "CANT DELETE DIRECTORY WITH OTHER THINGS IN IT: fs_rmdir\n");
free(directory);free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
return -ENOTEMPTY;
}
printf("before removing dir\n");
if(s3fs_remove_object(ctx->s3bucket, temp_path2) != 0) {
fprintf(stderr, "COULD NOT DELETE OBJECT: fs_rmdir\n");
free(directory);free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
return -EIO;
}
printf("after removing dir, before getting parent dir\n");
if((dir_size = s3fs_get_object(ctx->s3bucket, dir_name, &dir, 0, 0)) < 0){
fprintf(stderr, "INVALID DIRECTORY: fs_rmdir\n");
free(directory); free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
return -ENOENT;
}
s3dirent_t *dirent = (s3dirent_t *)dir;
int numdirents = dir_size/sizeof(s3dirent_t), i = 0;
printf("before for loop to find entry in parent to remove\n");
for(;i<numdirents;i++) {
if(!strcmp(dirent[i].name, base_name)) {
break;
}
}
if(i>=numdirents) {
fprintf(stderr, "NO DIRECTORY ENTRY TO REMOVE IN PARENT: fs_rmdir\n");
free(dirent);free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
return -EIO;
}
i++;
int j = 0;
for(;i<numdirents;i++) {
j = i-1;
dirent[j] = dirent[i];
}
printf("before updating entry\n");
ssize_t new_dir_size;
s3dirent_t *new_dirent = malloc(dir_size - sizeof(s3dirent_t));
memcpy(new_dirent, dirent, dir_size - sizeof(s3dirent_t));
new_dir_size = dir_size - sizeof(s3dirent_t);
if((dir_size = s3fs_put_object(ctx->s3bucket, dir_name, (uint8_t *)new_dirent, new_dir_size)) !=new_dir_size) {
fprintf(stderr, "DID NOT PUT OBJECT BACK CORRECTLY\n");
free(new_dirent); free(dirent);free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
return -EIO;
}
free(dirent); free(new_dirent);free(temp_path); free(temp_path1); free(temp_path2);free(dir_name); free(base_name);
printf("SUCCESSFULLY REMOVED DIRECTORY!\n");
return 0;
}
