fuse.cc

/*
 * receive request from fuse and call methods of yfs_client
 *
 * started life as low-level example in the fuse distribution.  we
 * have to use low-level interface in order to get i-numbers.  the
 * high-level interface only gives us complete paths.
 */

#include <fuse_lowlevel.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <arpa/inet.h>
#include "yfs_client.h"
#include <algorithm>
#include <sstream>


int myid;
yfs_client *yfs;

int id() { 
  return myid;
}


yfs_client::inum get_new_inum(bool is_file)
{
  yfs_client::inum new_inum;
//  srand(time(NULL));
  new_inum = rand();

  if (is_file)
    new_inum |= 0x80000000;
  else
    new_inum &= 0x7FFFFFFF;

  return new_inum;
}




yfs_client::status
getattr(yfs_client::inum inum, struct stat &st)
{
  yfs_client::status ret;

  bzero(&st, sizeof(st));

  st.st_ino = inum;
  printf("getattr %016llx %d\n", inum, yfs->isfile(inum));
  if(yfs->isfile(inum)){
     yfs_client::fileinfo info;
     ret = yfs->getfile(inum, info);
     if(ret != yfs_client::OK)
       return ret;
     st.st_mode = S_IFREG | 0666;
     st.st_nlink = 1;
     st.st_atime = info.atime;
     st.st_mtime = info.mtime;
     st.st_ctime = info.ctime;
     st.st_size = info.size;
     printf("   getattr -> %llu\n", info.size);
   } else {
     yfs_client::dirinfo info;
     ret = yfs->getdir(inum, info);
     if(ret != yfs_client::OK)
       return ret;
     st.st_mode = S_IFDIR | 0777;
     st.st_nlink = 2;
     st.st_atime = info.atime;
     st.st_mtime = info.mtime;
     st.st_ctime = info.ctime;
     printf("   getattr -> %lu %lu %lu\n", info.atime, info.mtime, info.ctime);
   }
   return yfs_client::OK;
}


void
fuseserver_getattr(fuse_req_t req, fuse_ino_t ino,
          struct fuse_file_info *fi)
{
    struct stat st;
    yfs_client::inum inum = ino; // req->in.h.nodeid;
    yfs_client::status ret;

    //Lab 4
    yfs->acquire(inum);

    ret = getattr(inum, st);

    yfs->release(inum);

    //Lab 4

    if(ret != yfs_client::OK){
      fuse_reply_err(req, ENOENT);

      return;
    }
    fuse_reply_attr(req, &st, 0);
}

void
fuseserver_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr, int to_set, struct fuse_file_info *fi)
{
  printf("fuseserver_setattr 0x%x\n", to_set);
  if (FUSE_SET_ATTR_SIZE & to_set) {
    printf("   fuseserver_setattr set size to %llu\n", attr->st_size);
    struct stat st;
    yfs_client::inum inum = ino;
    if (yfs->isfile(inum)) {  //Only a File
      std::string fileContent; 


      yfs->acquire(inum);//Lab 4 
      

      yfs->get_fileDir_content(inum, fileContent); //Get the Content
      size_t sizeDiff =  fileContent.size() - attr->st_size;
      if(sizeDiff > 0) {
        fileContent = fileContent.substr(0, attr->st_size);
      } else { //
        fileContent.append(-sizeDiff,'\0'); //Padding Bytes
      } 

      yfs->put(inum, fileContent); //Push the Contents
      getattr(inum, st); //Get the Attributes;Return it.

      yfs->release(inum); //Lab 4
 
      fuse_reply_attr(req, &st, 0);
    }  
    else
      fuse_reply_err(req, ENOSYS);
  } else {
    fuse_reply_err(req, ENOSYS);
  } 
}     

void
fuseserver_read(fuse_req_t req, fuse_ino_t ino, size_t size,
      off_t off, struct fuse_file_info *fi)
{

 yfs_client::inum fin = ino;
 
 if(yfs->isfile(fin)) {
  std::string fileContent, contentToRet;

  yfs->acquire(fin);  //Lab 4

  yfs->get_fileDir_content(fin, fileContent);
  yfs->release(fin); //Lab 4

  contentToRet = fileContent.substr(off, size);

  fuse_reply_buf(req, contentToRet.c_str(), contentToRet.size());
 }
 else
  fuse_reply_err(req, ENOSYS);
}

void
fuseserver_write(fuse_req_t req, fuse_ino_t ino,
  const char *buf, size_t size, off_t off,
  struct fuse_file_info *fi)
{

  yfs_client::inum fin = ino;
  if(yfs->isfile(fin)) {
  
   yfs->acquire(fin); //Lab 4

   std::string fileContent, contentToWrite = buf, toWrite;

   yfs->get_fileDir_content(fin, fileContent);
    
   //Preprocess the buf
 /*  size_t diff = contentToWrite.size() - size;
   if(diff < 0) //Need to Append More
   {
     toWrite = contentToWrite.append(-diff, '\0');
   } else {
     toWrite = contentToWrite.substr(0, size);
   }  */
  
   if(contentToWrite.size() >= size) {
      toWrite = contentToWrite.substr(0, size);
   } else {
      toWrite = contentToWrite.append(size - contentToWrite.size(), '\0');
   } 
  
   //Put it at the offset
   if(fileContent.size() < off) {   //Offset is greater
     fileContent.append(off-fileContent.size(), '\0'); //Append Zeros  
     fileContent.append(toWrite);
   } else if ( fileContent.size() <= off + size ) {
     fileContent = fileContent.substr(0, off);
     fileContent.append(toWrite); 
   } else {
     fileContent.replace(off, size, toWrite);
   }

   yfs->put(ino, fileContent);

   yfs->release(fin); //Lab 4

   fuse_reply_write(req, size);
 } 
 else
  fuse_reply_err(req, ENOSYS);
}

yfs_client::status
fuseserver_createhelper(fuse_ino_t parent, const char *name,
     mode_t mode, struct fuse_entry_param *e)
{
  // You fill this in
    std::cout << "Hh:" << std::endl;
 
  if(yfs->isdir(parent)) {

     yfs->acquire(parent);  //lab4
        
     //Check if File Already Exists
     std::string dirCon;
     yfs->get_fileDir_content(parent, dirCon);
     std::string nameToSearch = name;
     std::string::size_type pos = dirCon.find(nameToSearch+"=");
     if(pos != std::string::npos) 
     {	
	std::cout << "File or Dir Already Exists" << std::endl;
	yfs->release(parent);
	return yfs_client::EXIST;
     }	
     
     //Get a File No
     yfs_client::inum fileNum = get_new_inum(true);		
     
     yfs->acquire(fileNum); //Lab 4

     dirCon.append(name);  
     dirCon.append("=");
     dirCon.append(yfs->filename(fileNum));
     dirCon.append(";");

     yfs->put(fileNum, ""); //Put the File
     yfs->put(parent, dirCon); //Put the Directory

     e->attr_timeout = 0.0;
     e->entry_timeout = 0.0;
     e->ino = fileNum;	
     getattr(e->ino, e->attr);  
	

     //lab 4
     yfs->release(fileNum);
     yfs->release(parent);
     //Lab 4
     return yfs_client::OK;	
  }   
  return yfs_client::NOENT;
}  

void
fuseserver_create(fuse_req_t req, fuse_ino_t parent, const char *name,
   mode_t mode, struct fuse_file_info *fi)
{
  struct fuse_entry_param e;
  yfs_client::status status = fuseserver_createhelper(parent, name, mode, &e);
  if( status == yfs_client::OK ) {
    fuse_reply_create(req, &e, fi);
  } else if (status == yfs_client::EXIST) {
    fuse_reply_err(req, EEXIST);
  } else {
    fuse_reply_err(req, ENOENT);
  }
}

void fuseserver_mknod( fuse_req_t req, fuse_ino_t parent, 
    const char *name, mode_t mode, dev_t rdev ) {

  struct fuse_entry_param e;
  yfs_client::status status = fuseserver_createhelper(parent, name, mode, &e);

  if( status == yfs_client::OK ) {
    fuse_reply_entry(req, &e);
  } else if (status == yfs_client::EXIST) {
    fuse_reply_err(req, EEXIST);
  } else {
    fuse_reply_err(req, ENOENT);
  }
}  

void
fuseserver_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
{  
  struct fuse_entry_param e;
  bool found = true;

  e.attr_timeout = 0.0;
  e.entry_timeout = 0.0;

  // You fill this in:
  // Look up the file named `name' in the directory referred to by
  // `parent' in YFS. If the file was found, initialize e.ino and
  // e.attr appropriately.

  //Get the content of dir
  std::string dirCon, nameToSearch = name; 

  yfs_client::inum iNo; 

  yfs->acquire(parent); //Lab4
 
  yfs->get_fileDir_content(parent, dirCon);				
  size_t pos = dirCon.find(nameToSearch + "="); 
  
  if(pos == std::string::npos) 			
  { 				
    found = false;              		             
  }                                             		 
  else {
    std::string temp = dirCon.substr(pos);
    size_t start = temp.find_first_of("=");
    size_t end   = temp.find_first_of(";");
    std::string inum_str = temp.substr(start+1, end-1);	    

    e.ino = yfs->n2i(inum_str);
    iNo = e.ino;

     
    yfs->acquire(iNo); //Lab 4

    if(getattr(e.ino, e.attr) != yfs_client::OK) {
      found = false;    
    } 
   

  yfs->release(iNo);  //Lab4 
  }

  yfs->release(parent); //Lab4  

  if (found)
    fuse_reply_entry(req, &e);
  else
    fuse_reply_err(req, ENOENT);
}                                 


struct dirbuf {
    char *p;
    size_t size;
};

void dirbuf_add(struct dirbuf *b, const char *name, fuse_ino_t ino)
{
    struct stat stbuf;
    size_t oldsize = b->size;
    b->size += fuse_dirent_size(strlen(name));
    b->p = (char *) realloc(b->p, b->size);
    memset(&stbuf, 0, sizeof(stbuf));
    stbuf.st_ino = ino;
    fuse_add_dirent(b->p + oldsize, name, &stbuf, b->size);
}

#define min(x, y) ((x) < (y) ? (x) : (y))

int reply_buf_limited(fuse_req_t req, const char *buf, size_t bufsize,
          off_t off, size_t maxsize)
{
  if (off < bufsize)
    return fuse_reply_buf(req, buf + off, min(bufsize - off, maxsize));
  else
    return fuse_reply_buf(req, NULL, 0);
}

void
fuseserver_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
          off_t off, struct fuse_file_info *fi)
{
  yfs_client::inum inum = ino; // req->in.h.nodeid;
  struct dirbuf b;
  yfs_client::dirent e;

  printf("fuseserver_readdir\n");

  if(!yfs->isdir(inum)){
    fuse_reply_err(req, ENOTDIR);
    return;
  }

  memset(&b, 0, sizeof(b));
  
  std::string dirCon;

  yfs->acquire(inum); //Lab 4 

  yfs->get_fileDir_content(inum, dirCon);

  std::vector<std::string> list;
  std::stringstream ss(dirCon);
  std::string file;
  while(getline(ss, file, ';' )) 
    list.push_back(file);

  size_t pos;
  std::string file_name;
  yfs_client::inum file_inum;
  for (int i = 0; i < list.size(); i++)
  {
    pos = list[i].find("=");
    file_name = list[i].substr(0, pos);
    file_inum = yfs->n2i(list[i].substr(pos + 1));
    dirbuf_add(&b, file_name.c_str(), file_inum); 
  }    

  yfs->release(inum); //Lab 4

  reply_buf_limited(req, b.p, b.size, off, size);
  free(b.p);
}


void
fuseserver_open(fuse_req_t req, fuse_ino_t ino,
     struct fuse_file_info *fi)
{
  yfs_client::inum inum = ino;
  std::cout << "Hh:" << std::endl;
  if (yfs->isfile(inum))
  {
    fi->fh = fi->flags;
    fuse_reply_open(req, fi);
  }
  else
  {
    fuse_reply_err(req, ENOSYS);
  }  
}

void
fuseserver_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name,
     mode_t mode)
{
  struct fuse_entry_param e;

  if (yfs->isdir(parent)) {

   yfs->acquire(parent); //Lab 4 
 
   std::cout << "Lock Give:\n"; 
  
   std::string dirName = name;
   std::string dirContent;

   yfs_client::inum newNo = get_new_inum(false);//Get a DirNo

   yfs->acquire(newNo); //Lab 4


   yfs->get_fileDir_content(parent, dirContent);


   dirContent.append(name);
   dirContent.append("=");
   dirContent.append(yfs->filename(newNo));
   dirContent.append(";");

   yfs->put(newNo , ""); //Put the File
   yfs->put(parent, dirContent); //Put the Directory

   std::cout << "Dir:" << dirContent << std::endl;

   e.attr_timeout = 0.0;
   e.entry_timeout = 0.0;
   e.ino = newNo;
   getattr(e.ino, e.attr);


   yfs->release(newNo);  //Lab4
   std::cout << "This is Dpme:" << std::endl;
   yfs->release(parent); //Lab4
   std::cout << "Doing this:" << std::endl;

   fuse_reply_entry(req, &e);
  } else      
  fuse_reply_err(req, ENOSYS);
}  

void
fuseserver_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
{
  bool found = false;

    if (yfs->isdir(parent))
  {

  std::cout << "Hereee:" << std::endl;
  //Get the content of dir
  std::string dirCon, nameToSearch = name;

  yfs->acquire(parent); //Lab 4

  yfs->get_fileDir_content(parent, dirCon);
  size_t pos = dirCon.find(nameToSearch + "=");

  if(pos == std::string::npos)
  {
    found = false;
  }  
  else {
    found = true;
    std::string temp = dirCon.substr(pos);
    size_t start = temp.find_first_of("=");
    size_t end   = temp.find_first_of(";");
    std::string inum_str = temp.substr(start+1, end-1);
    dirCon.erase(pos,end+1);    

   
    yfs_client::inum iNo= yfs->n2i(inum_str);   
   
 
    yfs->put(parent, dirCon);

    yfs->acquire(iNo); //Lab4

    yfs->remove(iNo);

    yfs->release(iNo); //Lab4
           
  } 
  
  yfs->release(parent); //Lab 4
 }

  if (found)
    fuse_reply_err(req, 0);
  else
    fuse_reply_err(req, ENOENT);

  //fuse_reply_err(req, ENOSYS);
}

void
fuseserver_statfs(fuse_req_t req)
{
  struct statvfs buf;

  printf("statfs\n");

  memset(&buf, 0, sizeof(buf));

  buf.f_namemax = 255;
  buf.f_bsize = 512;

  fuse_reply_statfs(req, &buf);
}

struct fuse_lowlevel_ops fuseserver_oper;

int
main(int argc, char *argv[])
{
  char *mountpoint = 0;
  int err = -1;
  int fd;

  setvbuf(stdout, NULL, _IONBF, 0);

  if(argc != 4){
    fprintf(stderr, "Usage: yfs_client <mountpoint> <port-extent-server> <port-lock-server>\n");
    exit(1);
  }
  mountpoint = argv[1];

  srandom(getpid());

  myid = random();

  yfs = new yfs_client(argv[2], argv[3]);

  fuseserver_oper.getattr    = fuseserver_getattr;
  fuseserver_oper.statfs     = fuseserver_statfs;
  fuseserver_oper.readdir    = fuseserver_readdir;
  fuseserver_oper.lookup     = fuseserver_lookup;
  fuseserver_oper.create     = fuseserver_create;
  fuseserver_oper.mknod      = fuseserver_mknod;
  fuseserver_oper.open       = fuseserver_open;
  fuseserver_oper.read       = fuseserver_read;
  fuseserver_oper.write      = fuseserver_write;
  fuseserver_oper.setattr    = fuseserver_setattr;
  fuseserver_oper.unlink     = fuseserver_unlink;
  fuseserver_oper.mkdir      = fuseserver_mkdir;

  const char *fuse_argv[20];
  int fuse_argc = 0;
  fuse_argv[fuse_argc++] = argv[0];
#ifdef __APPLE__
  fuse_argv[fuse_argc++] = "-o";
  fuse_argv[fuse_argc++] = "nolocalcaches"; // no dir entry caching
  fuse_argv[fuse_argc++] = "-o";
  fuse_argv[fuse_argc++] = "daemon_timeout=86400";
#endif

  // everyone can play, why not?
  //fuse_argv[fuse_argc++] = "-o";
  //fuse_argv[fuse_argc++] = "allow_other";

  fuse_argv[fuse_argc++] = mountpoint;
  fuse_argv[fuse_argc++] = "-d";

  fuse_args args = FUSE_ARGS_INIT( fuse_argc, (char **) fuse_argv );
  int foreground;
  int res = fuse_parse_cmdline( &args, &mountpoint, 0 /*multithreaded*/, 
        &foreground );
  if( res == -1 ) {
    fprintf(stderr, "fuse_parse_cmdline failed\n");
    return 0;
  }
  
  args.allocated = 0;

  fd = fuse_mount(mountpoint, &args);
  if(fd == -1){
    fprintf(stderr, "fuse_mount failed\n");
    exit(1);
  }

  struct fuse_session *se;

  se = fuse_lowlevel_new(&args, &fuseserver_oper, sizeof(fuseserver_oper),
       NULL);
  if(se == 0){
    fprintf(stderr, "fuse_lowlevel_new failed\n");
    exit(1);
  }

  struct fuse_chan *ch = fuse_kern_chan_new(fd);
  if (ch == NULL) {
    fprintf(stderr, "fuse_kern_chan_new failed\n");
    exit(1);
  }

  fuse_session_add_chan(se, ch);
  // err = fuse_session_loop_mt(se);   // FK: wheelfs does this; why?
  err = fuse_session_loop(se);
    
  fuse_session_destroy(se);
  close(fd);
  fuse_unmount(mountpoint);

  return err ? 1 : 0;
}