home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / xap / xfm / xfm-1.000 / xfm-1 / xfm-1.3.2 / src / FmDirs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-24  |  6.7 KB  |  267 lines
  1. /*---------------------------------------------------------------------------
  2.   Module FmDirs.c                                                           
  3.  
  4.   (c) Simon Marlow 1990-1993
  5.   (c) Albert Graef 1994
  6.  
  7.   functions for manipulating directory lists, and some other utilities
  8.   related to the file system.
  9.  
  10.   modified 1-29-95 by rodgers@lvs-emh.lvs.loral.com (Kevin M. Rodgers)
  11.   to add filtering of icon/text directory displays by a filename filter.
  12.  
  13. -----------------------------------------------------------------------------*/
  14.  
  15. #include <memory.h>
  16. #include <string.h>
  17. #include <stdlib.h>
  18.  
  19. #include <X11/Intrinsic.h>
  20.  
  21. #include "Fm.h"
  22.  
  23. /*-----------------------------------------------------------------------------
  24.   STATIC DATA                                       
  25. -----------------------------------------------------------------------------*/
  26.  
  27. static SortType sort_type;
  28. static Boolean dirs_first;
  29.  
  30. /*-----------------------------------------------------------------------------
  31.   PRIVATE FUNCTIONS
  32. -----------------------------------------------------------------------------*/
  33.  
  34. static int comp(FileRec **fr1, FileRec **fr2)
  35. {
  36.   FileRec *fl1 = *fr1, *fl2 = *fr2;
  37.  
  38.   if (dirs_first) {
  39.     if (S_ISDIR(fl1->stats.st_mode)) {
  40.       if (!S_ISDIR(fl2->stats.st_mode))
  41.     return -1;
  42.     }
  43.     else if (S_ISDIR(fl2->stats.st_mode))
  44.       return 1;
  45.   }
  46.     
  47.   switch (sort_type) {
  48.   case SortByName:
  49.     return strcmp(fl1->name, fl2->name);
  50.   case SortBySize:
  51.     return (int)(fl2->stats.st_size - fl1->stats.st_size);
  52.   case SortByMTime:
  53.     return (int)(fl2->stats.st_mtime - fl1->stats.st_mtime);
  54.   }
  55.  
  56.   return 0;
  57. }
  58.  
  59. /*-----------------------------------------------------------------------------
  60.   PUBLIC FUNCTIONS
  61. -----------------------------------------------------------------------------*/
  62.  
  63. /* Read in the directory for the file window specified. Note that since we have
  64.    the stats available for the directory, we could simply check the modification
  65.    time, and only read in the directory if necessay. This isn't worth it though-
  66.    the time taken to stat all the files (which still needs to be done) far
  67.    outweighs the time to read in the dir */
  68.  
  69. Boolean readDirectory(FileWindowRec *fw)
  70. {
  71.   FileList fl = NULL;
  72.   DIR *dir;
  73.   struct dirent *entry;
  74.   int d, i, m;
  75.  
  76.   if ((d = findDev(fw->directory)) != -1) mountDev(d);
  77.   fw->dev = d;
  78.  
  79.   if (stat(fw->directory, &fw->stats))
  80.     goto error2;
  81.  
  82.   if (chdir(fw->directory))
  83.     goto error2;
  84.  
  85.   if (!(dir = opendir(".")))
  86.     goto error2;
  87.  
  88.   fw->n_bytes = 0;
  89.  
  90.   for(i = 0; (entry = readdir(dir)); i++) {
  91.     fl = (FileRec **) XTREALLOC(fl, (i+1)*sizeof(FileRec *));
  92.     fl[i] = (FileRec *) XtMalloc(sizeof(FileRec));
  93.     strcpy(fl[i]->name, entry->d_name);
  94. #ifdef MAGIC_HEADERS
  95.     magic_get_type(entry->d_name, fl[i]->magic_type);
  96. #endif
  97.     if (lstat(entry->d_name, &(fl[i]->stats)))
  98.       goto error1;
  99.     if (S_ISLNK(fl[i]->stats.st_mode)) {
  100.       fl[i]->sym_link = True;
  101.       stat(entry->d_name, &(fl[i]->stats));
  102.     }
  103.     else
  104.       fl[i]->sym_link = False;
  105.     fl[i]->selected = False;
  106.     fw->n_bytes += fl[i]->stats.st_size;
  107.   }
  108.  
  109.   if (closedir(dir))
  110.     goto error1;
  111.  
  112.   fw->files = fl;
  113.   fw->n_files = i;
  114.   return True;
  115.  
  116.  error1:
  117.   for(m = 0; m <= i; m++)
  118.     XTFREE(fl[m]);
  119.   XTFREE(fl);
  120.  
  121.  error2:
  122.   return False;
  123. } 
  124.  
  125. /*-----------------------------------------------------------------------------
  126.   Remove either files or directories from a FileList
  127. -----------------------------------------------------------------------------*/
  128.  
  129. void filterDirectory(FileWindowRec *fw, FilterType type)
  130. {
  131.   FileList fl = NULL, oldfl = fw->files;
  132.   int n = 0, m = 0;
  133.  
  134. #ifdef DEBUG_MALLOC
  135.   fprintf(stderr,"entering filterDirectory: %lu\n",malloc_inuse(NULL));
  136. #endif
  137.  
  138.   fw->n_bytes = 0;
  139.  
  140.   for (; m < fw->n_files; m++) {
  141.     if (
  142.     ( !strcmp(oldfl[m]->name,".") && (type == Directories) ) ||
  143.     ( strcmp(oldfl[m]->name,".") && 
  144.      (
  145.       !strcmp(oldfl[m]->name,"..") ||
  146.       (
  147.        (fw->show_hidden || (oldfl[m]->name[0] != '.')) &&
  148.        (
  149.         (S_ISDIR(oldfl[m]->stats.st_mode) && (type != Files)) ||
  150.         (!S_ISDIR(oldfl[m]->stats.st_mode) && type != Directories)
  151.         )
  152.        )
  153.       )
  154.      )
  155.     ) {
  156.       /* KMR now filter on dirFilter (I wouldn't dare mess with the above!) */
  157.       /* AG modified to exclude folders from filtering */
  158.       if ((type == Directories) || !fw->do_filter || 
  159.       S_ISDIR(oldfl[m]->stats.st_mode) ||
  160.       fnmatch(fw->dirFilter, oldfl[m]->name)) {
  161.     fl = (FileList) XTREALLOC(fl, (n+1)*sizeof(FileRec *));
  162.     fl[n] = oldfl[m];
  163.     n++;
  164.     fw->n_bytes += oldfl[m]->stats.st_size;
  165.       }
  166.       else
  167.     XTFREE(oldfl[m]);
  168.     }
  169.     else
  170.       XTFREE(oldfl[m]);
  171.   }
  172.   XTFREE(oldfl);
  173.   
  174. #ifdef DEBUG_MALLOC
  175.   fprintf(stderr,"exiting filterDirectory: %lu\n",malloc_inuse(NULL));
  176. #endif
  177.  
  178.   fw->n_files = n;
  179.   fw->files = fl;
  180. }  
  181.  
  182.  
  183. /*-----------------------------------------------------------------------------
  184.   Sort a directory according to the sort type and dfirst flag
  185. -----------------------------------------------------------------------------*/
  186.  
  187. void sortDirectory(FileList fl, int n, SortType type, Boolean dfirst)
  188. {
  189.   sort_type = type;
  190.   dirs_first = dfirst;
  191.   qsort(fl, n, sizeof(FileRec *), (int (*)(const void *, const void *))comp);
  192. }
  193.  
  194.  
  195. /*-----------------------------------------------------------------------------
  196.   Check permission for an operation, equivalent to UNIX access()
  197. -----------------------------------------------------------------------------*/
  198.  
  199. int permission(struct stat *stats, int perms)
  200. {
  201.   int mode = stats->st_mode;
  202.   int result = 0;
  203.  
  204.   if (user.uid == 0 || user.uid == stats->st_uid) {
  205.     if (mode & S_IRUSR)
  206.       result |= P_READ;
  207.     if (mode & S_IWUSR)
  208.       result |= P_WRITE;
  209.     if (mode & S_IXUSR)
  210.       result |= P_EXECUTE;
  211.   } 
  212.  
  213.   else if (user.uid == 0 || user.gid == stats->st_gid) {
  214.     if (mode & S_IRGRP)
  215.       result |= P_READ;
  216.     if (mode & S_IWGRP)
  217.       result |= P_WRITE;
  218.     if (mode & S_IXGRP)
  219.       result |= P_EXECUTE;
  220.   } 
  221.  
  222.   else {
  223.     if (mode & S_IROTH)
  224.       result |= P_READ;
  225.     if (mode & S_IWOTH)
  226.       result |= P_WRITE;
  227.     if (mode & S_IXOTH)
  228.       result |= P_EXECUTE;
  229.   } 
  230.  
  231.   return (result & perms) == perms;
  232. }
  233.  
  234. void makePermissionsString(char *s, int perms)
  235. {
  236.   s[0] = perms & S_IRUSR ? 'r' : '-'; 
  237.   s[1] = perms & S_IWUSR ? 'w' : '-'; 
  238.   s[2] = perms & S_IXUSR ? 'x' : '-'; 
  239.  
  240.   s[3] = perms & S_IRGRP ? 'r' : '-'; 
  241.   s[4] = perms & S_IWGRP ? 'w' : '-'; 
  242.   s[5] = perms & S_IXGRP ? 'x' : '-'; 
  243.  
  244.   s[6] = perms & S_IROTH ? 'r' : '-'; 
  245.   s[7] = perms & S_IWOTH ? 'w' : '-'; 
  246.   s[8] = perms & S_IXOTH ? 'x' : '-'; 
  247.   
  248.   s[9] = '\0';
  249. }
  250.  
  251. /*---------------------------------------------------------------------------*/
  252.  
  253. void freeFileList(FileWindowRec *fw)
  254. {
  255.   int i;
  256.  
  257.   if (fw->files) {
  258.     for (i = 0; i < fw->n_files; i++)
  259.       XTFREE(fw->files[i]);
  260.     XTFREE(fw->files);
  261.     fw->files = NULL;
  262.   }
  263.   fw->n_files = 0;
  264.   fw->n_bytes = 0;
  265. }  
  266.  
  267.