tools/torrent/mktorrent_crc/ftw.c

   1 /*
   2 This file is part of mktorrent
   3 Copyright (C) 2009 Emil Renner Berthing
   4
   5 mktorrent 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 mktorrent 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 */
  19 #ifndef ALLINONE
  20 #include <stdlib.h>
  21 #include <errno.h>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <unistd.h>
  27 #include <dirent.h>
  28
  29 #ifdef _WIN32
  30 #define DIRSEP_CHAR '\\'
  31 #else
  32 #define DIRSEP_CHAR '/'
  33 #endif /* _WIN32 */
  34
  35 #define EXPORT
  36 #endif /* ALLINONE */
  37
  38 #include "ftw.h"
  39
  40 struct dir_state {
  41         struct dir_state *next;
  42         struct dir_state *prev;
  43         size_t length;
  44         DIR *dir;
  45         off_t offset;
  46 };
  47
  48 static struct dir_state *dir_state_new(struct dir_state *prev,
  49                 struct dir_state *next)
  50 {
  51         struct dir_state *ds = malloc(sizeof(struct dir_state));
  52
  53         if (ds == NULL) {
  54                 fprintf(stderr, "Out of memory.\n");
  55                 return NULL;
  56         }
  57
  58         ds->prev = prev;
  59         ds->next = next;
  60
  61         return ds;
  62 }
  63
  64 static unsigned int dir_state_open(struct dir_state *ds, const char *name,
  65                 size_t length)
  66 {
  67         ds->dir = opendir(name);
  68         if (ds->dir == NULL) {
  69                 fprintf(stderr, "Error opening '%s': %s\n",
  70                                 name, strerror(errno));
  71                 return 1;
  72         }
  73
  74         ds->length = length;
  75
  76         return 0;
  77 }
  78
  79 static unsigned int dir_state_reopen(struct dir_state *ds, char *name)
  80 {
  81         name[ds->length] = '\0';
  82         ds->dir = opendir(name);
  83         if (ds->dir == NULL) {
  84                 fprintf(stderr, "Error opening '%s': %s\n",
  85                                 name, strerror(errno));
  86                 return 1;
  87         }
  88
  89         name[ds->length] = DIRSEP_CHAR;
  90
  91         seekdir(ds->dir, ds->offset);
  92
  93         return 0;
  94 }
  95
  96 static unsigned int dir_state_close(struct dir_state *ds)
  97 {
  98         ds->offset = telldir(ds->dir);
  99         if (ds->offset < 0) {
 100                 fprintf(stderr, "Error getting dir offset: %s\n",
 101                                 strerror(errno));
 102                 return 1;
 103         }
 104
 105         if (closedir(ds->dir)) {
 106                 fprintf(stderr, "Error closing directory: %s\n",
 107                                 strerror(errno));
 108                 return 1;
 109         }
 110
 111         ds->dir = NULL;
 112
 113         return 0;
 114 }
 115
 116 static unsigned int cleanup(struct dir_state *ds, char *path, int ret)
 117 {
 118         while (ds->prev)
 119                 ds = ds->prev;
 120
 121         do {
 122                 struct dir_state *next = ds->next;
 123                 free(ds);
 124                 ds = next;
 125         } while (ds);
 126
 127         if (path)
 128                 free(path);
 129
 130         return ret;
 131 }
 132
 133 EXPORT int file_tree_walk(const char *dirname, unsigned int nfds,
 134                 file_tree_walk_cb callback, void *data)
 135 {
 136         size_t path_size = 256;
 137         char *path;
 138         char *path_max;
 139         char *end;
 140         struct dir_state *ds = dir_state_new(NULL, NULL);
 141         struct dir_state *first_open;
 142         unsigned int nopen;
 143
 144         if (ds == NULL)
 145                 return -1;
 146
 147         path = malloc(path_size);
 148         if (path == NULL) {
 149                 fprintf(stderr, "Out of memory.\n");
 150                 return cleanup(ds, NULL, -1);
 151         }
 152         path_max = path + path_size;
 153
 154         /* copy dirname to path */
 155         end = path;
 156         while ((*end = *dirname)) {
 157                 dirname++;
 158                 end++;
 159                 if (end == path_max) {
 160                         char *new_path;
 161
 162                         new_path = realloc(path, 2*path_size);
 163                         if (new_path == NULL) {
 164                                 fprintf(stderr, "Out of memory.\n");
 165                                 return cleanup(ds, path, -1);
 166                         }
 167                         end = new_path + path_size;
 168                         path_size *= 2;
 169                         path = new_path;
 170                         path_max = path + path_size;
 171                 }
 172         }
 173
 174         /* strip ending directory separators */
 175         while (end > path && *(end-1) == DIRSEP_CHAR) {
 176                 end--;
 177                 *end = '\0';
 178         }
 179
 180         if (dir_state_open(ds, path, end - path))
 181                 return cleanup(ds, path, -1);
 182
 183         first_open = ds;
 184         nopen = 1;
 185
 186         *end = DIRSEP_CHAR;
 187
 188         while (1) {
 189                 struct dirent *de = readdir(ds->dir);
 190
 191                 if (de) {
 192                         struct stat sbuf;
 193                         const char *p;
 194                         int r;
 195
 196                         if (de->d_name[0] == '.'
 197                                         && (de->d_name[1] == '\0'
 198                                         || (de->d_name[1] == '.'
 199                                         && de->d_name[2] == '\0'))) {
 200                                 continue;
 201                         }
 202
 203                         end = path + ds->length + 1;
 204                         p = de->d_name;
 205                         while ((*end = *p)) {
 206                                 p++;
 207                                 end++;
 208                                 if (end == path_max) {
 209                                         char *new_path;
 210
 211                                         new_path = realloc(path, 2*path_size);
 212                                         if (new_path == NULL) {
 213                                                 fprintf(stderr, "Out of memory.\n");
 214                                                 return cleanup(ds, path, -1);
 215                                         }
 216                                         end = new_path + path_size;
 217                                         path_size *= 2;
 218                                         path = new_path;
 219                                         path_max = path + path_size;
 220                                 }
 221                         }
 222
 223                         if (stat(path, &sbuf)) {
 224                                 fprintf(stderr, "Error stat'ing '%s': %s\n",
 225                                                 path, strerror(errno));
 226                                 return cleanup(ds, path, -1);
 227                         }
 228
 229                         r = callback(path, &sbuf, data);
 230                         if (r)
 231                                 return cleanup(ds, path, r);
 232
 233                         if (S_ISDIR(sbuf.st_mode)) {
 234                                 if (ds->next == NULL &&
 235                                         (ds->next = dir_state_new(ds, NULL)) == NULL)
 236                                         return cleanup(ds, path, -1);
 237
 238                                 ds = ds->next;
 239
 240                                 if (nopen == nfds) {
 241                                         if (dir_state_close(first_open))
 242                                                 return cleanup(ds, path, -1);
 243                                         first_open = first_open->next;
 244                                         nopen--;
 245                                 }
 246
 247                                 if (dir_state_open(ds, path, end - path))
 248                                         return cleanup(ds, path, -1);
 249
 250                                 nopen++;
 251
 252                                 *end = DIRSEP_CHAR;
 253                         }
 254                 } else {
 255                         if (closedir(ds->dir)) {
 256                                 path[ds->length] = '\0';
 257                                 fprintf(stderr, "Error closing '%s': %s\n",
 258                                         path, strerror(errno));
 259                                 return cleanup(ds, path, -1);
 260                         }
 261
 262                         if (ds->prev == NULL)
 263                                 break;
 264
 265                         ds = ds->prev;
 266                         nopen--;
 267
 268                         if (ds->dir == NULL) {
 269                                 if (dir_state_reopen(ds, path))
 270                                         return cleanup(ds, path, -1);
 271                                 first_open = ds;
 272                                 nopen++;
 273                         }
 274                 }
 275         }
 276
 277         return cleanup(ds, path, 0);
 278 }