gout

gout.c (4946B)

---

 #include "gout.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "git/commit.h"
 #include "git/file.h"
 #include "git/git.h"
 #include "git/reference.h"
 #include "git/repo.h"
 #include "security.h"
 #include "utils.h"
 #include "writer/repo_writer.h"
 
 struct GoutOptions {
   const char* repodir;
   long long log_commit_limit; /* -1 indicates not used */
   const char* cachefile_path;
   const char* baseurl; /* base URL to make absolute RSS/Atom URI */
   RepoWriterType writer_type;
 };
 
 static void commit_callback(const GitCommit* commit, void* user_data);
 static void reference_callback(const GitReference* ref, void* user_data);
 static void file_callback(const GitFile* file, void* user_data);
 
 GoutOptions* gout_options_create(int argc, const char* argv[]) {
   GoutOptions options = {
       .repodir = NULL,
       .log_commit_limit = -1,
       .cachefile_path = NULL,
       .baseurl = "",
       .writer_type = kRepoWriterTypeHtml,
   };
   for (int i = 1; i < argc; i++) {
     if (argv[i][0] != '-') {
       // Cannot specify more than one repo directory.
       if (options.repodir) {
         return NULL;
       }
       options.repodir = argv[i];
     } else if (argv[i][1] == 'c') {
       // Cache the entries of the log page up to the point of the last commit.
       // The cachefile will store the last commit id and the entries in the
       // HTML table.  It is up to the user to make sure the state of the
       // cachefile is in sync with the history of the repository.
 
       // Mutually exclusive with -l.
       if (options.log_commit_limit > 0) {
         return NULL;
       }
       // Requires cachefile path argument.
       if (i + 1 >= argc) {
         return NULL;
       }
       options.cachefile_path = argv[++i];
     } else if (argv[i][1] == 'l') {
       // Write a maximum number of commits to the log.html file only.  However
       // the commit files are written as usual.
 
       // Mutually exclusive with -c option.
       if (options.cachefile_path) {
         return NULL;
       }
       // Requires log commits argument.
       if (i + 1 >= argc) {
         return NULL;
       }
       errno = 0;
       char* p;
       options.log_commit_limit = strtoll(argv[++i], &p, 10);
       if (!argv[i][0] || *p || options.log_commit_limit <= 0 || errno) {
         return NULL;
       }
     } else if (argv[i][1] == 'u') {
       // Requires log commits argument.
       if (i + 1 >= argc) {
         return NULL;
       }
       options.baseurl = argv[++i];
     } else if (argv[i][1] == 'H') {
       options.writer_type = kRepoWriterTypeHtml;
     } else if (argv[i][1] == 'G') {
       options.writer_type = kRepoWriterTypeGopher;
     }
   }
   // Must specify at least one repo directory.
   if (!options.repodir) {
     return NULL;
   }
   GoutOptions* options_out = ecalloc(1, sizeof(GoutOptions));
   *options_out = options;
   return options_out;
 }
 
 void gout_options_free(GoutOptions* options) {
   if (!options) {
     return;
   }
   options->repodir = NULL;
   options->log_commit_limit = -1;
   options->cachefile_path = NULL;
   options->baseurl = NULL;
   free(options);
 }
 
 void gout_init(const GoutOptions* options) {
   const char* readonly_paths[] = {options->repodir};
   size_t readonly_paths_count = 1;
   const char* readwrite_paths[2] = {".", NULL};
   size_t readwrite_paths_count = 1;
   if (options->cachefile_path) {
     readwrite_paths[1] = options->cachefile_path;
     readwrite_paths_count = 2;
   }
   restrict_filesystem_access(readonly_paths, readonly_paths_count,
                              readwrite_paths, readwrite_paths_count);
   restrict_system_operations(
       options->cachefile_path != NULL ? kGoutWithCachefile : kGout);
 
   gout_git_initialize();
 }
 
 void gout_run(const GoutOptions* options) {
   GitRepo* repo = gitrepo_create(options->repodir);
   RepoWriter* writer = repowriter_create(options->writer_type, repo);
   if (options->log_commit_limit >= 0) {
     repowriter_set_log_commit_limit(writer, options->log_commit_limit);
   }
   if (options->cachefile_path) {
     repowriter_set_log_cachefile(writer, options->cachefile_path);
   }
   if (options->baseurl) {
     repowriter_set_baseurl(writer, options->baseurl);
   }
 
   repowriter_begin(writer);
   gitrepo_for_each_commit(repo, commit_callback, writer);
   gitrepo_for_each_reference(repo, reference_callback, writer);
   gitrepo_for_each_file(repo, file_callback, writer);
   repowriter_end(writer);
 
   repowriter_free(writer);
   gitrepo_free(repo);
 }
 
 void gout_shutdown(void) {
   gout_git_shutdown();
 }
 
 void commit_callback(const GitCommit* ci, void* user_data) {
   RepoWriter* writer = (RepoWriter*)user_data;
   repowriter_add_commit(writer, ci);
 }
 
 void reference_callback(const GitReference* ref, void* user_data) {
   RepoWriter* writer = (RepoWriter*)user_data;
   repowriter_add_reference(writer, ref);
 }
 
 void file_callback(const GitFile* file, void* user_data) {
   RepoWriter* writer = (RepoWriter*)user_data;
   repowriter_add_file(writer, file);
 }