src/scanner.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. 
 * Copyright 2018 Mike Becker. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#include "scanner.h"
#include "bfile_heuristics.h"
#include "regex_parser.h"
#include <sys/stat.h>
#include <ctype.h>

#ifdef _MSC_VER
#include <windows.h>
#include <shlwapi.h>

void get_working_dir(const char** out_ptr, size_t *out_len) {
  static char cwd[MAX_PATH];
  if (GetCurrentDirectory(MAX_PATH, cwd) == 0) {
    fprintf(stderr, "Could not get current working directory.\n");
    exit(1);
  }
  size_t len = strlen(cwd);
  if (cwd[len - 1] != '/') {
    cwd[len++] = '/';
    cwd[len] = '\0';
  }
  *out_ptr = cwd;
  *out_len = len;
}
bool path_is_relative(const char *path) {
  return PathIsRelative(path);
}
int pathcmp(const char *p1, const char *p2) {
  return strcasecmp(p1, p2);
}
#else
#include <unistd.h>
void get_working_dir(const char** out_ptr, size_t *out_len) {
  static char cwd[PATH_MAX];
  if (getcwd(cwd, sizeof(cwd)) == NULL) {
    fprintf(stderr, "Could not get current working directory.\n");
    exit(1);
  }
  size_t len = strlen(cwd);
  if (cwd[len - 1] != '/') {
    cwd[len++] = '/';
    cwd[len] = '\0';
  }
  *out_ptr = cwd;
  *out_len = len;
}
bool path_is_relative(const char *path) {
  return path[0] != '/';
}
int pathcmp(const char *p1, const char *p2) {
  return strcmp(p1, p2);
}
#endif

typedef struct filelist filelist_t;

struct filelist {
  char *displayname;
  unsigned displayname_len;
  char *filename;
  char *ext;
  unsigned st_mode;
  filelist_t *next;
};

static bool testSuffix(char* filename, string_list_t* list) {
  bool ret = false;
  size_t tokenlen, fnamelen = strlen(filename);
  for (size_t t = 0 ; t < list->count ; t++) {
    tokenlen = strlen(list->items[t]);
    if (fnamelen >= tokenlen && tokenlen > 0) {
      if (strncmp(filename+fnamelen-tokenlen,
                  list->items[t], tokenlen) == 0) {
        ret = true;
        break;
      }
    }
  }
  return ret;
}

static void addResultPerExtension(scanresult_ext_t* result,
                                  char* ext, unsigned value) {
  if (!result) return;
  
  if (!ext) ext = "w/o";
  
  for (unsigned i = 0 ; i < result->count ; i++) {
    if (strcasecmp(result->extensions[i], ext) == 0) {
      result->result[i] += value;
      return;
    }
  }
  
  if (result->count == result->capacity) {
    unsigned newcap = result->capacity+8;
    char** extarr = realloc(result->extensions, newcap*sizeof(char*));
    unsigned* resultarr = realloc(result->result, newcap*sizeof(unsigned));
    if (!extarr || !resultarr) {
      fprintf(stderr, "Memory allocation error.\n");
      abort();
    }
    result->extensions = extarr;
    result->result = resultarr;
    result->capacity = newcap;
  }
  
  result->extensions[result->count] = strdup(ext);
  result->result[result->count] = value;
  result->count++;
}

scanresult_t* new_scanresult_t(settings_t* settings) {
  scanresult_t* result = calloc(1, sizeof(scanresult_t));
  if (settings->individual_sums) {
    result->ext = calloc(1, sizeof(scanresult_ext_t));
  }
  return result;
}

void destroy_scanresult_t(scanresult_t* result) {
  if (result->ext) {
    if (result->ext->count > 0) {
      for (unsigned i = 0 ; i < result->ext->count ; i++) {
        free(result->ext->extensions[i]);
      }
      free(result->ext->extensions);
      free(result->ext->result);
    }
    free(result->ext);
  }
  free(result);
}

static filelist_t *buildFileList(scanner_t scanner, settings_t* settings) {

  filelist_t* list = NULL;
  DIR *dirf;
  struct dirent *entry;
  struct stat statbuf;
  
  if ((dirf = opendir(scanner.dir)) == NULL) {
    fprintf(stderr, "%s - ", scanner.dir);
    perror("Directory access failed");
    return 0;
  }

  while ((entry = readdir(dirf)) != NULL) {
    if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
      
      /* Create new filelist entry */
      filelist_t *newentry = (filelist_t*) malloc(sizeof(filelist_t));
      newentry->next = NULL;
      
      newentry->displayname_len = strlen(entry->d_name);
      newentry->displayname = (char*) malloc(newentry->displayname_len+1);
      memcpy(newentry->displayname, entry->d_name, newentry->displayname_len);
      newentry->displayname[newentry->displayname_len] = 0;
      
      newentry->st_mode = 0;
      
      /* Construct absolute pathname string */
      size_t dirnamelen = strlen(scanner.dir);
      char *filename = (char*) malloc(2+dirnamelen+newentry->displayname_len);
      memcpy(filename, scanner.dir, dirnamelen);
      filename[dirnamelen] = settings->fileSeparator;
      memcpy(filename+dirnamelen+1, entry->d_name, newentry->displayname_len);
      filename[1+dirnamelen+newentry->displayname_len] = 0;
      newentry->filename = filename;
      
      /* Obtain file extension */
      newentry->ext = strrchr(newentry->displayname, '.');

      /* Check for subdirectory */
      if (stat(filename, &statbuf) == 0) {
        newentry->st_mode = statbuf.st_mode;
      } else {
        perror("  Error in stat call");
        continue;
      }
      
      if (list) {
        /* create fake root to have a pointer on the true root */
        filelist_t root;
        root.next = list;
        filelist_t *parent = &root;
        while (parent->next &&
            (strcasecmp(parent->next->displayname, newentry->displayname) < 0 ||
              (!S_ISDIR(newentry->st_mode) && S_ISDIR(parent->next->st_mode))
            ) &&
            (!S_ISDIR(newentry->st_mode) || S_ISDIR(parent->next->st_mode))
            ) {
          parent = parent->next;
        }
        newentry->next = parent->next;
        parent->next = newentry;
        list = root.next;
      } else {
        list = newentry;
      }
    }
  }
  
  closedir(dirf);
  
  return list;
}

static bool is_dir_excluded(settings_t* settings, const char* dir) {
  const string_list_t * const list = settings->excludeDirs;

  for (size_t i = 0 ; i < list->count ; i++) {
    /* determine if the list item is a path or a name */
    if (strchr(list->items[i], settings->fileSeparator) == NULL) {
      /* compare only the name */
      const char *dirpart = strrchr(dir, settings->fileSeparator);
      if (dirpart == NULL) {
        dirpart = dir;
      } else {
        dirpart++;
      }
      if (pathcmp(list->items[i], dirpart) == 0) {
        return true;
      }
    } else {
      /* compare the full paths */
      char* absdir = make_path_absolute(dir);
      if (pathcmp(list->items[i], absdir) == 0) {
        free(absdir);
        return true;
      }
      free(absdir);
    }
  }
  return false;
}

void scanDirectory(scanner_t scanner, settings_t* settings,
    string_list_t* output, scanresult_t* result) {

  result->result = 0;
  bool bfile;
  char *outbuf;
  const char *result_type = settings->count_chars ? "chars" : "lines";

  filelist_t *filelist = buildFileList(scanner, settings);

  while (filelist != NULL) {

    /* Scan subdirectories */
    if (!S_ISREG(filelist->st_mode)) {
      if (S_ISDIR(filelist->st_mode)) {
        if (settings->recursive) {
          if (is_dir_excluded(settings, filelist->filename)) {
            if (!settings->matchesOnly && settings->verbose) {
              /* Print hint */
              outbuf = malloc(81);
              snprintf(outbuf, 81, "%*s%*s%19s\n",
                       filelist->displayname_len + scanner.spaces,
                       filelist->displayname,
                       60 - filelist->displayname_len - scanner.spaces,
                       "", "no match");
              add_string(output, outbuf);
            }
          } else {
            string_list_t *recoutput = settings->verbose ? new_string_list_t() : NULL;
            scanresult_t recresult;
            recresult.ext = result->ext;
            scanDirectory(
                (scanner_t) {filelist->filename, scanner.spaces+1},
                settings, recoutput, &recresult);
            result->result += recresult.result;
            if (settings->verbose && (!settings->matchesOnly || recresult.result > 0)) {
              outbuf = (char*) malloc(81);
              snprintf(outbuf, 81, "%*s/%*s%13u %s\n",
                  filelist->displayname_len+scanner.spaces, filelist->displayname,
                  60-filelist->displayname_len-scanner.spaces-1, "",
                  recresult.result, result_type);
              add_string(output, outbuf);
              for (unsigned i = 0 ; i < recoutput->count ; i++) {
                add_string(output, recoutput->items[i]);
              }
            }
            destroy_string_list_t(recoutput);
          }
        }
      } else if (!settings->matchesOnly && settings->verbose) {
        outbuf = (char*) malloc(81);
        snprintf(outbuf, 81, "%*s\n",
                 filelist->displayname_len+scanner.spaces,
                 filelist->displayname);
        add_string(output, outbuf);
      }
    } else {
      if ((settings->includeSuffixes->count == 0
        || testSuffix(filelist->displayname, settings->includeSuffixes))
        && !testSuffix(filelist->displayname, settings->excludeSuffixes)) {

        /* Count */
        unsigned res_value = 0;
        bfile = false;
        bfile_reset(settings->bfileHeuristics);
        regex_parser_reset(settings->regex);
        char line_buffer[MAX_LINELENGTH + 1];
        unsigned line_buffer_pos = 0;

        FILE *file = fopen(filelist->filename, "r");
        if (file == NULL) {
          fprintf(stderr, "Error: %s", filelist->displayname);
          perror("  File acces failed");
        } else {
          int a;
          do {
            a = fgetc(file);

            bfile = bfile_check(settings->bfileHeuristics, a);

            /* ignore carriage return completely */
            if (a == 13) continue;

            if (a == 10 || a == EOF) {
              line_buffer[line_buffer_pos] = 0;
              if (regex_parser_do(settings->regex, line_buffer) == 0) {
                /* Subtract excluded lines/chars when matching has finished */
                if (!regex_parser_matching(settings->regex)) {
                  res_value -= settings->regex->matched_counted;
                }
              }

              if (settings->count_chars) {
                for (size_t i = 0 ; i < line_buffer_pos ; i++) {
                  if (!isspace(line_buffer[i])) res_value++;
                }
              } else {
                res_value++;
              }
              line_buffer_pos = 0;
            } else {
              if (line_buffer_pos < MAX_LINELENGTH) {
                line_buffer[line_buffer_pos] = (char) a;
                line_buffer_pos++;
              } else {
                line_buffer[line_buffer_pos] = 0;
                settings->confusing_lnlen = true;
              }
            }
          } while (!bfile && a != EOF);
          fclose(file);

          /* Print and sum line count */
          if (bfile) {
            if (!settings->matchesOnly && !settings->dirsOnly && settings->verbose) {
              outbuf = (char*) malloc(81);
              snprintf(outbuf, 81,
                  "%*s%*s%19s\n", filelist->displayname_len+scanner.spaces,
                  filelist->displayname,
                  60-filelist->displayname_len-scanner.spaces, "", "binary");
              add_string(output, outbuf);
            }
          } else {
            addResultPerExtension(result->ext, filelist->ext, res_value);
            result->result += res_value;
            if (!settings->dirsOnly && settings->verbose) {
              outbuf = (char*) malloc(81);
              snprintf(outbuf, 81, "%*s%*s%13u %s\n",
                       filelist->displayname_len+scanner.spaces,
                       filelist->displayname,
                       60-filelist->displayname_len-scanner.spaces,
                       "",
                       res_value,
                       result_type
              );
              add_string(output, outbuf);
            }
          }
        }
      } else {
        if (!settings->matchesOnly && !settings->dirsOnly && settings->verbose) {
          /* Print hint */
          outbuf = (char*) malloc(81);
          snprintf(outbuf, 81, "%*s%*s%19s\n",
              filelist->displayname_len+scanner.spaces, filelist->displayname,
              60-filelist->displayname_len-scanner.spaces, "", "no match");
          add_string(output, outbuf);
        }
      }
    }
    
    free(filelist->filename);
    free(filelist->displayname);
    filelist_t *freethis = filelist;
    filelist = filelist->next;
    free(freethis);
  }
}

char *make_path_absolute(const char *path) {
  static const char *cwd = NULL;
  static size_t cwdlen = 0;
#ifdef _WIN32
  static char fs = '\\';
#else
  static char fs = '/';
#endif /* _WIN32 */
  if (path_is_relative(path)) {
    if (cwdlen == 0) {
      get_working_dir(&cwd, &cwdlen);
    }
    size_t pathlen = strlen(path);
    char *result = malloc(pathlen+cwdlen+1);
    const char *part = path;
    size_t partlen = pathlen;
    if (part[0] == '.' && part[1] == fs) {
      part += 2;
      partlen -= 2;
    }
    memcpy(result, cwd, cwdlen);
    memcpy(result+cwdlen, part, partlen);
    result[cwdlen+partlen] = '\0';
    return result;
  } else {
    return strdup(path);
  }
}