/** Get file attributes.
*
* Similar to stat(). The 'st_dev' and 'st_blksize' fields are
* ignored. The 'st_ino' field is ignored except if the 'use_ino'
* mount option is given.
*/
int nphfuse_getattr(const char *path, struct stat *stbuf){
// extract_directory_file(dir,filename,path);
npheap_store *inode = NULL;
if(strcmp(path,"/")==0){
inode = getRootDirectory();
if(inode==NULL)
{
log_msg("Root directory not found in getattr.\n");
return -ENOENT;
}
else
{
log_msg("Assigning root stbuf in getattr\n");
memcpy(stbuf, &inode->mystat, sizeof(struct stat));
return 0;
}
}
inode = retrieve_inode(path);
if(inode == NULL){
return -ENOENT;
}
// else return the proper value
log_msg("Assigning normal stbuf in getattr\n");
memcpy(stbuf, &inode->mystat, sizeof(struct stat));
return 0;
}
/**
* Get attributes from an open file
*
* This method is called instead of the getattr() method if the
* file information is available.
*
* Currently this is only called after the create() method if that
* is implemented (see above). Later it may be called for
* invocations of fstat() too.
*
*/
int nphfuse_fgetattr(const char *path, struct stat *statbuf, struct fuse_file_info *fi)
{
log_msg("Into fgetattr.\n");
npheap_store *inode = NULL;
char dir[236];
char filename[128];
if(strcmp(path,"/")==0){
inode = getRootDirectory();
if(inode==NULL)
{
log_msg("Root directory not found in getattr.\n");
return -ENOENT;
}else{
log_msg("Everything worked fine\n");
memcpy(statbuf, &inode->mystat, sizeof(struct stat));
return 0;
}
}
inode = retrieve_inode(path);
if(inode==NULL){
return -ENOENT;
}
log_msg("Worked fine\n");
memcpy(statbuf, &inode->mystat, sizeof(struct stat));
return 0;
}
/** Change the owner and group of a file */
int nphfuse_chown(const char *path, uid_t uid, gid_t gid){
log_msg("Entry into CHOWN.\n");
npheap_store *inode = NULL;
struct timeval currTime;
if(strcmp (path,"/")==0){
log_msg("Calling getRootDirectory() in CHOWN.\n");
inode = getRootDirectory();
if(inode==NULL)
{
log_msg("Root directory not found. in CHOWN.\n");
return -ENOENT;
}
else
{
log_msg("Root directory found. in CHOWN.\n");
//Check if accessibilty can be given
int flag = checkAccess(inode);
//Deny the access
if(flag == 0){
return -EACCES;
}
//else set correct value
log_msg("Owner of root changed in CHOWN.\n", path);
gettimeofday(&currTime, NULL);
inode->mystat.st_uid = uid;
inode->mystat.st_gid = gid;
inode->mystat.st_ctime = currTime.tv_sec;
log_msg("Exit from CHOWN.\n");
return 0;
}
}
inode = retrieve_inode(path);
if(inode == NULL){
log_msg("Couldn't find path - %s - in CHOWN.\n", path);
return -ENOENT;
}
//Check Accessibility
int flag1 = checkAccess(inode);
//Deny the access
if(flag1 == 0){
return -EACCES;
}
//else set correct value
log_msg("Owner of path - %s - changed in CHOWN.\n", path);
gettimeofday(&currTime, NULL);
inode->mystat.st_uid = uid;
inode->mystat.st_gid = gid;
inode->mystat.st_ctime = currTime.tv_sec;
log_msg("Exit from CHOWN.\n");
return 0;
}
/** Change the access and/or modification times of a file */
int nphfuse_utime(const char *path, struct utimbuf *ubuf){
log_msg("Into utime.\n");
npheap_store *temp = NULL;
if(strcmp(path,"/")==0){
temp = getRootDirectory();
if(temp==NULL)
{
log_msg("Root directory not found in utime.\n");
return -ENOENT;
}
else
{
int flag = checkAccess(temp);
if(flag==0){
log_msg("Cannot access in root.\n");
return - EACCES;
}
// Set from ubuf
if(ubuf->actime){
temp->mystat.st_atime = ubuf->actime;
}
if(ubuf->modtime){
temp->mystat.st_mtime = ubuf->modtime;
}
log_msg("Ubuf ran successfully.! \n");
return 0;
}
}
temp = retrieve_inode(path);
if(temp==0){
log_msg("Cannot find the inode in ubuf.\n");
return -ENOENT;
}
int flag1 = checkAccess(temp);
if(flag1==0){
log_msg("Cannot access the asked inode.\n");
return - EACCES;
}
if(ubuf->actime){
temp->mystat.st_atime = ubuf->actime;
}
if(ubuf->modtime){
temp->mystat.st_mtime = ubuf->modtime;
}
log_msg("Ubuf ran successfully.! \n");
return 0;
}
int
find_ino(const char *path)
/* Returns inode number Or -1 on error */
{
char m_path[strlen(path)+1]; /* mutable string for path2tokens() */
int tokenc;
char **tokens;
char **tokenp; /* for travese tokens */
char *token;
inode_t *inodep;
dirent_t dir;
entry_t ent;
// indirect_t indirect;
insert_t insert;
strcpy(m_path, path);
if ((strcmp(path, "/") == 0) ||
(strcmp(path, "///") == 0))
return 1;
inodep = retrieve_root();
tokenc = path2tokens(m_path, &tokens);
if (tokenc < 0)
return -1;
tokenp = tokens;
int i;
int type = S_IFDIR; /* starts from root dir */
for (i=0;
( i<(tokenc-1) && I_ISDIR(type) );
i++, tokenp++)
{
token = *tokenp;
if ( ( insert=search_entry(token, inodep, &dir, &ent) ) < 0 )
return -1;
if (!(inodep = retrieve_inode(ent.et_ino)))
return -1;
type = inodep->i_type;
if (ent.et_ino != 1)
free(inodep);
}
if (i != (tokenc-1))
return -1;
token = *tokenp;
if ( (insert=search_entry(token, inodep, &dir, &ent)) < 0 )
return -1;
for (int i=0; i<tokenc; i++){ /* free tokens */
free(*(tokens+i));
}
free(tokens);
return ent.et_ino;
}
// both path and newpath are fs-relative
int nphfuse_rename(const char *path, const char *newpath)
{
log_msg("RENAME called for %s path to %s newpath\n", path, newpath);
struct timeval currTime;
npheap_store *inode = NULL;
char dir[236];
char filename[128];
//Root directory cannot be changed.
if(strcmp(path,"/")==0){
return -EACCES;
}
//Get inode into path
inode = retrieve_inode(path);
if(inode == NULL){
log_msg("Inode was not found in rename.\n");
return -ENOENT;
}
//Check if newpath is valid
int extract = extract_directory_file(dir, filename, newpath);
if(extract == 1){
log_msg("Newpath is invalid.\n");
return -EINVAL;
}
//Check if user has access
int flag = checkAccess(inode);
if(flag==0){
log_msg("Cannot access the directory.\n");
return - EACCES;
}
//memset the dirname and filename
//memset(inode->dirname, 0, 236);
//memset(inode->filename, 0, 128);
//copy the new path
strcpy(inode->dirname, dir);
strcpy(inode->filename, filename);
//Change the changetime
gettimeofday(&currTime, NULL);
inode->mystat.st_ctime = currTime.tv_sec;
log_msg("Exiting from RENAME.\n");
return 0;
}
/** File open operation
*
* No creation, or truncation flags (O_CREAT, O_EXCL, O_TRUNC)
* will be passed to open(). Open should check if the operation
* is permitted for the given flags. Optionally open may also
* return an arbitrary filehandle in the fuse_file_info structure,
* which will be passed to all file operations.
*
* Changed in version 2.2
*/
int nphfuse_open(const char *path, struct fuse_file_info *fi){
struct timeval currTime;
npheap_store *temp = NULL;
//Check for root directory
if(strcmp(path,"/")==0){
temp = getRootDirectory();
if(temp==NULL)
{
log_msg("Root directory not found in open.\n");
return -ENOENT;
}
else
{
int flag = checkAccess(temp);
//If cannot access
if(flag == 0){
log_msg("Root access denied.\n");
return -EACCES;
}
// Worked fine
log_msg("Access granted to root.\n");
return 0;
}
}
temp = retrieve_inode(path);
if(temp == NULL){
return -ENOENT;
}
int flag1 = checkAccess(temp);
//if cannot access
if(flag1 == 0){
log_msg("Access denied.\n");
return -EACCES;
}
//Everything worked fine
fi->fh = temp->mystat.st_ino;
gettimeofday(&currTime, NULL);
temp->mystat.st_atime = currTime.tv_sec;
return 0;
}
/** Open directory
*
* This method should check if the open operation is permitted for
* this directory
*
* Introduced in version 2.3
*/
int nphfuse_opendir(const char *path, struct fuse_file_info *fi){
// char *filename, *dir;
// extract_directory_file(&dir,&filename,path);
npheap_store *inode = NULL;
log_msg("Entry into OPENDIR.\n");
if(strcmp (path,"/")==0){
inode = getRootDirectory();
if(inode==NULL)
{
log_msg("Root directory not found in opendir.\n");
return -ENOENT;
}
else
{
//Check if accessibilty can be given
int flag = checkAccess(inode);
//Deny the access
log_msg("Root access %d (if 1 then yes)",flag);
if(flag == 0){
return -EACCES;
}
return 0;
}
}
inode = retrieve_inode(path);
if(inode == NULL){
log_msg("Couldn't find path - %s - in OPENDIR.\n", path);
return -ENOENT;
}
//Check Accessibility
int flag1 = checkAccess(inode);
//Deny the access
log_msg("Normal access %d (if 1 then yes)",flag1);
if(flag1 == 0){
return -EACCES;
}
//else return correct value
log_msg("Exit into OPENDIR.\n");
return 0;
}
/** Remove a file */
int nphfuse_unlink(const char *path){
//Individual file delete
npheap_store *inode = NULL;
log_msg("Into UNLINK for %s\n", path);
//Root directory cannot be deleted.
if(strcmp(path,"/")==0){
return -EACCES;
}
inode = retrieve_inode(path);
if(inode==NULL){
return -ENOENT;
}
//Check for permission
int flag = checkAccess(inode);
if(flag==0){
log_msg("Cannot access the directory\n");
return - EACCES;
}
//Check for dirname and filename
if(npheap_getsize(npheap_fd, inode->offset) != 0){
log_msg("Data offset exist. for %d data off\n", inode->offset);
npheap_delete(npheap_fd, inode->offset);
}
inode->dirname[0] = '\0';
inode->filename[0] = '\0';
blk_array[inode->offset] == NULL;
memset(inode, 0, sizeof(npheap_store));
log_msg("Exiting UNLINK.\n");
return 0;
}
int nphfuse_access(const char *path, int mask){
npheap_store *inode = NULL;
if(strcmp(path,"/")==0){
inode = getRootDirectory();
if(inode==NULL)
{
log_msg("Root directory not found in access.\n");
return -ENOENT;
}
else
{
log_msg("Checking Access of root\n");
int flag = checkAccess(inode);
if(flag==0){
log_msg("Cannot access the directory\n");
return -EACCES;
}
return 0;
}
}
inode = retrieve_inode(path);
if(inode == NULL){
return -ENOENT;
}
int flag = checkAccess(inode);
if(flag==0){
log_msg("Cannot access the directory\n");
return -EACCES;
}
return 0;
}
// I don't fully understand the documentation above -- it doesn't
// match the documentation for the read() system call which says it
// can return with anything up to the amount of data requested. nor
// with the fusexmp code which returns the amount of data also
// returned by read.
int nphfuse_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi){
log_msg("Into READ function.\n");
//Variables needed
npheap_store *inode = NULL;
struct timeval currTime;
char *blk_data = NULL;
//Root is not the file, so throw error
if(strcmp(path,"/")==0){
return -ENOENT;
}
inode = retrieve_inode(path);
if(inode==NULL){
log_msg("Couldn't find file.\n");
return -ENOENT;
}
//Check for the access
int flag = checkAccess(inode);
if(flag==0){
log_msg("Cannot access in root.\n");
return - EACCES;
}
blk_data = (char *)blk_array[inode->offset];
if(blk_data==NULL){
return -ENOENT;
}
size_t left_to_read = size;
size_t offset_read = offset;
size_t rem = 0;
size_t curr_buff = 0;
uint64_t curr_offset = 0;
uint64_t pos_in_offset = 0;
size_t curr_size = 0;
curr_size = npheap_getsize(npheap_fd, inode->offset);
if(curr_size == 0){
return 0;
}
log_msg("Reading started.\n");
while(left_to_read != 0){
//log_msg("Reached here\n");
pos_in_offset = offset_read/BLOCK_SIZE;
curr_offset = inode->offset;
while(pos_in_offset != 0){
curr_offset = dt_link[curr_offset-FIXED_VALUE];
pos_in_offset--;
}
blk_data = blk_array[curr_offset];
if(blk_data==NULL){
return -ENOENT;
}
log_msg("Reached with %s block data\n", blk_data);
if(npheap_getsize(npheap_fd, curr_offset) == 0){
return -EINVAL;
}
curr_size = npheap_getsize(npheap_fd, curr_offset);
rem = offset_read % BLOCK_SIZE;
if(curr_size <= left_to_read + rem){
log_msg("Reading still left.\n");
memcpy(buf + curr_buff, blk_data + rem, curr_size - rem);
offset_read = offset_read + curr_size - rem;
curr_buff = curr_buff + curr_size - rem;
left_to_read = left_to_read - curr_size + rem;
}else{
log_msg("Last read in the data block.\n");
memcpy(buf + curr_buff, blk_data + rem, left_to_read);
offset_read = offset_read + left_to_read;
curr_buff = curr_buff + left_to_read;
left_to_read = 0;
}
}
gettimeofday(&currTime, NULL);
inode->mystat.st_atime = currTime.tv_sec;
return curr_buff;
}