tagmanager/tm_file_entry.c

   1 /*
   2 *
   3 *   Copyright (c) 2001-2002, Biswapesh Chattopadhyay
   4 *
   5 *   This source code is released for free distribution under the terms of the
   6 *   GNU General Public License.
   7 *
   8 */
   9
  10 #include "general.h"
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15 #include <string.h>
  16 #include <dirent.h>
  17 #ifdef HAVE_FCNTL_H
  18 # include <fcntl.h>
  19 #endif
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #ifdef HAVE_FNMATCH_H
  23 # include <fnmatch.h>
  24 #endif
  25 #include <glib/gstdio.h>
  26
  27 #include "tm_work_object.h"
  28 #include "tm_file_entry.h"
  29
  30
  31 #if GLIB_CHECK_VERSION (2, 10, 0)
  32 /* Use GSlices if present */
  33
  34 #define FILE_NEW(T)             ((T) = g_slice_new0(TMFileEntry))
  35 #define FILE_FREE(T)    g_slice_free(TMFileEntry, (T))
  36
  37 #else /* GLib < 2.10 */
  38
  39 static GMemChunk *file_mem_chunk = NULL;
  40
  41 #define FILE_NEW(T) {\
  42         if (!file_mem_chunk) \
  43                 file_mem_chunk = g_mem_chunk_new("TMFileEntry MemChunk", sizeof(TMFileEntry), 1024 \
  44                   , G_ALLOC_AND_FREE); \
  45         (T) = g_chunk_new0(TMFileEntry, file_mem_chunk);}
  46
  47 #define FILE_FREE(T) g_mem_chunk_free(file_mem_chunk, (T))
  48
  49 #endif /* GLib version check */
  50
  51
  52 void tm_file_entry_print(TMFileEntry *entry, gpointer __unused__ user_data
  53   , guint level)
  54 {
  55         guint i;
  56
  57         g_return_if_fail(entry);
  58         for (i=0; i < level; ++i)
  59                 fputc('\t', stderr);
  60         fprintf(stderr, "%s\n", entry->name);
  61 }
  62
  63 gint tm_file_entry_compare(TMFileEntry *e1, TMFileEntry *e2)
  64 {
  65         g_return_val_if_fail(e1 && e2 && e1->name && e2->name, 0);
  66 #ifdef TM_DEBUG
  67         g_message("Comparing %s and %s", e1->name, e2->name);
  68 #endif
  69         return strcmp(e1->name, e2->name);
  70 }
  71
  72 /* TTimo - modified to handle symlinks */
  73 static TMFileType tm_file_entry_type(const char *path)
  74 {
  75         struct stat s;
  76
  77 #ifndef G_OS_WIN32
  78         if (0 != g_lstat(path, &s))
  79                 return tm_file_unknown_t;
  80 #endif
  81         if S_ISDIR(s.st_mode)
  82                 return tm_file_dir_t;
  83 #ifndef G_OS_WIN32
  84         else if (S_ISLNK(s.st_mode))
  85                 return tm_file_link_t;
  86 #endif
  87         else if S_ISREG(s.st_mode)
  88                 return tm_file_regular_t;
  89         else
  90                 return tm_file_unknown_t;
  91 }
  92
  93 static gboolean apply_filter(const char *name, GList *match, GList *unmatch
  94   , gboolean ignore_hidden)
  95 {
  96         GList *tmp;
  97         gboolean matched = (match == NULL);
  98         g_return_val_if_fail(name, FALSE);
  99         if (ignore_hidden && ('.' == name[0]))
 100                 return FALSE;
 101         /* TTimo - ignore .svn directories */
 102         if (!strcmp(name, ".svn"))
 103                 return FALSE;
 104         for (tmp = match; tmp; tmp = g_list_next(tmp))
 105         {
 106                 if (0 == fnmatch((char *) tmp->data, name, 0))
 107                 {
 108                         matched = TRUE;
 109                         break;
 110                 }
 111         }
 112         if (!matched)
 113                 return FALSE;
 114         for (tmp = unmatch; tmp; tmp = g_list_next(tmp))
 115         {
 116                 if (0 == fnmatch((char *) tmp->data, name, 0))
 117                 {
 118                         return FALSE;
 119                 }
 120         }
 121         return matched;
 122 }
 123
 124 TMFileEntry *tm_file_entry_new(const char *path, TMFileEntry *parent
 125   , gboolean recurse, GList *file_match, GList *file_unmatch
 126   , GList *dir_match, GList *dir_unmatch, gboolean ignore_hidden_files
 127   , gboolean ignore_hidden_dirs)
 128 {
 129         TMFileEntry *entry;
 130         /* GList *tmp; */
 131         char *real_path;
 132         DIR *dir;
 133         struct dirent *dir_entry;
 134         TMFileEntry *new_entry;
 135         char *file_name;
 136         struct stat s;
 137         char *entries = NULL;
 138
 139         g_return_val_if_fail (path != NULL, NULL);
 140
 141         /* TTimo - don't follow symlinks */
 142         if (tm_file_entry_type(path) == tm_file_link_t)
 143                 return NULL;
 144         real_path = tm_get_real_path(path);
 145         if (!real_path)
 146                 return NULL;
 147         FILE_NEW(entry);
 148         entry->type = tm_file_entry_type(real_path);
 149         entry->parent = parent;
 150         entry->path = real_path;
 151         entry->name = strrchr(entry->path, '/');
 152         if (entry->name)
 153                 ++ (entry->name);
 154         else
 155                 entry->name = entry->path;
 156         switch(entry->type)
 157         {
 158                 case tm_file_unknown_t:
 159                         g_free(real_path);
 160                         FILE_FREE(entry);
 161                         return NULL;
 162                 case tm_file_link_t:
 163                 case tm_file_regular_t:
 164                         if (parent && !apply_filter(entry->name, file_match, file_unmatch
 165                           , ignore_hidden_files))
 166                         {
 167                                 tm_file_entry_free(entry);
 168                                 return NULL;
 169                         }
 170                         break;
 171                 case tm_file_dir_t:
 172                         if (parent && !(recurse && apply_filter(entry->name, dir_match
 173                           , dir_unmatch, ignore_hidden_dirs)))
 174                         {
 175                                 tm_file_entry_free(entry);
 176                                 return NULL;
 177                         }
 178                         file_name = g_strdup_printf("%s/CVS/Entries", entry->path);
 179                         if (0 == g_stat(file_name, &s))
 180                         {
 181                                 if (S_ISREG(s.st_mode))
 182                                 {
 183                                         int fd;
 184                                         entries = g_new(char, s.st_size + 2);
 185                                         if (0 > (fd = open(file_name, O_RDONLY)))
 186                                         {
 187                                                 g_free(entries);
 188                                                 entries = NULL;
 189                                         }
 190                                         else
 191                                         {
 192                                                 off_t n =0;
 193                                                 off_t total_read = 1;
 194                                                 while (0 < (n = read(fd, entries + total_read, s.st_size - total_read)))
 195                                                         total_read += n;
 196                                                 entries[s.st_size] = '\0';
 197                                                 entries[0] = '\n';
 198                                                 close(fd);
 199                                                 entry->version = g_strdup("D");
 200                                         }
 201                                 }
 202                         }
 203                         g_free(file_name);
 204                         if (NULL != (dir = opendir(entry->path)))
 205                         {
 206                                 while (NULL != (dir_entry = readdir(dir)))
 207                                 {
 208                                         if ((0 == strcmp(dir_entry->d_name, "."))
 209                                           || (0 == strcmp(dir_entry->d_name, "..")))
 210                                                 continue;
 211                                         file_name = g_strdup_printf("%s/%s", entry->path, dir_entry->d_name);
 212                                         new_entry = tm_file_entry_new(file_name, entry, recurse
 213                                           , file_match, file_unmatch, dir_match, dir_unmatch
 214                                           , ignore_hidden_files, ignore_hidden_dirs);
 215                                         g_free(file_name);
 216                                         if (new_entry)
 217                                         {
 218                                                 if (entries)
 219                                                 {
 220                                                         char *str = g_strconcat("\n/", new_entry->name, "/", NULL);
 221                                                         char *name_pos = strstr(entries, str);
 222                                                         if (NULL != name_pos)
 223                                                         {
 224                                                                 int len = strlen(str);
 225                                                                 char *version_pos = strchr(name_pos + len, '/');
 226                                                                 if (NULL != version_pos)
 227                                                                 {
 228                                                                         *version_pos = '\0';
 229                                                                         new_entry->version = g_strdup(name_pos + len);
 230                                                                         *version_pos = '/';
 231                                                                 }
 232                                                         }
 233                                                         g_free(str);
 234                                                 }
 235                                                 entry->children = g_slist_prepend(entry->children, new_entry);
 236                                         }
 237                                 }
 238                         }
 239                         closedir(dir);
 240                         entry->children = g_slist_sort(entry->children, (GCompareFunc) tm_file_entry_compare);
 241                         if (entries)
 242                                 g_free(entries);
 243                         break;
 244         }
 245         return entry;
 246 }
 247
 248 void tm_file_entry_free(gpointer entry)
 249 {
 250         if (entry)
 251         {
 252                 TMFileEntry *file_entry = TM_FILE_ENTRY(entry);
 253                 if (file_entry->children)
 254                 {
 255                         GSList *tmp;
 256                         for (tmp = file_entry->children; tmp; tmp = g_slist_next(tmp))
 257                                 tm_file_entry_free(tmp->data);
 258                         g_slist_free(file_entry->children);
 259                 }
 260                 if (file_entry->version)
 261                         g_free(file_entry->version);
 262                 g_free(file_entry->path);
 263                 FILE_FREE(file_entry);
 264         }
 265 }
 266
 267 void tm_file_entry_foreach(TMFileEntry *entry, TMFileEntryFunc func
 268   , gpointer user_data, guint level, gboolean reverse)
 269 {
 270         g_return_if_fail (entry != NULL);
 271         g_return_if_fail (func != NULL);
 272
 273         if ((reverse) && (entry->children))
 274         {
 275                 GSList *tmp;
 276                 for (tmp = entry->children; tmp; tmp = g_slist_next(tmp))
 277                         tm_file_entry_foreach(TM_FILE_ENTRY(tmp->data), func
 278                           , user_data, level + 1, TRUE);
 279         }
 280         func(entry, user_data, level);
 281         if ((!reverse) && (entry->children))
 282         {
 283                 GSList *tmp;
 284                 for (tmp = entry->children; tmp; tmp = g_slist_next(tmp))
 285                         tm_file_entry_foreach(TM_FILE_ENTRY(tmp->data), func
 286                           , user_data, level + 1, FALSE);
 287         }
 288 }
 289
 290 GList *tm_file_entry_list(TMFileEntry *entry, GList *files)
 291 {
 292         GSList *tmp;
 293         files = g_list_prepend(files, g_strdup(entry->path));
 294         for (tmp = entry->children; tmp; tmp = g_slist_next(tmp))
 295         {
 296                 files = tm_file_entry_list((TMFileEntry *) tmp->data, files);
 297         }
 298         if (!files)
 299                 files = g_list_reverse(files);
 300         return files;
 301 }