tools/atree/files.cpp

   1 #include "files.h"
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #include <errno.h>
   6 #include <sys/stat.h>
   7 #include <unistd.h>
   8 #include <dirent.h>
   9 #include <fnmatch.h>
  10 #include <string.h>
  11 #include <stdlib.h>
  12
  13 static bool
  14 is_comment_line(const char* p)
  15 {
  16     while (*p && isspace(*p)) {
  17         p++;
  18     }
  19     return *p == '#';
  20 }
  21
  22 static string
  23 path_append(const string& base, const string& leaf)
  24 {
  25     string full = base;
  26     if (base.length() > 0 && leaf.length() > 0) {
  27         full += '/';
  28     }
  29     full += leaf;
  30     return full;
  31 }
  32
  33 static bool
  34 is_whitespace_line(const char* p)
  35 {
  36     while (*p) {
  37         if (!isspace(*p)) {
  38             return false;
  39         }
  40         p++;
  41     }
  42     return true;
  43 }
  44
  45 static bool
  46 is_exclude_line(const char* p) {
  47     while (*p) {
  48         if (*p == '-') {
  49             return true;
  50         }
  51         else if (isspace(*p)) {
  52             p++;
  53         }
  54         else {
  55             return false;
  56         }
  57     }
  58     return false;
  59 }
  60
  61 void
  62 split_line(const char* p, vector<string>* out)
  63 {
  64     const char* q = p;
  65     enum { WHITE, TEXT, IN_QUOTE } state = WHITE;
  66     while (*p) {
  67         if (*p == '#') {
  68             break;
  69         }
  70
  71         switch (state)
  72         {
  73             case WHITE:
  74                 if (!isspace(*p)) {
  75                     q = p;
  76                     state = (*p == '"') ? IN_QUOTE : TEXT;
  77                 }
  78                 break;
  79             case IN_QUOTE:
  80                 if (*p == '"') {
  81                     state = TEXT;
  82                     break;
  83                 }
  84                 // otherwise fall-through to TEXT case
  85             case TEXT:
  86                 if (state != IN_QUOTE && isspace(*p)) {
  87                     if (q != p) {
  88                         const char* start = q;
  89                         size_t len = p-q;
  90                         if (len > 2 && *start == '"' && start[len - 1] == '"') {
  91                             start++;
  92                             len -= 2;
  93                         }
  94                         out->push_back(string(start, len));
  95                     }
  96                     state = WHITE;
  97                 }
  98                 break;
  99         }
 100         p++;
 101     }
 102     if (state == TEXT) {
 103         const char* start = q;
 104         size_t len = p-q;
 105         if (len > 2 && *start == '"' && start[len - 1] == '"') {
 106             start++;
 107             len -= 2;
 108         }
 109         out->push_back(string(start, len));
 110     }
 111 }
 112
 113 static void
 114 add_file(vector<FileRecord>* files, const FileOpType fileOp,
 115             const string& listFile, int listLine,
 116             const string& sourceName, const string& outName)
 117 {
 118     FileRecord rec;
 119     rec.listFile = listFile;
 120     rec.listLine = listLine;
 121     rec.fileOp = fileOp;
 122     rec.sourceName = sourceName;
 123     rec.outName = outName;
 124     files->push_back(rec);
 125 }
 126
 127 static string
 128 replace_variables(const string& input,
 129                   const map<string, string>& variables,
 130                   bool* error) {
 131     if (variables.empty()) {
 132         return input;
 133     }
 134
 135     // Abort if the variable prefix is not found
 136     if (input.find("${") == string::npos) {
 137         return input;
 138     }
 139
 140     string result = input;
 141
 142     // Note: rather than be fancy to detect recursive replacements,
 143     // we simply iterate till a given threshold is met.
 144
 145     int retries = 1000;
 146     bool did_replace;
 147
 148     do {
 149         did_replace = false;
 150         for (map<string, string>::const_iterator it = variables.begin();
 151              it != variables.end(); ++it) {
 152             string::size_type pos = 0;
 153             while((pos = result.find(it->first, pos)) != string::npos) {
 154                 result = result.replace(pos, it->first.length(), it->second);
 155                 pos += it->second.length();
 156                 did_replace = true;
 157             }
 158         }
 159         if (did_replace && --retries == 0) {
 160             *error = true;
 161             fprintf(stderr, "Recursive replacement detected during variables "
 162                     "substitution. Full list of variables is: ");
 163
 164             for (map<string, string>::const_iterator it = variables.begin();
 165                  it != variables.end(); ++it) {
 166                 fprintf(stderr, "  %s=%s\n",
 167                         it->first.c_str(), it->second.c_str());
 168             }
 169
 170             return result;
 171         }
 172     } while (did_replace);
 173
 174     return result;
 175 }
 176
 177 int
 178 read_list_file(const string& filename,
 179                const map<string, string>& variables,
 180                vector<FileRecord>* files,
 181                vector<string>* excludes)
 182 {
 183     int err = 0;
 184     FILE* f = NULL;
 185     long size;
 186     char* buf = NULL;
 187     char *p, *q;
 188     int i, lineCount;
 189
 190     f = fopen(filename.c_str(), "r");
 191     if (f == NULL) {
 192         fprintf(stderr, "Could not open list file (%s): %s\n",
 193                     filename.c_str(), strerror(errno));
 194         err = errno;
 195         goto cleanup;
 196     }
 197
 198     err = fseek(f, 0, SEEK_END);
 199     if (err != 0) {
 200         fprintf(stderr, "Could not seek to the end of file %s. (%s)\n",
 201                     filename.c_str(), strerror(errno));
 202         err = errno;
 203         goto cleanup;
 204     }
 205
 206     size = ftell(f);
 207
 208     err = fseek(f, 0, SEEK_SET);
 209     if (err != 0) {
 210         fprintf(stderr, "Could not seek to the beginning of file %s. (%s)\n",
 211                     filename.c_str(), strerror(errno));
 212         err = errno;
 213         goto cleanup;
 214     }
 215
 216     buf = (char*)malloc(size+1);
 217     if (buf == NULL) {
 218         // (potentially large)
 219         fprintf(stderr, "out of memory (%ld)\n", size);
 220         err = ENOMEM;
 221         goto cleanup;
 222     }
 223
 224     if (1 != fread(buf, size, 1, f)) {
 225         fprintf(stderr, "error reading file %s. (%s)\n",
 226                     filename.c_str(), strerror(errno));
 227         err = errno;
 228         goto cleanup;
 229     }
 230
 231     // split on lines
 232     p = buf;
 233     q = buf+size;
 234     lineCount = 0;
 235     while (p<q) {
 236         if (*p == '\r' || *p == '\n') {
 237             *p = '\0';
 238             lineCount++;
 239         }
 240         p++;
 241     }
 242
 243     // read lines
 244     p = buf;
 245     for (i=0; i<lineCount; i++) {
 246         int len = strlen(p);
 247         q = p + len + 1;
 248         if (is_whitespace_line(p) || is_comment_line(p)) {
 249             ;
 250         }
 251         else if (is_exclude_line(p)) {
 252             while (*p != '-') p++;
 253             p++;
 254             excludes->push_back(string(p));
 255         }
 256         else {
 257             vector<string> words;
 258
 259             split_line(p, &words);
 260
 261 #if 0
 262             printf("[ ");
 263             for (size_t k=0; k<words.size(); k++) {
 264                 printf("'%s' ", words[k].c_str());
 265             }
 266             printf("]\n");
 267 #endif
 268             FileOpType op = FILE_OP_COPY;
 269             string paths[2];
 270             int pcount = 0;
 271             string errstr;
 272             for (vector<string>::iterator it = words.begin(); it != words.end(); ++it) {
 273                 const string& word = *it;
 274                 if (word == "rm") {
 275                     if (op != FILE_OP_COPY) {
 276                         errstr = "Error: you can only specifiy 'rm' or 'strip' once per line.";
 277                         break;
 278                     }
 279                     op = FILE_OP_REMOVE;
 280                 } else if (word == "strip") {
 281                     if (op != FILE_OP_COPY) {
 282                         errstr = "Error: you can only specifiy 'rm' or 'strip' once per line.";
 283                         break;
 284                     }
 285                     op = FILE_OP_STRIP;
 286                 } else if (pcount < 2) {
 287                     bool error = false;
 288                     paths[pcount++] = replace_variables(word, variables, &error);
 289                     if (error) {
 290                         err = 1;
 291                         goto cleanup;
 292                     }
 293                 } else {
 294                     errstr = "Error: More than 2 paths per line.";
 295                     break;
 296                 }
 297             }
 298
 299             if (pcount == 0 && !errstr.empty()) {
 300                 errstr = "Error: No path found on line.";
 301             }
 302
 303             if (!errstr.empty()) {
 304                 fprintf(stderr, "%s:%d: bad format: %s\n%s\nExpected: [SRC] [rm|strip] DEST\n",
 305                         filename.c_str(), i+1, p, errstr.c_str());
 306                 err = 1;
 307             } else {
 308                 if (pcount == 1) {
 309                     // pattern: [rm|strip] DEST
 310                     paths[1] = paths[0];
 311                 }
 312
 313                 add_file(files, op, filename, i+1, paths[0], paths[1]);
 314             }
 315         }
 316         p = q;
 317     }
 318
 319 cleanup:
 320     if (buf != NULL) {
 321         free(buf);
 322     }
 323     if (f != NULL) {
 324         fclose(f);
 325     }
 326     return err;
 327 }
 328
 329
 330 int
 331 locate(FileRecord* rec, const vector<string>& search)
 332 {
 333     if (rec->fileOp == FILE_OP_REMOVE) {
 334         // Don't touch source files when removing a destination.
 335         rec->sourceMod = 0;
 336         rec->sourceSize = 0;
 337         rec->sourceIsDir = false;
 338         return 0;
 339     }
 340
 341     int err;
 342
 343     for (vector<string>::const_iterator it=search.begin();
 344                 it!=search.end(); it++) {
 345         string full = path_append(*it, rec->sourceName);
 346         struct stat st;
 347         err = stat(full.c_str(), &st);
 348         if (err == 0) {
 349             rec->sourceBase = *it;
 350             rec->sourcePath = full;
 351             rec->sourceMod = st.st_mtime;
 352             rec->sourceSize = st.st_size;
 353             rec->sourceIsDir = S_ISDIR(st.st_mode);
 354             return 0;
 355         }
 356     }
 357
 358     fprintf(stderr, "%s:%d: couldn't locate source file: %s\n",
 359                 rec->listFile.c_str(), rec->listLine, rec->sourceName.c_str());
 360     return 1;
 361 }
 362
 363 void
 364 stat_out(const string& base, FileRecord* rec)
 365 {
 366     rec->outPath = path_append(base, rec->outName);
 367
 368     int err;
 369     struct stat st;
 370     err = stat(rec->outPath.c_str(), &st);
 371     if (err == 0) {
 372         rec->outMod = st.st_mtime;
 373         rec->outSize = st.st_size;
 374         rec->outIsDir = S_ISDIR(st.st_mode);
 375     } else {
 376         rec->outMod = 0;
 377         rec->outSize = 0;
 378         rec->outIsDir = false;
 379     }
 380 }
 381
 382 string
 383 dir_part(const string& filename)
 384 {
 385     int pos = filename.rfind('/');
 386     if (pos <= 0) {
 387         return ".";
 388     }
 389     return filename.substr(0, pos);
 390 }
 391
 392 static void
 393 add_more(const string& entry, bool isDir,
 394          const FileRecord& rec, vector<FileRecord>*more)
 395 {
 396     FileRecord r;
 397     r.listFile = rec.listFile;
 398     r.listLine = rec.listLine;
 399     r.sourceName = path_append(rec.sourceName, entry);
 400     r.sourcePath = path_append(rec.sourceBase, r.sourceName);
 401     struct stat st;
 402     int err = stat(r.sourcePath.c_str(), &st);
 403     if (err == 0) {
 404         r.sourceMod = st.st_mtime;
 405     }
 406     r.sourceIsDir = isDir;
 407     r.outName = path_append(rec.outName, entry);
 408     more->push_back(r);
 409 }
 410
 411 static bool
 412 matches_excludes(const char* file, const vector<string>& excludes)
 413 {
 414     for (vector<string>::const_iterator it=excludes.begin();
 415             it!=excludes.end(); it++) {
 416         if (0 == fnmatch(it->c_str(), file, FNM_PERIOD)) {
 417             return true;
 418         }
 419     }
 420     return false;
 421 }
 422
 423 static int
 424 list_dir(const string& path, const FileRecord& rec,
 425                 const vector<string>& excludes,
 426                 vector<FileRecord>* more)
 427 {
 428     int err;
 429
 430     string full = path_append(rec.sourceBase, rec.sourceName);
 431     full = path_append(full, path);
 432
 433     DIR *d = opendir(full.c_str());
 434     if (d == NULL) {
 435         return errno;
 436     }
 437
 438     vector<string> dirs;
 439
 440     struct dirent *ent;
 441     while (NULL != (ent = readdir(d))) {
 442         if (0 == strcmp(".", ent->d_name)
 443                 || 0 == strcmp("..", ent->d_name)) {
 444             continue;
 445         }
 446         if (matches_excludes(ent->d_name, excludes)) {
 447             continue;
 448         }
 449         string entry = path_append(path, ent->d_name);
 450 #ifdef HAVE_DIRENT_D_TYPE
 451                 bool is_directory = (ent->d_type == DT_DIR);
 452 #else
 453             // If dirent.d_type is missing, then use stat instead
 454                 struct stat stat_buf;
 455                 stat(entry.c_str(), &stat_buf);
 456                 bool is_directory = S_ISDIR(stat_buf.st_mode);
 457 #endif
 458         add_more(entry, is_directory, rec, more);
 459         if (is_directory) {
 460             dirs.push_back(entry);
 461         }
 462     }
 463     closedir(d);
 464
 465     for (vector<string>::iterator it=dirs.begin(); it!=dirs.end(); it++) {
 466         list_dir(*it, rec, excludes, more);
 467     }
 468
 469     return 0;
 470 }
 471
 472 int
 473 list_dir(const FileRecord& rec, const vector<string>& excludes,
 474             vector<FileRecord>* files)
 475 {
 476     return list_dir("", rec, excludes, files);
 477 }
 478
 479 FileRecord::FileRecord() {
 480     fileOp = FILE_OP_COPY;
 481 }
 482