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

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

Ftp客户端

开发平台：

Unix_Linux

mod_ls.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. /*
  21.  * Directory listing module for proftpd
  22.  * $Id: mod_ls.c,v 1.17 1999/10/01 03:34:14 macgyver Exp $
  23.  */
  25. #include "conf.h"
  27. #ifndef GLOB_ABORTED
  28. #define GLOB_ABORTED GLOB_ABEND
  29. #endif
  31. #define MAP_UID(x) (fakeuser ? fakeuser : auth_uid_name(cmd->tmp_pool,(x)))
  32. #define MAP_GID(x) (fakegroup ? fakegroup : auth_gid_name(cmd->tmp_pool,(x)))
  34. static void addfile(cmd_rec*,const char *, const char *, time_t);
  35. static int outputfiles(cmd_rec*);
  37. static int listfile(cmd_rec*,pool*,const char *name);
  38. static int listdir(cmd_rec*,pool*,const char *name,int list_dotdirs);
  40. static int matches = 0;
  41. static char *default_options;
  42. static int showdotfiles,showsymlinks,showsymlinks_hold;
  43. static int cmp(const void *a, const void *b);
  44. static char *fakeuser,*fakegroup;
  45. static umode_t fakemode;
  46. static int fakemodep;
  47. static int ls_errno = 0;
  48. static time_t ls_curtime = 0;
  50. /* ls options */
  51. int opt_a = 0,
  52.     opt_C = 0,
  53.     opt_d = 0,
  54.     opt_F = 0,
  55.     opt_l = 0,
  56.     opt_R = 0,
  57.     opt_r = 0,
  58.     opt_t = 0,
  59.     opt_STAT = 0;
  61. static char cwd[MAXPATHLEN+1] = "";
  63. static void push_cwd(char *_cwd, int *symhold)
  64. {
  65.   if(!_cwd) _cwd = cwd;
  66.   if(!symhold) symhold = &showsymlinks_hold;
  68.   sstrncpy(_cwd, fs_getcwd(), MAXPATHLEN);
  69.   *symhold = showsymlinks;
  70. }
  72. static void pop_cwd(char *_cwd, int *symhold)
  73. {
  74.   if(!_cwd) _cwd = cwd;
  75.   if(!symhold) symhold = &showsymlinks_hold;
  77.   fs_chdir(_cwd,*symhold);
  78.   showsymlinks = *symhold;
  79. }
  81. static int ls_perms_full(pool *p, cmd_rec *cmd, const char *path, int *hidden)
  82. {
  83.   int ret,ishidden,canon = 0;
  84.   char *fullpath;
  85.   long _fakemode;
  87.   fullpath = dir_realpath(p,path);
  88.   if(!fullpath) {
  89.     fullpath = dir_canonical_path(p,path);
  90.     canon = 1;
  91.   } if(!fullpath)
  92.     fullpath = pstrdup(p,path);
  93.   
  94.   if(canon)
  95.     ret = dir_check_canon(p,cmd->argv[0],cmd->group,fullpath,&ishidden);
  96.   else
  97.     ret = dir_check(p,cmd->argv[0],cmd->group,fullpath,&ishidden);
  99.   if(hidden)
  100. *hidden = ishidden;
  101.   
  102.   if(ishidden)
  103.    return 0;
  105.   if(session.dir_config) {
  106.     showsymlinks = get_param_int(session.dir_config->subset,
  107.                                  "ShowSymlinks",FALSE);
  109.     if(showsymlinks == -1)
  110.       showsymlinks = 1;
  111.   }
  113.   _fakemode = get_param_int(CURRENT_CONF,"DirFakeMode",FALSE);
  114.   if(_fakemode != -1) {
  115.     fakemode = (umode_t)_fakemode;
  116.     fakemodep = 1;
  117.   } else
  118.     fakemodep = 0;
  120.   return ret;
  121. }
  123. static int ls_perms(pool *p, cmd_rec *cmd, const char *path, int *hidden)
  124. {
  125.   int ret,ishidden;
  126.   char fullpath[MAXPATHLEN];
  127.   long _fakemode;
  129.   if(*path == '~')
  130. return ls_perms_full(p,cmd,path,hidden);
  132.   if(*path != '/')
  133.    fs_clean_path(pdircat(p,fs_getcwd(),path,NULL),fullpath,MAXPATHLEN);
  134.   else
  135. fs_clean_path(path,fullpath,MAXPATHLEN);
  136.   
  137.   ret = dir_check(p,cmd->argv[0],cmd->group,fullpath,&ishidden);
  139.   if(hidden)
  140.   *hidden = ishidden;
  141.   
  142.   if(ishidden)
  143.     return 0;
  145.   if(session.dir_config) {
  146.     showsymlinks = get_param_int(session.dir_config->subset,
  147.                                  "ShowSymlinks",FALSE);
  149.     if(showsymlinks == -1)
  150.       showsymlinks = 1;
  151.   }
  153.   _fakemode = get_param_int(CURRENT_CONF,"DirFakeMode",FALSE);
  154.   if(_fakemode != -1) {
  155.     fakemode = (umode_t)_fakemode;
  156.     fakemodep = 1;
  157.   } else
  158.     fakemodep = 0;
  160.   return ret;
  161. }
  163. static
  164. int sendline(char *fmt, ...)
  165. {
  166.   va_list msg;
  167.   char buf[1025];
  168.   int ret;
  170.   va_start(msg,fmt);
  171.   vsnprintf(buf,sizeof(buf),fmt,msg);
  172.   va_end(msg);
  174.   buf[1024] = '';
  176.   ret = data_xfer(buf,strlen(buf));
  177.   if(ret < 0) {
  178.     log_debug(DEBUG3,"data_xfer returned %d, error = %s",
  179.               ret,strerror(session.d->outf->xerrno));
  180.   }
  181.   return ret;
  182. }
  184. static
  185. void ls_done(cmd_rec *cmd)
  186. {
  187.   data_close(FALSE);
  188. }
  190. static
  191. int listfile(cmd_rec *cmd, pool *p, const char *name)
  192. {
  193.   int rval = 0, len;
  194.   time_t mtime;
  195.   char m[1024],l[1024];
  196.   struct stat st;
  197.   char months[12][4] =
  198.   { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  199.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
  200.   
  201.   struct tm *t;
  202.   char suffix[2];
  203.   
  204.   if(!p) p = cmd->tmp_pool;
  205.   
  206.   if(fs_lstat(name,&st) == 0) {
  207.     suffix[0] = suffix[1] = '';
  209.     if(S_ISLNK(st.st_mode) && !showsymlinks) {
  210.       /* attempt to fully dereference symlink */
  211.       struct stat l_st;
  213.       if(fs_stat(name,&l_st) != -1) {
  214.         memcpy(&st,&l_st,sizeof(st));
  215. if((len = fs_readlink(name, m, sizeof(m))) < 0)
  216.   return 0;
  218. m[len] = '';
  220.         if(!ls_perms_full(p,cmd,m,NULL))
  221.           return 0;
  222.       } else {
  223.         return 0;
  224.       }
  225.     } else if(S_ISLNK(st.st_mode)) {
  226.       if((len = fs_readlink(name, l, sizeof(l))) < 0)
  227. return 0;
  228.       
  229.       l[len] = '';
  230.       
  231.       if(!ls_perms_full(p,cmd,l,NULL))
  232.         return 0;
  233.     } else if(!ls_perms(p,cmd,name,NULL)) {
  234.       return 0;
  235.     }
  237.     mtime = st.st_mtime;
  238.     t = localtime((time_t*)&mtime);
  239.     if(!t) {
  240.       add_response_err(R_421,"Fatal error (localtime() returned NULL?!?)");
  241.       return -1;
  242.     }
  244.     if(opt_F) {
  245.       if(S_ISLNK(st.st_mode))
  246.         suffix[0] = '@';
  247.       else if(S_ISDIR(st.st_mode)) {
  248.         suffix[0] = '/';
  249.         rval = 1;
  250.       } else if(st.st_mode & 0111)
  251.         suffix[0] = '*';
  252.     }
  254.     if(opt_l) {
  255.       sstrncpy(m, " ---------", sizeof(m));
  256.       switch(st.st_mode & S_IFMT) {
  257.       case S_IFREG:
  258.         m[0] = '-';
  259.         break;
  260.       case S_IFLNK:
  261.         m[0] = 'l';
  262.         break;
  263.       case S_IFDIR:
  264.         m[0] = 'd';
  265.         rval = 1;
  266.         break;
  267.       }
  269.       if(m[0] != ' ') {
  270.         char nameline[MAXPATHLEN + MAXPATHLEN + 128];
  271.         char timeline[6];
  272.         umode_t mode = st.st_mode;
  274.         if(fakemodep)
  275.           mode = fakemode;
  277.         if(mode & 256)
  278.           m[1] = 'r';
  279.         if(mode & 128)
  280.           m[2] = 'w';
  281.         if(mode & 64 || ((mode & 256) && S_ISDIR(st.st_mode)))
  282.           m[3] = 'x';
  283.         if(mode & 32)
  284.           m[4] = 'r';
  285.         if(mode & 16)
  286.           m[5] = 'w';
  287.         if(mode & 8 || ((mode & 32) && S_ISDIR(st.st_mode)))
  288.           m[6] = 'x';
  289.         if(mode & 4)
  290.           m[7] = 'r';
  291.         if(mode & 2)
  292.           m[8] = 'w';
  293.         if(mode & 1 || ((mode & 4) && S_ISDIR(st.st_mode)))
  294.           m[9] = 'x';
  296.         if(ls_curtime - mtime > 180 * 24 * 60 * 60)
  297.           snprintf(timeline, sizeof(timeline), "%5d",t->tm_year+1900);
  298.         else
  299.           snprintf(timeline, sizeof(timeline), "%02d:%02d",t->tm_hour,t->tm_min);
  301.         snprintf(nameline, sizeof(nameline), "%s %3d %-8s %-8s %8d %s %2d %s %s", m,
  302.                 (int)st.st_nlink, MAP_UID((int)st.st_uid), 
  303.                 MAP_GID((int)st.st_gid),
  304.                 (unsigned int)st.st_size, months[t->tm_mon],
  305.                 t->tm_mday, timeline, name);
  307.         if(S_ISLNK(st.st_mode)) {
  308.           char *p = nameline + strlen(nameline);
  310.           suffix[0] = '';
  311.           if(opt_F && fs_stat(name, &st) == 0) {
  312.             if(S_ISLNK(st.st_mode))
  313.               suffix[0] = '@';
  314.             else if(S_ISDIR(st.st_mode))
  315.               suffix[0] = '/';
  316.             else if(st.st_mode & 0111)
  317.               suffix[0] = '*';
  318.           }
  320.           snprintf(p, sizeof(nameline) - strlen(nameline) - 4, " -> %s", l);
  321.         }
  323. if(opt_STAT)
  324.   add_response(R_211,"%s%s",nameline,suffix);
  325. else
  326.           addfile(cmd,nameline,suffix,mtime);
  327.       }
  328.     } else {
  329.       if(S_ISREG(st.st_mode) ||
  330.          S_ISDIR(st.st_mode) ||
  331.          S_ISLNK(st.st_mode))
  332.            addfile(cmd,name,suffix,mtime);
  334.     }
  335.   }
  336.   return rval;
  337. }
  339. static int colwidth = 0;
  340. static int filenames = 0;
  342. struct filename {
  343.   struct filename *down;
  344.   struct filename *right;
  345.   int top;
  346.   char line[1];
  347. };
  349. struct sort_filename {
  350.   time_t mtime;
  351.   char *name,*suffix;
  352. };
  353.   
  354. static struct filename *head = NULL;
  355. static struct filename *tail = NULL;
  356. static array_header *sort_arr = NULL;
  357. static pool *fpool = NULL;
  358.  
  359. static void addfile(cmd_rec *cmd, const char *name, const char *suffix, time_t mtime)
  360. {
  361.   struct  filename *p;
  362.   int l;
  364.   if(!name || !suffix)
  365.     return;
  367.   if(opt_t) {
  368.     struct sort_filename *s;
  370.     if(!fpool)
  371.       fpool = make_sub_pool(cmd->tmp_pool);
  373.     if(!sort_arr)
  374.       sort_arr = make_array(fpool,50,sizeof(struct sort_filename));
  376.     s = (struct sort_filename*)push_array(sort_arr);
  377.     s->mtime = mtime;
  378.     s->name = pstrdup(fpool,name);
  379.     s->suffix = pstrdup(fpool,suffix);
  381.     return;
  382.   }
  384.   matches++;
  386.   l = strlen(name) + strlen(suffix);
  387.   if(l > colwidth)
  388.     colwidth = l;
  390.   if(!fpool)
  391.     fpool = make_sub_pool(cmd->tmp_pool);
  393.   p = (struct filename*) pcalloc(fpool, sizeof(struct filename) + l + 1);
  394. #if 0
  395.   log_debug(DEBUG4,"alloc: %dn",sizeof(struct filename) + l + 1);
  396. #endif
  398.   snprintf(p->line, l + 1, "%s%s", name, suffix);
  400.   if(tail)
  401.     tail->down = p;
  402.   else
  403.     head = p;
  405.   tail = p;
  406.   filenames++;
  407. }
  409. #if 0
  410. static
  411. void RANGE(void *ptr)
  412. {
  413.   char *cp = (char*)ptr;
  414.   if(cp) {
  415.    *cp;
  416.   }
  417. }
  418. #endif
  420. static
  421. int _compare_file_mtime(const struct sort_filename *f1,
  422.                         const struct sort_filename *f2)
  423. {
  424.   if(f1->mtime > f2->mtime)
  425.     return -1;
  426.   else if(f1->mtime < f2->mtime)
  427.     return 1;
  429.   return 0;
  430. }
  432. static
  433. int _compare_file_mtime_reversed(const struct sort_filename *f1,
  434.                         const struct sort_filename *f2)
  435. {
  436.   return -_compare_file_mtime(f1, f2);
  437. }
  439. static
  440. void sortfiles(cmd_rec *cmd)
  441. {
  442.   struct sort_filename *s;
  443.   int i;
  445.   if(opt_t && sort_arr) {
  446.     qsort(sort_arr->elts, sort_arr->nelts, sizeof(struct sort_filename),
  447.           (int (*)(const void*,const void*))
  448.   (opt_r ? _compare_file_mtime_reversed : _compare_file_mtime));
  450.     opt_t = 0;
  451.     for(i = 0, s = (struct sort_filename*)sort_arr->elts; i < sort_arr->nelts; i++, s++)
  452.       addfile(cmd,s->name,s->suffix,s->mtime);
  453.     opt_t = 1;
  454.   }
  455.     
  456.   sort_arr = NULL;
  457. }
  459. static
  460. int outputfiles(cmd_rec *cmd)
  461. {
  462.   int n;
  463.   struct  filename *p;
  464.   struct filename *q;
  466.   if(opt_t)
  467.     sortfiles(cmd);
  469.   if(!head) /* nothing to display */
  470.     return 0;
  472.   tail->down = NULL;
  473.   tail = NULL;
  474.   colwidth = ( colwidth | 7 ) + 1;
  475.   if(opt_l || !opt_C)
  476.     colwidth = 75;
  478.   /* avoid division by 0 if colwidth > 75 */
  479.   if(colwidth > 75)
  480.     colwidth = 75;
  482.   p = head;
  483.   p->top = 1;
  484.   n = (filenames + (75 / colwidth)-1) / (75 / colwidth);
  485.   while(n && p) {
  486.     p = p->down;
  487.     if(p)
  488.       p->top = 0;
  489.     n--;
  490.   }
  492.   q = head;
  493.   while(p) {
  494.     p->top = q->top;
  495.     q->right = p;
  496.     q = q->down;
  497.     p = p->down;
  498.   }
  500.   while(q) {
  501.     q->right = NULL;
  502.     q = q->down;
  503.   }
  505.   p = head;
  506.   while(p && p->down && !p->down->top)
  507.     p = p->down;
  508.   if(p && p->down)
  509.     p->down = NULL;
  511. #if 0
  512.   if(opt_l)
  513.     if(sendline("total 0n") < 0)
  514.       return -1;
  515. #endif
  516.   
  517.   p = head;
  518.   while(p) {
  519.     q = p;
  520.     p = p->down;
  521.     while(q) {
  522.       char pad[6];
  524.       if(q->right) {
  525.         sstrncpy(pad, "ttttt", sizeof(pad));
  526.         pad[(colwidth + 7 - strlen(q->line)) / 8] = '';
  527.       } else {
  528.         sstrncpy(pad, "n", sizeof(pad));
  529.       }
  531.       if(sendline("%s%s", q->line, pad) < 0)
  532.         return -1;
  534.       q = q->right;
  535.     }
  536.   }
  538.   destroy_pool(fpool);
  539.   fpool = NULL;
  540.   sort_arr = NULL;
  541.   head = tail = NULL;
  542.   colwidth = 0;
  543.   filenames = 0;
  544.   return 0;
  545. }
  548. static
  549. void discard_output()
  550. {
  551.   if(fpool)
  552.     destroy_pool(fpool);
  553.   fpool = NULL;
  555.   head = tail = NULL;
  556.   colwidth = 0;
  557.   filenames = 0;
  558. }
  561. static int cmp(const void *a, const void *b)
  562. {
  563.   return strcmp(*(const char **)a, *(const char **)b);
  564. }
  566. static
  567. char **sreaddir(pool *workp, const char *dirname, const int sort)
  568. {
  569.   DIR  *d;
  570.   struct dirent *de;
  571.   struct stat st;
  572.   int i;
  573.   char **p;
  574.   char *s;
  575.   int dsize;
  577.   if(fs_stat(dirname,&st) < 0) 
  578.     return NULL;
  580.   if(!S_ISDIR(st.st_mode)) {
  581.     errno = ENOTDIR;
  582.     return NULL;
  583.   }
  585.   if((d = opendir(dirname)) == NULL)
  586.     return NULL;
  588.   dsize = st.st_size / 2 + 256;
  590. realloc_buf:
  591.   p = (char**)palloc(workp,dsize);
  593.   s = dsize + (char*)p;
  594.   i = 0;
  596.   while((de = readdir(d)) != NULL) {
  597.     if((unsigned int)p + (i+1)*sizeof(char*) + strlen(de->d_name) + 1
  598.          > (unsigned int)s) {
  599.       log_debug(DEBUG0,"reallocating sreaddir buffer from %d bytes to %d bytes.",
  600.       dsize,dsize*2);
  601.       dsize *= 2;
  602.       rewinddir(d);
  603.       goto realloc_buf;
  604.     }
  605.     s -= strlen(de->d_name) + 1;
  606.     sstrncpy(s, de->d_name, strlen(de->d_name) + 1);
  607.     p[i++] = s;
  608.   }
  610.   closedir(d);
  611.   p[i] = NULL;
  613.   if(sort)
  614. qsort(p,i,sizeof(char*),cmp);
  615.   
  616.   return p;
  617. }
  619. /* listdir required chdir first */
  620. static int listdir(cmd_rec *cmd, pool *workp, const char *name, int list_dotdirs)
  621. {
  622.   char **dir;
  623.   int dest_workp = 0;
  625.   if(XFER_ABORTED)
  626. return -1;
  628.   if(!workp) {
  629.     workp = make_sub_pool(cmd->tmp_pool);
  630.     dest_workp++;
  631.   } else {
  632.     workp = make_sub_pool(workp);
  633.     dest_workp++;
  634.   }
  636.   dir = sreaddir(workp,".",TRUE);
  638.   if(dir) {
  639.     char **s;
  640.     char **r;
  642.     int d = 0;
  644. #if 0
  645.     if(opt_l) {
  646.       if(opt_STAT)
  647.         add_response(R_211,"total 0");
  648.       else if(sendline("total 0n") < 0)
  649.         return -1;
  650.     }
  651. #endif
  652.     
  653.     s = dir;
  654.     while(*s) {
  655.       if(**s != '.') {
  656.         d = listfile(cmd,workp,*s);
  657.       } else if(!opt_a && showdotfiles != 1 && list_dotdirs) {
  658.         if( (((*s)[1] == '') ||
  659.             (((*s)[1] == '.') &&
  660.              ((*s)[2] == '')))) {
  661.           d = listfile(cmd,workp,*s);
  662.           if(d > 0)
  663.             d = 0;
  664.         }
  665.       } else if(opt_a || showdotfiles == 1) {
  666.         if(!opt_a && (((*s)[1] == '') ||
  667.            (((*s)[1] == '.') &&
  668.             ((*s)[2] == ''))))
  669.           d = 0;
  670. else
  671.   d = listfile(cmd,workp,*s);
  672.       } else {
  673.         d = 0;
  674.       }
  675.       if(!d)
  676.         *s = NULL;
  677.       s++;
  678.     }
  680.     if(outputfiles(cmd) < 0) {
  681.       if(dest_workp)
  682.         destroy_pool(workp);
  683.       return -1;
  684.     }
  686.     r = dir;
  687.     while(opt_R && r != s) {
  688.       char cwd[MAXPATHLEN];
  689.       int symhold;
  691.       if(*r && (strcmp(*r,".") == 0 || strcmp(*r,"..") == 0)) {
  692.         r++;
  693.         continue;
  694.       }
  695.       
  696.       push_cwd(cwd,&symhold);
  697.      
  698.       if(*r && ls_perms_full(workp,cmd,(char*)*r,NULL) 
  699.     && !fs_chdir_canon(*r,showsymlinks)) {
  700.         char *subdir;
  702. if(strcmp(name,".") == 0)
  703.           subdir = *r;
  704.         else
  705.           subdir = pdircat(workp,name,*r,NULL);
  707. if(opt_STAT) {
  708.   add_response(R_211,"");
  709.           add_response(R_211,"%s:",subdir);
  710. } else if(sendline("n%s:n",subdir) < 0) {
  711.           pop_cwd(cwd,&symhold);
  712.           if(dest_workp)
  713.             destroy_pool(workp);
  714.           return -1;
  715.         }
  717.         if(listdir(cmd,workp,subdir,list_dotdirs) < 0) {
  718.           pop_cwd(cwd,&symhold);
  719.           if(dest_workp)
  720.             destroy_pool(workp);
  721.           return -1;
  722.         }
  724.         pop_cwd(cwd,&symhold);
  725.       }
  726.       r++;
  727.     }
  728.   }
  730.   if(dest_workp)
  731.     destroy_pool(workp);
  733.   return 0;
  734. }
  736. static
  737. void ls_terminate()
  738. {
  739.   if(!opt_STAT) {
  740.     discard_output();
  741.     if(!XFER_ABORTED) {  /* an error has occured, other than client ABOR */
  742.       if(ls_errno)
  743.         data_abort(ls_errno,FALSE);
  744.       else
  745.         data_abort((session.d && session.d->outf ? 
  746.                    session.d->outf->xerrno : errno),FALSE);
  747.     }
  748.     ls_errno = 0;
  749.   } else if(ls_errno) {
  750.     add_response(R_211,"ERROR: %s",strerror(ls_errno));
  751.     ls_errno = 0;
  752.   }
  753. }
  755. static
  756. void _parse_options(char **opt, int *glob_flags)
  757. {
  758.   while(isspace((UCHAR)**opt))
  759.     opt++;
  761.   while(*opt && **opt == '-') {
  762.     while((*opt)++ && isalnum((UCHAR)**opt)) {
  763.       switch(**opt) {
  764.       case 'a':
  765.         opt_a++;
  766.         break;
  767.       case 'l':
  768.         opt_l++;
  769.         opt_C = 0;
  770.         break;
  771.       case '1':
  772.         opt_l = opt_C = 0;
  773.         break;
  774.       case 'C':
  775.         opt_l = 0;
  776.         opt_C++;
  777.         break;
  778.       case 'F':
  779.         opt_F++;
  780.         break;
  781.       case 'r':
  782.         opt_r++;
  783.         break;
  784.       case 'R':
  785.         opt_R++;
  786.         break;
  787.       case 'd':
  788.         opt_d++;
  789.         break;
  790.       case 't':
  791.         opt_t++;
  792.         if(glob_flags)
  793.           *glob_flags |= GLOB_NOSORT;;
  794.         break;
  795.       }
  796.     }
  797.     while(isspace((UCHAR)**opt)) 
  798.       (*opt)++;
  800.   }
  801. }
  803. static
  804. int dolist(cmd_rec *cmd, const char *opt, int clearflags)
  805. {
  806.   int skiparg = 0;
  807.   int glob_flags = GLOB_PERIOD;
  808.   char *arg = (char*)opt;
  810.   matches = 0;
  811.   ls_curtime = time(NULL);
  813.   if(clearflags)
  814.     opt_a = opt_C = opt_d = opt_F = opt_r = opt_R = opt_t = opt_STAT = 0;
  816.   if(default_options)
  817.     _parse_options(&default_options,&glob_flags);
  818.   _parse_options(&arg,&glob_flags);
  820.   /* open data connection */
  821.   if(!opt_STAT) {
  822.     session.flags |= SF_ASCII_OVERRIDE;
  823.     if(data_open(NULL,"file list",IO_WRITE,0) < 0)
  824.       return -1;
  825.   }
  827.   if(arg && *arg) {
  828.     int justone;
  830.     justone = 1;
  831.     while(arg) {
  832.       glob_t g;
  833.       int    a;
  834.       char   pbuffer[MAXPATHLEN];
  836.       char   *endarg = strchr(arg,' ');
  838.       if(endarg) {
  839.         *endarg++ = '';
  840.         justone = 0;
  841.       }
  843.       if(*arg == '~') {
  844.         struct passwd *pw;
  845. int i;
  846.         const char *p;
  848.         i = 0;
  849.         p = arg;
  850.         p++;
  852.         while(*p && *p != '/')
  853.           pbuffer[i++] = *p++;
  854.         pbuffer[i] = '';
  856.         if((pw = auth_getpwnam(cmd->tmp_pool,i ? pbuffer : session.user)))
  857.           snprintf(pbuffer, sizeof(pbuffer), "%s%s",pw->pw_dir,p);
  858.         else
  859.           *pbuffer = '';
  860.       } else
  861.         *pbuffer = '';
  863.       /* check perms on the directory/file we are about to scan */
  864.       if(!ls_perms_full(cmd->tmp_pool,cmd,(*pbuffer ? (char*)pbuffer:(char*)arg),NULL)) {
  865.         a = -1; skiparg = 1;
  866.       } else {
  867.         skiparg = 0;
  868.         a = fs_glob(*pbuffer ? pbuffer:arg, glob_flags,
  869.                  NULL, &g);
  870.       }
  872.       if(!a) {
  873.         char **path;
  875.         path = g.gl_pathv;
  876.         if(path && path[0] && path[1])
  877.           justone = 0;
  879.         while(path && *path) {
  880.           struct stat st;
  882.           /* if opt_a is not set, don't display dot files, except for
  883.            * ./ and ../
  884.            */
  886.           if(**path == '.' && !opt_a && showdotfiles != 1 && 
  887.      (*path)[1] != ''  && ((*path)[1] != '.' ||
  888.      ((*path)[1] == '.' && (*path)[2] != ''))) {
  889.             **path = '';
  890.             path++;
  891.             continue;
  892.           }
  894.           if(fs_lstat(*path,&st) == 0) {
  895.             mode_t target_mode,lmode;
  896.     target_mode = st.st_mode;
  898.             if(S_ISLNK(st.st_mode) && (lmode = file_mode((char*)*path)) != 0) {
  899.               if(!showsymlinks)
  900.                 st.st_mode = lmode;
  901.               target_mode = lmode;
  902.             }
  904.             if(opt_d || !(S_ISDIR(target_mode))) {
  905.               if(listfile(cmd,NULL,*path) < 0) {
  906.                 ls_terminate();
  907. fs_globfree(&g);
  908.                 return -1;
  909.               }
  910.               **path = '';
  911.             }
  912.           } else {
  913.             **path = '';
  914.           }
  915.           path++;
  916.         }
  918. if(outputfiles(cmd) < 0) {
  919.           ls_terminate();
  920.           fs_globfree(&g);
  921.   return -1;
  922.         }
  924.         path = g.gl_pathv;
  925.         while(path && *path) {
  926.           if(**path && ls_perms_full(cmd->tmp_pool,cmd,*path,NULL)) {
  927.             char cwd[MAXPATHLEN];
  928.             int symhold;
  930.             if(!justone) {
  931.               if(opt_STAT) {
  932. add_response(R_211,"");
  933. add_response(R_211,"%s:",*path);
  934.       } else
  935.                 sendline("n%s:n",*path);
  936.             }
  938.             push_cwd(cwd,&symhold);
  940.             if(!fs_chdir_canon(*path,showsymlinks)) {
  941.               int ret = listdir(cmd,NULL,*path,FALSE);
  942.               pop_cwd(cwd,&symhold);
  944.               if(ret < 0) {
  945.                 ls_terminate();
  946. fs_globfree(&g);
  947.                 return -1;
  948.               }
  949.             }
  950.           }
  951.           if(XFER_ABORTED) {
  952.     discard_output();
  953.             fs_globfree(&g);
  954.     return -1;
  955.   }
  956.           path++;
  957.         }
  959.       } else if(!skiparg) {
  960.         if(a == GLOB_NOSPACE) {
  961.           add_response(R_226,"Out of memory during globbing of %s", arg);
  962.         } else if(a == GLOB_ABORTED) {
  963.           add_response(R_226,"Read error during globbing of %s", arg);
  964.         } else if(a != GLOB_NOMATCH) {
  965.           add_response(R_226,"Unknown error during globbing of %s", arg);
  966.         }
  967.       }
  969.       if(!skiparg)
  970.         fs_globfree(&g);
  971.       arg = endarg;
  973.       if(XFER_ABORTED) {
  974. discard_output();
  975.         return -1;
  976.       }
  977.     }
  978.   } else {
  979.     if(ls_perms_full(cmd->tmp_pool,cmd,".",NULL)) {
  980.       if(opt_d) {
  981.         if(listfile(cmd,NULL,".") < 0) {
  982.           ls_terminate();
  983.           return -1;
  984.         }
  985.       } else {
  986.         if(listdir(cmd,NULL,".",FALSE) < 0) {
  987.           ls_terminate(); 
  988.   return -1;
  989.         }
  990.       }
  991.     }
  993.     if(outputfiles(cmd) < 0) {
  994.       ls_terminate();
  995.       return -1;
  996.     }
  997.   }
  999.   return 0;
  1000. }
  1002. /* display listing of a single file, no permission checking is done.
  1003.  * error is only returned if the data connection cannot be opened
  1004.  * or is aborted.
  1005.  */
  1007. static
  1008. int nlstfile(cmd_rec *cmd, const char *file)
  1009. {
  1010. int err;
  1012. /* If the data connection isn't open, open it now. */
  1013. if((session.flags & SF_XFER) == 0) {
  1014. if(data_open(NULL,"file list",IO_WRITE,0) < 0) {
  1015. data_reset();
  1016. return -1;
  1017. }
  1018. session.flags |= SF_ASCII_OVERRIDE;
  1019. }
  1021. if((err = sendline("%sn",file)) < 0)
  1022. return err;
  1024. return 1;
  1025. }
  1027. /* display listing of a directory, ACL checks performed on each entry,
  1028.  * sent in NLST fashion.  Files which are inaccessible via ACL are skipped,
  1029.  * error returned if data conn cannot be opened or is aborted.
  1030.  */
  1032. static int nlstdir(cmd_rec *cmd, const char *dir) {
  1033.   char **list, *p, *f, file[MAXPATHLEN];
  1034.   char cwd[MAXPATHLEN];
  1035.   pool *workp;
  1036.   int curdir = 0, i, symhold, count = 0;
  1037.   mode_t mode;
  1038.   
  1039.   workp = make_sub_pool(cmd->tmp_pool);
  1040.   
  1041.   if(!*dir || (*dir == '.' && !dir[1]) || strncmp(dir,"./",2) == 0) {
  1042.     curdir = 1;
  1043.     dir = "";
  1044.   } else {
  1045.     push_cwd(cwd,&symhold);
  1046.   }
  1047.   
  1048.   if(fs_chdir_canon(dir,showsymlinks)) {
  1049.     destroy_pool(workp);
  1050.     return 0;
  1051.   }
  1052.   
  1053.   if((list = sreaddir(workp,".",FALSE)) == NULL) {
  1054.     if(!curdir)
  1055.       pop_cwd(cwd,&symhold);
  1056.     destroy_pool(workp);
  1057.     return 0;
  1058.   }
  1059.   
  1060.   while(*list && count >= 0) {
  1061.     p = *list; list++;
  1062.     
  1063.     if(*p == '.' && (((p[1] == '') || ((p[2] == '.') &&
  1064.  (p[3] == '')))) )
  1065.       continue;
  1066.     
  1067.     if(*p == '.' && showdotfiles != 1)
  1068.       continue;
  1069.     
  1070.     if((i = fs_readlink(p, file, sizeof(file))) > 0) {
  1071.       file[i] = '';
  1072.       f = file;
  1073.     } else {
  1074.       f = p;
  1075.     }
  1076.     
  1077.     if(ls_perms(workp,cmd,f,NULL)) {
  1078.       /* If the data connection isn't open, open it now. */
  1079.       if((session.flags & SF_XFER) == 0) {
  1080. if(data_open(NULL,"file list",IO_WRITE,0) < 0) {
  1081.   data_reset();
  1082.   count = -1;
  1083.   continue;
  1084. }
  1085. session.flags |= SF_ASCII_OVERRIDE;
  1086.       }
  1087.       
  1088.       if((mode = file_mode(f)) == 0)
  1089. continue;
  1090.       
  1091.       if(!curdir) {
  1092. if(sendline("%s/%sn",dir,p) < 0)
  1093.   count = -1;
  1094. else count++;
  1095.       } else {
  1096. if(sendline("%sn",p) < 0)
  1097.   count = -1;
  1098. else count++;
  1099.       }
  1100.     }
  1101.   }
  1102.   
  1103.   if(!curdir)
  1104.     pop_cwd(cwd,&symhold);
  1105.   
  1106.   destroy_pool(workp);
  1107.   
  1108.   return count;
  1109. }
  1111. MODRET genericlist(cmd_rec *cmd)
  1112. {
  1113.   int err;
  1114.   long _fakemode;
  1116.   showsymlinks = get_param_int(TOPLEVEL_CONF,"ShowSymlinks",FALSE);
  1118.   if(showsymlinks == -1)
  1119.     showsymlinks = 1;
  1121.   default_options = get_param_ptr(TOPLEVEL_CONF,"LsDefaultOptions",FALSE);
  1122.   fakeuser = get_param_ptr(TOPLEVEL_CONF,"DirFakeUser",FALSE);
  1123.   fakegroup = get_param_ptr(TOPLEVEL_CONF,"DirFakeGroup",FALSE);
  1124.   _fakemode = (long)get_param_int(TOPLEVEL_CONF,"DirFakeMode",FALSE);
  1125.   showdotfiles = get_param_int(TOPLEVEL_CONF,"ShowDotFiles",FALSE);
  1127.   if(_fakemode != -1) {
  1128.     fakemode = (umode_t)_fakemode;
  1129.     fakemodep = 1;
  1130.   } else
  1131.     fakemodep = 0;
  1133.   err = dolist(cmd,cmd->arg,TRUE);
  1134.   if(XFER_ABORTED) {
  1135.     data_abort(0,0);
  1136.     err = -1;
  1137.   } else if(session.flags & SF_XFER)
  1138.     ls_done(cmd);
  1140.   opt_l = 0;
  1141.   return (err == -1 ? ERROR(cmd) : HANDLED(cmd));
  1142. }
  1144. MODRET fini_nlst(cmd_rec *cmd)
  1145. {
  1146.   data_cleanup();
  1147.   return DECLINED(cmd);
  1148. }
  1150. MODRET cmd_stat(cmd_rec *cmd)
  1151. {
  1152.   char *arg = cmd->arg;
  1153.   long _fakemode;
  1155.   if(cmd->argc < 2) {
  1156.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  1157.     return ERROR(cmd);
  1158.   }
  1160.   if(*arg == '-')
  1161.     while(!isspace((UCHAR)*arg)) arg++;
  1162.   while(isspace((UCHAR)*arg)) arg++;
  1164.   showsymlinks = get_param_int(TOPLEVEL_CONF,"ShowSymlinks",FALSE);
  1166.   if(showsymlinks == -1)
  1167.     showsymlinks = 1;
  1169.   default_options = get_param_ptr(TOPLEVEL_CONF,"LsDefaultOptions",FALSE);
  1170.   fakeuser = get_param_ptr(TOPLEVEL_CONF,"DirFakeUser",FALSE);
  1171.   fakegroup = get_param_ptr(TOPLEVEL_CONF,"DirFakeGroup",FALSE);
  1172.   _fakemode = (long)get_param_int(TOPLEVEL_CONF,"DirFakeMode",FALSE);
  1173.   showdotfiles = get_param_int(TOPLEVEL_CONF,"ShowDotFiles",FALSE);
  1174.   
  1175.   if(_fakemode != -1) {
  1176.     fakemode = (umode_t)_fakemode;
  1177.     fakemodep = 1;
  1178.   } else
  1179.     fakemodep = 0;
  1181.   opt_C = opt_d = opt_F = opt_R;
  1182.   opt_a = opt_l = opt_STAT = 1;
  1184.   add_response(R_211,"status of %s:",arg);
  1185.   dolist(cmd,cmd->arg,FALSE);
  1186.   add_response(R_211,"End of Status");
  1187.   return HANDLED(cmd);
  1188. }
  1190. MODRET cmd_list(cmd_rec *cmd)
  1191. {
  1192.   MODRET ret;
  1193.   
  1194.   opt_l = 1;
  1195.   ret = genericlist(cmd);
  1196.   return ret;
  1197. }
  1199. /* NLST is a very simplistic directory listing, unlike LIST (which
  1200.  * emululates ls), it only sends a list of all files/directories
  1201.  * matching the glob(s).
  1202.  */
  1204. MODRET cmd_nlst(cmd_rec *cmd)
  1205. {
  1206. char *target,line[MAXPATHLEN];
  1207. int count = 0;
  1208. int ret = 0;
  1210. /* In case the client used NLST instead of LIST
  1211.  */
  1213. if(cmd->argc > 1 && cmd->argv[1][0] == '-')
  1214. return genericlist(cmd);
  1216. showsymlinks = get_param_int(TOPLEVEL_CONF,"ShowSymlinks",FALSE);
  1218. if(showsymlinks == -1)
  1219. showsymlinks = 1;
  1220. showdotfiles = get_param_int(TOPLEVEL_CONF,"ShowDotFiles",FALSE);
  1222. if(cmd->argc == 1)
  1223. target = ".";
  1224. else
  1225. target = cmd->arg;
  1227. /* If the target starts with '~' ... */
  1228. if(*target == '~') {
  1229. char pb[MAXPATHLEN];
  1230. struct passwd *pw;
  1231. int i;
  1232. const char *p;
  1234. i = 0;
  1235. p = target;
  1236. p++;
  1238. while(*p && *p !='/')
  1239. pb[i++] = *p++;
  1240. pb[i] = '';
  1242. if((pw = auth_getpwnam(cmd->tmp_pool,i ? pb : session.user))) {
  1243.   snprintf(pb, sizeof(pb), "%s%s",pw->pw_dir,p);
  1244.   sstrncpy(line, pb, sizeof(line));
  1245.   target = line;
  1246. }
  1247. }
  1249. /* If the target is a glob, get the listing of files/dirs to send
  1250.  */
  1252. if(strpbrk(target,"{[*?") != NULL) {
  1253. glob_t g;
  1254. char **path,*p;
  1256. if(fs_glob(target,GLOB_PERIOD,NULL,&g) != 0) {
  1257. add_response_err(R_550,"No files found.");
  1258. return ERROR(cmd);
  1259. }
  1261. /* Iterate through each matching entry */
  1262. path = g.gl_pathv;
  1263. while(path && *path && ret >= 0) {
  1264. struct stat st;
  1266. /* Skip ./ and ../ */
  1267. p = *path; path++;
  1268. if(*p == '.' && (
  1269. ((p[1] == '') ||
  1270. ((p[1] == '.') &&
  1271.  (p[2] == '')))) )
  1272. continue;
  1274. if(*p == '.' && showdotfiles != 1)
  1275. continue;
  1277. if(fs_stat(p,&st) == 0) {
  1278. /* If it's a directory, hand off to nlstdir */
  1279. if(S_ISDIR(st.st_mode))
  1280. ret = nlstdir(cmd,p);
  1281. else if(S_ISREG(st.st_mode) &&
  1282. ls_perms(cmd->tmp_pool,cmd,p,NULL))
  1283. ret = nlstfile(cmd,p);
  1284. if(ret > 0)
  1285. count += ret;
  1286. }
  1287. }
  1288. fs_globfree(&g);
  1289. } else {
  1290. /* A single target, if it's a directory, list the contents,
  1291.  * if it's a file, just list the file.
  1292.  */
  1293. int hidden;
  1294. struct stat st;
  1296. if(!ls_perms(cmd->tmp_pool,cmd,target,&hidden)) {
  1297. if(hidden)
  1298. add_response_err(R_550,"%s: No such file or directory",cmd->arg);
  1299. else
  1300. add_response_err(R_550,"%s: Permission denied",cmd->arg);
  1301. return ERROR(cmd);
  1302. }
  1304. /* Make sure the target is a file or directory,
  1305.  * and that we have access to it.
  1306.  */
  1307. if(fs_stat(target,&st) < 0) {
  1308. add_response_err(R_550,"%s: %s",
  1309. cmd->arg,strerror(errno));
  1310. return ERROR(cmd);
  1311. }
  1313. if(S_ISREG(st.st_mode))
  1314. ret = nlstfile(cmd,target);
  1315. else if(S_ISDIR(st.st_mode)) {
  1316. if(access(target,R_OK) != 0) {
  1317. add_response_err(R_550,"%s: %s",
  1318. cmd->arg,strerror(errno));
  1319. return ERROR(cmd);
  1320. }
  1321. ret = nlstdir(cmd,target);
  1322. } else {
  1323. add_response_err(R_550,"%s: Not a regular file",
  1324. cmd->arg,strerror(errno));
  1325. return ERROR(cmd);
  1326. }
  1328. if(ret > 0)
  1329. count += ret;
  1330. }
  1332. if(XFER_ABORTED) {
  1333. data_abort(0,0);
  1334. ret = -1;
  1335. } else {
  1336. if(ret == 0 && !count && (session.flags & SF_XFER) == 0) {
  1337. add_response_err(R_550,"No files found.");
  1338. ret = -1;
  1339. } else if(session.flags & SF_XFER)
  1340. ls_done(cmd);
  1342. /* Note that the data connection is NOT cleared here,
  1343.  * as an error in NLST still leaves data ready for
  1344.  * another command
  1345.  */
  1346. }
  1348. return (ret < 0 ? ERROR(cmd) : HANDLED(cmd));
  1349. }
  1351. MODRET _sethide(cmd_rec *cmd, const char *param)
  1352. {
  1353.   int bool;
  1354.   char *as = "ftp";
  1356.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1358.   if(cmd->argc < 2 || cmd->argc > 3)
  1359.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"syntax: ",
  1360.                    param," On|Off [<id to display>]",NULL));
  1362.   bool = get_boolean(cmd,1);
  1363.   if(bool > 0) {
  1364.     if(cmd->argc > 2)
  1365.       as = cmd->argv[2];
  1367.     add_config_param_str(param,1,as);
  1368.   } else if(!bool)
  1369.     add_config_param_str(param,0);
  1371.   return HANDLED(cmd);
  1372. }
  1374. MODRET set_dirfakeuser(cmd_rec *cmd)
  1375. {
  1376.   return _sethide(cmd,"DirFakeUser");
  1377. }
  1379. MODRET set_dirfakegroup(cmd_rec *cmd)
  1380. {
  1381.   return _sethide(cmd,"DirFakeGroup");
  1382. }
  1384. MODRET set_dirfakemode(cmd_rec *cmd)
  1385. {
  1386.   config_rec *c;
  1387.   unsigned long fake;
  1388.   char *endp;
  1390.   CHECK_ARGS(cmd,1);
  1391.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL|CONF_DIR);
  1393.   fake = (unsigned long)strtol(cmd->argv[1],&endp,8);
  1395.   if(endp && *endp)
  1396.     CONF_ERROR(cmd,"argument must be an octal number.");
  1398.   c = add_config_param("DirFakeMode",1,(void*)fake);
  1399.   c->flags |= CF_MERGEDOWN;
  1401.   return HANDLED(cmd);
  1402. }
  1404. MODRET set_lsdefaultoptions(cmd_rec *cmd)
  1405. {
  1406.   CHECK_ARGS(cmd,1);
  1407.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1409.   add_config_param_str("LsDefaultOptions",1,cmd->argv[1]);
  1411.   return HANDLED(cmd);
  1412. }
  1414. MODRET set_showdotfiles(cmd_rec *cmd)
  1415. {
  1416.   int b;
  1417.   
  1418.   CHECK_ARGS(cmd,1);
  1419.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1421.   if((b = get_boolean(cmd,1)) == -1)
  1422.     CONF_ERROR(cmd,"expected boolean argument.");
  1424.   add_config_param("ShowDotFiles",1,(void*)b);
  1425.   return HANDLED(cmd);
  1426. }
  1428. static conftable ls_config[] = {
  1429.   { "DirFakeUser", set_dirfakeuser, NULL },
  1430.   { "DirFakeGroup", set_dirfakegroup, NULL },
  1431.   { "DirFakeMode", set_dirfakemode, NULL },
  1432.   { "LsDefaultOptions", set_lsdefaultoptions, NULL },
  1433.   { "ShowDotFiles", set_showdotfiles, NULL },
  1434.   { NULL, NULL, NULL }
  1435. };
  1437. cmdtable ls_commands[] = {
  1438.   { CMD,   C_NLST, G_DIRS, cmd_nlst, TRUE, FALSE, CL_DIRS },
  1439.   { CMD, C_LIST, G_DIRS, cmd_list, TRUE, FALSE, CL_DIRS },
  1440.   { CMD,  C_STAT, G_DIRS, cmd_stat, TRUE, FALSE, CL_DIRS },
  1441.   { LOG_CMD, C_LIST, G_NONE, fini_nlst, FALSE, FALSE },
  1442.   { LOG_CMD, C_NLST, G_NONE, fini_nlst, FALSE, FALSE },
  1443.   { 0, NULL }
  1444. };
  1446. module ls_module = {
  1447.   NULL,NULL, /* Always NULL */
  1448.   0x20, /* API version */
  1449.   "ls", /* Module name */
  1450.   ls_config,
  1451.   ls_commands,
  1452.   NULL,
  1453.   NULL,NULL
  1454. };