git: update to v2.24.1

[cgit.git] / scan-tree.c

diff --git a/scan-tree.c b/scan-tree.c
index e9878248346eaf8d48f6a5c8d3053fcf51d5270c..6a2f65a86b2cda7826df470836f9757ba86abf98 100644 (file)
--- a/scan-tree.c
+++ b/scan-tree.c
@@ -1,200 +1,267 @@
 /* scan-tree.c
 /* scan-tree.c

- * 
- * Copyright (C) 2008-2009 Lars Hjemli
- * Copyright (C) 2010 Jason A. Donenfeld <Jason@zx2c4.com>
+ *
+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"

+#include "scan-tree.h"

 #include "configfile.h"
 #include "html.h"
 #include "configfile.h"
 #include "html.h"

-
-#define MAX_PATH 4096
+#include <config.h>

 
 /* return 1 if path contains a objects/ directory and a HEAD file */
 static int is_git_dir(const char *path)
 {
        struct stat st;
 
 /* return 1 if path contains a objects/ directory and a HEAD file */
 static int is_git_dir(const char *path)
 {
        struct stat st;

-       static char buf[MAX_PATH];
+       struct strbuf pathbuf = STRBUF_INIT;
+       int result = 0;

 
 

-       if (snprintf(buf, MAX_PATH, "%s/objects", path) >= MAX_PATH) {
-               fprintf(stderr, "Insanely long path: %s\n", path);
-               return 0;
-       }
-       if (stat(buf, &st)) {
+       strbuf_addf(&pathbuf, "%s/objects", path);
+       if (stat(pathbuf.buf, &st)) {

                if (errno != ENOENT)
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                path, strerror(errno), errno);
                if (errno != ENOENT)
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                path, strerror(errno), errno);

-               return 0;
+               goto out;

        }
        if (!S_ISDIR(st.st_mode))
        }
        if (!S_ISDIR(st.st_mode))

-               return 0;
+               goto out;

 
 

-       sprintf(buf, "%s/HEAD", path);
-       if (stat(buf, &st)) {
+       strbuf_reset(&pathbuf);
+       strbuf_addf(&pathbuf, "%s/HEAD", path);
+       if (stat(pathbuf.buf, &st)) {

                if (errno != ENOENT)
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                path, strerror(errno), errno);
                if (errno != ENOENT)
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                path, strerror(errno), errno);

-               return 0;
+               goto out;

        }
        if (!S_ISREG(st.st_mode))
        }
        if (!S_ISREG(st.st_mode))

-               return 0;
+               goto out;

 
 

-       return 1;
+       result = 1;
+out:
+       strbuf_release(&pathbuf);
+       return result;

 }
 
 }
 

-struct cgit_repo *repo;
-repo_config_fn config_fn;
-char *owner;
+static struct cgit_repo *repo;
+static repo_config_fn config_fn;

 
 

-static void repo_config(const char *name, const char *value)
+static void scan_tree_repo_config(const char *name, const char *value)

 {
        config_fn(repo, name, value);
 }
 
 {
        config_fn(repo, name, value);
 }
 

-static int git_owner_config(const char *key, const char *value, void *cb)
+static int gitconfig_config(const char *key, const char *value, void *cb)

 {
 {

+       const char *name;
+

        if (!strcmp(key, "gitweb.owner"))
        if (!strcmp(key, "gitweb.owner"))

-               owner = xstrdup(value);
+               config_fn(repo, "owner", value);
+       else if (!strcmp(key, "gitweb.description"))
+               config_fn(repo, "desc", value);
+       else if (!strcmp(key, "gitweb.category"))
+               config_fn(repo, "section", value);
+       else if (!strcmp(key, "gitweb.homepage"))
+               config_fn(repo, "homepage", value);
+       else if (skip_prefix(key, "cgit.", &name))
+               config_fn(repo, name, value);
+

        return 0;
 }
 
        return 0;
 }
 

-static void add_repo(const char *base, const char *path, repo_config_fn fn)
+static char *xstrrchr(char *s, char *from, int c)
+{
+       while (from >= s && *from != c)
+               from--;
+       return from < s ? NULL : from;
+}
+
+static void add_repo(const char *base, struct strbuf *path, repo_config_fn fn)

 {
        struct stat st;
        struct passwd *pwd;
 {
        struct stat st;
        struct passwd *pwd;

-       char *p;
+       size_t pathlen;
+       struct strbuf rel = STRBUF_INIT;
+       char *p, *slash;
+       int n;

        size_t size;
 
        size_t size;
 

-       if (stat(path, &st)) {
+       if (stat(path->buf, &st)) {

                fprintf(stderr, "Error accessing %s: %s (%d)\n",
                fprintf(stderr, "Error accessing %s: %s (%d)\n",

-                       path, strerror(errno), errno);
+                       path->buf, strerror(errno), errno);

                return;
        }
                return;
        }

-       if (!stat(fmt("%s/noweb", path), &st))
+
+       strbuf_addch(path, '/');
+       pathlen = path->len;
+
+       if (ctx.cfg.strict_export) {
+               strbuf_addstr(path, ctx.cfg.strict_export);
+               if(stat(path->buf, &st))
+                       return;
+               strbuf_setlen(path, pathlen);
+       }
+
+       strbuf_addstr(path, "noweb");
+       if (!stat(path->buf, &st))

                return;
                return;

+       strbuf_setlen(path, pathlen);

 
 

-       owner = NULL;
-       if (ctx.cfg.enable_gitweb_owner)
-               git_config_from_file(git_owner_config, fmt("%s/config", path), NULL);
-       if (base == path)
-               p = fmt("%s", path);
+       if (!starts_with(path->buf, base))
+               strbuf_addbuf(&rel, path);

        else
        else

-               p = fmt("%s", path + strlen(base) + 1);
-
-       if (!strcmp(p + strlen(p) - 5, "/.git"))
-               p[strlen(p) - 5] = '\0';
-
-       repo = cgit_add_repo(xstrdup(p));
-       if (ctx.cfg.remove_suffix)
-               if ((p = strrchr(repo->url, '.')) && !strcmp(p, ".git"))
-                       *p = '\0';
-       repo->name = repo->url;
-       repo->path = xstrdup(path);
-       while (!owner) {
+               strbuf_addstr(&rel, path->buf + strlen(base) + 1);
+
+       if (!strcmp(rel.buf + rel.len - 5, "/.git"))
+               strbuf_setlen(&rel, rel.len - 5);
+       else if (rel.len && rel.buf[rel.len - 1] == '/')
+               strbuf_setlen(&rel, rel.len - 1);
+
+       repo = cgit_add_repo(rel.buf);
+       config_fn = fn;
+       if (ctx.cfg.enable_git_config) {
+               strbuf_addstr(path, "config");
+               git_config_from_file(gitconfig_config, path->buf, NULL);
+               strbuf_setlen(path, pathlen);
+       }
+
+       if (ctx.cfg.remove_suffix) {
+               size_t urllen;
+               strip_suffix(repo->url, ".git", &urllen);
+               strip_suffix_mem(repo->url, &urllen, "/");
+               repo->url[urllen] = '\0';
+       }
+       repo->path = xstrdup(path->buf);
+       while (!repo->owner) {

                if ((pwd = getpwuid(st.st_uid)) == NULL) {
                        fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",
                if ((pwd = getpwuid(st.st_uid)) == NULL) {
                        fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",

-                               path, strerror(errno), errno);
+                               path->buf, strerror(errno), errno);

                        break;
                }
                if (pwd->pw_gecos)
                        if ((p = strchr(pwd->pw_gecos, ',')))
                                *p = '\0';
                        break;
                }
                if (pwd->pw_gecos)
                        if ((p = strchr(pwd->pw_gecos, ',')))
                                *p = '\0';

-               owner = xstrdup(pwd->pw_gecos ? pwd->pw_gecos : pwd->pw_name);
+               repo->owner = xstrdup(pwd->pw_gecos ? pwd->pw_gecos : pwd->pw_name);

        }
        }

-       repo->owner = owner;
-
-       p = fmt("%s/description", path);
-       if (!stat(p, &st))
-               readfile(p, &repo->desc, &size);

 
 

-       p = fmt("%s/README.html", path);
-       if (!stat(p, &st))
-               repo->readme = "README.html";
+       if (repo->desc == cgit_default_repo_desc || !repo->desc) {
+               strbuf_addstr(path, "description");
+               if (!stat(path->buf, &st))
+                       readfile(path->buf, &repo->desc, &size);
+               strbuf_setlen(path, pathlen);
+       }

 
 

-       p = fmt("%s/cgitrc", path);
-       if (!stat(p, &st)) {
-               config_fn = fn;
-               parse_configfile(xstrdup(p), &repo_config);
+       if (ctx.cfg.section_from_path) {
+               n = ctx.cfg.section_from_path;
+               if (n > 0) {
+                       slash = rel.buf - 1;
+                       while (slash && n && (slash = strchr(slash + 1, '/')))
+                               n--;
+               } else {
+                       slash = rel.buf + rel.len;
+                       while (slash && n && (slash = xstrrchr(rel.buf, slash - 1, '/')))
+                               n++;
+               }
+               if (slash && !n) {
+                       *slash = '\0';
+                       repo->section = xstrdup(rel.buf);
+                       *slash = '/';
+                       if (starts_with(repo->name, repo->section)) {
+                               repo->name += strlen(repo->section);
+                               if (*repo->name == '/')
+                                       repo->name++;
+                       }
+               }

        }
        }

+
+       strbuf_addstr(path, "cgitrc");
+       if (!stat(path->buf, &st))
+               parse_configfile(path->buf, &scan_tree_repo_config);
+
+       strbuf_release(&rel);

 }
 
 static void scan_path(const char *base, const char *path, repo_config_fn fn)
 {
 }
 
 static void scan_path(const char *base, const char *path, repo_config_fn fn)
 {

-       DIR *dir;
+       DIR *dir = opendir(path);

        struct dirent *ent;
        struct dirent *ent;

-       char *buf;
+       struct strbuf pathbuf = STRBUF_INIT;
+       size_t pathlen = strlen(path);

        struct stat st;
 
        struct stat st;
 

-       if (is_git_dir(path)) {
-               add_repo(base, path, fn);
-               return;
-       }
-       if (is_git_dir(fmt("%s/.git", path))) {
-               add_repo(base, fmt("%s/.git", path), fn);
-               return;
-       }
-       dir = opendir(path);

        if (!dir) {
                fprintf(stderr, "Error opening directory %s: %s (%d)\n",
                        path, strerror(errno), errno);
                return;
        }
        if (!dir) {
                fprintf(stderr, "Error opening directory %s: %s (%d)\n",
                        path, strerror(errno), errno);
                return;
        }

-       while((ent = readdir(dir)) != NULL) {
+
+       strbuf_add(&pathbuf, path, strlen(path));
+       if (is_git_dir(pathbuf.buf)) {
+               add_repo(base, &pathbuf, fn);
+               goto end;
+       }
+       strbuf_addstr(&pathbuf, "/.git");
+       if (is_git_dir(pathbuf.buf)) {
+               add_repo(base, &pathbuf, fn);
+               goto end;
+       }
+       /*
+        * Add one because we don't want to lose the trailing '/' when we
+        * reset the length of pathbuf in the loop below.
+        */
+       pathlen++;
+       while ((ent = readdir(dir)) != NULL) {

                if (ent->d_name[0] == '.') {
                        if (ent->d_name[1] == '\0')
                                continue;
                        if (ent->d_name[1] == '.' && ent->d_name[2] == '\0')
                                continue;
                if (ent->d_name[0] == '.') {
                        if (ent->d_name[1] == '\0')
                                continue;
                        if (ent->d_name[1] == '.' && ent->d_name[2] == '\0')
                                continue;

+                       if (!ctx.cfg.scan_hidden_path)
+                               continue;

                }
                }

-               buf = malloc(strlen(path) + strlen(ent->d_name) + 2);
-               if (!buf) {
-                       fprintf(stderr, "Alloc error on %s: %s (%d)\n",
-                               path, strerror(errno), errno);
-                       exit(1);
-               }
-               sprintf(buf, "%s/%s", path, ent->d_name);
-               if (stat(buf, &st)) {
+               strbuf_setlen(&pathbuf, pathlen);
+               strbuf_addstr(&pathbuf, ent->d_name);
+               if (stat(pathbuf.buf, &st)) {

                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",

-                               buf, strerror(errno), errno);
-                       free(buf);
+                               pathbuf.buf, strerror(errno), errno);

                        continue;
                }
                if (S_ISDIR(st.st_mode))
                        continue;
                }
                if (S_ISDIR(st.st_mode))

-                       scan_path(base, buf, fn);
-               free(buf);
+                       scan_path(base, pathbuf.buf, fn);

        }
        }

+end:
+       strbuf_release(&pathbuf);

        closedir(dir);
 }
 
        closedir(dir);
 }
 

-#define lastc(s) s[strlen(s) - 1]
-

 void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn)
 {
 void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn)
 {

-       char line[MAX_PATH * 2], *z;
+       struct strbuf line = STRBUF_INIT;

        FILE *projects;
        int err;
        FILE *projects;
        int err;

-       
+

        projects = fopen(projectsfile, "r");
        if (!projects) {
                fprintf(stderr, "Error opening projectsfile %s: %s (%d)\n",
                        projectsfile, strerror(errno), errno);
        projects = fopen(projectsfile, "r");
        if (!projects) {
                fprintf(stderr, "Error opening projectsfile %s: %s (%d)\n",
                        projectsfile, strerror(errno), errno);

+               return;

        }
        }

-       while (fgets(line, sizeof(line), projects) != NULL) {
-               for (z = &lastc(line);
-                    strlen(line) && strchr("\n\r", *z);
-                    z = &lastc(line))
-                       *z = '\0';
-               if (strlen(line))
-                       scan_path(path, fmt("%s/%s", path, line), fn);
+       while (strbuf_getline(&line, projects) != EOF) {
+               if (!line.len)
+                       continue;
+               strbuf_insert(&line, 0, "/", 1);
+               strbuf_insert(&line, 0, path, strlen(path));
+               scan_path(path, line.buf, fn);

        }
        if ((err = ferror(projects))) {
                fprintf(stderr, "Error reading from projectsfile %s: %s (%d)\n",
                        projectsfile, strerror(err), err);
        }
        fclose(projects);
        }
        if ((err = ferror(projects))) {
                fprintf(stderr, "Error reading from projectsfile %s: %s (%d)\n",
                        projectsfile, strerror(err), err);
        }
        fclose(projects);

+       strbuf_release(&line);

 }
 
 void scan_tree(const char *path, repo_config_fn fn)
 }
 
 void scan_tree(const char *path, repo_config_fn fn)