1 files changed, 12 insertions, 2 deletions

diff --git a/ui-snapshot.c b/ui-snapshot.c
index 9c4d086..76457d6 100644
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -117,72 +117,82 @@ static int make_snapshot(const struct cgit_snapshot_format *format,
 char *dwim_filename = NULL;
 const char *dwim_refname = NULL;
 
 static int ref_cb(const char *refname, const unsigned char *sha1, int flags,
                   void *cb_data)
 {
         const char *r = refname;
         while (r && *r) {
                 fprintf(stderr, "  cmp %s with %s:", dwim_filename, r);
                 if (!strcmp(dwim_filename, r)) {
                         fprintf(stderr, "MATCH!\n");
                         dwim_refname = refname;
                         return 1;
                 }
                 fprintf(stderr, "no match\n");
                 if (isdigit(*r))
                         break;
                 r++;
         }
         return 0;
 }
 
 /* Try to guess the requested revision by combining repo name and tag name
  * and comparing this to the requested snapshot name. E.g. the requested
  * snapshot is "cgit-0.7.2.tar.gz" while repo name is "cgit" and tag name
  * is "v0.7.2". First, the reponame is stripped off, leaving "-0.7.2.tar.gz".
  * Next, any '-' and '_' characters are stripped, leaving "0.7.2.tar.gz".
  * Finally, the requested format suffix is removed and we end up with "0.7.2".
  * Then we test each tag against this dwimmed filename, and for each tag
  * we even try to remove any leading characters which are non-digits. I.e.
  * we first compare with "v0.7.2", then with "0.7.2" and we've got a match.
  */
 static const char *get_ref_from_filename(const char *url, const char *filename,
                                          const struct cgit_snapshot_format *fmt)
 {
         const char *reponame = cgit_repobasename(url);
         fprintf(stderr, "reponame=%s, filename=%s\n", reponame, filename);
         if (prefixcmp(filename, reponame))
                 return NULL;
         filename += strlen(reponame);
         while (filename && (*filename == '-' || *filename == '_'))
                 filename++;
         dwim_filename = xstrdup(filename);
         dwim_filename[strlen(filename) - strlen(fmt->suffix)] = '\0';
         for_each_tag_ref(ref_cb, NULL);
         return dwim_refname;
 }
 
-void cgit_print_snapshot(const char *head, const char *hex, const char *prefix,
+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;
 
         f = get_format(filename);
         if (!f) {
                 ctx.page.mimetype = "text/html";
                 cgit_print_http_headers(&ctx);
                 cgit_print_docstart(&ctx);
                 cgit_print_pageheader(&ctx);
                 cgit_print_error(fmt("Unsupported snapshot format: %s", filename));
                 cgit_print_docend();
                 return;
         }
 
-        if (!hex && dwim)
+        if (!hex && dwim) {
                 hex = get_ref_from_filename(ctx.repo->url, filename, f);
+                if (hex != NULL) {
+                        prefix = xstrdup(filename);
+                        prefix[strlen(filename) - strlen(f->suffix)] = '\0';
+                }
+        }
 
         if (!hex)
                 hex = head;
 
+        if (!prefix)
+                prefix = xstrdup(cgit_repobasename(ctx.repo->url));
+
         make_snapshot(f, hex, prefix, filename);
+        free(prefix);
 }