/* * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2005, 2006, 2008, * 2009, 2011, 2012, 2014, 2015, 2016, 2017, 2018, 2020 * Tama Communications Corporation * * This file is part of GNU GLOBAL. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifdef HAVE_CONFIG_H #include #endif #include #include #ifdef HAVE_DIRENT_H #include #include #include #endif #ifdef HAVE_LIMITS_H #include #endif #include #ifdef STDC_HEADERS #include #endif #ifdef HAVE_STRING_H #include #else #include #endif #ifdef HAVE_UNISTD_H #include #endif #if defined(_WIN32) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN #include #undef SLIST_ENTRY #endif #include "gparam.h" #include "regex.h" #include "abs2rel.h" #include "char.h" #include "checkalloc.h" #include "conf.h" #include "die.h" #include "find.h" #include "getdbpath.h" #include "gtagsop.h" #include "is_unixy.h" #include "langmap.h" #include "locatestring.h" #include "makepath.h" #include "path.h" #include "strbuf.h" #include "strlimcpy.h" #include "test.h" #include "vstack.h" /* * use an appropriate string comparison for the file system; define the position of the root slash. */ #if defined(_WIN32) || defined(__DJGPP__) #define STRCMP stricmp #define STRNCMP strnicmp #define ROOT 2 #define S_ISSOCK(mode) (0) #else #define STRCMP strcmp #define STRNCMP strncmp #define ROOT 0 #endif /* * usage of find_xxx() * * find_open(NULL); * while (path = find_read()) { * ... * } * find_close(); * */ static regex_t *skip; /**< regex for skipping units */ static regex_t *suff; /**< regex for suffixes */ static FILE *ip; static FILE *temp; static char *rootdir; static char cwddir[MAXPATHLEN]; static int find_mode; static int find_eof; #define FIND_OPEN 1 #define FILELIST_OPEN 2 extern int qflag; extern int debug; static const int allow_blank = 1; static const int check_looplink = 1; static int accept_dotfiles = 0; static int skip_unreadable = 0; static int find_explain = 0; static int skip_symlink = 0; /** * get the reason for skipping * * @param[in] path path name (must start with "./") * @return | * directory or not: 1: directory, 0: file * reason: 1: dot file, 0: others */ static int getreason(const char *path) { int db, type = 0, is_directory = 0; const char *p; /* seek to the last character */ p = path + strlen(path) - 1; if (*p == '/') { is_directory = 1; p--; } /* seek to the basename */ for (; path < p; p--) if (*p == '/') break; if (*p == '/') p++; /* check for dot files */ if (*p == '.') { type = 1; } else { /* check for tag files */ for (db = 0; db < GTAGLIM; db++) if (!strcmp(dbname(db), p)) type = 2; } return is_directory << 8 | type; } /** * prepare_source: preparing regular expression. * * @return compiled regular expression for source files. */ static regex_t * prepare_source(void) { static regex_t suff_area; STRBUF *sb = strbuf_open(0); char *default_langmap = DEFAULTLANGMAP; char *langmap = default_langmap; char *p; int flags = REG_EXTENDED; /* * load icase_path option. */ if (getconfb("icase_path")) flags |= REG_ICASE; #if defined(_WIN32) || defined(__DJGPP__) flags |= REG_ICASE; #endif /* * make suffix list. */ strbuf_reset(sb); if (getconfs("langmap", sb)) langmap = check_strdup(strbuf_value(sb)); strbuf_reset(sb); p = langmap; strbuf_puts(sb, "/("); if (debug) fprintf(stderr, "langmap = %s\n", langmap); while (*p) { /* skip language name */ for (; *p && *p != ':'; p++) ; if (*p == 0) die_with_code(2, "syntax error in the langmap '%s'.", langmap); p++; /* pick up a suffix or a glob pattern */ while (*p == '.' || *p == '(') { if (*p == '.') { /* suffix */ strbuf_puts(sb, "[^/]+\\."); for (p++; *p && *p != '.' && *p != '(' && *p != ','; p++) { if (!isalnum(*p)) strbuf_putc(sb, '\\'); strbuf_putc(sb, *p); } } else if (*p == '(') { /* glob pattern */ for (p++; *p && *p != ')'; p++) { if (*p == '.') strbuf_puts(sb, "\\."); else if (*p == '*') strbuf_puts(sb, "[^/]*"); else if (*p == '?') strbuf_puts(sb, "[^/]"); else if (*p == '[') { strbuf_putc(sb, '['); if (*++p == '!') { strbuf_putc(sb, '^'); p++; } for (; *p && *p != ']'; p++) strbuf_putc(sb, *p); if (*p == 0) die_with_code(2, "syntax error in the langmap '%s'.", langmap); strbuf_putc(sb, ']'); } else strbuf_putc(sb, *p); } if (*p == 0) die_with_code(2, "syntax error in the langmap '%s'.", langmap); p++; } strbuf_putc(sb, '|'); } if (*p == ',') p++; } strbuf_unputc(sb, '|'); strbuf_puts(sb, ")$"); if (debug) fprintf(stderr, "prepare_source: %s\n", strbuf_value(sb)); if (regcomp(&suff_area, strbuf_value(sb), flags) != 0) die("cannot compile regular expression."); strbuf_close(sb); if (langmap != default_langmap) free(langmap); return &suff_area; } /** * prepare_skip: prepare skipping files. * * Globals used (output): * listarray[]: skip list. * list_count: count of skip list. * * @return compiled regular expression for skip files. */ static regex_t * prepare_skip(void) { static regex_t skip_area; char *skiplist; STRBUF *reg = strbuf_open(0); char *p, *q; int flags = REG_EXTENDED|REG_NEWLINE; /* * load icase_path option. */ if (getconfb("icase_path")) flags |= REG_ICASE; #if defined(_WIN32) || defined(__DJGPP__) flags |= REG_ICASE; #endif /* * load skip data. */ if (!getconfs("skip", reg)) { strbuf_close(reg); return NULL; } skiplist = check_strdup(strbuf_value(reg)); if (debug) fprintf(stderr, "DBG: Original skip list:\n%s\n", skiplist); strbuf_reset(reg); /* * construct regular expression. */ strbuf_putc(reg, '('); /* ) */ /* * Hard coded skip files: * (1) files which start with '.' * (2) tag files */ /* skip files which start with '.' e.g. .cvsignore */ if (!accept_dotfiles) { strbuf_puts(reg, "/\\.[^/]+$|"); strbuf_puts(reg, "/\\.[^/]+/|"); } /* skip tag files */ strbuf_puts(reg, "/GTAGS$|"); strbuf_puts(reg, "/GRTAGS$|"); strbuf_puts(reg, "/GSYMS$|"); strbuf_puts(reg, "/GPATH$|"); for (p = skiplist; *p; ) { char *skipf; STATIC_STRBUF(sb); strbuf_clear(sb); while (*p && *p == ',') p++; if (*p == '\0') break; for (; *p; p++) { if (*p == ',') break; if (*p == '\\' && *(p + 1) == ',') p++; strbuf_putc(sb, *p); } skipf = strbuf_value(sb); /* '/' means project root directory */ if (*skipf == '/') { strbuf_puts(reg, "^\\./"); skipf++; } else { strbuf_putc(reg, '/'); } for (q = skipf; *q; q++) { /* * replaces wild cards into regular expressions. * * '*' -> '[^/]*' * '?' -> '[^/]' * '[...]' -> '[...]' * '[!...]' -> '[^...]' */ if (*q == '[') { char *c = q; STATIC_STRBUF(class); int isclass = 1; strbuf_clear(class); strbuf_putc(class, *c++); /* '[' */ if (*c == '\0') isclass = 0; else if (*c == ']') strbuf_putc(class, *c++); else if (*c == '!') { strbuf_putc(class, '^'); c++; } else strbuf_putc(class, *c++); if (isclass) { while (*c && *c != ']') strbuf_putc(class, *c++); if (*c == ']') strbuf_putc(class, *c); /* ']' */ else isclass = 0; } if (isclass) { strbuf_puts(reg, strbuf_value(class)); q = c; } else { /* 'class' is thrown away */ strbuf_putc(reg, '\\'); strbuf_putc(reg, *q); } } else if (*q == '*') strbuf_puts(reg, "[^/]*"); else if (*q == '?') strbuf_puts(reg, "[^/]"); else if (*q == '\\' && *(q + 1) == ',') strbuf_putc(reg, *++q); else if (isregexchar(*q)) { strbuf_putc(reg, '\\'); strbuf_putc(reg, *q); } else { if (*q == '\\' && *(q + 1) != '\0') { strbuf_putc(reg, *q++); strbuf_putc(reg, *q); } else strbuf_putc(reg, *q); } } if (*(q - 1) != '/') strbuf_putc(reg, '$'); if (*p == ',') strbuf_putc(reg, '|'); } strbuf_unputc(reg, '|'); strbuf_putc(reg, ')'); /* * compile regular expression. */ if (debug) fprintf(stderr, "DBG: Regular expression of the skip list:\n%s\n", strbuf_value(reg)); if (regcomp(&skip_area, strbuf_value(reg), flags) != 0) die("cannot compile regular expression."); strbuf_close(reg); free(skiplist); return &skip_area; } /** * issourcefile: check whether or not a source file. * * @param[in] path path name (must start with "./") * @return 1: source file, 0: other file */ int issourcefile(const char *path) { if (suff == NULL) { suff = prepare_source(); /* XXX this cannot return NULL */ if (suff == NULL) die("prepare_source failed."); } if (regexec(suff, path, 0, 0, 0) == 0) return 1; return 0; } /** * skipthisfile: check whether or not we accept this file. * * @param[in] path path name (must start with "./") * @return 1: skip, 0: don't skip * * [Note] * Specification of required path name: * - Path must start with "./". * - Directory path name must end with "/". */ int skipthisfile(const char *path) { regmatch_t m; int i; /* * unit check. */ if (skip == NULL) { skip = prepare_skip(); if (skip == NULL) die("prepare_skip failed."); } if (regexec(skip, path, 1, &m, 0) == 0) { if (debug) { int len = strlen(path); fprintf(stderr, "DBG: "); for (i = 0; i < len; i++) { if (m.rm_so == i) fputc('[', stderr); if (m.rm_eo == i) fputc(']', stderr); fputc(path[i], stderr); } if (m.rm_eo == len) fputc(']', stderr); fprintf(stderr, " => SKIPPED\n"); } if (find_explain) { int type = getreason(path); const char *kind = (type >> 8) ? "Directory" : "File"; fprintf(stderr, " - %s '%s' is skipped", kind, trimpath(path)); switch (type & 0xff) { case 1: fprintf(stderr, " because the name begins with a dot.\n"); break; case 2: fprintf(stderr, " because it is a tag file.\n"); break; case 0: fprintf(stderr, " by the skip list.\n"); break; } } return 1; } else { if (debug) fprintf(stderr, "%s\n", path); } return 0; } /* * Directory Stack */ static char dir[MAXPATHLEN]; /**< directory path */ static VSTACK *vstack; /**< dynamic allocated stack */ struct stack_entry { STRBUF *sb; char *real; char *dirp, *start, *end, *p; }; /** * getrealpath: return a real path of dir using allocated area. */ static char * getrealpath(const char *dir) { char *real; if ((real = realpath(dir, NULL)) == NULL) die("cannot get real path of '%s'.", trimpath(dir)); return real; } /** * has_symlinkloop: whether or not dir has a symbolic link loops. * * @param[in] dir directory (should end by "/") * @return 1: has a loop, 0: don't have a loop */ static int has_symlinkloop(const char *dir) { struct stack_entry *sp; char *real, *p; int i, ret = 0; if (!strcmp(dir, "./")) return 0; if ((real = realpath(dir, NULL)) == NULL) die("cannot get real path of '%s'.", trimpath(dir)); #ifdef SLOOPDEBUG fprintf(stderr, "======== has_symlinkloop ======\n"); fprintf(stderr, "dir = '%s', real path = '%s'\n", dir, real); fprintf(stderr, "TEST-1\n"); fprintf(stderr, "\tcheck '%s' < '%s'\n", real, rootdir); #endif p = locatestring(rootdir, real, MATCH_AT_FIRST); if (p && (*p == '/' || *p == '\0' || !strcmp(real, "/"))) { ret = 1; goto out; } sp = varray_assign(vstack->varray, 0, 0); #ifdef SLOOPDEBUG fprintf(stderr, "TEST-2\n"); #endif for (i = vstack->stack_top; i >= 0; i--) { #ifdef SLOOPDEBUG fprintf(stderr, "%d:\tcheck '%s' == '%s'\n", i, real, sp[i].real); #endif if (!strcmp(sp[i].real, real)) { ret = 1; goto out; } } #ifdef SLOOPDEBUG fprintf(stderr, "===============================\n"); #endif out: free(real); return ret; } /** * skips '.', '..'. * It also skips '.xxxx' and tag files for performance. */ static int ignore(const char *path) { int db; if (path[0] == '.') { if (path[1] == '\0' || (path[1] == '.' && path[2] == '\0')) return 1; if (!find_explain && !accept_dotfiles) return 1; } if (!find_explain) { if (path[0] == 'G') { for (db = 0; db < GTAGLIM; db++) if (!strcmp(dbname(db), path)) return 1; } } return 0; } /** * getdirs: get directory list * * @param[in] dir directory (should end by "/") * @param[out] sb string buffer * @return -1: error, 0: normal * * format of directory list: * |ddir1\0ffile1\0| * means directory "dir1", file "file1". */ static int getdirs(const char *dir, STRBUF *sb) { DIR *dirp; struct dirent *dp; struct stat st; if (check_looplink && has_symlinkloop(dir)) { warning("symbolic link loop detected. '%s' is ignored.", trimpath(dir)); return -1; } if ((dirp = opendir(dir)) == NULL) { warning("cannot open directory '%s'. ignored.", trimpath(dir)); return -1; } while ((dp = readdir(dirp)) != NULL) { if (ignore(dp->d_name)) continue; if (stat(makepath(dir, dp->d_name, NULL), &st) < 0) { warning("cannot stat '%s'. ignored.", trimpath(dp->d_name)); continue; } if (S_ISSOCK(st.st_mode) || S_ISFIFO(st.st_mode) || S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { warning("file is not regular file '%s'. ignored.", trimpath(dp->d_name)); continue; } if (access(makepath(dir, dp->d_name, NULL), R_OK) < 0) { if (!skip_unreadable) die("cannot read file '%s'.", trimpath(dp->d_name)); warning("cannot read '%s'. ignored.", trimpath(dp->d_name)); continue; } #ifndef __DJGPP__ if (skip_symlink > 0) { #if defined(_WIN32) && !defined(__CYGWIN__) DWORD attr = GetFileAttributes(makepath(dir, dp->d_name, NULL)); if (attr != -1 && (attr & FILE_ATTRIBUTE_REPARSE_POINT)) #else struct stat st2; if (lstat(makepath(dir, dp->d_name, NULL), &st2) < 0) { warning("cannot lstat '%s'. ignored.", trimpath(dp->d_name)); continue; } if (S_ISLNK(st2.st_mode)) #endif { if (((skip_symlink & SKIP_SYMLINK_FOR_DIR) && S_ISDIR(st.st_mode)) || ((skip_symlink & SKIP_SYMLINK_FOR_FILE) && S_ISREG(st.st_mode))) { if (find_explain) fprintf(stderr, " - Symbolic link '%s' is skipped.\n", trimpath(makepath(dir, dp->d_name, NULL))); continue; } } } #endif if (S_ISDIR(st.st_mode)) strbuf_putc(sb, 'd'); else if (S_ISREG(st.st_mode)) strbuf_putc(sb, 'f'); else strbuf_putc(sb, ' '); strbuf_puts(sb, dp->d_name); strbuf_putc(sb, '\0'); } (void)closedir(dirp); return 0; } /** * set_accept_dotfiles: make find to accept dot files and dot directries. */ void set_accept_dotfiles(void) { accept_dotfiles = 1; } /** * set_skip_unreadable: make find to ignore unreadable files. */ void set_skip_unreadable(void) { skip_unreadable = 1; } /** * set_skip_symlink: set rules for symbolic links. * * mode 0: accept symbolic link * SKIP_SYMLINK_FOR_DIR: skip symbolic links for a dir * SKIP_SYMLINK_FOR_FILE: skip symbolic links for a file * SKIP_SYMLINK_FOR_ALL: skip symbolic links */ void set_skip_symlink(int mode) { skip_symlink = mode; } /** * find_open: start iterator without GPATH. * * @param[in] start start directory, * If NULL, assumed "." (current) directory. * @param[in] explain print verbose message */ void find_open(const char *start, int explain) { struct stack_entry *curp; assert(find_mode == 0); find_mode = FIND_OPEN; find_explain = explain; if (!start) start = "./"; if ((rootdir = realpath(start, NULL)) == NULL) die("cannot get real path of '%s'.", trimpath(dir)); /* * setup stack. */ vstack = vstack_open(sizeof(struct stack_entry), 50); curp = vstack_push(vstack); strlimcpy(dir, start, sizeof(dir)); curp->dirp = dir + strlen(dir); curp->sb = strbuf_open(0); curp->real = getrealpath(dir); if (getdirs(dir, curp->sb) < 0) die("Work is given up."); curp->start = curp->p = strbuf_value(curp->sb); curp->end = curp->start + strbuf_getlen(curp->sb); strlimcpy(cwddir, get_root(), sizeof(cwddir)); } /** * find_open_filelist: find_open like interface for handling output of find(1). * * @param[in] filename file including list of file names. * When "-" is specified, read from standard input. * @param[in] root root directory of source tree * @param[in] explain print verbose message */ void find_open_filelist(const char *filename, const char *root, int explain) { size_t rootdir_len; assert(find_mode == 0); find_mode = FILELIST_OPEN; find_explain = explain; if (!strcmp(filename, "-")) { /* * If the filename is '-', copy standard input onto * temporary file to be able to read repeatedly. */ if (temp == NULL) { char buf[MAXPATHLEN]; temp = tmpfile(); while (fgets(buf, sizeof(buf), stdin) != NULL) fputs(buf, temp); } rewind(temp); ip = temp; } else { ip = fopen(filename, "r"); if (ip == NULL) die("cannot open '%s'.", trimpath(filename)); } /* * rootdir always ends with '/'. * * rootdir_len is two characters longer than root to be able * to append a "/" if needed and the string terminator * ofcourse. */ rootdir_len = strlen(root) + 2; rootdir = malloc(rootdir_len); if (!rootdir) die("short of memory."); snprintf(rootdir, rootdir_len, "%s%s", root, strcmp(root+ROOT, "/") ? "/" : ""); strlimcpy(cwddir, root, sizeof(cwddir)); } /** * find_read_filelist: read path from file * * @return path */ static char * find_read_filelist(void) { STATIC_STRBUF(ib); /* * The buf has room for one character ' ' in front. * * __buf * +---+---+---+---+ +---+ * |' '| | | ..... | * +---+---+---+---+ +---+ * ^ * buf * <--- bufsize ---> */ static char __buf[MAXPATHLEN + 2]; static char *buf = &__buf[1]; static int bufsize = sizeof(__buf) - 1; static char *path; strbuf_clear(ib); for (;;) { path = strbuf_fgets(ib, ip, STRBUF_NOCRLF); if (path == NULL) { /* EOF */ find_eof = 1; return NULL; } if (*path == '\0') { /* skip empty line. */ continue; } /* * Lines which start with ". " are considered to be comments. */ if (*path == '.' && *(path + 1) == ' ') continue; /* * Skip the following: * o directory * o file which does not exist * o dead symbolic link */ if (!test("f", path)) { if (test("d", path)) warning("'%s' is a directory. ignored.", trimpath(path)); else warning("'%s' not found. ignored.", trimpath(path)); continue; } /* * normalize path name. * * rootdir /a/b/ * buf /a/b/c/d.c -> c/d.c -> ./c/d.c */ if (normalize(path, rootdir, cwddir, buf, bufsize) == NULL) { warning("'%s' is out of source tree. ignored.", trimpath(path)); continue; } path = buf; /* * Now GLOBAL can treat the path which includes blanks. * This message is obsoleted. */ if (!allow_blank && locatestring(path, " ", MATCH_LAST)) { warning("'%s' ignored, because it includes blank.", trimpath(path)); continue; } if (skipthisfile(path)) continue; /* * A blank at the head of path means * other than source file. */ if (!issourcefile(path)) *--path = ' '; return path; } } /** * find_read_traverse: read path without GPATH. * * @return path */ static char * find_read_traverse(void) { static char val[MAXPATHLEN]; char path[MAXPATHLEN]; struct stack_entry *curp = vstack_top(vstack); for (;;) { while (curp->p < curp->end) { char type = *(curp->p); const char *unit = curp->p + 1; curp->p += strlen(curp->p) + 1; /* * Skip files described in the skip list. */ /* makepath() returns unsafe module local area. */ strlimcpy(path, makepath(dir, unit, NULL), sizeof(path)); if (type == 'd') strcat(path, "/"); if (skipthisfile(path)) continue; if (type == 'f') { /* * Skip the following: * o directory * o file which does not exist * o dead symbolic link */ if (!test("f", path)) { if (test("d", path)) warning("'%s' is a directory. ignored.", trimpath(path)); else warning("'%s' not found. ignored.", trimpath(path)); continue; } /* * Now GLOBAL can treat the path which includes blanks. * This message is obsoleted. */ if (!allow_blank && locatestring(path, " ", MATCH_FIRST)) { warning("'%s' ignored, because it includes blank.", trimpath(path)); continue; } /* * A blank at the head of path means * other than source file. */ if (issourcefile(path)) { strlimcpy(val, path, sizeof(val)); } else { /* other file like 'Makefile' */ val[0] = ' '; strlimcpy(&val[1], path, sizeof(val) - 1); } val[sizeof(val) - 1] = '\0'; return val; } if (type == 'd') { STRBUF *sb = strbuf_open(0); char *dirp = curp->dirp; strcat(dirp, unit); strcat(dirp, "/"); if (getdirs(dir, sb) < 0) { strbuf_close(sb); *(curp->dirp) = 0; continue; } /* * Push stack. */ curp = vstack_push(vstack); curp->dirp = dirp + strlen(dirp); curp->real = getrealpath(dir); curp->sb = sb; curp->start = curp->p = strbuf_value(sb); curp->end = curp->start + strbuf_getlen(sb); } } strbuf_close(curp->sb); curp->sb = NULL; free(curp->real); curp->real = NULL; /* * Pop stack. */ curp = vstack_pop(vstack); if (curp == NULL) break; *(curp->dirp) = 0; } find_eof = 1; return NULL; } /** * find_read: read path without GPATH. * * @return path */ char * find_read(void) { static char *path; assert(find_mode != 0); if (find_eof) path = NULL; else if (find_mode == FILELIST_OPEN) path = find_read_filelist(); else if (find_mode == FIND_OPEN) path = find_read_traverse(); else die("find_read: internal error."); return path; } /** * find_close: close iterator. */ void find_close(void) { assert(find_mode != 0); if (find_mode == FIND_OPEN) { if (vstack) vstack_close(vstack); } else if (find_mode == FILELIST_OPEN) { /* * The --file=- option is specified, we don't close file * to read it repeatedly. */ if (ip != temp) fclose(ip); } else { die("find_close: internal error."); } if (rootdir) free(rootdir); if (suff) regfree(suff); if (skip) regfree(skip); find_eof = find_mode = 0; }