Merge branch 'stable'

* stable:
  CGIT 0.7.2
  Use GIT-1.5.3.8
  Compare string lengths when parsing the snapshot mask
  Default repo description to "[no description]"

4 files changed, 7 insertions, 6 deletions

diff --git a/Makefile b/Makefile
index eed59df..e39be18 100644
--- a/Makefile
+++ b/Makefile
@@ -1,83 +1,83 @@
-CGIT_VERSION = v0.7.1
+CGIT_VERSION = v0.7.2
 CGIT_SCRIPT_NAME = cgit.cgi
 CGIT_SCRIPT_PATH = /var/www/htdocs/cgit
 CGIT_CONFIG = /etc/cgitrc
 CACHE_ROOT = /var/cache/cgit
 SHA1_HEADER = <openssl/sha.h>
-GIT_VER = 1.5.3.5
+GIT_VER = 1.5.3.8
 GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2
 
 #
 # Let the user override the above settings.
 #
 -include cgit.conf
 
 
 EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lcrypto
 OBJECTS = shared.o cache.o parsing.o html.o ui-shared.o ui-repolist.o \
 	ui-summary.o ui-log.o ui-tree.o ui-commit.o ui-diff.o \
 	ui-snapshot.o ui-blob.o ui-tag.o ui-refs.o ui-patch.o
 
 
 ifdef NEEDS_LIBICONV
 	EXTLIBS += -liconv
 endif
 
 
 .PHONY: all git test install clean distclean emptycache force-version get-git
 
 all: cgit git
 
 VERSION: force-version
 	@./gen-version.sh "$(CGIT_VERSION)"
 -include VERSION
 
 
 CFLAGS += -g -Wall -Igit
 CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)'
 CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"'
 CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'
 CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'
 CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"'
 
 
 cgit: cgit.c $(OBJECTS)
 	$(CC) $(CFLAGS) cgit.c -o cgit $(OBJECTS) $(EXTLIBS)
 
 $(OBJECTS): cgit.h git/xdiff/lib.a git/libgit.a VERSION
 
 git/xdiff/lib.a: | git
 
 git/libgit.a: | git
 
 git:
 	cd git && $(MAKE) xdiff/lib.a
 	cd git && $(MAKE) libgit.a
 
 test: all
 	$(MAKE) -C tests
 
 install: all
 	mkdir -p $(DESTDIR)$(CGIT_SCRIPT_PATH)
 	install cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
 	install cgit.css $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.css
 	install cgit.png $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.png
 
 uninstall:
 	rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
 	rm -f $(CGIT_SCRIPT_PATH)/cgit.css
 	rm -f $(CGIT_SCRIPT_PATH)/cgit.png
 
 clean:
 	rm -f cgit VERSION *.o
 	cd git && $(MAKE) clean
 
 distclean: clean
 	git clean -d -x
 	cd git && git clean -d -x
 
 emptycache:
 	rm -rf $(DESTDIR)$(CACHE_ROOT)/*
 
 get-git:
 	curl $(GIT_URL) | tar -xj && rm -rf git && mv git-$(GIT_VER) git
diff --git a/git b/git
-Subproject 3f2a7ae2c84c921e11041a5edc2522964fc1cce
+Subproject aadd4efa715f56e0eac5ac459c8ff4933b56d4c
diff --git a/shared.c b/shared.c
index 9c992c8..bf0581f 100644
--- a/shared.c
+++ b/shared.c
@@ -25,193 +25,193 @@ char *cgit_agefile      = "info/web/last-modified";
 char *cgit_virtual_root = NULL;
 char *cgit_script_name  = CGIT_SCRIPT_NAME;
 char *cgit_cache_root   = CGIT_CACHE_ROOT;
 char *cgit_repo_group   = NULL;
 char *cgit_robots       = "index, nofollow";
 char *cgit_clone_prefix = NULL;
 
 int cgit_nocache               =  0;
 int cgit_snapshots             =  0;
 int cgit_enable_index_links    =  0;
 int cgit_enable_log_filecount  =  0;
 int cgit_enable_log_linecount  =  0;
 int cgit_max_lock_attempts     =  5;
 int cgit_cache_root_ttl        =  5;
 int cgit_cache_repo_ttl        =  5;
 int cgit_cache_dynamic_ttl     =  5;
 int cgit_cache_static_ttl      = -1;
 int cgit_cache_max_create_time =  5;
 int cgit_summary_log           =  0;
 int cgit_summary_tags          =  0;
 int cgit_summary_branches      =  0;
 int cgit_renamelimit           = -1;
 
 int cgit_max_msg_len = 60;
 int cgit_max_repodesc_len = 60;
 int cgit_max_commit_count = 50;
 
 int cgit_query_has_symref = 0;
 int cgit_query_has_sha1   = 0;
 
 char *cgit_querystring  = NULL;
 char *cgit_query_repo   = NULL;
 char *cgit_query_page   = NULL;
 char *cgit_query_head   = NULL;
 char *cgit_query_search = NULL;
 char *cgit_query_grep   = NULL;
 char *cgit_query_sha1   = NULL;
 char *cgit_query_sha2   = NULL;
 char *cgit_query_path   = NULL;
 char *cgit_query_name   = NULL;
 int   cgit_query_ofs    = 0;
 
 int htmlfd = 0;
 
 
 int cgit_get_cmd_index(const char *cmd)
 {
 	static char *cmds[] = {"log", "commit", "diff", "tree", "blob",
 			       "snapshot", "tag", "refs", "patch", NULL};
 	int i;
 
 	for(i = 0; cmds[i]; i++)
 		if (!strcmp(cmd, cmds[i]))
 			return i + 1;
 	return 0;
 }
 
 int chk_zero(int result, char *msg)
 {
 	if (result != 0)
 		die("%s: %s", msg, strerror(errno));
 	return result;
 }
 
 int chk_positive(int result, char *msg)
 {
 	if (result <= 0)
 		die("%s: %s", msg, strerror(errno));
 	return result;
 }
 
 int chk_non_negative(int result, char *msg)
 {
     	if (result < 0)
 	    	die("%s: %s",msg, strerror(errno));
 	return result;
 }
 
 struct repoinfo *add_repo(const char *url)
 {
 	struct repoinfo *ret;
 
 	if (++cgit_repolist.count > cgit_repolist.length) {
 		if (cgit_repolist.length == 0)
 			cgit_repolist.length = 8;
 		else
 			cgit_repolist.length *= 2;
 		cgit_repolist.repos = xrealloc(cgit_repolist.repos,
 					       cgit_repolist.length *
 					       sizeof(struct repoinfo));
 	}
 
 	ret = &cgit_repolist.repos[cgit_repolist.count-1];
 	ret->url = trim_end(url, '/');
 	ret->name = ret->url;
 	ret->path = NULL;
-	ret->desc = NULL;
+	ret->desc = "[no description]";
 	ret->owner = NULL;
 	ret->group = cgit_repo_group;
 	ret->defbranch = "master";
 	ret->snapshots = cgit_snapshots;
 	ret->enable_log_filecount = cgit_enable_log_filecount;
 	ret->enable_log_linecount = cgit_enable_log_linecount;
 	ret->module_link = cgit_module_link;
 	ret->readme = NULL;
 	return ret;
 }
 
 struct repoinfo *cgit_get_repoinfo(const char *url)
 {
 	int i;
 	struct repoinfo *repo;
 
 	for (i=0; i<cgit_repolist.count; i++) {
 		repo = &cgit_repolist.repos[i];
 		if (!strcmp(repo->url, url))
 			return repo;
 	}
 	return NULL;
 }
 
 void cgit_global_config_cb(const char *name, const char *value)
 {
 	if (!strcmp(name, "root-title"))
 		cgit_root_title = xstrdup(value);
 	else if (!strcmp(name, "css"))
 		cgit_css = xstrdup(value);
 	else if (!strcmp(name, "logo"))
 		cgit_logo = xstrdup(value);
 	else if (!strcmp(name, "index-header"))
 		cgit_index_header = xstrdup(value);
 	else if (!strcmp(name, "index-info"))
 		cgit_index_info = xstrdup(value);
 	else if (!strcmp(name, "logo-link"))
 		cgit_logo_link = xstrdup(value);
 	else if (!strcmp(name, "module-link"))
 		cgit_module_link = xstrdup(value);
 	else if (!strcmp(name, "virtual-root")) {
 		cgit_virtual_root = trim_end(value, '/');
 		if (!cgit_virtual_root && (!strcmp(value, "/")))
 			cgit_virtual_root = "";
 	} else if (!strcmp(name, "nocache"))
 		cgit_nocache = atoi(value);
 	else if (!strcmp(name, "snapshots"))
 		cgit_snapshots = cgit_parse_snapshots_mask(value);
 	else if (!strcmp(name, "enable-index-links"))
 		cgit_enable_index_links = atoi(value);
 	else if (!strcmp(name, "enable-log-filecount"))
 		cgit_enable_log_filecount = atoi(value);
 	else if (!strcmp(name, "enable-log-linecount"))
 		cgit_enable_log_linecount = atoi(value);
 	else if (!strcmp(name, "cache-root"))
 		cgit_cache_root = xstrdup(value);
 	else if (!strcmp(name, "cache-root-ttl"))
 		cgit_cache_root_ttl = atoi(value);
 	else if (!strcmp(name, "cache-repo-ttl"))
 		cgit_cache_repo_ttl = atoi(value);
 	else if (!strcmp(name, "cache-static-ttl"))
 		cgit_cache_static_ttl = atoi(value);
 	else if (!strcmp(name, "cache-dynamic-ttl"))
 		cgit_cache_dynamic_ttl = atoi(value);
 	else if (!strcmp(name, "max-message-length"))
 		cgit_max_msg_len = atoi(value);
 	else if (!strcmp(name, "max-repodesc-length"))
 		cgit_max_repodesc_len = atoi(value);
 	else if (!strcmp(name, "max-commit-count"))
 		cgit_max_commit_count = atoi(value);
 	else if (!strcmp(name, "summary-log"))
 		cgit_summary_log = atoi(value);
 	else if (!strcmp(name, "summary-branches"))
 		cgit_summary_branches = atoi(value);
 	else if (!strcmp(name, "summary-tags"))
 		cgit_summary_tags = atoi(value);
 	else if (!strcmp(name, "agefile"))
 		cgit_agefile = xstrdup(value);
 	else if (!strcmp(name, "renamelimit"))
 		cgit_renamelimit = atoi(value);
 	else if (!strcmp(name, "robots"))
 		cgit_robots = xstrdup(value);
 	else if (!strcmp(name, "clone-prefix"))
 		cgit_clone_prefix = xstrdup(value);
 	else if (!strcmp(name, "repo.group"))
 		cgit_repo_group = xstrdup(value);
 	else if (!strcmp(name, "repo.url"))
 		cgit_repo = add_repo(value);
 	else if (!strcmp(name, "repo.name"))
 		cgit_repo->name = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.path"))
 		cgit_repo->path = trim_end(value, '/');
 	else if (cgit_repo && !strcmp(name, "repo.clone-url"))
 		cgit_repo->clone_url = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.desc"))
 		cgit_repo->desc = xstrdup(value);
diff --git a/ui-snapshot.c b/ui-snapshot.c
index 4d1aa88..dfedd8f 100644
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -37,120 +37,121 @@ static int write_compressed_tar_archive(struct archiver_args *args,const char *f
 	chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT");
 	chk_zero(close(stdout2), "Closing uncompressed STDOUT");
 	chk_zero(close(rw[1]), "Closing write end of pipe in parent");
 	chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process");
 	if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) )
 		cgit_print_error("Failed to compress archive");
 
 	return rv;
 }
 
 static int write_tar_gzip_archive(struct archiver_args *args)
 {
 	return write_compressed_tar_archive(args,"gzip");
 }
 
 static int write_tar_bzip2_archive(struct archiver_args *args)
 {
 	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[] = {
 	{ ".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 }
 };
 
 #define snapshot_archives_len (sizeof(snapshot_archives) / sizeof(*snapshot_archives))
 
 void cgit_print_snapshot(struct cacheitem *item, const char *head,
 			 const char *hex, const char *prefix,
 			 const char *filename, int snapshots)
 {
 	const struct snapshot_archive_t* sat;
 	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));
 		args.base = fmt("%s/", prefix);
 		args.tree = commit->tree;
 		args.time = commit->date;
 		cgit_print_snapshot_start(sat->mimetype, filename, item);
 		(*sat->write_func)(&args);
 		return;
 	}
 	cgit_print_error(fmt("Unsupported snapshot format: %s", filename));
 }
 
 void cgit_print_snapshot_links(const char *repo, const char *head,
 			       const char *hex, int snapshots)
 {
 	const struct snapshot_archive_t* sat;
     	char *filename;
 	int f;
 
 	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/>");
 	}
 }
 
 int cgit_parse_snapshots_mask(const char *str)
 {
 	const struct snapshot_archive_t* sat;
 	static const char *delim = " \t,:/|;";
-	int f, tl, rv = 0;
+	int f, tl, sl, rv = 0;
 
 	/* 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))) {
+			sl = strlen(sat->suffix);
+			if((tl == sl && !strncmp(sat->suffix, str, tl)) ||
+			   (tl == sl-1 && !strncmp(sat->suffix+1, str, tl-1))) {
 				rv |= sat->bit;
 				break;
 			}
 		}
 		str += tl;
 	}
 	return rv;
 }
 
 /* vim:set sw=8: */