开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
fs.c
资源名称：proftpd-1.2.0pre8.tar.gz　[点击查看]
上传用户：pycemail
上传日期：2007-01-04
资源大小：329k
文件大小：29k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

fs.c：源码内容
  1. /*
  2.  * ProFTPD - FTP server daemon
  3.  * Copyright (c) 1997, 1998 Public Flood Software
  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 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.  */
  20. /* ProFTPD virtual/modular file-system support
  21.  * $Id: fs.c,v 1.6 1999/09/18 18:26:38 macgyver Exp $
  22.  */
  24. #include "conf.h"
  26. typedef struct opendir_struct opendir_t;
  28. struct opendir_struct {
  29.   opendir_t *next,*prev;
  31.   DIR *dir;
  32.   fsdir_t *fsdir;
  33. };
  35. static fsdir_t *fs = NULL;
  36. static fsmatch_t *fs_match = NULL;
  37. static fsdir_t *fs_cwd = NULL,*fs_std = NULL;
  39. static xaset_t *opendir_list;
  40. static void *fs_cache_dir = NULL;
  41. static fsdir_t *fs_cache_fsdir = NULL;
  43. /* virtual working directory */
  44. static char vwd[MAXPATHLEN] = "/";
  45. static char cwd[MAXPATHLEN] = "/";
  47. /* the following static functions are simply wrappers for libc
  48.  * (the fs_std)
  49.  */
  51. static int std_stat(fsdir_t *f, const char *path, struct stat *sbuf)
  52. { return stat(path,sbuf); }
  53. static int std_lstat(fsdir_t *f, const char *path, struct stat *sbuf)
  54. { return lstat(path,sbuf); }
  55. static int std_rename(fsdir_t *f, const char *ren_from, const char *ren_to)
  56. { return rename(ren_from,ren_to); }
  57. static int std_unlink(fsdir_t *f, const char *path)
  58. { return unlink(path); }
  59. static int std_open(fsdir_t *f, const char *path, int access)
  60. { return open(path,access,0666); }
  61. static int std_creat(fsdir_t *f,const char *path, mode_t mode)
  62. { return creat(path,mode); }
  63. static int std_close(fsdir_t *f, int fd)
  64. { return close(fd); }
  65. static int std_read(fsdir_t *f, int fd, char *buf, size_t size)
  66. { return read(fd,buf,size); }
  67. static int std_write(fsdir_t *f, int fd, const char *buf, size_t size)
  68. { return write(fd,buf,size); }
  69. static off_t std_lseek(fsdir_t *f, int fd, off_t offset, int whence)
  70. { return lseek(fd,offset,whence); }
  71. static int std_link(fsdir_t *f, const char *path1, const char *path2)
  72. { return link(path1,path2); }
  73. static int std_symlink(fsdir_t *f, const char *path1, const char *path2)
  74. { return symlink(path1,path2); }
  75. static int std_readlink(fsdir_t *f, const char *path, char *buf, size_t max)
  76. { return readlink(path,buf,max); }
  77. static int std_chmod(fsdir_t *f, const char *path, mode_t mode)
  78. { return chmod(path,mode); }
  79. static int std_chown(fsdir_t *f, const char *path, uid_t uid, gid_t gid)
  80. { return chown(path,uid,gid); }
  81. static int std_chdir(fsdir_t *f, const char *path)
  82. { return chdir(path); }
  83. static void *std_opendir(fsdir_t *f, const char *path)
  84. { return opendir(path); }
  85. static int std_closedir(fsdir_t *f, void *dir)
  86. { return closedir((DIR*)dir); }
  87. static struct dirent *std_readdir(fsdir_t *f, void *dir)
  88. { return readdir((DIR*)dir); }
  90. fsmatch_t *fs_register_match(char *name, int opmask)
  91. {
  92.   fsmatch_t *newfs;
  94.   if(!name)
  95.     return NULL;
  97.   newfs = calloc(1,sizeof(fsmatch_t));
  99.   if(!newfs)
  100.     return NULL;
  102.   newfs->name = strdup(name);
  103.   newfs->opmask = opmask;
  105.   newfs->next = fs_match;
  106.   fs_match = newfs;
  108.   return newfs;
  109. }
  111. fsdir_t *fs_register(char *name)
  112. {
  113.   fsdir_t *parent = NULL,*f,*newfs;
  114.   int best = 0,i;
  116.   newfs = calloc(1,sizeof(fsdir_t));
  118.   if(!newfs)
  119.     return NULL;
  121.   if(name)
  122.     newfs->name = strdup(name);
  124.   newfs->stat = std_stat;
  125.   newfs->lstat = std_lstat;
  126.   newfs->rename = std_rename;
  127.   newfs->unlink = std_unlink;
  128.   newfs->open = std_open;
  129.   newfs->creat = std_creat;
  130.   newfs->close = std_close;
  131.   newfs->read = std_read;
  132.   newfs->write = std_write;
  133.   newfs->lseek = std_lseek;
  134.   newfs->link = std_link;
  135.   newfs->symlink = std_symlink;
  136.   newfs->chmod = std_chmod;
  137.   newfs->chown = std_chown;
  138.   newfs->chdir = std_chdir;
  139.   newfs->readlink = std_readlink;
  141.   newfs->opendir = std_opendir;
  142.   newfs->closedir = std_closedir;
  143.   newfs->readdir = std_readdir;
  145.   /* find proper parent */
  146.   if(newfs->name) {
  147.     for(f = fs; f; f=f->next) {
  148.       if(f->name) {
  149.         i = strlen(f->name);
  150.         if(!strncmp(f->name,newfs->name,i) && i > best) {
  151.           best = i; 
  152.           parent = f;
  153.         }
  154.       }
  155.     }
  157.     if(parent)
  158.       newfs->parent = parent;
  159.     else
  160.       newfs->parent = fs_std;
  161.   }
  163.   newfs->next = fs;
  164.   fs = newfs;
  165.   return newfs;
  166. }
  168. void fs_unregister(fsdir_t *fsd)
  169. {
  170.   /* not yet done */
  171. }
  173. static fsdir_t *_scan_fsdir(const char *path)
  174. {
  175.   fsdir_t *f,*found = NULL;
  176.   register int i,best = 0;
  178.   for(f = fs; f; f=f->next) {
  179.     if(f->name) {
  180.       i = strlen(f->name);
  181.       if(!strncmp(f->name,path,i) && i > best) {
  182.         best = i;
  183.         found = f;
  184.       }
  185.     }
  186.   }
  188.   return found;
  189. }
  191. static fsmatch_t *_scan_fsmatch(const char *path, int op)
  192. {
  193.   fsmatch_t *fm;
  195.   for(fm = fs_match; fm; fm=fm->next) {
  196.     if((fm->opmask & op) && fnmatch(fm->name,path,0) == 0)
  197.       return fm;
  198.   }
  200.   return NULL;
  201. }
  203. /* fs_lookup_dir() is called when we want to perform some sort of
  204.  * directory operation on a directory or file.  A "closest" match
  205.  * algorithm is used.  If the lookup fails or is not "close enough"
  206.  * (i.e. the final target does not exactly match an existing fsdir_t,
  207.  * we can for matchable targets and call dir_hit, then rescan
  208.  * the fsdir_t list.  The rescan is performed in case any modules
  209.  * registered fs handlers during the hit.
  210.  */
  212. fsdir_t *fs_lookup_dir(const char *path,int op)
  213. {
  214.   char buf[MAXPATHLEN];
  215.   char tmpbuf[MAXPATHLEN];
  216.   fsdir_t *f;
  217.   fsmatch_t *fm = NULL;
  218.   int exact = 0;
  220.   sstrncpy(buf,path,MAXPATHLEN);
  222.   if(buf[0] != '/')
  223.     fs_dircat(tmpbuf,sizeof(tmpbuf),cwd,buf);
  224.   else
  225.     sstrncpy(tmpbuf,buf,sizeof(tmpbuf));
  226.   
  227.   f = _scan_fsdir(tmpbuf);
  229.   /* we found a match, now see if it's close enough */
  230.   if(f) {
  231.     if(!strcmp(tmpbuf,f->name))
  232.       exact = 1;
  233.   }
  235.   if(!f || !exact) {
  236.     /* look for a fsmatch */
  237.     fm = _scan_fsmatch(tmpbuf,op);
  239.     if(op & FSOP_FILEMASK) {
  240.       if(fm && fm->file_hit((f ? f : fs_std),tmpbuf,op) > 0)
  241.         /* now rescan */
  242.         f = _scan_fsdir(tmpbuf);
  243.     } else {
  244.       if(fm && fm->dir_hit((f ? f : fs_std),tmpbuf,op) > 0)
  245.         f = _scan_fsdir(tmpbuf);
  246.     }
  247.   }
  249.   return (f ? f : fs_std);
  250. }
  252. /* fs_lookup_file() performs the same function as fs_lookup_dir, however
  253.  * because we are performing a file lookup, the target is the subdirectory
  254.  * _containing_ the actual target.  A basic optimization is used here,
  255.  * if the path contains no '/' characters, fs_cwd is returned.
  256.  */
  258. fsdir_t *fs_lookup_file(const char *path, char **deref, int op)
  259. {
  260.   if(!strchr(path,'/')) {
  261.     fsmatch_t *fm;
  263.     fm = _scan_fsmatch(path,op);
  264.     if(!fm || fm->file_hit(fs_cwd,path,op) <= 0) {
  265.       struct stat sbuf;
  267.       if(fs_cwd->lstat(fs_cwd,path,&sbuf) == -1 || !S_ISLNK(sbuf.st_mode))
  268.         return fs_cwd;
  269.     } else {
  270.       char linkbuf[MAXPATHLEN];
  271.       int i;
  273.       if((i = fs_cwd->readlink(fs_cwd,path, &linkbuf[2],
  274.        MAXPATHLEN - 3)) != -1) {
  275.         linkbuf[i] = '';
  276.         if(!strchr(linkbuf, '/')) {
  277.           if(i + 3 > MAXPATHLEN)
  278.             i = MAXPATHLEN - 3;
  280.           memmove(&linkbuf[2], linkbuf, i + 1);
  281.   
  282.           linkbuf[i+2] = '';
  283.           linkbuf[0] = '.';
  284.           linkbuf[1] = '/';
  285.           return fs_lookup_file_canon(linkbuf,deref,op);
  286.         }
  287.       }
  288.       
  289.       return fs_cwd;
  290.     }
  291.   }
  293. #if 0
  294.   target = rindex(workpath,'/');
  295.   if(target == workpath) {
  296.     if(*(target+1))
  297.       *target = '';
  298.   } else if(target)
  299.     *target = '';
  300. #endif
  302.   return fs_lookup_dir(path,op);
  303. }
  305. fsdir_t *fs_lookup_file_canon(const char *path, char **deref, int op)
  306. {
  307.   static char workpath[MAXPATHLEN];
  309.   if(fs_resolve_partial(path, workpath, MAXPATHLEN, FSOP_OPEN) == -1) {
  310.     if(*path == '/' || *path == '~')
  311.       fs_interpolate(path, workpath, MAXPATHLEN);
  312.     else
  313.       fs_dircat(workpath, sizeof(workpath), cwd, path);
  314.   }
  316.   if(deref)
  317.     *deref = workpath;
  319.   return fs_lookup_file(workpath, deref, op);
  320. }
  322. void fs_setcwd(const char *dir)
  323. {
  324.   fs_resolve_path(dir,cwd,MAXPATHLEN,FSOP_CHDIR);
  325.   sstrncpy(vwd,dir,MAXPATHLEN);
  326.   fs_cwd = fs_lookup_dir(cwd,FSOP_CHDIR);
  327. }
  329. const char *fs_getcwd()
  330. { return cwd; }
  332. const char *fs_getvwd()
  333. { return vwd; }
  335. void fs_dircat(char *buf, int len, const char *dir1, const char *dir2)
  336. {
  337.   /* make temporary copies so that memory areas can overlap */
  338.   char *_dir1, *_dir2;
  339.   int i;
  341.   /* This is an experimental test to see if we've got reasonable
  342.    * directories to concatenate.  If we don't, then we default to
  343.    * the root directory.
  344.    */
  345.   if((strlen(dir1) + strlen(dir2) + 1) > MAXPATHLEN) {
  346.     sstrncpy(buf, "/", len);
  347.     return;
  348.   }
  349.   
  350.   _dir1 = strdup(dir1);
  351.   _dir2 = strdup(dir2);
  352.   
  353.   i = strlen(_dir1) - 1;
  354.   
  355.   if(*_dir2 == '/') {
  356.     sstrncpy(buf, _dir2, len);
  357.     free(_dir1);
  358.     free(_dir2);
  359.     return;
  360.   }
  361.   
  362.   sstrncpy(buf, _dir1, len);
  363.   if(i && *(_dir1 + i) != '/')
  364.     sstrcat(buf, "/", MAXPATHLEN);
  366.   sstrcat(buf, _dir2, MAXPATHLEN);
  367.   
  368.   if(!*buf) {
  369.    *buf++ = '/';
  370.    *buf = '';
  371.   }
  372.   
  373.   free(_dir1);
  374.   free(_dir2);
  375. }
  377. int fs_interpolate(const char *path, char *buf, int maxlen)
  378. {
  379.   pool *p;
  380.   struct passwd *pw;
  381.   char *user,*tmp;
  382.   char workpath[MAXPATHLEN];
  383.   int i;
  385.   if(!path)
  386.     return -1;
  388.   sstrncpy(workpath,path,MAXPATHLEN);
  390.   if(workpath[0] == '~') {
  391.     user = &workpath[1];
  392.     tmp = index(user,'/');
  394.     if(tmp)
  395.       *tmp++ = '';
  397.     if(!*user)
  398.       user = session.user;
  400.     p = make_sub_pool(permanent_pool);
  401.     pw = auth_getpwnam(p,user);
  402.     destroy_pool(p);
  404.     if(!pw) {
  405.       errno = ENOENT;
  406.       return -1;
  407.     }
  409.     sstrncpy(buf,pw->pw_dir,maxlen);
  410.     i = strlen(buf);
  412.     if(tmp && i < maxlen && buf[i-1] != '/')
  413.       buf[i++] = '/';
  415.     if(tmp)
  416.       sstrncpy(&buf[i],tmp,maxlen - i);
  417.   } else
  418.     sstrncpy(buf,workpath,maxlen);
  420.   return 0;
  421. }
  423. int fs_resolve_partial(const char *path, char *buf, int maxlen, int op)
  424. {
  425.   char curpath[MAXPATHLEN] = "",
  426.        workpath[MAXPATHLEN] = "",
  427.        namebuf[MAXPATHLEN],
  428.        linkpath[MAXPATHLEN],
  429.        *where,*ptr,*last;
  431.   fsdir_t *f;
  432.   int len,fini = 1,link_cnt = 0;
  433.   ino_t last_inode = 0;
  434.   struct stat sbuf;
  436.   if(!path)
  437.     return -1;
  439.   if(*path != '/') {
  440.     if(*path == '~')
  441.       fs_interpolate(path,curpath,sizeof(curpath));
  442.     else {
  443.       sstrncpy(curpath,path,sizeof(curpath));
  444.       sstrncpy(workpath,cwd,sizeof(workpath));
  445.     }
  446.   } else
  447.     sstrncpy(curpath,path,sizeof(curpath));
  449.   while(fini--) {
  450.     where = curpath;
  451.     while(*where != '') {
  452.       if(!strcmp(where, ".")) {
  453.         where++;
  454.         continue;
  455.       }
  456.       
  457.       /* handle ".." */
  458.       if(!strcmp(where,"..")) {
  459.         where += 2;
  460.         ptr = last = workpath;
  461.         while(*ptr) {
  462.           if(*ptr == '/')
  463.             last = ptr;
  464.           ptr++;
  465.         }
  467.         *last = '';
  468.         continue;
  469.       }
  470.       
  471.       /* handle "./" */
  472.       if(!strncmp(where, "./", 2)) {
  473.         where += 2;
  474.         continue;
  475.       }
  476.       
  477.       /* handle "../" */
  478.       if(!strncmp(where, "../", 3)) {
  479.         where += 3;
  480.         ptr = last = workpath;
  481.         while(*ptr) {
  482.           if(*ptr == '/')
  483.             last = ptr;
  484.           ptr++;
  485.         }
  487.         *last = '';
  488.         continue;
  489.       }
  490.       
  491.       ptr = strchr(where, '/');
  492.       if(!ptr)
  493.         ptr = where + strlen(where) - 1;
  494.       else
  495.         *ptr = '';
  497.       sstrncpy(namebuf, workpath, sizeof(namebuf));
  498.       if(*namebuf) {
  499.         for(last = namebuf; *last; last++) ;
  500.         if(*--last != '/')
  501.           sstrcat(namebuf, "/", MAXPATHLEN);
  502.       } else
  503.         sstrcat(namebuf, "/", MAXPATHLEN);
  504.       
  505.       sstrcat(namebuf, where, MAXPATHLEN);
  506.       
  507.       where = ++ptr;
  509.       f = fs_lookup_dir(namebuf,op);
  510.       
  511.       if(f->lstat(f, namebuf, &sbuf) == -1) {
  512.         errno = ENOENT;
  513.         return -1;
  514.       }
  515.       
  516.       if(S_ISLNK(sbuf.st_mode)) {
  517.         /* Detect an obvious recursive symlink */
  518.         if(sbuf.st_ino && (ino_t)sbuf.st_ino == last_inode) {
  519.           errno = ENOENT;
  520.           return -1;
  521.         }
  523.         last_inode = (ino_t)sbuf.st_ino;
  524.         if(++link_cnt > 32) {
  525.           errno = ELOOP;
  526.           return -1;
  527.         }
  529.         if((len = f->readlink(f,namebuf,linkpath,MAXPATHLEN)) <= 0) {
  530.           errno = ENOENT;
  531.           return -1;
  532.         }
  534.         *(linkpath+len) = '';
  535.         if(*linkpath == '/')
  536.           *workpath = '';
  537.         if(*linkpath == '~') {
  538.           char tmpbuf[MAXPATHLEN];
  540.           *workpath = '';
  541.           sstrncpy(tmpbuf,linkpath,sizeof(tmpbuf));
  542.           fs_interpolate(tmpbuf,linkpath,sizeof(linkpath));
  543.         }
  544.         if(*where) {
  545.           sstrcat(linkpath,"/",MAXPATHLEN);
  546.           sstrcat(linkpath,where,MAXPATHLEN);
  547.         }
  548.         sstrncpy(curpath,linkpath,sizeof(curpath));
  549.         fini++;
  550.         break; /* continue main loop */
  551.       }
  553.       if(S_ISDIR(sbuf.st_mode)) {
  554.         sstrncpy(workpath, namebuf, sizeof(workpath));
  555.         continue;
  556.       }
  558.       if(*where) {
  559.         errno = ENOENT;
  560.         return -1;               /* path/notadir/morepath */
  561.       } else
  562.         sstrncpy(workpath, namebuf, sizeof(workpath));
  563.     }
  564.   }
  566.   if(!workpath[0])
  567.     sstrncpy(workpath, "/", sizeof(workpath));
  569.   sstrncpy(buf, workpath, maxlen);
  570.   return 0;
  571. }
  572.   
  573. int fs_resolve_path(const char *path, char *buf, int maxlen, int op)
  574. {
  575.   char curpath[MAXPATHLEN],
  576.        workpath[MAXPATHLEN],
  577.        namebuf[MAXPATHLEN],
  578.        linkpath[MAXPATHLEN],
  579.        *where,*ptr,*last;
  581.   fsdir_t *f;
  583.   int len,fini = 1,link_cnt = 0;
  584.   ino_t last_inode = 0;
  585.   struct stat sbuf;
  587.   if(!path)
  588.     return -1;
  590.   if(fs_interpolate(path,curpath,MAXPATHLEN) == -1)
  591.     sstrncpy(curpath,path,MAXPATHLEN);
  594.   if(curpath[0] != '/')
  595.     sstrncpy(workpath,cwd,MAXPATHLEN);
  596.   else
  597.     workpath[0] = '';
  599.   while(fini--) {
  600.     where = curpath;
  601.     while(*where != '') {
  602.       if(!strcmp(where,".")) {
  603.         where++;
  604.         continue;
  605.       }
  607.       /* handle "./" */
  608.       if(!strncmp(where,"./",2)) {
  609.         where+=2;
  610.         continue;
  611.       }
  613.       /* handle "../" */
  614.       if(!strncmp(where,"../",3)) {
  615.         where+=3;
  616.         ptr = last = workpath;
  617.         while(*ptr) {
  618.           if(*ptr == '/')
  619.             last = ptr;
  620.           ptr++;
  621.         }
  623.         *last = '';
  624.         continue;
  625.       }
  627.       ptr = strchr(where,'/');
  628.       if(!ptr)
  629.         ptr = where + strlen(where) - 1;
  630.       else
  631.         *ptr = '';
  633.       sstrncpy(namebuf,workpath,sizeof(namebuf));
  635.       if(*namebuf) {
  636.         for(last = namebuf; *last; last++) ;
  637.         if(*--last != '/')
  638.           sstrcat(namebuf,"/",MAXPATHLEN);
  639.       } else
  640.         sstrcat(namebuf,"/",MAXPATHLEN);
  642.       sstrcat(namebuf,where,MAXPATHLEN);
  644.       where = ++ptr;
  646.       f = fs_lookup_dir(namebuf,op);
  648.       if(f->lstat(f,namebuf,&sbuf) == -1) {
  649.         errno = ENOENT;
  650.         return -1;
  651.       }
  652.     
  653.       if(S_ISLNK(sbuf.st_mode)) {
  654.         /* Detect an obvious recursive symlink */
  655.         if(sbuf.st_ino && (ino_t)sbuf.st_ino == last_inode) {
  656.           errno = ENOENT;
  657.           return -1;
  658.         }
  660.         last_inode = (ino_t)sbuf.st_ino;
  661.         if(++link_cnt > 32) {
  662.           errno = ELOOP;
  663.           return -1;
  664.         }
  666.         if((len = f->readlink(f,namebuf,linkpath,MAXPATHLEN)) <= 0) {
  667.           errno = ENOENT;
  668.           return -1;
  669.         }
  671.         *(linkpath+len) = '';
  672.         if(*linkpath == '/')
  673.           *workpath = '';
  674.         if(*linkpath == '~') {
  675.           char tmpbuf[MAXPATHLEN];
  677.           *workpath = '';
  678.           sstrncpy(tmpbuf,linkpath,sizeof(tmpbuf));
  679.           fs_interpolate(tmpbuf,linkpath,sizeof(linkpath));
  680.         }
  681.         if(*where) {
  682.           sstrcat(linkpath,"/",MAXPATHLEN);
  683.           sstrcat(linkpath,where,MAXPATHLEN);
  684.         }
  685.         sstrncpy(curpath,linkpath,sizeof(curpath));
  686.         fini++;
  687.         break; /* continue main loop */
  688.       }
  690.       if(S_ISDIR(sbuf.st_mode)) {
  691.         sstrncpy(workpath,namebuf,sizeof(workpath));
  692.         continue;
  693.       }
  695.       if(*where) {
  696.         errno = ENOENT;
  697.         return -1;               /* path/notadir/morepath */
  698.       } else
  699.         sstrncpy(workpath,namebuf,sizeof(workpath));
  700.     }
  701.   }
  703.   if(!workpath[0])
  704.     sstrncpy(workpath,"/",sizeof(workpath));
  706.   sstrncpy(buf,workpath,maxlen);
  707.   return 0;
  708. }
  710. void fs_clean_path(const char *path, char *buf, int maxlen)
  711. {
  712.   char workpath[MAXPATHLEN] = "";
  713.   char curpath[MAXPATHLEN];
  714.   char namebuf[MAXPATHLEN];
  715.   char *where,*ptr,*last;
  716.   int fini = 1;
  718.   if(!path)
  719.     return;
  721.   sstrncpy(curpath,path,MAXPATHLEN);
  722.   
  723.   /* main loop */
  724.   while(fini--) {
  725.     where = curpath;
  726.     while(*where != '') {
  727.       if(!strcmp(where,".")) {
  728.         where++;
  729.         continue;
  730.       }
  732.       /* handle "./" */
  733.       if(!strncmp(where,"./",2)) {
  734.         where += 2;
  735.         continue;
  736.       }
  738.       /* handle ".." */
  739.       if(!strcmp(where,"..")) {
  740.         where+=2;
  741.         ptr = last = workpath;
  742.         while(*ptr) {
  743.           if(*ptr == '/')
  744.             last = ptr;
  745.           ptr++;
  746.         }
  748.         *last = '';
  749.         continue;
  750.       }
  752.       /* handle "../" */
  753.       if(!strncmp(where,"../",3)) {
  754.         where += 3;
  755.         ptr = last = workpath;
  756.         while(*ptr) {
  757.           if(*ptr == '/')
  758.             last = ptr;
  759.           ptr++;
  760.         }
  761.         *last = '';
  762.         continue;
  763.       }
  764.       ptr = strchr(where,'/');
  765.       if(!ptr)
  766.         ptr = where + strlen(where) - 1;
  767.       else
  768.         *ptr = '';
  770.       sstrncpy(namebuf,workpath,MAXPATHLEN);
  771.       
  772.       if(*namebuf) {
  773.         for(last = namebuf; *last; last++) ;
  774.         if(*--last != '/')
  775.           sstrcat(namebuf,"/",MAXPATHLEN);
  776.       } else
  777.         sstrcat(namebuf,"/",MAXPATHLEN);
  779.       sstrcat(namebuf,where,MAXPATHLEN);
  780.       namebuf[MAXPATHLEN-1] = '';
  781.       
  782.       where = ++ptr;
  784.       sstrncpy(workpath,namebuf,sizeof(workpath));
  785.     }
  786.   }
  788.   if(!workpath[0])
  789.     sstrncpy(workpath,"/",sizeof(workpath));
  791.   sstrncpy(buf,workpath,maxlen);  
  792. }
  794. void fs_virtual_path(const char *path, char *buf, int maxlen)
  795. {
  796.   char curpath[MAXPATHLEN],
  797.        workpath[MAXPATHLEN],
  798.        namebuf[MAXPATHLEN],
  799.        *where,*ptr,*last;
  801.   int fini = 1;
  803.   if(!path)
  804.     return;
  806.   if(fs_interpolate(path,curpath,MAXPATHLEN) == -1)
  807.     sstrncpy(curpath,path,MAXPATHLEN);
  809.   if(curpath[0] != '/')
  810.     sstrncpy(workpath,vwd,MAXPATHLEN);
  811.   else
  812.     workpath[0] = '';
  814.   /* curpath is path resolving */
  815.   /* linkpath is path a symlink pointed to */
  816.   /* workpath is the path we've resolved */
  818.   /* main loop */
  819.   while(fini--) {
  820.     where = curpath;
  821.     while(*where != '') {
  822.       if(!strcmp(where,".")) {
  823.         where++;
  824.         continue;
  825.       }
  827.       /* handle "./" */
  828.       if(!strncmp(where,"./",2)) {
  829.         where += 2;
  830.         continue;
  831.       }
  833.       /* handle ".." */
  834.       if(!strcmp(where,"..")) {
  835.         where+=2;
  836.         ptr = last = workpath;
  837.         while(*ptr) {
  838.           if(*ptr == '/')
  839.             last = ptr;
  840.           ptr++;
  841.         }
  843.         *last = '';
  844.         continue;
  845.       }
  847.       /* handle "../" */
  848.       if(!strncmp(where,"../",3)) {
  849.         where += 3;
  850.         ptr = last = workpath;
  851.         while(*ptr) {
  852.           if(*ptr == '/')
  853.             last = ptr;
  854.           ptr++;
  855.         }
  856.         *last = '';
  857.         continue;
  858.       }
  859.       ptr = strchr(where,'/');
  860.       if(!ptr)
  861.         ptr = where + strlen(where) - 1;
  862.       else
  863.         *ptr = '';
  865.       sstrncpy(namebuf,workpath,sizeof(namebuf));
  866.       if(*namebuf) {
  867.         for(last = namebuf; *last; last++) ;
  868.         if(*--last != '/')
  869.           sstrcat(namebuf,"/",MAXPATHLEN);
  870.       } else
  871.         sstrcat(namebuf,"/",MAXPATHLEN);
  873.       sstrcat(namebuf,where,MAXPATHLEN);
  875.       where = ++ptr;
  877.       sstrncpy(workpath,namebuf,sizeof(workpath));
  878.     }
  879.   }
  881.   if(!workpath[0])
  882.     sstrncpy(workpath,"/",sizeof(workpath));
  884.   sstrncpy(buf,workpath,maxlen);  
  885. }
  887. int fs_chdir_canon(const char *path, int hidesymlink)
  888. {
  889.   char resbuf[MAXPATHLEN];
  890.   fsdir_t *f;
  891.   int ret;
  893.   if(fs_resolve_partial(path,resbuf,MAXPATHLEN,FSOP_CHDIR) == -1) {
  894.     errno = ENOENT;
  895.     return -1;
  896.   }
  898.   f = fs_lookup_dir(resbuf,FSOP_CHDIR);
  899.   ret = f->chdir(f,resbuf);
  901.   if(ret != -1) {
  902.     /* chdir succeeded, so we set fs_cwd for future references
  903.      */
  904.      fs_cwd = f;
  905.      sstrncpy(cwd,resbuf,sizeof(cwd));
  906.      if(hidesymlink)
  907.        fs_virtual_path(path,vwd,MAXPATHLEN);
  908.      else
  909.        sstrncpy(vwd,resbuf,sizeof(vwd));
  910.   }
  912.   return ret;  
  913. }
  915. int fs_chdir(const char *path, int hidesymlink)
  916. {
  917.   char resbuf[MAXPATHLEN];
  918.   fsdir_t *f;
  919.   int ret;
  921.   fs_clean_path(path,resbuf,MAXPATHLEN);
  922.   
  923.   f = fs_lookup_dir(path,FSOP_CHDIR);
  924.   ret = f->chdir(f,resbuf);
  926.   if(ret != -1) {
  927.     /* chdir succeeded, so we set fs_cwd for future references
  928.      */
  929.      fs_cwd = f;
  930.      sstrncpy(cwd,resbuf,sizeof(cwd));
  931.      if(hidesymlink)
  932.        fs_virtual_path(path,vwd,MAXPATHLEN);
  933.      else
  934.        sstrncpy(vwd,resbuf,sizeof(vwd));
  935.   }
  937.   return ret;  
  938. }
  940. /* fs_opendir, fs_closedir and fs_readdir all use a nifty 
  941.  * optimization, caching the last-recently-used fsdir_t, and
  942.  * avoid future fsdir_t lookups when iterating via readdir.
  943.  */
  945. void *fs_opendir(const char *path)
  946. {
  947.   fsdir_t *f;
  948.   opendir_t *od;
  950.   DIR *ret;
  952.   if(!strchr(path,'/'))
  953.     f = fs_cwd;
  954.   else {
  955.     char buf[MAXPATHLEN];
  957.     if(fs_resolve_partial(path,buf,MAXPATHLEN,FSOP_OPENDIR) == -1) {
  958.       errno = ENOENT;
  959.       return NULL;
  960.     }
  961.     f = fs_lookup_dir(buf,FSOP_OPENDIR);
  962.   }
  964.   ret = f->opendir(f,path);
  965.   if(!ret)
  966.     return NULL;
  968.   /* cache it here */
  969.   fs_cache_dir = ret;
  970.   fs_cache_fsdir = f;
  972.   od = malloc(sizeof(opendir_t));
  973.   if(!od) {
  974.     f->closedir(f,ret);
  975.     errno = ENOMEM;
  976.     return NULL;
  977.   }
  979.   od->dir = ret;
  980.   od->fsdir = f;
  981.   xaset_insert(opendir_list,(xasetmember_t*)od);
  983.   return ret;
  984. }
  986. static fsdir_t *find_opendir(void *d, int closing)
  987. {
  988.   fsdir_t *f = NULL;
  990.   if(d == fs_cache_dir) {
  991.     f = fs_cache_fsdir;
  992.     if(closing) {
  993.       fs_cache_dir = NULL;
  994.       fs_cache_fsdir = NULL;
  995.     }
  996.   } else {
  997.     opendir_t *od;
  999.     for(od = (opendir_t*)opendir_list->xas_list; od; od=od->next)
  1000.       if(od->dir == d) {
  1001.         f = od->fsdir;
  1002.         break;
  1003.       }
  1005.     if(closing && od) {
  1006.       xaset_remove(opendir_list,(xasetmember_t*)od);
  1007.       free(od);
  1008.     }
  1009.   }
  1011.   return f;
  1012. }
  1014. int fs_closedir(void *d)
  1015. {
  1016.   fsdir_t *f;
  1018.   f = find_opendir(d,1);
  1020.   if(!f)
  1021.     return -1;
  1023.   return f->closedir(f,d);
  1024. }
  1026. struct dirent *fs_readdir(void *d)
  1027. {
  1028.   fsdir_t *f;
  1030.   f = find_opendir(d,0);
  1032.   if(!f)
  1033.     return NULL;
  1035.   return f->readdir(f,d);
  1036. }
  1038. /*******************************/
  1039. /* all other fs functions here */
  1040. /*******************************/
  1042. int fs_stat_canon(const char *path, struct stat *sbuf)
  1043. {
  1044.   fsdir_t *f;
  1046.   f = fs_lookup_file_canon(path,NULL,FSOP_STAT);
  1047.   return f->stat(f,path,sbuf);
  1048. }
  1050. int fs_stat(const char *path, struct stat *sbuf)
  1051. {
  1052.   fsdir_t *f;
  1054.   f = fs_lookup_file(path,NULL,FSOP_STAT);
  1055.   return f->stat(f,path,sbuf);
  1056. }
  1058. int fs_lstat_canon(const char *path, struct stat *sbuf)
  1059. {
  1060.   fsdir_t *f;
  1062.   f = fs_lookup_file_canon(path,NULL,FSOP_LSTAT);
  1063.   return f->lstat(f,path,sbuf);
  1064. }
  1066. int fs_lstat(const char *path, struct stat *sbuf)
  1067. {
  1068.   fsdir_t *f;
  1070.   f = fs_lookup_file(path,NULL,FSOP_LSTAT);
  1071.   return f->lstat(f,path,sbuf);
  1072. }
  1074. int fs_readlink_canon(const char *path, char *buf, int maxlen)
  1075. {
  1076.   fsdir_t *f;
  1078.   f = fs_lookup_file_canon(path,NULL,FSOP_READLINK);
  1079.   return f->readlink(f,path,buf,maxlen);
  1080. }
  1082. int fs_readlink(const char *path, char *buf, int maxlen)
  1083. {
  1084.   fsdir_t *f;
  1086.   f = fs_lookup_file(path,NULL,FSOP_READLINK);
  1087.   return f->readlink(f,path,buf,maxlen);
  1088. }
  1090. /* fs_glob() is just a wrapper for glob, setting the various gl_
  1091.  * callbacks to our fs functions.
  1092.  */
  1094. int fs_glob(const char *pattern, int flags,
  1095.             int (*errfunc)(const char *, int),
  1096.             glob_t *pglob)
  1097. {
  1098.   if(pglob) {
  1099.     flags |= GLOB_ALTDIRFUNC;
  1100.     
  1101.     pglob->gl_closedir = (void (*)(void*))fs_closedir;
  1102.     pglob->gl_readdir = fs_readdir;
  1103.     pglob->gl_opendir = fs_opendir;
  1104.     pglob->gl_lstat = fs_lstat;
  1105.     pglob->gl_stat = fs_stat;
  1106.   }
  1108.   return glob(pattern,flags,errfunc,pglob);
  1109. }
  1111. void fs_globfree(glob_t *pglob)
  1112. { globfree(pglob); }
  1114. int fs_rename_canon(const char *rfrom, const char *rto)
  1115. {
  1116.   fsdir_t *f;
  1118.   f = fs_lookup_file_canon(rfrom,NULL,FSOP_RENAME);
  1120.   if(f != fs_lookup_file_canon(rto,NULL,FSOP_RENAME)) {
  1121.     errno = EXDEV;
  1122.     return -1;
  1123.   }
  1125.   return f->rename(f,rfrom,rto);
  1126. }
  1128. int fs_rename(const char *rfrom, const char *rto)
  1129. {
  1130.   fsdir_t *f;
  1132.   f = fs_lookup_file(rfrom,NULL,FSOP_RENAME);
  1134.   if(f != fs_lookup_file(rto,NULL,FSOP_RENAME)) {
  1135.     errno = EXDEV;
  1136.     return -1;
  1137.   }
  1139.   return f->rename(f,rfrom,rto);
  1140. }
  1142. int fs_unlink_canon(const char *name)
  1143. {
  1144.   fsdir_t *f;
  1146.   f = fs_lookup_file_canon(name,NULL,FSOP_UNLINK);
  1148.   return f->unlink(f,name);
  1149. }
  1151. int fs_unlink(const char *name)
  1152. {
  1153.   fsdir_t *f;
  1155.   f = fs_lookup_file(name,NULL,FSOP_UNLINK);
  1157.   return f->unlink(f,name);
  1158. }
  1160. fsdir_t *fs_open_canon(const char *name, int flags, int *fd)
  1161. {
  1162.   char *deref;
  1163.   fsdir_t *f;
  1164.   int ret;
  1166.   f = fs_lookup_file_canon(name,&deref,FSOP_OPEN);
  1168.   ret = f->open(f,deref,flags);
  1169.   if(ret == -1)
  1170.     return NULL;
  1172.   if(fd)
  1173.     *fd = ret;
  1175.   return f;  
  1176. }
  1178. fsdir_t *fs_open(const char *name, int flags, int *fd)
  1179. {
  1180.   fsdir_t *f;
  1181.   int ret;
  1183.   f = fs_lookup_file(name,NULL,FSOP_OPEN);
  1185.   ret = f->open(f,name,flags);
  1186.   if(ret == -1)
  1187.     return NULL;
  1189.   if(fd)
  1190.     *fd = ret;
  1192.   return f;  
  1193. }
  1195. fsdir_t *fs_creat_canon(const char *name, mode_t mode, int *fd)
  1196. {
  1197.   char *deref;
  1198.   fsdir_t *f;
  1199.   int ret;
  1201.   f = fs_lookup_file_canon(name,&deref,FSOP_CREAT);
  1202.   ret = f->creat(f,deref,mode);
  1204.   if(ret == -1)
  1205.     return NULL;
  1207.   if(fd)
  1208.     *fd = ret;
  1210.   return f;
  1211. }
  1213. fsdir_t *fs_creat(const char *name, mode_t mode, int *fd)
  1214. {
  1215.   fsdir_t *f;
  1216.   int ret;
  1218.   f = fs_lookup_file(name,NULL,FSOP_CREAT);
  1219.   ret = f->creat(f,name,mode);
  1221.   if(ret == -1)
  1222.     return NULL;
  1224.   if(fd)
  1225.     *fd = ret;
  1227.   return f;
  1228. }
  1230. int fs_close(fsdir_t *f, int fd)
  1231. { return f->close(f,fd); }
  1233. int fs_read(fsdir_t *f, int fd, char *buf, size_t size)
  1234. { return f->read(f,fd,buf,size); }
  1236. int fs_write(fsdir_t *f, int fd, const char *buf, size_t size)
  1237. { return f->write(f,fd,buf,size); }
  1239. off_t fs_lseek(fsdir_t *f, int fd, off_t offset, int whence)
  1240. { return f->lseek(f,fd,offset,whence); }
  1242. int fs_link_canon(const char *lfrom, const char *lto)
  1243. {
  1244.   fsdir_t *f;
  1246.   f = fs_lookup_file_canon(lfrom,NULL,FSOP_LINK);
  1247.   if(f != fs_lookup_file_canon(lto,NULL,FSOP_LINK)) {
  1248.     errno = EXDEV;
  1249.     return -1;
  1250.   }
  1252.   return f->link(f,lfrom,lto);
  1253. }
  1255. int fs_link(const char *lfrom, const char *lto)
  1256. {
  1257.   fsdir_t *f;
  1259.   f = fs_lookup_file(lfrom,NULL,FSOP_LINK);
  1260.   if(f != fs_lookup_file(lto,NULL,FSOP_LINK)) {
  1261.     errno = EXDEV;
  1262.     return -1;
  1263.   }
  1265.   return f->link(f,lfrom,lto);
  1266. }
  1268. int fs_symlink_canon(const char *lfrom, const char *lto)
  1269. {
  1270.   fsdir_t *f;
  1272.   f = fs_lookup_file_canon(lto,NULL,FSOP_SYMLINK);
  1273.   return f->symlink(f,lfrom,lto);
  1274. }
  1276. int fs_symlink(const char *lfrom, const char *lto)
  1277. {
  1278.   fsdir_t *f;
  1280.   f = fs_lookup_file(lto,NULL,FSOP_SYMLINK);
  1281.   return f->symlink(f,lfrom,lto);
  1282. }
  1284. int fs_chmod_canon(const char *name, mode_t mode)
  1285. {
  1286.   char *deref;
  1287.   fsdir_t *f;
  1289.   f = fs_lookup_file_canon(name,&deref,FSOP_CHMOD);
  1290.   return f->chmod(f,deref,mode);
  1291. }
  1293. int fs_chmod(const char *name, mode_t mode)
  1294. {
  1295.   fsdir_t *f;
  1297.   f = fs_lookup_file(name,NULL,FSOP_CHMOD);
  1298.   return f->chmod(f,name,mode);
  1299. }
  1301. int fs_chown_canon(const char *name, uid_t uid, gid_t gid)
  1302. {
  1303.   fsdir_t *f;
  1305.   f = fs_lookup_file_canon(name,NULL,FSOP_CHOWN);
  1306.   return f->chown(f,name,uid,gid);
  1307. }
  1309. int fs_chown(const char *name, uid_t uid, gid_t gid)
  1310. {
  1311.   fsdir_t *f;
  1313.   f = fs_lookup_file(name,NULL,FSOP_CHOWN);
  1314.   return f->chown(f,name,uid,gid);
  1315. }
  1317. /* fs_gets is not truely a vfs function, however it's included here
  1318.  * for simplicity.
  1319.  */
  1321. char *fs_gets(char *buf, size_t size, fsdir_t *f, int fd)
  1322. {
  1323.   char *bp;
  1324.   int toread;
  1325.   static IOBUF *iobuf = NULL;
  1327.   if(!f) {
  1328.     errno = EBADF;
  1329.     return NULL;
  1330.   }
  1332.   
  1333.   if(!iobuf) {
  1334.     iobuf = (IOBUF*)pcalloc(permanent_pool,sizeof(IOBUF));
  1335.     iobuf->buf = iobuf->cp = palloc(permanent_pool,1024);
  1336.     iobuf->left = iobuf->bufsize = 1024;
  1337.   }
  1339.   bp = buf;
  1341.   while(size) {
  1342.     if(!iobuf->cp || iobuf->left == 1024) { /* empty buffer */
  1343.       toread = fs_read(f,fd,iobuf->buf,(size < 1024 ? size : 1024));
  1344.       if(toread <= 0) {
  1345.         if(bp != buf) {
  1346.           *bp = '';
  1347.           return buf;
  1348.         } else
  1349.           return NULL;
  1350.       }
  1352.       iobuf->left = 1024 - toread;
  1353.       iobuf->cp = iobuf->buf;
  1354.     } else
  1355.       toread = 1024 - iobuf->left;
  1357.     while(size && *iobuf->cp != 'n' && toread--) {
  1358.       *bp++ = *iobuf->cp++;
  1359.       size--;
  1360.       iobuf->left++;
  1361.     }
  1363.     if(size && toread && *iobuf->cp == 'n') {
  1364.       size--; toread--;
  1365.       *bp++ = *iobuf->cp++;
  1366.       iobuf->left++;
  1367.       break;
  1368.     }
  1370.     if(!toread)
  1371.       iobuf->cp = NULL;
  1372.   }
  1374.   *bp = '';
  1375.   return buf;
  1376. }
  1378. int init_fs()
  1379. {
  1380.   char cwdbuf[MAXPATHLEN];
  1382.   opendir_list = xaset_create(permanent_pool,NULL);
  1383.   fs_std = fs_register(NULL);
  1385.   if(getcwd(cwdbuf,MAXPATHLEN))
  1386.     fs_setcwd(cwdbuf);
  1387.   else {
  1388.     chdir("/");
  1389.     fs_setcwd("/");
  1390.   }
  1391.   
  1392.   return 0;
  1393. }