Roxen.git/ server/ modules/ filesystems/ filesystem.pike > f4e53686861947ca9aac1e2168542f2404654025 [Annotate]

// This is a roxen module. Copyright © 1996 - 1999, Idonex AB. 

// This is a virtual "file-system". 

// It will be located somewhere in the name-space of the server. 

// Also inherited by some of the other filesystems. 

inherit "module"; 

inherit "roxenlib"; 

inherit "socket"; 

constant cvs_version= "$Id: filesystem.pike,v 1.71 2000/03/07 23:58:06 mast Exp $"; 

constant thread_safe=1; 

#include <module.h> 

#include <roxen.h> 

#include <stat.h> 

#include <request_trace.h> 

#if DEBUG_LEVEL > 20 

# ifndef FILESYSTEM_DEBUG 

#  define FILESYSTEM_DEBUG 

# endif 

#endif 

#ifdef FILESYSTEM_DEBUG 

# define FILESYSTEM_WERR(X) werror("Filesystem: "+X+"\n") 

#else 

# define FILESYSTEM_WERR(X) 

#endif 

#ifdef QUOTA_DEBUG 

# define QUOTA_WERR(X) werror("QUOTA: "+X+"\n") 

#else 

# define QUOTA_WERR(X) 

#endif 

constant module_type = MODULE_LOCATION; 

constant module_name = "Filesystem"; 

constant module_doc = 

("This is a virtual filesystem, use it to make files available to "+ 

 "the users of your WWW-server. If you want to serve any 'normal' " 

 "files from your server, you will have to have atleast one filesystem.") ; 

constant module_unique = 0; 

int redirects, accesses, errors, dirlists; 

int puts, deletes, mkdirs, moves, chmods; 

static mapping http_low_answer(int errno, string data, string|void desc) 

{ 

  mapping res = ::http_low_answer(errno, data); 

  if (desc) { 

    res->rettext = desc; 

  } 

  return res; 

} 

static int do_stat = 1; 

string status() 

{ 

  return "<h2>Accesses to this filesystem</h2>"+ 

    (redirects?"<b>Redirects</b>: "+redirects+"<br>":"")+ 

    (accesses?"<b>Normal files</b>: "+accesses+"<br>" 

     :"No file accesses<br>")+ 

    (QUERY(put)&&puts?"<b>Puts</b>: "+puts+"<br>":"")+ 

    (QUERY(put)&&mkdirs?"<b>Mkdirs</b>: "+mkdirs+"<br>":"")+ 

    (QUERY(put)&&QUERY(delete)&&moves? 

     "<b>Moved files</b>: "+moves+"<br>":"")+ 

    (QUERY(put)&&chmods?"<b>CHMODs</b>: "+chmods+"<br>":"")+ 

    (QUERY(delete)&&deletes?"<b>Deletes</b>: "+deletes+"<br>":"")+ 

    (errors?"<b>Permission denied</b>: "+errors 

     +" (not counting .htaccess)<br>":"")+ 

    (dirlists?"<b>Directories</b>:"+dirlists+"<br>":""); 

} 

void create() 

{ 

  defvar("mountpoint", "/", "Mount point", TYPE_LOCATION|VAR_INITIAL, 

         "This is where the module will be inserted in the "+ 

         "namespace of your server."); 

  defvar("searchpath", "NONE", "Search path", TYPE_DIR|VAR_INITIAL, 

         "This is where the module will find the files in the real "+ 

         "file system"); 

  defvar(".files", 0, "Show hidden files", TYPE_FLAG|VAR_MORE, 

         "If set, hidden files will be shown in dirlistings and you " 

         "will be able to retrieve them."); 

  defvar("dir", 1, "Enable directory listings per default", TYPE_FLAG|VAR_MORE, 

         "If set, you have to create a file named .www_not_browsable " 

         "or .nodiraccess in a directory to disable directory listings." 

         " If unset, a file named .www_browsable in a directory will " 

         "_enable_ directory listings.\n"); 

  defvar("tilde", 0, "Show backup files", TYPE_FLAG|VAR_MORE, 

         "If set, files ending with '~' or '#' or '.bak' will "+ 

         "be shown in directory listings"); 

  defvar("put", 0, "Handle the PUT method", TYPE_FLAG, 

         "If set, PUT can be used to upload files to the server."); 

  defvar("delete", 0, "Handle the DELETE method", TYPE_FLAG, 

         "If set, DELETE can be used to delete files from the " 

         "server."); 

  defvar("check_auth", 1, "Require authentication for modification", 

         TYPE_FLAG, 

         "Only allow authenticated users to use methods other than " 

         "GET and POST. If unset, this filesystem will be a _very_ " 

         "public one (anyone can edit files located on it)"); 

  defvar("stat_cache", 0, "Cache the results of stat(2)", 

         TYPE_FLAG|VAR_MORE, 

         "This can speed up the retrieval of files up to 70% if you " 

         "use NFS, but it does use some memory.\n" 

         "<p>Also note that the cached results are only rechecked when the " 

         "file is fetched with the no-cache pragma (produced e.g. by " 

         "Alt-Ctrl-Reload in Netscape), when the module is reloaded " 

         "or when the cached entry has expired. " 

         "Thus, it's not recommended to use this on filesystems that " 

         "change a lot."); 

  defvar("access_as_user", 0, "Access file as the logged in user", 

         TYPE_FLAG|VAR_MORE, 

         "Access file as the logged in user. This is useful for eg " 

         "named-ftp.<br>\n" 

         "WARNING: This can have severe impact on performance when using " 

         "threads, since all threads need to be locked every time such " 

         "an access is done."); 

  defvar("no_symlinks", 0, "Forbid access to symlinks", TYPE_FLAG|VAR_MORE, 

         "Forbid access to paths containing symbolic links.<br>\n" 

         "NOTE: This can cause *alot* of lstat system-calls to be performed " 

         "and can make the server much slower."); 

  defvar("charset", "iso-8859-1", "File charset", TYPE_STRING, 

         "The charset the files on disk have."); 

  defvar("internal_files", ({}), "Internal files", TYPE_STRING_LIST, 

         "A comma separated list of glob patterns that matches files " 

         "which should be considered internal. Internal files can't be " 

         "requested directly from a client, won't show up in directory " 

         "listings and can never be uploaded, moved or deleted from a " 

         "client. They can only be accessed internally, e.g. with the " 

         "RXML <tt>&lt;insert&gt;</tt> and <tt>&lt;use&gt;</tt> tags."); 

} 

string path; 

int stat_cache; 

void start() 

{ 

  path = QUERY(searchpath); 

  stat_cache = QUERY(stat_cache); 

  FILESYSTEM_WERR("Online at "+QUERY(mountpoint)+" (path="+path+")"); 

  cache_expire("stat_cache"); 

} 

string query_location() 

{ 

  return QUERY(mountpoint); 

} 

#define FILTER_INTERNAL_FILE(f, id) \ 

  (!id->misc->internal_get && sizeof (filter (QUERY (internal_files), glob, (f/"/")[-1]))) 

mixed stat_file( string f, RequestID id ) 

{ 

  array fs; 

  FILESYSTEM_WERR("stat_file for \""+f+"\""); 

  if (FILTER_INTERNAL_FILE (f, id)) return 0; 

  if(stat_cache && !id->pragma["no-cache"] && 

     (fs=cache_lookup("stat_cache",path+f))) 

    return fs[0]; 

  object privs; 

  if (((int)id->misc->uid) && ((int)id->misc->gid) && 

      (QUERY(access_as_user))) { 

    // NB: Root-access is prevented. 

    privs=Privs("Statting file", (int)id->misc->uid, (int)id->misc->gid ); 

  } 

  fs = file_stat(path + f);  /* No security currently in this function */ 

  privs = 0; 

  if(!stat_cache) 

    return fs; 

  cache_set("stat_cache", path+f, ({fs})); 

  return fs; 

} 

string real_file( string f, RequestID id ) 

{ 

  if(this->stat_file( f, id )) 

/* This filesystem might be inherited by other filesystem, therefore 

   'this'  */ 

    return path + f; 

} 

int dir_filter_function(string f, RequestID id) 

{ 

  if(f[0]=='.' && !QUERY(.files))           return 0; 

  if(!QUERY(tilde) && backup_extension(f))  return 0; 

  if (FILTER_INTERNAL_FILE (f, id))         return 0; 

  return 1; 

} 

array find_dir( string f, RequestID id ) 

{ 

  mixed ret; 

  array dir; 

  FILESYSTEM_WERR("find_dir for \""+f+"\""); 

  object privs; 

  if (((int)id->misc->uid) && ((int)id->misc->gid) && 

      (QUERY(access_as_user))) { 

    // NB: Root-access is prevented. 

    privs=Privs("Getting dir", (int)id->misc->uid, (int)id->misc->gid ); 

  } 

  if(!(dir = get_dir( path + f ))) { 

    privs = 0; 

    return 0; 

  } 

  privs = 0; 

  if(!QUERY(dir)) 

    // Access to this dir is allowed. 

    if(search(dir, ".www_browsable") == -1) 

    { 

      errors++; 

      return 0; 

    } 

  // Access to this dir is not allowed. 

  if(sizeof(dir & ({".nodiraccess",".www_not_browsable",".nodir_access"}))) 

  { 

    errors++; 

    return 0; 

  } 

  dirlists++; 

  // Pass _all_ files, hide none. 

  if(QUERY(tilde) && QUERY(.files) && 

     (!sizeof (QUERY (internal_files)) || id->misc->internal_get)) 

    /* This is quite a lot faster */ 

    return dir; 

  return Array.filter(dir, dir_filter_function, id); 

} 

mapping putting = ([]); 

void done_with_put( array(object|string) id_arr ) 

{ 

//  werror("Done with put.\n"); 

  object to; 

  object from; 

  object id; 

  string oldf; 

  [to, from, id, oldf] = id_arr; 

  FILESYSTEM_WERR(sprintf("done_with_put(%O)\n" 

                          "from: %O\n", 

                          id_arr, mkmapping(indices(from), values(from)))); 

  to->close(); 

  from->set_blocking(); 

  m_delete(putting, from); 

  if (putting[from] && (putting[from] != 0x7fffffff)) { 

    // Truncated! 

    id->send_result(http_low_answer(400, 

                                    "<h2>Bad Request - " 

                                    "Expected more data.</h2>")); 

  } else { 

    id->send_result(http_low_answer(200, "<h2>Transfer Complete.</h2>")); 

  } 

} 

void got_put_data( array (object|string) id_arr, string data ) 

{ 

// werror(strlen(data)+" .. "); 

  object to; 

  object from; 

  object id; 

  string oldf; 

  [to, from, id, oldf] = id_arr; 

  // Truncate at end. 

  data = data[..putting[from]]; 

  if (id->misc->quota_obj && 

      !id->misc->quota_obj->check_quota(oldf, sizeof(data))) { 

    to->close(); 

    from->set_blocking(); 

    m_delete(putting, from); 

    id->send_result(http_low_answer(413, "<h2>Out of disk quota.</h2>", 

                                    "413 Out of disk quota")); 

    return; 

  } 

  int bytes = to->write( data ); 

  if (bytes < sizeof(data)) { 

    // Out of disk! 

    to->close(); 

    from->set_blocking(); 

    m_delete(putting, from); 

    id->send_result(http_low_answer(413, "<h2>Disk full.</h2>")); 

    return; 

  } else { 

    if (id->misc->quota_obj && 

        !id->misc->quota_obj->allocate(oldf, bytes)) { 

      to->close(); 

      from->set_blocking(); 

      m_delete(putting, from); 

      id->send_result(http_low_answer(413, "<h2>Out of disk quota.</h2>", 

                                      "413 Out of disk quota")); 

      return; 

    } 

    if (putting[from] != 0x7fffffff) { 

      putting[from] -= bytes; 

    } 

    if(putting[from] <= 0) { 

      putting[from] = 0;        // Paranoia 

      done_with_put( id_arr ); 

    } 

  } 

} 

int _file_size(string X,object id) 

{ 

  array fs; 

  if(!id->pragma["no-cache"]&&(fs=cache_lookup("stat_cache",(X)))) 

  { 

    id->misc->stat = fs[0]; 

    return fs[0]?fs[0][ST_SIZE]:-1; 

  } 

  if(fs = file_stat(X)) 

  { 

    id->misc->stat = fs; 

    cache_set("stat_cache",(X),({fs})); 

    return fs[ST_SIZE]; 

  } else 

    cache_set("stat_cache",(X),({0})); 

  return -1; 

} 

#define FILE_SIZE(X) (stat_cache?_file_size((X),id):Stdio.file_size(X)) 

int contains_symlinks(string root, string path) 

{ 

  array arr = path/"/"; 

  foreach(arr - ({ "" }), path) { 

    root += "/" + path; 

    if (arr = file_stat(root, 1)) { 

      if (arr[1] == -3) { 

        return(1); 

      } 

    } else { 

      return(0); 

    } 

  } 

  return(0); 

} 

mixed find_file( string f, RequestID id ) 

{ 

  TRACE_ENTER("find_file(\""+f+"\")", 0); 

  object o; 

  int size; 

  string tmp; 

  string oldf = f; 

  FILESYSTEM_WERR("Request for \""+f+"\""); 

  string mountpoint = QUERY(mountpoint); 

  string uri = combine_path(mountpoint + "/" + f, "."); 

  f = path + f; 

#ifdef __NT__ 

  if(f[-1]=='/') f = f[..strlen(f)-2]; 

#endif 

  size = FILE_SIZE( f ); 

  /* 

   * FIXME: Should probably move path-info extraction here. 

   *    /grubba 1998-08-26 

   */ 

  switch(id->method) 

  { 

  case "GET": 

  case "HEAD": 

  case "POST": 

    switch(-size) 

    { 

    case 1: 

    case 3: 

    case 4: 

      TRACE_LEAVE("No file"); 

      return 0; /* Is no-file */ 

    case 2: 

      TRACE_LEAVE("Is directory"); 

      return -1; /* Is dir */ 

    default: 

      if(f[ -1 ] == '/') /* Trying to access file with '/' appended */ 

      { 

        /* Neotron was here. I changed this to always return 0 since 

         * CGI-scripts with path info = / won't work otherwise. If 

         * someone accesses a file with "/" appended, a 404 no such 

         * file isn't that weird. Both Apache and Netscape return the 

         * accessed page, resulting in incorrect links from that page. 

         * 

         * FIXME: The proper way to do this would probably be to set path info 

         *   here, and have the redirect be done by the extension modules, 

         *   or by the protocol module if there isn't any extension module. 

         *      /grubba 1998-08-26 

         */ 

        return 0; 

        /* Do not try redirect on top level directory */ 

        if(sizeof(id->not_query) < 2) 

          return 0; 

        redirects++; 

        // Note: Keep the query part. 

        /* FIXME: Should probably keep prestates etc too. 

         *      /grubba 1999-01-14 

         */ 

        string new_query = 

          http_encode_string(id->not_query[..sizeof(id->not_query)-2]) + 

          (id->query?("?" + id->query):""); 

        TRACE_LEAVE("Redirecting to \"" + new_query + "\""); 

        return http_redirect(new_query, id); 

      } 

      if(!id->misc->internal_get) { 

        if (!QUERY(.files) 

            && (tmp = (id->not_query/"/")[-1]) 

            && tmp[0] == '.') { 

          TRACE_LEAVE("Is .-file"); 

          return 0; 

        } 

        if (FILTER_INTERNAL_FILE (f, id)) { 

          TRACE_LEAVE ("Is internal file"); 

          return 0; 

        } 

      } 

      TRACE_ENTER("Opening file \"" + f + "\"", 0); 

      object privs; 

      if (((int)id->misc->uid) && ((int)id->misc->gid) && 

          (QUERY(access_as_user))) { 

        // NB: Root-access is prevented. 

        privs=Privs("Getting file", (int)id->misc->uid, (int)id->misc->gid ); 

      } 

      o = open( f, "r" ); 

      privs = 0; 

      if(!o || (QUERY(no_symlinks) && (contains_symlinks(path, oldf)))) 

      { 

        errors++; 

        report_error("Open of " + f + " failed. Permission denied.\n"); 

        TRACE_LEAVE(""); 

        TRACE_LEAVE("Permission denied."); 

        return http_low_answer(403, "<h2>File exists, but access forbidden " 

                               "by user</h2>"); 

      } 

      id->realfile = f; 

      TRACE_LEAVE(""); 

      accesses++; 

      TRACE_LEAVE("Normal return");