silentbob/silentbob-1.4.1/gclib/src/fs.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include <gclib.h>
   8 #include <gclib_c.h>
   9 #include <sys/syscall.h>
  10
  11 /* 2005 */
  12 __export int Dreaddir_r (char * NAME, dirent ** OUTDIR)
  13 {
  14         int i;
  15         int count = 128;
  16         DIR * m_dir;
  17         dirent * m_dirent = NULL;
  18         dirent * m_alldirent = NULL;
  19         int m_Res = 0;
  20
  21         m_dir = opendir (NAME);
  22         if (OUTDIR == NULL)
  23                 return 0;
  24
  25         if (m_dir == NULL) {
  26                 *OUTDIR = NULL;
  27                 return 0;
  28         }
  29
  30         m_alldirent = CNEW(dirent, count);
  31
  32         i = 0;
  33         while (true) {
  34                 for (; i < count; i++) {
  35                         m_dirent = readdir (m_dir);
  36                         if (m_dirent == NULL)
  37                                 break;
  38                         m_Res++;
  39                         memcpy (&m_alldirent[i], m_dirent, sizeof (struct dirent));
  40                 }
  41
  42                 if (m_dirent == NULL)
  43                         break;
  44
  45                 if (i == count) {
  46                         m_alldirent = (dirent *) gc_realloc ((char *)m_alldirent,
  47                                         count * sizeof (struct dirent),
  48                                         (count << 1) * sizeof (struct dirent));
  49                         count <<= 1;
  50                 }
  51         }
  52
  53         closedir (m_dir);
  54         if (OUTDIR)
  55                 *OUTDIR = m_alldirent;
  56
  57         DSRET (m_alldirent)
  58         return m_Res;
  59 }
  60
  61 __export DArray * Dlstat_r (DArray * m_names)
  62 {
  63         DArray * m_array = new DArray;
  64         struct stat * m_stat;
  65         int i;
  66
  67         if (! m_names)
  68                 return NULL;
  69
  70         for (i = 0; i < m_names->get_size (); i++) {
  71                 m_stat = new struct stat;
  72                 lstat (m_names->get (i), m_stat);
  73                 m_array->add (LPCHAR (m_stat));
  74         }
  75
  76         DSRET (m_array);
  77         return m_array;
  78 }
  79
  80 __export DArray * Dstat_r (char *__from, dirent * m_dirents, int count)
  81 {
  82         DArray * m_array = new DArray;
  83         struct stat * m_stat;
  84         int i;
  85         char m_name[4096];
  86
  87         if ((! m_dirents) || (! __from))
  88                 return NULL;
  89
  90         for (i = 0; i < count; i++) {
  91                 m_stat = new struct stat;
  92                 snprintf (m_name, 4096, "%s/%s", __from, m_dirents[i].d_name);
  93                 stat (m_name, m_stat);
  94                 m_array->add (LPCHAR (m_stat));
  95         }
  96
  97         DSRET (m_array);
  98         return m_array;
  99 }
 100
 101 /* 24/06/06 */
 102 __export DList * Dreaddir_r (char * path)
 103 {
 104         DIR * m_dir;
 105         DList * Ret;
 106         struct dirent * m_dirent;
 107
 108         if (! path)
 109                 return NULL;
 110
 111         m_dir = opendir (path);
 112         if (! m_dir)
 113                 return NULL;
 114
 115         Ret = new DList;
 116         while (true) {
 117                 m_dirent = readdir (m_dir);
 118                 if (! m_dirent)
 119                         break;
 120                 m_dirent = (struct dirent *) memdup (m_dirent, sizeof (struct dirent));
 121                 Ret->add_tail (LPCHAR (m_dirent));
 122         }
 123
 124         closedir (m_dir);
 125         return Ret;
 126 }
 127
 128 /* 24/06/06 */
 129 __export DArray * Dfiles (char * path)
 130 {
 131         DIR * m_dir;
 132         DArray * Ret;
 133         struct dirent * m_dirent;
 134
 135         if (! path)
 136                 return NULL;
 137
 138         m_dir = opendir (path);
 139         if (! m_dir)
 140                 return NULL;
 141
 142         Ret = new DArray;
 143         while (true) {
 144                 m_dirent = readdir (m_dir);
 145                 if (! m_dirent)
 146                         break;
 147                 m_dirent = (struct dirent *) memdup (m_dirent, sizeof (struct dirent));
 148                 Ret->add (LPCHAR (strdup (m_dirent->d_name)));
 149                 DROP (m_dirent);
 150         }
 151
 152         closedir (m_dir);
 153         return Ret;
 154 }
 155
 156 #ifdef __NR_fadvise64
 157 int Dposix_fadvise (int fd, int offset, int len, int advice)
 158 {
 159         return posix_fadvise (fd, offset, len, advice);
 160 //      return syscall (__NR_fadvise64, fd, 0, offset, len, advice);
 161 }
 162 #else
 163 int Dposix_fadvise (int fd, int offset, int len, int advice)
 164 {
 165 #warning "Dposix_fadvise is broken.\n"
 166         return 0;
 167 }
 168 #endif
 169