use cgit_httpscheme() for atom feed

[cgit.git] / ui-snapshot.c

diff --git a/ui-snapshot.c b/ui-snapshot.c
index bd34a28a41713cccffff7a52742e4a61038e0544..5372f5d3d8b42a474713fe0867f4b50d96f5acf1 100644 (file)
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -7,6 +7,8 @@
  */
 
 #include "cgit.h"
  */
 
 #include "cgit.h"

+#include "html.h"
+#include "ui-shared.h"

 
 static int write_compressed_tar_archive(struct archiver_args *args,const char *filter)
 {
 
 static int write_compressed_tar_archive(struct archiver_args *args,const char *filter)
 {


@@ -54,102 +56,150 @@ static int write_tar_bzip2_archive(struct archiver_args *args)
        return write_compressed_tar_archive(args,"bzip2");
 }
 
        return write_compressed_tar_archive(args,"bzip2");
 }
 

-static const struct snapshot_archive_t {
-       const char *suffix;
-       const char *mimetype;
-       write_archive_fn_t write_func;
-       int bit;
-}      snapshot_archives[] = {
+const struct cgit_snapshot_format cgit_snapshot_formats[] = {

        { ".zip", "application/x-zip", write_zip_archive, 0x1 },
        { ".zip", "application/x-zip", write_zip_archive, 0x1 },

-       { ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 },
-       { ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 },
-       { ".tar", "application/x-tar", write_tar_archive, 0x8 }
+       { ".tar.gz", "application/x-gzip", write_tar_gzip_archive, 0x2 },
+       { ".tar.bz2", "application/x-bzip2", write_tar_bzip2_archive, 0x4 },
+       { ".tar", "application/x-tar", write_tar_archive, 0x8 },
+       {}

 };
 
 };
 

-#define snapshot_archives_len (sizeof(snapshot_archives) / sizeof(*snapshot_archives))
+static const struct cgit_snapshot_format *get_format(const char *filename)
+{
+       const struct cgit_snapshot_format *fmt;
+       int fl, sl;
+
+       fl = strlen(filename);
+       for(fmt = cgit_snapshot_formats; fmt->suffix; fmt++) {
+               sl = strlen(fmt->suffix);
+               if (sl >= fl)
+                       continue;
+               if (!strcmp(fmt->suffix, filename + fl - sl))
+                       return fmt;
+       }
+       return NULL;
+}

 
 

-void cgit_print_snapshot(struct cacheitem *item, const char *head,
+static int make_snapshot(const struct cgit_snapshot_format *format,

                         const char *hex, const char *prefix,
                         const char *hex, const char *prefix,

-                        const char *filename, int snapshots)
+                        const char *filename)

 {
 {

-       const struct snapshot_archive_t* sat;

        struct archiver_args args;
        struct commit *commit;
        unsigned char sha1[20];
        struct archiver_args args;
        struct commit *commit;
        unsigned char sha1[20];

-       int f, sl, fnl = strlen(filename);

 
 

-       for(f=0; f<snapshot_archives_len; f++) {
-               sat = &snapshot_archives[f];
-               if(!(snapshots & sat->bit))
-                       continue;
-               sl = strlen(sat->suffix);
-               if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix))
-                       continue;
-               if (!hex)
-                       hex = head;
-               if(get_sha1(hex, sha1)) {
-                       cgit_print_error(fmt("Bad object id: %s", hex));
-                       return;
-               }
-               commit = lookup_commit_reference(sha1);
-               if(!commit) {
-                       cgit_print_error(fmt("Not a commit reference: %s", hex));
-                       return;;
-               }
-               memset(&args,0,sizeof(args));
+       if(get_sha1(hex, sha1)) {
+               cgit_print_error(fmt("Bad object id: %s", hex));
+               return 1;
+       }
+       commit = lookup_commit_reference(sha1);
+       if(!commit) {
+               cgit_print_error(fmt("Not a commit reference: %s", hex));
+               return 1;
+       }
+       memset(&args, 0, sizeof(args));
+       if (prefix) {

                args.base = fmt("%s/", prefix);
                args.base = fmt("%s/", prefix);

-               args.tree = commit->tree;
-               cgit_print_snapshot_start(sat->mimetype, filename, item);
-               (*sat->write_func)(&args);
-               return;
+               args.baselen = strlen(prefix) + 1;
+       } else {
+               args.base = "";
+               args.baselen = 0;

        }
        }

-       cgit_print_error(fmt("Unsupported snapshot format: %s", filename));
+       args.tree = commit->tree;
+       args.time = commit->date;
+       ctx.page.mimetype = xstrdup(format->mimetype);
+       ctx.page.filename = xstrdup(filename);
+       cgit_print_http_headers(&ctx);
+       format->write_func(&args);
+       return 0;

 }
 
 }
 

-void cgit_print_snapshot_links(const char *repo, const char *head,
-                              const char *hex, int snapshots)
+/* Try to guess the requested revision from the requested snapshot name.
+ * First the format extension is stripped, e.g. "cgit-0.7.2.tar.gz" become
+ * "cgit-0.7.2". If this is a valid commit object name we've got a winner.
+ * Otherwise, if the snapshot name has a prefix matching the result from
+ * repo_basename(), we strip the basename and any following '-' and '_'
+ * characters ("cgit-0.7.2" -> "0.7.2") and check the resulting name once
+ * more. If this still isn't a valid commit object name, we check if pre-
+ * pending a 'v' to the remaining snapshot name ("0.7.2" -> "v0.7.2") gives
+ * us something valid.
+ */
+static const char *get_ref_from_filename(const char *url, const char *filename,
+                                        const struct cgit_snapshot_format *format)

 {
 {

-       const struct snapshot_archive_t* sat;
-       char *filename;
-       int f;
+       const char *reponame;
+       unsigned char sha1[20];
+       char *snapshot;

 
 

-       for(f=0; f<snapshot_archives_len; f++) {
-               sat = &snapshot_archives[f];
-               if(!(snapshots & sat->bit))
-                       continue;
-               filename = fmt("%s-%s%s", cgit_repobasename(repo), hex,
-                              sat->suffix);
-               cgit_snapshot_link(filename, NULL, NULL, (char *)head,
-                                  (char *)hex, filename);
-               html("<br/>");
+       snapshot = xstrdup(filename);
+       snapshot[strlen(snapshot) - strlen(format->suffix)] = '\0';
+       fprintf(stderr, "snapshot=%s\n", snapshot);
+
+       if (get_sha1(snapshot, sha1) == 0)
+               return snapshot;
+
+       reponame = cgit_repobasename(url);
+       fprintf(stderr, "reponame=%s\n", reponame);
+       if (prefixcmp(snapshot, reponame) == 0) {
+               snapshot += strlen(reponame);
+               while (snapshot && (*snapshot == '-' || *snapshot == '_'))
+                       snapshot++;

        }
        }

+
+       if (get_sha1(snapshot, sha1) == 0)
+               return snapshot;
+
+       snapshot = fmt("v%s", snapshot);
+       if (get_sha1(snapshot, sha1) == 0)
+               return snapshot;
+
+       return NULL;

 }
 
 }
 

-int cgit_parse_snapshots_mask(const char *str)
+void show_error(char *msg)

 {
 {

-       const struct snapshot_archive_t* sat;
-       static const char *delim = " \t,:/|;";
-       int f, tl, rv = 0;
+       ctx.page.mimetype = "text/html";
+       cgit_print_http_headers(&ctx);
+       cgit_print_docstart(&ctx);
+       cgit_print_pageheader(&ctx);
+       cgit_print_error(msg);
+       cgit_print_docend();
+}

 
 

-       /* favor legacy setting */
-       if(atoi(str))
-               return 1;
-       for(;;) {
-               str += strspn(str,delim);
-               tl = strcspn(str,delim);
-               if(!tl)
-                       break;
-               for(f=0; f<snapshot_archives_len; f++) {
-                       sat = &snapshot_archives[f];
-                       if(!(strncmp(sat->suffix, str, tl) &&
-                            strncmp(sat->suffix+1, str, tl-1))) {
-                               rv |= sat->bit;
-                               break;
-                       }
+void cgit_print_snapshot(const char *head, const char *hex,
+                        const char *filename, int snapshots, int dwim)
+{
+       const struct cgit_snapshot_format* f;
+       char *prefix = NULL;
+
+       if (!filename) {
+               show_error("No snapshot name specified");
+               return;
+       }
+
+       f = get_format(filename);
+       if (!f) {
+               show_error(xstrdup(fmt("Unsupported snapshot format: %s",
+                                      filename)));
+               return;
+       }
+
+       if (!hex && dwim) {
+               hex = get_ref_from_filename(ctx.repo->url, filename, f);
+               if (hex == NULL) {
+                       html_status(404, "Not found", 0);
+                       return;

                }
                }

-               str += tl;
+               prefix = xstrdup(filename);
+               prefix[strlen(filename) - strlen(f->suffix)] = '\0';

        }
        }

-       return rv;
-}

 
 

-/* vim:set sw=8: */
+       if (!hex)
+               hex = head;
+
+       if (!prefix)
+               prefix = xstrdup(cgit_repobasename(ctx.repo->url));
+
+       make_snapshot(f, hex, prefix, filename);
+       free(prefix);
+}