author | Lars Hjemli <hjemli@gmail.com> | 2008-01-13 17:34:37 (UTC) |
---|---|---|
committer | Lars Hjemli <hjemli@gmail.com> | 2008-01-13 17:34:37 (UTC) |
commit | 2122c696a34133a616b9ec6d72abe9eb89e728aa (patch) (unidiff) | |
tree | fc3c4693f77b04c1eaf549841d5bae46d9801608 | |
parent | f39c3c99a12154cdafcdc501a821e3fadd3c0602 (diff) | |
parent | b74cc91574a9284d2f6446fd2ef3df6298ed6992 (diff) | |
download | cgit-2122c696a34133a616b9ec6d72abe9eb89e728aa.zip cgit-2122c696a34133a616b9ec6d72abe9eb89e728aa.tar.gz cgit-2122c696a34133a616b9ec6d72abe9eb89e728aa.tar.bz2 |
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]"
-rw-r--r-- | Makefile | 4 | ||||
m--------- | git | 0 | ||||
-rw-r--r-- | shared.c | 2 | ||||
-rw-r--r-- | ui-snapshot.c | 7 |
4 files changed, 7 insertions, 6 deletions
@@ -1,83 +1,83 @@ | |||
1 | CGIT_VERSION = v0.7.1 | 1 | CGIT_VERSION = v0.7.2 |
2 | CGIT_SCRIPT_NAME = cgit.cgi | 2 | CGIT_SCRIPT_NAME = cgit.cgi |
3 | CGIT_SCRIPT_PATH = /var/www/htdocs/cgit | 3 | CGIT_SCRIPT_PATH = /var/www/htdocs/cgit |
4 | CGIT_CONFIG = /etc/cgitrc | 4 | CGIT_CONFIG = /etc/cgitrc |
5 | CACHE_ROOT = /var/cache/cgit | 5 | CACHE_ROOT = /var/cache/cgit |
6 | SHA1_HEADER = <openssl/sha.h> | 6 | SHA1_HEADER = <openssl/sha.h> |
7 | GIT_VER = 1.5.3.5 | 7 | GIT_VER = 1.5.3.8 |
8 | GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2 | 8 | GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2 |
9 | 9 | ||
10 | # | 10 | # |
11 | # Let the user override the above settings. | 11 | # Let the user override the above settings. |
12 | # | 12 | # |
13 | -include cgit.conf | 13 | -include cgit.conf |
14 | 14 | ||
15 | 15 | ||
16 | EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lcrypto | 16 | EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lcrypto |
17 | OBJECTS = shared.o cache.o parsing.o html.o ui-shared.o ui-repolist.o \ | 17 | OBJECTS = shared.o cache.o parsing.o html.o ui-shared.o ui-repolist.o \ |
18 | ui-summary.o ui-log.o ui-tree.o ui-commit.o ui-diff.o \ | 18 | ui-summary.o ui-log.o ui-tree.o ui-commit.o ui-diff.o \ |
19 | ui-snapshot.o ui-blob.o ui-tag.o ui-refs.o ui-patch.o | 19 | ui-snapshot.o ui-blob.o ui-tag.o ui-refs.o ui-patch.o |
20 | 20 | ||
21 | 21 | ||
22 | ifdef NEEDS_LIBICONV | 22 | ifdef NEEDS_LIBICONV |
23 | EXTLIBS += -liconv | 23 | EXTLIBS += -liconv |
24 | endif | 24 | endif |
25 | 25 | ||
26 | 26 | ||
27 | .PHONY: all git test install clean distclean emptycache force-version get-git | 27 | .PHONY: all git test install clean distclean emptycache force-version get-git |
28 | 28 | ||
29 | all: cgit git | 29 | all: cgit git |
30 | 30 | ||
31 | VERSION: force-version | 31 | VERSION: force-version |
32 | @./gen-version.sh "$(CGIT_VERSION)" | 32 | @./gen-version.sh "$(CGIT_VERSION)" |
33 | -include VERSION | 33 | -include VERSION |
34 | 34 | ||
35 | 35 | ||
36 | CFLAGS += -g -Wall -Igit | 36 | CFLAGS += -g -Wall -Igit |
37 | CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)' | 37 | CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)' |
38 | CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"' | 38 | CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"' |
39 | CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"' | 39 | CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"' |
40 | CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"' | 40 | CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"' |
41 | CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"' | 41 | CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"' |
42 | 42 | ||
43 | 43 | ||
44 | cgit: cgit.c $(OBJECTS) | 44 | cgit: cgit.c $(OBJECTS) |
45 | $(CC) $(CFLAGS) cgit.c -o cgit $(OBJECTS) $(EXTLIBS) | 45 | $(CC) $(CFLAGS) cgit.c -o cgit $(OBJECTS) $(EXTLIBS) |
46 | 46 | ||
47 | $(OBJECTS): cgit.h git/xdiff/lib.a git/libgit.a VERSION | 47 | $(OBJECTS): cgit.h git/xdiff/lib.a git/libgit.a VERSION |
48 | 48 | ||
49 | git/xdiff/lib.a: | git | 49 | git/xdiff/lib.a: | git |
50 | 50 | ||
51 | git/libgit.a: | git | 51 | git/libgit.a: | git |
52 | 52 | ||
53 | git: | 53 | git: |
54 | cd git && $(MAKE) xdiff/lib.a | 54 | cd git && $(MAKE) xdiff/lib.a |
55 | cd git && $(MAKE) libgit.a | 55 | cd git && $(MAKE) libgit.a |
56 | 56 | ||
57 | test: all | 57 | test: all |
58 | $(MAKE) -C tests | 58 | $(MAKE) -C tests |
59 | 59 | ||
60 | install: all | 60 | install: all |
61 | mkdir -p $(DESTDIR)$(CGIT_SCRIPT_PATH) | 61 | mkdir -p $(DESTDIR)$(CGIT_SCRIPT_PATH) |
62 | install cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME) | 62 | install cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME) |
63 | install cgit.css $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.css | 63 | install cgit.css $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.css |
64 | install cgit.png $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.png | 64 | install cgit.png $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.png |
65 | 65 | ||
66 | uninstall: | 66 | uninstall: |
67 | rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME) | 67 | rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME) |
68 | rm -f $(CGIT_SCRIPT_PATH)/cgit.css | 68 | rm -f $(CGIT_SCRIPT_PATH)/cgit.css |
69 | rm -f $(CGIT_SCRIPT_PATH)/cgit.png | 69 | rm -f $(CGIT_SCRIPT_PATH)/cgit.png |
70 | 70 | ||
71 | clean: | 71 | clean: |
72 | rm -f cgit VERSION *.o | 72 | rm -f cgit VERSION *.o |
73 | cd git && $(MAKE) clean | 73 | cd git && $(MAKE) clean |
74 | 74 | ||
75 | distclean: clean | 75 | distclean: clean |
76 | git clean -d -x | 76 | git clean -d -x |
77 | cd git && git clean -d -x | 77 | cd git && git clean -d -x |
78 | 78 | ||
79 | emptycache: | 79 | emptycache: |
80 | rm -rf $(DESTDIR)$(CACHE_ROOT)/* | 80 | rm -rf $(DESTDIR)$(CACHE_ROOT)/* |
81 | 81 | ||
82 | get-git: | 82 | get-git: |
83 | curl $(GIT_URL) | tar -xj && rm -rf git && mv git-$(GIT_VER) git | 83 | curl $(GIT_URL) | tar -xj && rm -rf git && mv git-$(GIT_VER) git |
diff --git a/git b/git | |||
Subproject 3f2a7ae2c84c921e11041a5edc2522964fc1cce | Subproject aadd4efa715f56e0eac5ac459c8ff4933b56d4c | ||
@@ -1,313 +1,313 @@ | |||
1 | /* shared.c: global vars + some callback functions | 1 | /* shared.c: global vars + some callback functions |
2 | * | 2 | * |
3 | * Copyright (C) 2006 Lars Hjemli | 3 | * Copyright (C) 2006 Lars Hjemli |
4 | * | 4 | * |
5 | * Licensed under GNU General Public License v2 | 5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) | 6 | * (see COPYING for full license text) |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include "cgit.h" | 9 | #include "cgit.h" |
10 | 10 | ||
11 | struct repolist cgit_repolist; | 11 | struct repolist cgit_repolist; |
12 | struct repoinfo *cgit_repo; | 12 | struct repoinfo *cgit_repo; |
13 | int cgit_cmd; | 13 | int cgit_cmd; |
14 | 14 | ||
15 | const char *cgit_version = CGIT_VERSION; | 15 | const char *cgit_version = CGIT_VERSION; |
16 | 16 | ||
17 | char *cgit_root_title = "Git repository browser"; | 17 | char *cgit_root_title = "Git repository browser"; |
18 | char *cgit_css = "/cgit.css"; | 18 | char *cgit_css = "/cgit.css"; |
19 | char *cgit_logo = "/git-logo.png"; | 19 | char *cgit_logo = "/git-logo.png"; |
20 | char *cgit_index_header = NULL; | 20 | char *cgit_index_header = NULL; |
21 | char *cgit_index_info = NULL; | 21 | char *cgit_index_info = NULL; |
22 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; | 22 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
23 | char *cgit_module_link = "./?repo=%s&page=commit&id=%s"; | 23 | char *cgit_module_link = "./?repo=%s&page=commit&id=%s"; |
24 | char *cgit_agefile = "info/web/last-modified"; | 24 | char *cgit_agefile = "info/web/last-modified"; |
25 | char *cgit_virtual_root = NULL; | 25 | char *cgit_virtual_root = NULL; |
26 | char *cgit_script_name = CGIT_SCRIPT_NAME; | 26 | char *cgit_script_name = CGIT_SCRIPT_NAME; |
27 | char *cgit_cache_root = CGIT_CACHE_ROOT; | 27 | char *cgit_cache_root = CGIT_CACHE_ROOT; |
28 | char *cgit_repo_group = NULL; | 28 | char *cgit_repo_group = NULL; |
29 | char *cgit_robots = "index, nofollow"; | 29 | char *cgit_robots = "index, nofollow"; |
30 | char *cgit_clone_prefix = NULL; | 30 | char *cgit_clone_prefix = NULL; |
31 | 31 | ||
32 | int cgit_nocache = 0; | 32 | int cgit_nocache = 0; |
33 | int cgit_snapshots = 0; | 33 | int cgit_snapshots = 0; |
34 | int cgit_enable_index_links = 0; | 34 | int cgit_enable_index_links = 0; |
35 | int cgit_enable_log_filecount = 0; | 35 | int cgit_enable_log_filecount = 0; |
36 | int cgit_enable_log_linecount = 0; | 36 | int cgit_enable_log_linecount = 0; |
37 | int cgit_max_lock_attempts = 5; | 37 | int cgit_max_lock_attempts = 5; |
38 | int cgit_cache_root_ttl = 5; | 38 | int cgit_cache_root_ttl = 5; |
39 | int cgit_cache_repo_ttl = 5; | 39 | int cgit_cache_repo_ttl = 5; |
40 | int cgit_cache_dynamic_ttl = 5; | 40 | int cgit_cache_dynamic_ttl = 5; |
41 | int cgit_cache_static_ttl = -1; | 41 | int cgit_cache_static_ttl = -1; |
42 | int cgit_cache_max_create_time = 5; | 42 | int cgit_cache_max_create_time = 5; |
43 | int cgit_summary_log = 0; | 43 | int cgit_summary_log = 0; |
44 | int cgit_summary_tags = 0; | 44 | int cgit_summary_tags = 0; |
45 | int cgit_summary_branches = 0; | 45 | int cgit_summary_branches = 0; |
46 | int cgit_renamelimit = -1; | 46 | int cgit_renamelimit = -1; |
47 | 47 | ||
48 | int cgit_max_msg_len = 60; | 48 | int cgit_max_msg_len = 60; |
49 | int cgit_max_repodesc_len = 60; | 49 | int cgit_max_repodesc_len = 60; |
50 | int cgit_max_commit_count = 50; | 50 | int cgit_max_commit_count = 50; |
51 | 51 | ||
52 | int cgit_query_has_symref = 0; | 52 | int cgit_query_has_symref = 0; |
53 | int cgit_query_has_sha1 = 0; | 53 | int cgit_query_has_sha1 = 0; |
54 | 54 | ||
55 | char *cgit_querystring = NULL; | 55 | char *cgit_querystring = NULL; |
56 | char *cgit_query_repo = NULL; | 56 | char *cgit_query_repo = NULL; |
57 | char *cgit_query_page = NULL; | 57 | char *cgit_query_page = NULL; |
58 | char *cgit_query_head = NULL; | 58 | char *cgit_query_head = NULL; |
59 | char *cgit_query_search = NULL; | 59 | char *cgit_query_search = NULL; |
60 | char *cgit_query_grep = NULL; | 60 | char *cgit_query_grep = NULL; |
61 | char *cgit_query_sha1 = NULL; | 61 | char *cgit_query_sha1 = NULL; |
62 | char *cgit_query_sha2 = NULL; | 62 | char *cgit_query_sha2 = NULL; |
63 | char *cgit_query_path = NULL; | 63 | char *cgit_query_path = NULL; |
64 | char *cgit_query_name = NULL; | 64 | char *cgit_query_name = NULL; |
65 | int cgit_query_ofs = 0; | 65 | int cgit_query_ofs = 0; |
66 | 66 | ||
67 | int htmlfd = 0; | 67 | int htmlfd = 0; |
68 | 68 | ||
69 | 69 | ||
70 | int cgit_get_cmd_index(const char *cmd) | 70 | int cgit_get_cmd_index(const char *cmd) |
71 | { | 71 | { |
72 | static char *cmds[] = {"log", "commit", "diff", "tree", "blob", | 72 | static char *cmds[] = {"log", "commit", "diff", "tree", "blob", |
73 | "snapshot", "tag", "refs", "patch", NULL}; | 73 | "snapshot", "tag", "refs", "patch", NULL}; |
74 | int i; | 74 | int i; |
75 | 75 | ||
76 | for(i = 0; cmds[i]; i++) | 76 | for(i = 0; cmds[i]; i++) |
77 | if (!strcmp(cmd, cmds[i])) | 77 | if (!strcmp(cmd, cmds[i])) |
78 | return i + 1; | 78 | return i + 1; |
79 | return 0; | 79 | return 0; |
80 | } | 80 | } |
81 | 81 | ||
82 | int chk_zero(int result, char *msg) | 82 | int chk_zero(int result, char *msg) |
83 | { | 83 | { |
84 | if (result != 0) | 84 | if (result != 0) |
85 | die("%s: %s", msg, strerror(errno)); | 85 | die("%s: %s", msg, strerror(errno)); |
86 | return result; | 86 | return result; |
87 | } | 87 | } |
88 | 88 | ||
89 | int chk_positive(int result, char *msg) | 89 | int chk_positive(int result, char *msg) |
90 | { | 90 | { |
91 | if (result <= 0) | 91 | if (result <= 0) |
92 | die("%s: %s", msg, strerror(errno)); | 92 | die("%s: %s", msg, strerror(errno)); |
93 | return result; | 93 | return result; |
94 | } | 94 | } |
95 | 95 | ||
96 | int chk_non_negative(int result, char *msg) | 96 | int chk_non_negative(int result, char *msg) |
97 | { | 97 | { |
98 | if (result < 0) | 98 | if (result < 0) |
99 | die("%s: %s",msg, strerror(errno)); | 99 | die("%s: %s",msg, strerror(errno)); |
100 | return result; | 100 | return result; |
101 | } | 101 | } |
102 | 102 | ||
103 | struct repoinfo *add_repo(const char *url) | 103 | struct repoinfo *add_repo(const char *url) |
104 | { | 104 | { |
105 | struct repoinfo *ret; | 105 | struct repoinfo *ret; |
106 | 106 | ||
107 | if (++cgit_repolist.count > cgit_repolist.length) { | 107 | if (++cgit_repolist.count > cgit_repolist.length) { |
108 | if (cgit_repolist.length == 0) | 108 | if (cgit_repolist.length == 0) |
109 | cgit_repolist.length = 8; | 109 | cgit_repolist.length = 8; |
110 | else | 110 | else |
111 | cgit_repolist.length *= 2; | 111 | cgit_repolist.length *= 2; |
112 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, | 112 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, |
113 | cgit_repolist.length * | 113 | cgit_repolist.length * |
114 | sizeof(struct repoinfo)); | 114 | sizeof(struct repoinfo)); |
115 | } | 115 | } |
116 | 116 | ||
117 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; | 117 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; |
118 | ret->url = trim_end(url, '/'); | 118 | ret->url = trim_end(url, '/'); |
119 | ret->name = ret->url; | 119 | ret->name = ret->url; |
120 | ret->path = NULL; | 120 | ret->path = NULL; |
121 | ret->desc = NULL; | 121 | ret->desc = "[no description]"; |
122 | ret->owner = NULL; | 122 | ret->owner = NULL; |
123 | ret->group = cgit_repo_group; | 123 | ret->group = cgit_repo_group; |
124 | ret->defbranch = "master"; | 124 | ret->defbranch = "master"; |
125 | ret->snapshots = cgit_snapshots; | 125 | ret->snapshots = cgit_snapshots; |
126 | ret->enable_log_filecount = cgit_enable_log_filecount; | 126 | ret->enable_log_filecount = cgit_enable_log_filecount; |
127 | ret->enable_log_linecount = cgit_enable_log_linecount; | 127 | ret->enable_log_linecount = cgit_enable_log_linecount; |
128 | ret->module_link = cgit_module_link; | 128 | ret->module_link = cgit_module_link; |
129 | ret->readme = NULL; | 129 | ret->readme = NULL; |
130 | return ret; | 130 | return ret; |
131 | } | 131 | } |
132 | 132 | ||
133 | struct repoinfo *cgit_get_repoinfo(const char *url) | 133 | struct repoinfo *cgit_get_repoinfo(const char *url) |
134 | { | 134 | { |
135 | int i; | 135 | int i; |
136 | struct repoinfo *repo; | 136 | struct repoinfo *repo; |
137 | 137 | ||
138 | for (i=0; i<cgit_repolist.count; i++) { | 138 | for (i=0; i<cgit_repolist.count; i++) { |
139 | repo = &cgit_repolist.repos[i]; | 139 | repo = &cgit_repolist.repos[i]; |
140 | if (!strcmp(repo->url, url)) | 140 | if (!strcmp(repo->url, url)) |
141 | return repo; | 141 | return repo; |
142 | } | 142 | } |
143 | return NULL; | 143 | return NULL; |
144 | } | 144 | } |
145 | 145 | ||
146 | void cgit_global_config_cb(const char *name, const char *value) | 146 | void cgit_global_config_cb(const char *name, const char *value) |
147 | { | 147 | { |
148 | if (!strcmp(name, "root-title")) | 148 | if (!strcmp(name, "root-title")) |
149 | cgit_root_title = xstrdup(value); | 149 | cgit_root_title = xstrdup(value); |
150 | else if (!strcmp(name, "css")) | 150 | else if (!strcmp(name, "css")) |
151 | cgit_css = xstrdup(value); | 151 | cgit_css = xstrdup(value); |
152 | else if (!strcmp(name, "logo")) | 152 | else if (!strcmp(name, "logo")) |
153 | cgit_logo = xstrdup(value); | 153 | cgit_logo = xstrdup(value); |
154 | else if (!strcmp(name, "index-header")) | 154 | else if (!strcmp(name, "index-header")) |
155 | cgit_index_header = xstrdup(value); | 155 | cgit_index_header = xstrdup(value); |
156 | else if (!strcmp(name, "index-info")) | 156 | else if (!strcmp(name, "index-info")) |
157 | cgit_index_info = xstrdup(value); | 157 | cgit_index_info = xstrdup(value); |
158 | else if (!strcmp(name, "logo-link")) | 158 | else if (!strcmp(name, "logo-link")) |
159 | cgit_logo_link = xstrdup(value); | 159 | cgit_logo_link = xstrdup(value); |
160 | else if (!strcmp(name, "module-link")) | 160 | else if (!strcmp(name, "module-link")) |
161 | cgit_module_link = xstrdup(value); | 161 | cgit_module_link = xstrdup(value); |
162 | else if (!strcmp(name, "virtual-root")) { | 162 | else if (!strcmp(name, "virtual-root")) { |
163 | cgit_virtual_root = trim_end(value, '/'); | 163 | cgit_virtual_root = trim_end(value, '/'); |
164 | if (!cgit_virtual_root && (!strcmp(value, "/"))) | 164 | if (!cgit_virtual_root && (!strcmp(value, "/"))) |
165 | cgit_virtual_root = ""; | 165 | cgit_virtual_root = ""; |
166 | } else if (!strcmp(name, "nocache")) | 166 | } else if (!strcmp(name, "nocache")) |
167 | cgit_nocache = atoi(value); | 167 | cgit_nocache = atoi(value); |
168 | else if (!strcmp(name, "snapshots")) | 168 | else if (!strcmp(name, "snapshots")) |
169 | cgit_snapshots = cgit_parse_snapshots_mask(value); | 169 | cgit_snapshots = cgit_parse_snapshots_mask(value); |
170 | else if (!strcmp(name, "enable-index-links")) | 170 | else if (!strcmp(name, "enable-index-links")) |
171 | cgit_enable_index_links = atoi(value); | 171 | cgit_enable_index_links = atoi(value); |
172 | else if (!strcmp(name, "enable-log-filecount")) | 172 | else if (!strcmp(name, "enable-log-filecount")) |
173 | cgit_enable_log_filecount = atoi(value); | 173 | cgit_enable_log_filecount = atoi(value); |
174 | else if (!strcmp(name, "enable-log-linecount")) | 174 | else if (!strcmp(name, "enable-log-linecount")) |
175 | cgit_enable_log_linecount = atoi(value); | 175 | cgit_enable_log_linecount = atoi(value); |
176 | else if (!strcmp(name, "cache-root")) | 176 | else if (!strcmp(name, "cache-root")) |
177 | cgit_cache_root = xstrdup(value); | 177 | cgit_cache_root = xstrdup(value); |
178 | else if (!strcmp(name, "cache-root-ttl")) | 178 | else if (!strcmp(name, "cache-root-ttl")) |
179 | cgit_cache_root_ttl = atoi(value); | 179 | cgit_cache_root_ttl = atoi(value); |
180 | else if (!strcmp(name, "cache-repo-ttl")) | 180 | else if (!strcmp(name, "cache-repo-ttl")) |
181 | cgit_cache_repo_ttl = atoi(value); | 181 | cgit_cache_repo_ttl = atoi(value); |
182 | else if (!strcmp(name, "cache-static-ttl")) | 182 | else if (!strcmp(name, "cache-static-ttl")) |
183 | cgit_cache_static_ttl = atoi(value); | 183 | cgit_cache_static_ttl = atoi(value); |
184 | else if (!strcmp(name, "cache-dynamic-ttl")) | 184 | else if (!strcmp(name, "cache-dynamic-ttl")) |
185 | cgit_cache_dynamic_ttl = atoi(value); | 185 | cgit_cache_dynamic_ttl = atoi(value); |
186 | else if (!strcmp(name, "max-message-length")) | 186 | else if (!strcmp(name, "max-message-length")) |
187 | cgit_max_msg_len = atoi(value); | 187 | cgit_max_msg_len = atoi(value); |
188 | else if (!strcmp(name, "max-repodesc-length")) | 188 | else if (!strcmp(name, "max-repodesc-length")) |
189 | cgit_max_repodesc_len = atoi(value); | 189 | cgit_max_repodesc_len = atoi(value); |
190 | else if (!strcmp(name, "max-commit-count")) | 190 | else if (!strcmp(name, "max-commit-count")) |
191 | cgit_max_commit_count = atoi(value); | 191 | cgit_max_commit_count = atoi(value); |
192 | else if (!strcmp(name, "summary-log")) | 192 | else if (!strcmp(name, "summary-log")) |
193 | cgit_summary_log = atoi(value); | 193 | cgit_summary_log = atoi(value); |
194 | else if (!strcmp(name, "summary-branches")) | 194 | else if (!strcmp(name, "summary-branches")) |
195 | cgit_summary_branches = atoi(value); | 195 | cgit_summary_branches = atoi(value); |
196 | else if (!strcmp(name, "summary-tags")) | 196 | else if (!strcmp(name, "summary-tags")) |
197 | cgit_summary_tags = atoi(value); | 197 | cgit_summary_tags = atoi(value); |
198 | else if (!strcmp(name, "agefile")) | 198 | else if (!strcmp(name, "agefile")) |
199 | cgit_agefile = xstrdup(value); | 199 | cgit_agefile = xstrdup(value); |
200 | else if (!strcmp(name, "renamelimit")) | 200 | else if (!strcmp(name, "renamelimit")) |
201 | cgit_renamelimit = atoi(value); | 201 | cgit_renamelimit = atoi(value); |
202 | else if (!strcmp(name, "robots")) | 202 | else if (!strcmp(name, "robots")) |
203 | cgit_robots = xstrdup(value); | 203 | cgit_robots = xstrdup(value); |
204 | else if (!strcmp(name, "clone-prefix")) | 204 | else if (!strcmp(name, "clone-prefix")) |
205 | cgit_clone_prefix = xstrdup(value); | 205 | cgit_clone_prefix = xstrdup(value); |
206 | else if (!strcmp(name, "repo.group")) | 206 | else if (!strcmp(name, "repo.group")) |
207 | cgit_repo_group = xstrdup(value); | 207 | cgit_repo_group = xstrdup(value); |
208 | else if (!strcmp(name, "repo.url")) | 208 | else if (!strcmp(name, "repo.url")) |
209 | cgit_repo = add_repo(value); | 209 | cgit_repo = add_repo(value); |
210 | else if (!strcmp(name, "repo.name")) | 210 | else if (!strcmp(name, "repo.name")) |
211 | cgit_repo->name = xstrdup(value); | 211 | cgit_repo->name = xstrdup(value); |
212 | else if (cgit_repo && !strcmp(name, "repo.path")) | 212 | else if (cgit_repo && !strcmp(name, "repo.path")) |
213 | cgit_repo->path = trim_end(value, '/'); | 213 | cgit_repo->path = trim_end(value, '/'); |
214 | else if (cgit_repo && !strcmp(name, "repo.clone-url")) | 214 | else if (cgit_repo && !strcmp(name, "repo.clone-url")) |
215 | cgit_repo->clone_url = xstrdup(value); | 215 | cgit_repo->clone_url = xstrdup(value); |
216 | else if (cgit_repo && !strcmp(name, "repo.desc")) | 216 | else if (cgit_repo && !strcmp(name, "repo.desc")) |
217 | cgit_repo->desc = xstrdup(value); | 217 | cgit_repo->desc = xstrdup(value); |
218 | else if (cgit_repo && !strcmp(name, "repo.owner")) | 218 | else if (cgit_repo && !strcmp(name, "repo.owner")) |
219 | cgit_repo->owner = xstrdup(value); | 219 | cgit_repo->owner = xstrdup(value); |
220 | else if (cgit_repo && !strcmp(name, "repo.defbranch")) | 220 | else if (cgit_repo && !strcmp(name, "repo.defbranch")) |
221 | cgit_repo->defbranch = xstrdup(value); | 221 | cgit_repo->defbranch = xstrdup(value); |
222 | else if (cgit_repo && !strcmp(name, "repo.snapshots")) | 222 | else if (cgit_repo && !strcmp(name, "repo.snapshots")) |
223 | cgit_repo->snapshots = cgit_snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */ | 223 | cgit_repo->snapshots = cgit_snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */ |
224 | else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount")) | 224 | else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount")) |
225 | cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value); | 225 | cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value); |
226 | else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount")) | 226 | else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount")) |
227 | cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value); | 227 | cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value); |
228 | else if (cgit_repo && !strcmp(name, "repo.module-link")) | 228 | else if (cgit_repo && !strcmp(name, "repo.module-link")) |
229 | cgit_repo->module_link= xstrdup(value); | 229 | cgit_repo->module_link= xstrdup(value); |
230 | else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) { | 230 | else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) { |
231 | if (*value == '/') | 231 | if (*value == '/') |
232 | cgit_repo->readme = xstrdup(value); | 232 | cgit_repo->readme = xstrdup(value); |
233 | else | 233 | else |
234 | cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value)); | 234 | cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value)); |
235 | } else if (!strcmp(name, "include")) | 235 | } else if (!strcmp(name, "include")) |
236 | cgit_read_config(value, cgit_global_config_cb); | 236 | cgit_read_config(value, cgit_global_config_cb); |
237 | } | 237 | } |
238 | 238 | ||
239 | void cgit_querystring_cb(const char *name, const char *value) | 239 | void cgit_querystring_cb(const char *name, const char *value) |
240 | { | 240 | { |
241 | if (!strcmp(name,"r")) { | 241 | if (!strcmp(name,"r")) { |
242 | cgit_query_repo = xstrdup(value); | 242 | cgit_query_repo = xstrdup(value); |
243 | cgit_repo = cgit_get_repoinfo(value); | 243 | cgit_repo = cgit_get_repoinfo(value); |
244 | } else if (!strcmp(name, "p")) { | 244 | } else if (!strcmp(name, "p")) { |
245 | cgit_query_page = xstrdup(value); | 245 | cgit_query_page = xstrdup(value); |
246 | cgit_cmd = cgit_get_cmd_index(value); | 246 | cgit_cmd = cgit_get_cmd_index(value); |
247 | } else if (!strcmp(name, "url")) { | 247 | } else if (!strcmp(name, "url")) { |
248 | cgit_parse_url(value); | 248 | cgit_parse_url(value); |
249 | } else if (!strcmp(name, "qt")) { | 249 | } else if (!strcmp(name, "qt")) { |
250 | cgit_query_grep = xstrdup(value); | 250 | cgit_query_grep = xstrdup(value); |
251 | } else if (!strcmp(name, "q")) { | 251 | } else if (!strcmp(name, "q")) { |
252 | cgit_query_search = xstrdup(value); | 252 | cgit_query_search = xstrdup(value); |
253 | } else if (!strcmp(name, "h")) { | 253 | } else if (!strcmp(name, "h")) { |
254 | cgit_query_head = xstrdup(value); | 254 | cgit_query_head = xstrdup(value); |
255 | cgit_query_has_symref = 1; | 255 | cgit_query_has_symref = 1; |
256 | } else if (!strcmp(name, "id")) { | 256 | } else if (!strcmp(name, "id")) { |
257 | cgit_query_sha1 = xstrdup(value); | 257 | cgit_query_sha1 = xstrdup(value); |
258 | cgit_query_has_sha1 = 1; | 258 | cgit_query_has_sha1 = 1; |
259 | } else if (!strcmp(name, "id2")) { | 259 | } else if (!strcmp(name, "id2")) { |
260 | cgit_query_sha2 = xstrdup(value); | 260 | cgit_query_sha2 = xstrdup(value); |
261 | cgit_query_has_sha1 = 1; | 261 | cgit_query_has_sha1 = 1; |
262 | } else if (!strcmp(name, "ofs")) { | 262 | } else if (!strcmp(name, "ofs")) { |
263 | cgit_query_ofs = atoi(value); | 263 | cgit_query_ofs = atoi(value); |
264 | } else if (!strcmp(name, "path")) { | 264 | } else if (!strcmp(name, "path")) { |
265 | cgit_query_path = trim_end(value, '/'); | 265 | cgit_query_path = trim_end(value, '/'); |
266 | } else if (!strcmp(name, "name")) { | 266 | } else if (!strcmp(name, "name")) { |
267 | cgit_query_name = xstrdup(value); | 267 | cgit_query_name = xstrdup(value); |
268 | } | 268 | } |
269 | } | 269 | } |
270 | 270 | ||
271 | void *cgit_free_commitinfo(struct commitinfo *info) | 271 | void *cgit_free_commitinfo(struct commitinfo *info) |
272 | { | 272 | { |
273 | free(info->author); | 273 | free(info->author); |
274 | free(info->author_email); | 274 | free(info->author_email); |
275 | free(info->committer); | 275 | free(info->committer); |
276 | free(info->committer_email); | 276 | free(info->committer_email); |
277 | free(info->subject); | 277 | free(info->subject); |
278 | free(info->msg); | 278 | free(info->msg); |
279 | free(info->msg_encoding); | 279 | free(info->msg_encoding); |
280 | free(info); | 280 | free(info); |
281 | return NULL; | 281 | return NULL; |
282 | } | 282 | } |
283 | 283 | ||
284 | int hextoint(char c) | 284 | int hextoint(char c) |
285 | { | 285 | { |
286 | if (c >= 'a' && c <= 'f') | 286 | if (c >= 'a' && c <= 'f') |
287 | return 10 + c - 'a'; | 287 | return 10 + c - 'a'; |
288 | else if (c >= 'A' && c <= 'F') | 288 | else if (c >= 'A' && c <= 'F') |
289 | return 10 + c - 'A'; | 289 | return 10 + c - 'A'; |
290 | else if (c >= '0' && c <= '9') | 290 | else if (c >= '0' && c <= '9') |
291 | return c - '0'; | 291 | return c - '0'; |
292 | else | 292 | else |
293 | return -1; | 293 | return -1; |
294 | } | 294 | } |
295 | 295 | ||
296 | char *trim_end(const char *str, char c) | 296 | char *trim_end(const char *str, char c) |
297 | { | 297 | { |
298 | int len; | 298 | int len; |
299 | char *s, *t; | 299 | char *s, *t; |
300 | 300 | ||
301 | if (str == NULL) | 301 | if (str == NULL) |
302 | return NULL; | 302 | return NULL; |
303 | t = (char *)str; | 303 | t = (char *)str; |
304 | len = strlen(t); | 304 | len = strlen(t); |
305 | while(len > 0 && t[len - 1] == c) | 305 | while(len > 0 && t[len - 1] == c) |
306 | len--; | 306 | len--; |
307 | 307 | ||
308 | if (len == 0) | 308 | if (len == 0) |
309 | return NULL; | 309 | return NULL; |
310 | 310 | ||
311 | c = t[len]; | 311 | c = t[len]; |
312 | t[len] = '\0'; | 312 | t[len] = '\0'; |
313 | s = xstrdup(t); | 313 | s = xstrdup(t); |
diff --git a/ui-snapshot.c b/ui-snapshot.c index 4d1aa88..dfedd8f 100644 --- a/ui-snapshot.c +++ b/ui-snapshot.c | |||
@@ -1,156 +1,157 @@ | |||
1 | /* ui-snapshot.c: generate snapshot of a commit | 1 | /* ui-snapshot.c: generate snapshot of a commit |
2 | * | 2 | * |
3 | * Copyright (C) 2006 Lars Hjemli | 3 | * Copyright (C) 2006 Lars Hjemli |
4 | * | 4 | * |
5 | * Licensed under GNU General Public License v2 | 5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) | 6 | * (see COPYING for full license text) |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include "cgit.h" | 9 | #include "cgit.h" |
10 | 10 | ||
11 | static int write_compressed_tar_archive(struct archiver_args *args,const char *filter) | 11 | static int write_compressed_tar_archive(struct archiver_args *args,const char *filter) |
12 | { | 12 | { |
13 | int rw[2]; | 13 | int rw[2]; |
14 | pid_t gzpid; | 14 | pid_t gzpid; |
15 | int stdout2; | 15 | int stdout2; |
16 | int status; | 16 | int status; |
17 | int rv; | 17 | int rv; |
18 | 18 | ||
19 | stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing"); | 19 | stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing"); |
20 | chk_zero(pipe(rw), "Opening pipe from compressor subprocess"); | 20 | chk_zero(pipe(rw), "Opening pipe from compressor subprocess"); |
21 | gzpid = chk_non_negative(fork(), "Forking compressor subprocess"); | 21 | gzpid = chk_non_negative(fork(), "Forking compressor subprocess"); |
22 | if(gzpid==0) { | 22 | if(gzpid==0) { |
23 | /* child */ | 23 | /* child */ |
24 | chk_zero(close(rw[1]), "Closing write end of pipe in child"); | 24 | chk_zero(close(rw[1]), "Closing write end of pipe in child"); |
25 | chk_zero(close(STDIN_FILENO), "Closing STDIN"); | 25 | chk_zero(close(STDIN_FILENO), "Closing STDIN"); |
26 | chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin"); | 26 | chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin"); |
27 | execlp(filter,filter,NULL); | 27 | execlp(filter,filter,NULL); |
28 | _exit(-1); | 28 | _exit(-1); |
29 | } | 29 | } |
30 | /* parent */ | 30 | /* parent */ |
31 | chk_zero(close(rw[0]), "Closing read end of pipe"); | 31 | chk_zero(close(rw[0]), "Closing read end of pipe"); |
32 | chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor"); | 32 | chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor"); |
33 | 33 | ||
34 | rv = write_tar_archive(args); | 34 | rv = write_tar_archive(args); |
35 | 35 | ||
36 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor"); | 36 | chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor"); |
37 | chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT"); | 37 | chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT"); |
38 | chk_zero(close(stdout2), "Closing uncompressed STDOUT"); | 38 | chk_zero(close(stdout2), "Closing uncompressed STDOUT"); |
39 | chk_zero(close(rw[1]), "Closing write end of pipe in parent"); | 39 | chk_zero(close(rw[1]), "Closing write end of pipe in parent"); |
40 | chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process"); | 40 | chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process"); |
41 | if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) ) | 41 | if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) ) |
42 | cgit_print_error("Failed to compress archive"); | 42 | cgit_print_error("Failed to compress archive"); |
43 | 43 | ||
44 | return rv; | 44 | return rv; |
45 | } | 45 | } |
46 | 46 | ||
47 | static int write_tar_gzip_archive(struct archiver_args *args) | 47 | static int write_tar_gzip_archive(struct archiver_args *args) |
48 | { | 48 | { |
49 | return write_compressed_tar_archive(args,"gzip"); | 49 | return write_compressed_tar_archive(args,"gzip"); |
50 | } | 50 | } |
51 | 51 | ||
52 | static int write_tar_bzip2_archive(struct archiver_args *args) | 52 | static int write_tar_bzip2_archive(struct archiver_args *args) |
53 | { | 53 | { |
54 | return write_compressed_tar_archive(args,"bzip2"); | 54 | return write_compressed_tar_archive(args,"bzip2"); |
55 | } | 55 | } |
56 | 56 | ||
57 | static const struct snapshot_archive_t { | 57 | static const struct snapshot_archive_t { |
58 | const char *suffix; | 58 | const char *suffix; |
59 | const char *mimetype; | 59 | const char *mimetype; |
60 | write_archive_fn_t write_func; | 60 | write_archive_fn_t write_func; |
61 | int bit; | 61 | int bit; |
62 | }snapshot_archives[] = { | 62 | }snapshot_archives[] = { |
63 | { ".zip", "application/x-zip", write_zip_archive, 0x1 }, | 63 | { ".zip", "application/x-zip", write_zip_archive, 0x1 }, |
64 | { ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 }, | 64 | { ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 }, |
65 | { ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 }, | 65 | { ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 }, |
66 | { ".tar", "application/x-tar", write_tar_archive, 0x8 } | 66 | { ".tar", "application/x-tar", write_tar_archive, 0x8 } |
67 | }; | 67 | }; |
68 | 68 | ||
69 | #define snapshot_archives_len (sizeof(snapshot_archives) / sizeof(*snapshot_archives)) | 69 | #define snapshot_archives_len (sizeof(snapshot_archives) / sizeof(*snapshot_archives)) |
70 | 70 | ||
71 | void cgit_print_snapshot(struct cacheitem *item, const char *head, | 71 | void cgit_print_snapshot(struct cacheitem *item, const char *head, |
72 | const char *hex, const char *prefix, | 72 | const char *hex, const char *prefix, |
73 | const char *filename, int snapshots) | 73 | const char *filename, int snapshots) |
74 | { | 74 | { |
75 | const struct snapshot_archive_t* sat; | 75 | const struct snapshot_archive_t* sat; |
76 | struct archiver_args args; | 76 | struct archiver_args args; |
77 | struct commit *commit; | 77 | struct commit *commit; |
78 | unsigned char sha1[20]; | 78 | unsigned char sha1[20]; |
79 | int f, sl, fnl = strlen(filename); | 79 | int f, sl, fnl = strlen(filename); |
80 | 80 | ||
81 | for(f=0; f<snapshot_archives_len; f++) { | 81 | for(f=0; f<snapshot_archives_len; f++) { |
82 | sat = &snapshot_archives[f]; | 82 | sat = &snapshot_archives[f]; |
83 | if(!(snapshots & sat->bit)) | 83 | if(!(snapshots & sat->bit)) |
84 | continue; | 84 | continue; |
85 | sl = strlen(sat->suffix); | 85 | sl = strlen(sat->suffix); |
86 | if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix)) | 86 | if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix)) |
87 | continue; | 87 | continue; |
88 | if (!hex) | 88 | if (!hex) |
89 | hex = head; | 89 | hex = head; |
90 | if(get_sha1(hex, sha1)) { | 90 | if(get_sha1(hex, sha1)) { |
91 | cgit_print_error(fmt("Bad object id: %s", hex)); | 91 | cgit_print_error(fmt("Bad object id: %s", hex)); |
92 | return; | 92 | return; |
93 | } | 93 | } |
94 | commit = lookup_commit_reference(sha1); | 94 | commit = lookup_commit_reference(sha1); |
95 | if(!commit) { | 95 | if(!commit) { |
96 | cgit_print_error(fmt("Not a commit reference: %s", hex)); | 96 | cgit_print_error(fmt("Not a commit reference: %s", hex)); |
97 | return;; | 97 | return;; |
98 | } | 98 | } |
99 | memset(&args,0,sizeof(args)); | 99 | memset(&args,0,sizeof(args)); |
100 | args.base = fmt("%s/", prefix); | 100 | args.base = fmt("%s/", prefix); |
101 | args.tree = commit->tree; | 101 | args.tree = commit->tree; |
102 | args.time = commit->date; | 102 | args.time = commit->date; |
103 | cgit_print_snapshot_start(sat->mimetype, filename, item); | 103 | cgit_print_snapshot_start(sat->mimetype, filename, item); |
104 | (*sat->write_func)(&args); | 104 | (*sat->write_func)(&args); |
105 | return; | 105 | return; |
106 | } | 106 | } |
107 | cgit_print_error(fmt("Unsupported snapshot format: %s", filename)); | 107 | cgit_print_error(fmt("Unsupported snapshot format: %s", filename)); |
108 | } | 108 | } |
109 | 109 | ||
110 | void cgit_print_snapshot_links(const char *repo, const char *head, | 110 | void cgit_print_snapshot_links(const char *repo, const char *head, |
111 | const char *hex, int snapshots) | 111 | const char *hex, int snapshots) |
112 | { | 112 | { |
113 | const struct snapshot_archive_t* sat; | 113 | const struct snapshot_archive_t* sat; |
114 | char *filename; | 114 | char *filename; |
115 | int f; | 115 | int f; |
116 | 116 | ||
117 | for(f=0; f<snapshot_archives_len; f++) { | 117 | for(f=0; f<snapshot_archives_len; f++) { |
118 | sat = &snapshot_archives[f]; | 118 | sat = &snapshot_archives[f]; |
119 | if(!(snapshots & sat->bit)) | 119 | if(!(snapshots & sat->bit)) |
120 | continue; | 120 | continue; |
121 | filename = fmt("%s-%s%s", cgit_repobasename(repo), hex, | 121 | filename = fmt("%s-%s%s", cgit_repobasename(repo), hex, |
122 | sat->suffix); | 122 | sat->suffix); |
123 | cgit_snapshot_link(filename, NULL, NULL, (char *)head, | 123 | cgit_snapshot_link(filename, NULL, NULL, (char *)head, |
124 | (char *)hex, filename); | 124 | (char *)hex, filename); |
125 | html("<br/>"); | 125 | html("<br/>"); |
126 | } | 126 | } |
127 | } | 127 | } |
128 | 128 | ||
129 | int cgit_parse_snapshots_mask(const char *str) | 129 | int cgit_parse_snapshots_mask(const char *str) |
130 | { | 130 | { |
131 | const struct snapshot_archive_t* sat; | 131 | const struct snapshot_archive_t* sat; |
132 | static const char *delim = " \t,:/|;"; | 132 | static const char *delim = " \t,:/|;"; |
133 | int f, tl, rv = 0; | 133 | int f, tl, sl, rv = 0; |
134 | 134 | ||
135 | /* favor legacy setting */ | 135 | /* favor legacy setting */ |
136 | if(atoi(str)) | 136 | if(atoi(str)) |
137 | return 1; | 137 | return 1; |
138 | for(;;) { | 138 | for(;;) { |
139 | str += strspn(str,delim); | 139 | str += strspn(str,delim); |
140 | tl = strcspn(str,delim); | 140 | tl = strcspn(str,delim); |
141 | if(!tl) | 141 | if(!tl) |
142 | break; | 142 | break; |
143 | for(f=0; f<snapshot_archives_len; f++) { | 143 | for(f=0; f<snapshot_archives_len; f++) { |
144 | sat = &snapshot_archives[f]; | 144 | sat = &snapshot_archives[f]; |
145 | if(!(strncmp(sat->suffix, str, tl) && | 145 | sl = strlen(sat->suffix); |
146 | strncmp(sat->suffix+1, str, tl-1))) { | 146 | if((tl == sl && !strncmp(sat->suffix, str, tl)) || |
147 | (tl == sl-1 && !strncmp(sat->suffix+1, str, tl-1))) { | ||
147 | rv |= sat->bit; | 148 | rv |= sat->bit; |
148 | break; | 149 | break; |
149 | } | 150 | } |
150 | } | 151 | } |
151 | str += tl; | 152 | str += tl; |
152 | } | 153 | } |
153 | return rv; | 154 | return rv; |
154 | } | 155 | } |
155 | 156 | ||
156 | /* vim:set sw=8: */ | 157 | /* vim:set sw=8: */ |