src/main.cc

   1 /***************************************************************************
   2  *  Copyright (C) 2006  Kent Gustavsson <nedo80@gmail.com>
   3  ****************************************************************************/
   4 /*
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19 #define FUSE_USE_VERSION 25
  20
  21 #include <fuse.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <fuse_opt.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <cstdlib>
  30
  31 #include <iostream>
  32 #include <fstream>
  33 #include "rarblock.h"
  34 #include "rararchive.h"
  35
  36 RARArchive arc;
  37
  38 static int rarfs_getattr(const char *p, struct stat *stbuf)
  39 {
  40         int res = 0;
  41
  42         std::string path = p + 1;
  43         int pos;
  44         while ( (pos = path.find("/")) != std::string::npos )
  45                 path.replace(pos,1,"\\");
  46
  47         memset(stbuf, 0, sizeof(struct stat));
  48         if(strcmp(p, "/") == 0)
  49         {
  50                 stbuf->st_mode = S_IFDIR | 0755;
  51                 stbuf->st_nlink = 2;
  52
  53                 arc.GetDate(path, &stbuf->st_atim);
  54                 arc.GetDate(path, &stbuf->st_mtim);
  55         }
  56         else if(arc.HasFolder(path))
  57         {
  58                 stbuf->st_mode = S_IFDIR | 0755;
  59                 stbuf->st_nlink = 2;
  60                 arc.GetDate(path, &stbuf->st_atim);
  61                 arc.GetDate(path, &stbuf->st_mtim);
  62         }
  63         else if(arc.HasFile(path))
  64         {
  65                 stbuf->st_mode = S_IFREG | 0444;
  66                 stbuf->st_nlink = 1;
  67                 stbuf->st_size = arc.GetFileSize(path);
  68                 arc.GetDate(path, &stbuf->st_atim);
  69                 arc.GetDate(path, &stbuf->st_mtim);
  70         }
  71         else
  72                 res = -ENOENT;
  73
  74         return res;
  75 }
  76
  77 static int rarfs_readdir(const char *p, void *buf, fuse_fill_dir_t filler,
  78                          off_t offset, struct fuse_file_info *fi)
  79 {
  80         std::vector<std::string> list = arc.GetFiles();
  81         std::vector<std::string>::iterator iter;
  82         std::map < std::string, int > ugly;
  83
  84         std::string path = p + 1;
  85         int pos;
  86         while ( (pos = path.find("/")) != std::string::npos )
  87                 path.replace(pos,1,"\\");
  88
  89         if(strcmp(p, "/") != 0)
  90         {
  91                 if (!arc.HasFolder(path))
  92                         return -ENOENT;
  93         }
  94
  95         filler(buf, ".", NULL, 0);
  96         filler(buf, "..", NULL, 0);
  97
  98         for(iter = list.begin() ; iter != list.end() ; iter++)
  99         {
 100                 if( iter->size() > path.size() )
 101                 {
 102                         if ( iter->substr(0, path.size()) == path )
 103                         {
 104                                 std::string file = iter->substr(path.size());
 105                                 if ( file[0] == '\\' )
 106                                         file = file.substr(1);
 107
 108                                 if( file.find("\\") == std::string::npos )
 109                                 {
 110                                         filler(buf, file.c_str(), NULL, 0);
 111                                 }
 112                         }
 113                 }
 114         }
 115
 116         list = arc.GetFolders();
 117         for(iter = list.begin() ; iter != list.end() ; iter++)
 118         {
 119                 if( iter->size() > path.size() )
 120                 {
 121                         if ( iter->substr(0, path.size()) == path )
 122                         {
 123                                 std::string folder = iter->substr(path.size());
 124                                 if ( folder[0] == '\\' )
 125                                         folder = folder.substr(1);
 126                                 folder = folder.substr(0, folder.find("\\"));
 127                                 ugly[folder] = 1;
 128                         }
 129                 }
 130         }
 131
 132         std::map <std::string, int>::iterator ui;
 133         for( ui = ugly.begin() ; ui != ugly.end() ; ui++)
 134                 filler(buf, ui->first.c_str(), NULL, 0);
 135
 136         return 0;
 137 }
 138
 139 static int rarfs_open(const char *p, fuse_file_info *fi)
 140 {
 141         std::string path = p + 1;
 142         int pos;
 143         while ( (pos = path.find("/")) != std::string::npos )
 144                 path.replace(pos,1,"\\");
 145
 146
 147         if(!arc.HasFile(path))
 148                 return -ENOENT;
 149
 150
 151         if((fi->flags & 3) != O_RDONLY)
 152                 return -EACCES;
 153
 154         return 0;
 155 }
 156
 157 static int rarfs_read(const char *p, char *buf, size_t size, off_t offset, fuse_file_info *fi)
 158 {
 159         std::string path = p + 1;
 160         int pos;
 161         while ( (pos = path.find("/")) != std::string::npos )
 162                 path.replace(pos,1,"\\");
 163
 164         size_t len;
 165         if(!arc.HasFile(path))
 166                 return -ENOENT;
 167
 168         return arc.Read(path.c_str(), buf, size, offset) ;
 169 }
 170
 171 static struct fuse_operations rarfs_oper;
 172
 173 struct Opt
 174 {
 175         Opt();
 176
 177         char rarfile[512];
 178         bool mount_expected;
 179
 180         static const int KEEP = 1;
 181         static const int DISCARD = 0;
 182 };
 183
 184 Opt::Opt() :
 185 mount_expected(true)
 186 {
 187         rarfile[0] = 0;
 188 }
 189
 190 static struct fuse_opt rarfs_opts[] = {
 191 };
 192
 193 static int rarfs_opt_proc(void *data, const char *arg, int key,
 194                           struct fuse_args *outargs)
 195 {
 196         Opt *param = static_cast<Opt*>(data);
 197
 198         switch (key) {
 199                 case FUSE_OPT_KEY_NONOPT:
 200                         if( param->rarfile[0] == 0 )
 201                         {
 202                                 strcpy(param->rarfile, arg);
 203                                 return Opt::DISCARD;
 204                         }
 205                         break;
 206         }
 207
 208         return Opt::KEEP;
 209 }
 210
 211 int main( int argc, char ** argv)
 212 {
 213
 214         struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
 215         Opt param;
 216
 217         if (fuse_opt_parse(&args, &param, rarfs_opts, rarfs_opt_proc) == -1)
 218                 exit(1);
 219
 220         if ( param.mount_expected )
 221         {
 222                 if ( ! arc.Init(param.rarfile) )
 223                 {
 224                         printf("USAGE: %s <file> <dir>\n", argv[0]);
 225                         return -1;
 226                 }
 227
 228                 rarfs_oper.getattr = rarfs_getattr;
 229                 rarfs_oper.readdir = rarfs_readdir;
 230                 rarfs_oper.open = rarfs_open;
 231                 rarfs_oper.read = rarfs_read;
 232
 233                 arc.Parse(false);
 234         }
 235
 236         return fuse_main(args.argc, args.argv, &rarfs_oper);
 237 }