5 files changed, 116 insertions, 17 deletions

diff --git a/cgit.c b/cgit.c
index c263872..eff5b7a 100644
--- a/cgit.c
+++ b/cgit.c
@@ -114,113 +114,122 @@ void config_cb(const char *name, const char *value)
         else if (!strcmp(name, "logo"))
                 ctx.cfg.logo = xstrdup(value);
         else if (!strcmp(name, "index-header"))
                 ctx.cfg.index_header = xstrdup(value);
         else if (!strcmp(name, "index-info"))
                 ctx.cfg.index_info = xstrdup(value);
         else if (!strcmp(name, "logo-link"))
                 ctx.cfg.logo_link = xstrdup(value);
         else if (!strcmp(name, "module-link"))
                 ctx.cfg.module_link = xstrdup(value);
         else if (!strcmp(name, "virtual-root")) {
                 ctx.cfg.virtual_root = trim_end(value, '/');
                 if (!ctx.cfg.virtual_root && (!strcmp(value, "/")))
                         ctx.cfg.virtual_root = "";
         } else if (!strcmp(name, "nocache"))
                 ctx.cfg.nocache = atoi(value);
         else if (!strcmp(name, "noplainemail"))
                 ctx.cfg.noplainemail = atoi(value);
         else if (!strcmp(name, "noheader"))
                 ctx.cfg.noheader = atoi(value);
         else if (!strcmp(name, "snapshots"))
                 ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);
         else if (!strcmp(name, "enable-filter-overrides"))
                 ctx.cfg.enable_filter_overrides = atoi(value);
+        else if (!strcmp(name, "enable-gitweb-owner"))
+                ctx.cfg.enable_gitweb_owner = atoi(value);
         else if (!strcmp(name, "enable-index-links"))
                 ctx.cfg.enable_index_links = atoi(value);
         else if (!strcmp(name, "enable-log-filecount"))
                 ctx.cfg.enable_log_filecount = atoi(value);
         else if (!strcmp(name, "enable-log-linecount"))
                 ctx.cfg.enable_log_linecount = atoi(value);
         else if (!strcmp(name, "enable-remote-branches"))
                 ctx.cfg.enable_remote_branches = atoi(value);
         else if (!strcmp(name, "enable-subject-links"))
                 ctx.cfg.enable_subject_links = atoi(value);
         else if (!strcmp(name, "enable-tree-linenumbers"))
                 ctx.cfg.enable_tree_linenumbers = atoi(value);
         else if (!strcmp(name, "max-stats"))
                 ctx.cfg.max_stats = cgit_find_stats_period(value, NULL);
         else if (!strcmp(name, "cache-size"))
                 ctx.cfg.cache_size = atoi(value);
         else if (!strcmp(name, "cache-root"))
                 ctx.cfg.cache_root = xstrdup(expand_macros(value));
         else if (!strcmp(name, "cache-root-ttl"))
                 ctx.cfg.cache_root_ttl = atoi(value);
         else if (!strcmp(name, "cache-repo-ttl"))
                 ctx.cfg.cache_repo_ttl = atoi(value);
         else if (!strcmp(name, "cache-scanrc-ttl"))
                 ctx.cfg.cache_scanrc_ttl = atoi(value);
         else if (!strcmp(name, "cache-static-ttl"))
                 ctx.cfg.cache_static_ttl = atoi(value);
         else if (!strcmp(name, "cache-dynamic-ttl"))
                 ctx.cfg.cache_dynamic_ttl = atoi(value);
         else if (!strcmp(name, "about-filter"))
                 ctx.cfg.about_filter = new_filter(value, 0);
         else if (!strcmp(name, "commit-filter"))
                 ctx.cfg.commit_filter = new_filter(value, 0);
         else if (!strcmp(name, "embedded"))
                 ctx.cfg.embedded = atoi(value);
         else if (!strcmp(name, "max-atom-items"))
                 ctx.cfg.max_atom_items = atoi(value);
         else if (!strcmp(name, "max-message-length"))
                 ctx.cfg.max_msg_len = atoi(value);
         else if (!strcmp(name, "max-repodesc-length"))
                 ctx.cfg.max_repodesc_len = atoi(value);
         else if (!strcmp(name, "max-blob-size"))
                 ctx.cfg.max_blob_size = atoi(value);
         else if (!strcmp(name, "max-repo-count"))
                 ctx.cfg.max_repo_count = atoi(value);
         else if (!strcmp(name, "max-commit-count"))
                 ctx.cfg.max_commit_count = atoi(value);
+        else if (!strcmp(name, "project-list"))
+                ctx.cfg.project_list = xstrdup(expand_macros(value));
         else if (!strcmp(name, "scan-path"))
                 if (!ctx.cfg.nocache && ctx.cfg.cache_size)
                         process_cached_repolist(expand_macros(value));
+                else if (ctx.cfg.project_list)
+                        scan_projects(expand_macros(value),
+                                      ctx.cfg.project_list, repo_config);
                 else
                         scan_tree(expand_macros(value), repo_config);
         else if (!strcmp(name, "source-filter"))
                 ctx.cfg.source_filter = new_filter(value, 1);
         else if (!strcmp(name, "summary-log"))
                 ctx.cfg.summary_log = atoi(value);
         else if (!strcmp(name, "summary-branches"))
                 ctx.cfg.summary_branches = atoi(value);
         else if (!strcmp(name, "summary-tags"))
                 ctx.cfg.summary_tags = atoi(value);
         else if (!strcmp(name, "side-by-side-diffs"))
                 ctx.cfg.ssdiff = atoi(value);
         else if (!strcmp(name, "agefile"))
                 ctx.cfg.agefile = xstrdup(value);
         else if (!strcmp(name, "renamelimit"))
                 ctx.cfg.renamelimit = atoi(value);
+        else if (!strcmp(name, "remove-suffix"))
+                ctx.cfg.remove_suffix = atoi(value);
         else if (!strcmp(name, "robots"))
                 ctx.cfg.robots = xstrdup(value);
         else if (!strcmp(name, "clone-prefix"))
                 ctx.cfg.clone_prefix = xstrdup(value);
         else if (!strcmp(name, "local-time"))
                 ctx.cfg.local_time = atoi(value);
         else if (!prefixcmp(name, "mimetype."))
                 add_mimetype(name + 9, value);
         else if (!strcmp(name, "include"))
                 parse_configfile(expand_macros(value), config_cb);
 }
 
 static void querystring_cb(const char *name, const char *value)
 {
         if (!value)
                 value = "";
 
         if (!strcmp(name,"r")) {
                 ctx.qry.repo = xstrdup(value);
                 ctx.repo = cgit_get_repoinfo(value);
         } else if (!strcmp(name, "p")) {
                 ctx.qry.page = xstrdup(value);
         } else if (!strcmp(name, "url")) {
                 if (*value == '/')
@@ -265,58 +274,61 @@ static void querystring_cb(const char *name, const char *value)
         }
 }
 
 char *xstrdupn(const char *str)
 {
         return (str ? xstrdup(str) : NULL);
 }
 
 static void prepare_context(struct cgit_context *ctx)
 {
         memset(ctx, 0, sizeof(*ctx));
         ctx->cfg.agefile = "info/web/last-modified";
         ctx->cfg.nocache = 0;
         ctx->cfg.cache_size = 0;
         ctx->cfg.cache_dynamic_ttl = 5;
         ctx->cfg.cache_max_create_time = 5;
         ctx->cfg.cache_repo_ttl = 5;
         ctx->cfg.cache_root = CGIT_CACHE_ROOT;
         ctx->cfg.cache_root_ttl = 5;
         ctx->cfg.cache_scanrc_ttl = 15;
         ctx->cfg.cache_static_ttl = -1;
         ctx->cfg.css = "/cgit.css";
         ctx->cfg.logo = "/cgit.png";
         ctx->cfg.local_time = 0;
+        ctx->cfg.enable_gitweb_owner = 1;
         ctx->cfg.enable_tree_linenumbers = 1;
         ctx->cfg.max_repo_count = 50;
         ctx->cfg.max_commit_count = 50;
         ctx->cfg.max_lock_attempts = 5;
         ctx->cfg.max_msg_len = 80;
         ctx->cfg.max_repodesc_len = 80;
         ctx->cfg.max_blob_size = 0;
         ctx->cfg.max_stats = 0;
         ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s";
+        ctx->cfg.project_list = NULL;
         ctx->cfg.renamelimit = -1;
+        ctx->cfg.remove_suffix = 0;
         ctx->cfg.robots = "index, nofollow";
         ctx->cfg.root_title = "Git repository browser";
         ctx->cfg.root_desc = "a fast webinterface for the git dscm";
         ctx->cfg.script_name = CGIT_SCRIPT_NAME;
         ctx->cfg.section = "";
         ctx->cfg.summary_branches = 10;
         ctx->cfg.summary_log = 10;
         ctx->cfg.summary_tags = 10;
         ctx->cfg.max_atom_items = 10;
         ctx->cfg.ssdiff = 0;
         ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG"));
         ctx->env.http_host = xstrdupn(getenv("HTTP_HOST"));
         ctx->env.https = xstrdupn(getenv("HTTPS"));
         ctx->env.no_http = xstrdupn(getenv("NO_HTTP"));
         ctx->env.path_info = xstrdupn(getenv("PATH_INFO"));
         ctx->env.query_string = xstrdupn(getenv("QUERY_STRING"));
         ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD"));
         ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME"));
         ctx->env.server_name = xstrdupn(getenv("SERVER_NAME"));
         ctx->env.server_port = xstrdupn(getenv("SERVER_PORT"));
         ctx->page.mimetype = "text/html";
         ctx->page.charset = PAGE_ENCODING;
         ctx->page.filename = NULL;
         ctx->page.size = 0;
@@ -553,73 +565,84 @@ void print_repolist(FILE *f, struct cgit_repolist *list, int start)
                 print_repo(f, &list->repos[i]);
 }
 
 /* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'
  * and return 0 on success.
  */
 static int generate_cached_repolist(const char *path, const char *cached_rc)
 {
         char *locked_rc;
         int idx;
         FILE *f;
 
         locked_rc = xstrdup(fmt("%s.lock", cached_rc));
         f = fopen(locked_rc, "wx");
         if (!f) {
                 /* Inform about the error unless the lockfile already existed,
                  * since that only means we've got concurrent requests.
                  */
                 if (errno != EEXIST)
                         fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",
                                 locked_rc, strerror(errno), errno);
                 return errno;
         }
         idx = cgit_repolist.count;
-        scan_tree(path, repo_config);
+        if (ctx.cfg.project_list)
+                scan_projects(path, ctx.cfg.project_list, repo_config);
+        else
+                scan_tree(path, repo_config);
         print_repolist(f, &cgit_repolist, idx);
         if (rename(locked_rc, cached_rc))
                 fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",
                         locked_rc, cached_rc, strerror(errno), errno);
         fclose(f);
         return 0;
 }
 
 static void process_cached_repolist(const char *path)
 {
         struct stat st;
         char *cached_rc;
         time_t age;
+        unsigned long hash;
 
-        cached_rc = xstrdup(fmt("%s/rc-%8x", ctx.cfg.cache_root,
-                hash_str(path)));
+        hash = hash_str(path);
+        if (ctx.cfg.project_list)
+                hash += hash_str(ctx.cfg.project_list);
+        cached_rc = xstrdup(fmt("%s/rc-%8x", ctx.cfg.cache_root, hash));
 
         if (stat(cached_rc, &st)) {
                 /* Nothing is cached, we need to scan without forking. And
                  * if we fail to generate a cached repolist, we need to
                  * invoke scan_tree manually.
                  */
-                if (generate_cached_repolist(path, cached_rc))
-                        scan_tree(path, repo_config);
+                if (generate_cached_repolist(path, cached_rc)) {
+                        if (ctx.cfg.project_list)
+                                scan_projects(path, ctx.cfg.project_list,
+                                              repo_config);
+                        else
+                                scan_tree(path, repo_config);
+                }
                 return;
         }
 
         parse_configfile(cached_rc, config_cb);
 
         /* If the cached configfile hasn't expired, lets exit now */
         age = time(NULL) - st.st_mtime;
         if (age <= (ctx.cfg.cache_scanrc_ttl * 60))
                 return;
 
         /* The cached repolist has been parsed, but it was old. So lets
          * rescan the specified path and generate a new cached repolist
          * in a child-process to avoid latency for the current request.
          */
         if (fork())
                 return;
 
         exit(generate_cached_repolist(path, cached_rc));
 }
 
 static void cgit_parse_args(int argc, const char **argv)
 {
         int i;
         int scan = 0;
diff --git a/cgit.h b/cgit.h
index 32d9d2b..4090cd4 100644
--- a/cgit.h
+++ b/cgit.h
@@ -146,83 +146,86 @@ struct cgit_query {
         int nohead;
         char *sort;
         int showmsg;
         int ssdiff;
         int show_all;
         int context;
         int ignorews;
         char *vpath;
 };
 
 struct cgit_config {
         char *agefile;
         char *cache_root;
         char *clone_prefix;
         char *css;
         char *favicon;
         char *footer;
         char *head_include;
         char *header;
         char *index_header;
         char *index_info;
         char *logo;
         char *logo_link;
         char *module_link;
+        char *project_list;
         char *robots;
         char *root_title;
         char *root_desc;
         char *root_readme;
         char *script_name;
         char *section;
         char *virtual_root;
         int cache_size;
         int cache_dynamic_ttl;
         int cache_max_create_time;
         int cache_repo_ttl;
         int cache_root_ttl;
         int cache_scanrc_ttl;
         int cache_static_ttl;
         int embedded;
         int enable_filter_overrides;
+        int enable_gitweb_owner;
         int enable_index_links;
         int enable_log_filecount;
         int enable_log_linecount;
         int enable_remote_branches;
         int enable_subject_links;
         int enable_tree_linenumbers;
         int local_time;
         int max_atom_items;
         int max_repo_count;
         int max_commit_count;
         int max_lock_attempts;
         int max_msg_len;
         int max_repodesc_len;
         int max_blob_size;
         int max_stats;
         int nocache;
         int noplainemail;
         int noheader;
         int renamelimit;
+        int remove_suffix;
         int snapshots;
         int summary_branches;
         int summary_log;
         int summary_tags;
         int ssdiff;
         struct string_list mimetypes;
         struct cgit_filter *about_filter;
         struct cgit_filter *commit_filter;
         struct cgit_filter *source_filter;
 };
 
 struct cgit_page {
         time_t modified;
         time_t expires;
         size_t size;
         char *mimetype;
         char *charset;
         char *filename;
         char *etag;
         char *title;
         int status;
         char *statusmsg;
 };
 
diff --git a/cgitrc.5.txt b/cgitrc.5.txt
index a853522..5d77973 100644
--- a/cgitrc.5.txt
+++ b/cgitrc.5.txt
@@ -74,48 +74,53 @@ clone-prefix::
         Space-separated list of common prefixes which, when combined with a
         repository url, generates valid clone urls for the repository. This
         setting is only used if `repo.clone-url` is unspecified. Default value:
         none.
 
 commit-filter::
         Specifies a command which will be invoked to format commit messages.
         The command will get the message on its STDIN, and the STDOUT from the
         command will be included verbatim as the commit message, i.e. this can
         be used to implement bugtracker integration. Default value: none.
 
 css::
         Url which specifies the css document to include in all cgit pages.
         Default value: "/cgit.css".
 
 embedded::
         Flag which, when set to "1", will make cgit generate a html fragment
         suitable for embedding in other html pages. Default value: none. See
         also: "noheader".
         
 enable-filter-overrides::
         Flag which, when set to "1", allows all filter settings to be
         overridden in repository-specific cgitrc files. Default value: none.
 
+enable-gitweb-owner::
+        If set to "1" and scan-path is enabled, we first check each repository
+        for the git config value "gitweb.owner" to determine the owner.
+        Default value: "1". See also: scan-path.
+
 enable-index-links::
         Flag which, when set to "1", will make cgit generate extra links for
         each repo in the repository index (specifically, to the "summary",
         "commit" and "tree" pages). Default value: "0".
 
 enable-log-filecount::
         Flag which, when set to "1", will make cgit print the number of
         modified files for each commit on the repository log page. Default
         value: "0".
 
 enable-log-linecount::
         Flag which, when set to "1", will make cgit print the number of added
         and removed lines for each commit on the repository log page. Default
         value: "0".
 
 enable-remote-branches::
         Flag which, when set to "1", will make cgit display remote branches
         in the summary and refs views. Default value: "0". See also:
         "repo.enable-remote-branches".
 
 enable-subject-links::
         Flag which, when set to "1", will make cgit use the subject of the
         parent commit as link text when generating links to parent commits
         in commit view. Default value: "0". See also:
@@ -203,78 +208,91 @@ max-stats::
 
 mimetype.<ext>::
         Set the mimetype for the specified filename extension. This is used
         by the `plain` command when returning blob content.
 
 module-link::
         Text which will be used as the formatstring for a hyperlink when a
         submodule is printed in a directory listing. The arguments for the
         formatstring are the path and SHA1 of the submodule commit. Default
         value: "./?repo=%s&page=commit&id=%s"
 
 nocache::
         If set to the value "1" caching will be disabled. This settings is
         deprecated, and will not be honored starting with cgit-1.0. Default
         value: "0".
 
 noplainemail::
         If set to "1" showing full author email adresses will be disabled.
         Default value: "0".
 
 noheader::
         Flag which, when set to "1", will make cgit omit the standard header
         on all pages. Default value: none. See also: "embedded".
 
+project-list::
+        A list of subdirectories inside of scan-path, relative to it, that
+        should loaded as git repositories. This must be defined prior to
+        scan-path. Default value: none. See also: scan-path.
+
+remove-suffix::
+        If set to "1" and scan-path is enabled, if any repositories are found
+        with a suffix of ".git", this suffix will be removed for the url and
+        name. Default value: "0". See also: scan-path.
+
 renamelimit::
         Maximum number of files to consider when detecting renames. The value
          "-1" uses the compiletime value in git (for further info, look at
           `man git-diff`). Default value: "-1".
 
 repo.group::
         Legacy alias for "section". This option is deprecated and will not be
         supported in cgit-1.0.
 
 robots::
         Text used as content for the "robots" meta-tag. Default value:
         "index, nofollow".
 
 root-desc::
         Text printed below the heading on the repository index page. Default
         value: "a fast webinterface for the git dscm".
 
 root-readme::
         The content of the file specified with this option will be included
         verbatim below the "about" link on the repository index page. Default
         value: none.
 
 root-title::
         Text printed as heading on the repository index page. Default value:
         "Git Repository Browser".
 
 scan-path::
         A path which will be scanned for repositories. If caching is enabled,
         the result will be cached as a cgitrc include-file in the cache
-        directory. Default value: none. See also: cache-scanrc-ttl.
+        directory. If project-list has been defined prior to scan-path,
+        scan-path loads only the directories listed in the file pointed to by
+        project-list. Default value: none. See also: cache-scanrc-ttl,
+        project-list.
 
 section::
         The name of the current repository section - all repositories defined
         after this option will inherit the current section name. Default value:
         none.
 
 side-by-side-diffs::
         If set to "1" shows side-by-side diffs instead of unidiffs per
         default. Default value: "0".
 
 snapshots::
         Text which specifies the default set of snapshot formats generated by
         cgit. The value is a space-separated list of zero or more of the
         values "tar", "tar.gz", "tar.bz2" and "zip". Default value: none.
 
 source-filter::
         Specifies a command which will be invoked to format plaintext blobs
         in the tree view. The command will get the blob content on its STDIN
         and the name of the blob as its only command line argument. The STDOUT
         from the command will be included verbatim as the blob contents, i.e.
         this can be used to implement e.g. syntax highlighting. Default value:
         none.
 
 summary-branches::
@@ -509,24 +527,25 @@ repo.snapshots=0
 # Disable line-counts for this repo
 repo.enable-log-linecount=0
 
 # Restrict the max statistics period for this repo
 repo.max-stats=month
 ....
 
 
 BUGS
 ----
 Comments currently cannot appear on the same line as a setting; the comment
 will be included as part of the value. E.g. this line:
 
         robots=index  # allow indexing
 
 will generate the following html element:
 
         <meta name='robots' content='index  # allow indexing'/>
 
 
 
 AUTHOR
 ------
 Lars Hjemli <hjemli@gmail.com>
+Jason A. Donenfeld <Jason@zx2c4.com>
diff --git a/scan-tree.c b/scan-tree.c
index 1e18f3c..e987824 100644
--- a/scan-tree.c
+++ b/scan-tree.c
@@ -1,104 +1,131 @@
+/* scan-tree.c
+ * 
+ * Copyright (C) 2008-2009 Lars Hjemli
+ * Copyright (C) 2010 Jason A. Donenfeld <Jason@zx2c4.com>
+ *
+ * Licensed under GNU General Public License v2
+ *   (see COPYING for full license text)
+ */
+
 #include "cgit.h"
 #include "configfile.h"
 #include "html.h"
 
 #define MAX_PATH 4096
 
 /* 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];
 
         if (snprintf(buf, MAX_PATH, "%s/objects", path) >= MAX_PATH) {
                 fprintf(stderr, "Insanely long path: %s\n", path);
                 return 0;
         }
         if (stat(buf, &st)) {
                 if (errno != ENOENT)
                         fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                 path, strerror(errno), errno);
                 return 0;
         }
         if (!S_ISDIR(st.st_mode))
                 return 0;
 
         sprintf(buf, "%s/HEAD", path);
         if (stat(buf, &st)) {
                 if (errno != ENOENT)
                         fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                 path, strerror(errno), errno);
                 return 0;
         }
         if (!S_ISREG(st.st_mode))
                 return 0;
 
         return 1;
 }
 
 struct cgit_repo *repo;
 repo_config_fn config_fn;
+char *owner;
 
 static void repo_config(const char *name, const char *value)
 {
         config_fn(repo, name, value);
 }
 
+static int git_owner_config(const char *key, const char *value, void *cb)
+{
+        if (!strcmp(key, "gitweb.owner"))
+                owner = xstrdup(value);
+        return 0;
+}
+
 static void add_repo(const char *base, const char *path, repo_config_fn fn)
 {
         struct stat st;
         struct passwd *pwd;
         char *p;
         size_t size;
 
         if (stat(path, &st)) {
                 fprintf(stderr, "Error accessing %s: %s (%d)\n",
                         path, strerror(errno), errno);
                 return;
         }
         if (!stat(fmt("%s/noweb", path), &st))
                 return;
-        if ((pwd = getpwuid(st.st_uid)) == NULL) {
-                fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",
-                        path, strerror(errno), errno);
-                return;
-        }
+
+        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);
         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);
-        p = (pwd && pwd->pw_gecos) ? strchr(pwd->pw_gecos, ',') : NULL;
-        if (p)
-                *p = '\0';
-        repo->owner = (pwd ? xstrdup(pwd->pw_gecos ? pwd->pw_gecos : pwd->pw_name) : "");
+        while (!owner) {
+                if ((pwd = getpwuid(st.st_uid)) == NULL) {
+                        fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",
+                                path, strerror(errno), errno);
+                        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 = 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";
 
         p = fmt("%s/cgitrc", path);
         if (!stat(p, &st)) {
                 config_fn = fn;
                 parse_configfile(xstrdup(p), &repo_config);
         }
 }
 
 static void scan_path(const char *base, const char *path, repo_config_fn fn)
 {
         DIR *dir;
         struct dirent *ent;
         char *buf;
         struct stat st;
 
         if (is_git_dir(path)) {
@@ -121,28 +148,56 @@ static void scan_path(const char *base, const char *path, repo_config_fn fn)
                                 continue;
                         if (ent->d_name[1] == '.' && ent->d_name[2] == '\0')
                                 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)) {
                         fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                 buf, strerror(errno), errno);
                         free(buf);
                         continue;
                 }
                 if (S_ISDIR(st.st_mode))
                         scan_path(base, buf, fn);
                 free(buf);
         }
         closedir(dir);
 }
 
+#define lastc(s) s[strlen(s) - 1]
+
+void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn)
+{
+        char line[MAX_PATH * 2], *z;
+        FILE *projects;
+        int err;
+        
+        projects = fopen(projectsfile, "r");
+        if (!projects) {
+                fprintf(stderr, "Error opening projectsfile %s: %s (%d)\n",
+                        projectsfile, strerror(errno), errno);
+        }
+        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);
+        }
+        if ((err = ferror(projects))) {
+                fprintf(stderr, "Error reading from projectsfile %s: %s (%d)\n",
+                        projectsfile, strerror(err), err);
+        }
+        fclose(projects);
+}
+
 void scan_tree(const char *path, repo_config_fn fn)
 {
         scan_path(path, path, fn);
 }
diff --git a/scan-tree.h b/scan-tree.h
index 11539f4..1afbd4b 100644
--- a/scan-tree.h
+++ b/scan-tree.h
@@ -1,3 +1,2 @@
-
-
+extern void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn);
 extern void scan_tree(const char *path, repo_config_fn fn);