|
diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..5b6e7c6 --- a/dev/null +++ b/ COPYING |
|
@@ -0,0 +1,340 @@ |
| |
1 | GNU GENERAL PUBLIC LICENSE |
| |
2 | Version 2, June 1991 |
| |
3 | |
| |
4 | Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
| |
5 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| |
6 | Everyone is permitted to copy and distribute verbatim copies |
| |
7 | of this license document, but changing it is not allowed. |
| |
8 | |
| |
9 | Preamble |
| |
10 | |
| |
11 | The licenses for most software are designed to take away your |
| |
12 | freedom to share and change it. By contrast, the GNU General Public |
| |
13 | License is intended to guarantee your freedom to share and change free |
| |
14 | software--to make sure the software is free for all its users. This |
| |
15 | General Public License applies to most of the Free Software |
| |
16 | Foundation's software and to any other program whose authors commit to |
| |
17 | using it. (Some other Free Software Foundation software is covered by |
| |
18 | the GNU Library General Public License instead.) You can apply it to |
| |
19 | your programs, too. |
| |
20 | |
| |
21 | When we speak of free software, we are referring to freedom, not |
| |
22 | price. Our General Public Licenses are designed to make sure that you |
| |
23 | have the freedom to distribute copies of free software (and charge for |
| |
24 | this service if you wish), that you receive source code or can get it |
| |
25 | if you want it, that you can change the software or use pieces of it |
| |
26 | in new free programs; and that you know you can do these things. |
| |
27 | |
| |
28 | To protect your rights, we need to make restrictions that forbid |
| |
29 | anyone to deny you these rights or to ask you to surrender the rights. |
| |
30 | These restrictions translate to certain responsibilities for you if you |
| |
31 | distribute copies of the software, or if you modify it. |
| |
32 | |
| |
33 | For example, if you distribute copies of such a program, whether |
| |
34 | gratis or for a fee, you must give the recipients all the rights that |
| |
35 | you have. You must make sure that they, too, receive or can get the |
| |
36 | source code. And you must show them these terms so they know their |
| |
37 | rights. |
| |
38 | |
| |
39 | We protect your rights with two steps: (1) copyright the software, and |
| |
40 | (2) offer you this license which gives you legal permission to copy, |
| |
41 | distribute and/or modify the software. |
| |
42 | |
| |
43 | Also, for each author's protection and ours, we want to make certain |
| |
44 | that everyone understands that there is no warranty for this free |
| |
45 | software. If the software is modified by someone else and passed on, we |
| |
46 | want its recipients to know that what they have is not the original, so |
| |
47 | that any problems introduced by others will not reflect on the original |
| |
48 | authors' reputations. |
| |
49 | |
| |
50 | Finally, any free program is threatened constantly by software |
| |
51 | patents. We wish to avoid the danger that redistributors of a free |
| |
52 | program will individually obtain patent licenses, in effect making the |
| |
53 | program proprietary. To prevent this, we have made it clear that any |
| |
54 | patent must be licensed for everyone's free use or not licensed at all. |
| |
55 | |
| |
56 | The precise terms and conditions for copying, distribution and |
| |
57 | modification follow. |
| |
58 | |
| |
59 | GNU GENERAL PUBLIC LICENSE |
| |
60 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
| |
61 | |
| |
62 | 0. This License applies to any program or other work which contains |
| |
63 | a notice placed by the copyright holder saying it may be distributed |
| |
64 | under the terms of this General Public License. The "Program", below, |
| |
65 | refers to any such program or work, and a "work based on the Program" |
| |
66 | means either the Program or any derivative work under copyright law: |
| |
67 | that is to say, a work containing the Program or a portion of it, |
| |
68 | either verbatim or with modifications and/or translated into another |
| |
69 | language. (Hereinafter, translation is included without limitation in |
| |
70 | the term "modification".) Each licensee is addressed as "you". |
| |
71 | |
| |
72 | Activities other than copying, distribution and modification are not |
| |
73 | covered by this License; they are outside its scope. The act of |
| |
74 | running the Program is not restricted, and the output from the Program |
| |
75 | is covered only if its contents constitute a work based on the |
| |
76 | Program (independent of having been made by running the Program). |
| |
77 | Whether that is true depends on what the Program does. |
| |
78 | |
| |
79 | 1. You may copy and distribute verbatim copies of the Program's |
| |
80 | source code as you receive it, in any medium, provided that you |
| |
81 | conspicuously and appropriately publish on each copy an appropriate |
| |
82 | copyright notice and disclaimer of warranty; keep intact all the |
| |
83 | notices that refer to this License and to the absence of any warranty; |
| |
84 | and give any other recipients of the Program a copy of this License |
| |
85 | along with the Program. |
| |
86 | |
| |
87 | You may charge a fee for the physical act of transferring a copy, and |
| |
88 | you may at your option offer warranty protection in exchange for a fee. |
| |
89 | |
| |
90 | 2. You may modify your copy or copies of the Program or any portion |
| |
91 | of it, thus forming a work based on the Program, and copy and |
| |
92 | distribute such modifications or work under the terms of Section 1 |
| |
93 | above, provided that you also meet all of these conditions: |
| |
94 | |
| |
95 | a) You must cause the modified files to carry prominent notices |
| |
96 | stating that you changed the files and the date of any change. |
| |
97 | |
| |
98 | b) You must cause any work that you distribute or publish, that in |
| |
99 | whole or in part contains or is derived from the Program or any |
| |
100 | part thereof, to be licensed as a whole at no charge to all third |
| |
101 | parties under the terms of this License. |
| |
102 | |
| |
103 | c) If the modified program normally reads commands interactively |
| |
104 | when run, you must cause it, when started running for such |
| |
105 | interactive use in the most ordinary way, to print or display an |
| |
106 | announcement including an appropriate copyright notice and a |
| |
107 | notice that there is no warranty (or else, saying that you provide |
| |
108 | a warranty) and that users may redistribute the program under |
| |
109 | these conditions, and telling the user how to view a copy of this |
| |
110 | License. (Exception: if the Program itself is interactive but |
| |
111 | does not normally print such an announcement, your work based on |
| |
112 | the Program is not required to print an announcement.) |
| |
113 | |
| |
114 | These requirements apply to the modified work as a whole. If |
| |
115 | identifiable sections of that work are not derived from the Program, |
| |
116 | and can be reasonably considered independent and separate works in |
| |
117 | themselves, then this License, and its terms, do not apply to those |
| |
118 | sections when you distribute them as separate works. But when you |
| |
119 | distribute the same sections as part of a whole which is a work based |
| |
120 | on the Program, the distribution of the whole must be on the terms of |
| |
121 | this License, whose permissions for other licensees extend to the |
| |
122 | entire whole, and thus to each and every part regardless of who wrote it. |
| |
123 | |
| |
124 | Thus, it is not the intent of this section to claim rights or contest |
| |
125 | your rights to work written entirely by you; rather, the intent is to |
| |
126 | exercise the right to control the distribution of derivative or |
| |
127 | collective works based on the Program. |
| |
128 | |
| |
129 | In addition, mere aggregation of another work not based on the Program |
| |
130 | with the Program (or with a work based on the Program) on a volume of |
| |
131 | a storage or distribution medium does not bring the other work under |
| |
132 | the scope of this License. |
| |
133 | |
| |
134 | 3. You may copy and distribute the Program (or a work based on it, |
| |
135 | under Section 2) in object code or executable form under the terms of |
| |
136 | Sections 1 and 2 above provided that you also do one of the following: |
| |
137 | |
| |
138 | a) Accompany it with the complete corresponding machine-readable |
| |
139 | source code, which must be distributed under the terms of Sections |
| |
140 | 1 and 2 above on a medium customarily used for software interchange; or, |
| |
141 | |
| |
142 | b) Accompany it with a written offer, valid for at least three |
| |
143 | years, to give any third party, for a charge no more than your |
| |
144 | cost of physically performing source distribution, a complete |
| |
145 | machine-readable copy of the corresponding source code, to be |
| |
146 | distributed under the terms of Sections 1 and 2 above on a medium |
| |
147 | customarily used for software interchange; or, |
| |
148 | |
| |
149 | c) Accompany it with the information you received as to the offer |
| |
150 | to distribute corresponding source code. (This alternative is |
| |
151 | allowed only for noncommercial distribution and only if you |
| |
152 | received the program in object code or executable form with such |
| |
153 | an offer, in accord with Subsection b above.) |
| |
154 | |
| |
155 | The source code for a work means the preferred form of the work for |
| |
156 | making modifications to it. For an executable work, complete source |
| |
157 | code means all the source code for all modules it contains, plus any |
| |
158 | associated interface definition files, plus the scripts used to |
| |
159 | control compilation and installation of the executable. However, as a |
| |
160 | special exception, the source code distributed need not include |
| |
161 | anything that is normally distributed (in either source or binary |
| |
162 | form) with the major components (compiler, kernel, and so on) of the |
| |
163 | operating system on which the executable runs, unless that component |
| |
164 | itself accompanies the executable. |
| |
165 | |
| |
166 | If distribution of executable or object code is made by offering |
| |
167 | access to copy from a designated place, then offering equivalent |
| |
168 | access to copy the source code from the same place counts as |
| |
169 | distribution of the source code, even though third parties are not |
| |
170 | compelled to copy the source along with the object code. |
| |
171 | |
| |
172 | 4. You may not copy, modify, sublicense, or distribute the Program |
| |
173 | except as expressly provided under this License. Any attempt |
| |
174 | otherwise to copy, modify, sublicense or distribute the Program is |
| |
175 | void, and will automatically terminate your rights under this License. |
| |
176 | However, parties who have received copies, or rights, from you under |
| |
177 | this License will not have their licenses terminated so long as such |
| |
178 | parties remain in full compliance. |
| |
179 | |
| |
180 | 5. You are not required to accept this License, since you have not |
| |
181 | signed it. However, nothing else grants you permission to modify or |
| |
182 | distribute the Program or its derivative works. These actions are |
| |
183 | prohibited by law if you do not accept this License. Therefore, by |
| |
184 | modifying or distributing the Program (or any work based on the |
| |
185 | Program), you indicate your acceptance of this License to do so, and |
| |
186 | all its terms and conditions for copying, distributing or modifying |
| |
187 | the Program or works based on it. |
| |
188 | |
| |
189 | 6. Each time you redistribute the Program (or any work based on the |
| |
190 | Program), the recipient automatically receives a license from the |
| |
191 | original licensor to copy, distribute or modify the Program subject to |
| |
192 | these terms and conditions. You may not impose any further |
| |
193 | restrictions on the recipients' exercise of the rights granted herein. |
| |
194 | You are not responsible for enforcing compliance by third parties to |
| |
195 | this License. |
| |
196 | |
| |
197 | 7. If, as a consequence of a court judgment or allegation of patent |
| |
198 | infringement or for any other reason (not limited to patent issues), |
| |
199 | conditions are imposed on you (whether by court order, agreement or |
| |
200 | otherwise) that contradict the conditions of this License, they do not |
| |
201 | excuse you from the conditions of this License. If you cannot |
| |
202 | distribute so as to satisfy simultaneously your obligations under this |
| |
203 | License and any other pertinent obligations, then as a consequence you |
| |
204 | may not distribute the Program at all. For example, if a patent |
| |
205 | license would not permit royalty-free redistribution of the Program by |
| |
206 | all those who receive copies directly or indirectly through you, then |
| |
207 | the only way you could satisfy both it and this License would be to |
| |
208 | refrain entirely from distribution of the Program. |
| |
209 | |
| |
210 | If any portion of this section is held invalid or unenforceable under |
| |
211 | any particular circumstance, the balance of the section is intended to |
| |
212 | apply and the section as a whole is intended to apply in other |
| |
213 | circumstances. |
| |
214 | |
| |
215 | It is not the purpose of this section to induce you to infringe any |
| |
216 | patents or other property right claims or to contest validity of any |
| |
217 | such claims; this section has the sole purpose of protecting the |
| |
218 | integrity of the free software distribution system, which is |
| |
219 | implemented by public license practices. Many people have made |
| |
220 | generous contributions to the wide range of software distributed |
| |
221 | through that system in reliance on consistent application of that |
| |
222 | system; it is up to the author/donor to decide if he or she is willing |
| |
223 | to distribute software through any other system and a licensee cannot |
| |
224 | impose that choice. |
| |
225 | |
| |
226 | This section is intended to make thoroughly clear what is believed to |
| |
227 | be a consequence of the rest of this License. |
| |
228 | |
| |
229 | 8. If the distribution and/or use of the Program is restricted in |
| |
230 | certain countries either by patents or by copyrighted interfaces, the |
| |
231 | original copyright holder who places the Program under this License |
| |
232 | may add an explicit geographical distribution limitation excluding |
| |
233 | those countries, so that distribution is permitted only in or among |
| |
234 | countries not thus excluded. In such case, this License incorporates |
| |
235 | the limitation as if written in the body of this License. |
| |
236 | |
| |
237 | 9. The Free Software Foundation may publish revised and/or new versions |
| |
238 | of the General Public License from time to time. Such new versions will |
| |
239 | be similar in spirit to the present version, but may differ in detail to |
| |
240 | address new problems or concerns. |
| |
241 | |
| |
242 | Each version is given a distinguishing version number. If the Program |
| |
243 | specifies a version number of this License which applies to it and "any |
| |
244 | later version", you have the option of following the terms and conditions |
| |
245 | either of that version or of any later version published by the Free |
| |
246 | Software Foundation. If the Program does not specify a version number of |
| |
247 | this License, you may choose any version ever published by the Free Software |
| |
248 | Foundation. |
| |
249 | |
| |
250 | 10. If you wish to incorporate parts of the Program into other free |
| |
251 | programs whose distribution conditions are different, write to the author |
| |
252 | to ask for permission. For software which is copyrighted by the Free |
| |
253 | Software Foundation, write to the Free Software Foundation; we sometimes |
| |
254 | make exceptions for this. Our decision will be guided by the two goals |
| |
255 | of preserving the free status of all derivatives of our free software and |
| |
256 | of promoting the sharing and reuse of software generally. |
| |
257 | |
| |
258 | NO WARRANTY |
| |
259 | |
| |
260 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
| |
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
| |
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
| |
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
| |
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| |
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
| |
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
| |
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
| |
268 | REPAIR OR CORRECTION. |
| |
269 | |
| |
270 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
| |
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
| |
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
| |
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
| |
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
| |
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
| |
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
| |
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
| |
278 | POSSIBILITY OF SUCH DAMAGES. |
| |
279 | |
| |
280 | END OF TERMS AND CONDITIONS |
| |
281 | |
| |
282 | How to Apply These Terms to Your New Programs |
| |
283 | |
| |
284 | If you develop a new program, and you want it to be of the greatest |
| |
285 | possible use to the public, the best way to achieve this is to make it |
| |
286 | free software which everyone can redistribute and change under these terms. |
| |
287 | |
| |
288 | To do so, attach the following notices to the program. It is safest |
| |
289 | to attach them to the start of each source file to most effectively |
| |
290 | convey the exclusion of warranty; and each file should have at least |
| |
291 | the "copyright" line and a pointer to where the full notice is found. |
| |
292 | |
| |
293 | <one line to give the program's name and a brief idea of what it does.> |
| |
294 | Copyright (C) <year> <name of author> |
| |
295 | |
| |
296 | This program is free software; you can redistribute it and/or modify |
| |
297 | it under the terms of the GNU General Public License as published by |
| |
298 | the Free Software Foundation; either version 2 of the License, or |
| |
299 | (at your option) any later version. |
| |
300 | |
| |
301 | This program is distributed in the hope that it will be useful, |
| |
302 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| |
303 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| |
304 | GNU General Public License for more details. |
| |
305 | |
| |
306 | You should have received a copy of the GNU General Public License |
| |
307 | along with this program; if not, write to the Free Software |
| |
308 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| |
309 | |
| |
310 | |
| |
311 | Also add information on how to contact you by electronic and paper mail. |
| |
312 | |
| |
313 | If the program is interactive, make it output a short notice like this |
| |
314 | when it starts in an interactive mode: |
| |
315 | |
| |
316 | Gnomovision version 69, Copyright (C) year name of author |
| |
317 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
| |
318 | This is free software, and you are welcome to redistribute it |
| |
319 | under certain conditions; type `show c' for details. |
| |
320 | |
| |
321 | The hypothetical commands `show w' and `show c' should show the appropriate |
| |
322 | parts of the General Public License. Of course, the commands you use may |
| |
323 | be called something other than `show w' and `show c'; they could even be |
| |
324 | mouse-clicks or menu items--whatever suits your program. |
| |
325 | |
| |
326 | You should also get your employer (if you work as a programmer) or your |
| |
327 | school, if any, to sign a "copyright disclaimer" for the program, if |
| |
328 | necessary. Here is a sample; alter the names: |
| |
329 | |
| |
330 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
| |
331 | `Gnomovision' (which makes passes at compilers) written by James Hacker. |
| |
332 | |
| |
333 | <signature of Ty Coon>, 1 April 1989 |
| |
334 | Ty Coon, President of Vice |
| |
335 | |
| |
336 | This General Public License does not permit incorporating your program into |
| |
337 | proprietary programs. If your program is a subroutine library, you may |
| |
338 | consider it more useful to permit linking proprietary applications with the |
| |
339 | library. If this is what you want to do, use the GNU Library General |
| |
340 | Public License instead of this License. |
|
|
diff --git a/cache.c b/cache.c index 1be1ea4..b034c48 100644 --- a/ cache.c+++ b/ cache.c |
|
@@ -1,86 +1,94 @@ |
| |
1 | /* cache.c: cache management |
| |
2 | * |
| |
3 | * Copyright (C) 2006 Lars Hjemli |
| |
4 | * |
| |
5 | * Licensed under GNU General Public License v2 |
| |
6 | * (see COPYING for full license text) |
| |
7 | */ |
| |
8 | |
1 | #include "cgit.h" |
9 | #include "cgit.h" |
2 | |
10 | |
3 | const int NOLOCK = -1; |
11 | const int NOLOCK = -1; |
4 | |
12 | |
5 | int cache_lookup(struct cacheitem *item) |
13 | int cache_lookup(struct cacheitem *item) |
6 | { |
14 | { |
7 | if (!cgit_query_repo) { |
15 | if (!cgit_query_repo) { |
8 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); |
16 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); |
9 | item->ttl = cgit_cache_root_ttl; |
17 | item->ttl = cgit_cache_root_ttl; |
10 | } else if (!cgit_query_page) { |
18 | } else if (!cgit_query_page) { |
11 | item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, |
19 | item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, |
12 | cgit_query_repo)); |
20 | cgit_query_repo)); |
13 | item->ttl = cgit_cache_repo_ttl; |
21 | item->ttl = cgit_cache_repo_ttl; |
14 | } else { |
22 | } else { |
15 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, |
23 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, |
16 | cgit_query_repo, cgit_query_page, |
24 | cgit_query_repo, cgit_query_page, |
17 | cgit_querystring)); |
25 | cgit_querystring)); |
18 | if (cgit_query_has_symref) |
26 | if (cgit_query_has_symref) |
19 | item->ttl = cgit_cache_dynamic_ttl; |
27 | item->ttl = cgit_cache_dynamic_ttl; |
20 | else if (cgit_query_has_sha1) |
28 | else if (cgit_query_has_sha1) |
21 | item->ttl = cgit_cache_static_ttl; |
29 | item->ttl = cgit_cache_static_ttl; |
22 | else |
30 | else |
23 | item->ttl = cgit_cache_repo_ttl; |
31 | item->ttl = cgit_cache_repo_ttl; |
24 | } |
32 | } |
25 | if (stat(item->name, &item->st)) { |
33 | if (stat(item->name, &item->st)) { |
26 | item->st.st_mtime = 0; |
34 | item->st.st_mtime = 0; |
27 | return 0; |
35 | return 0; |
28 | } |
36 | } |
29 | return 1; |
37 | return 1; |
30 | } |
38 | } |
31 | |
39 | |
32 | int cache_create_dirs() |
40 | int cache_create_dirs() |
33 | { |
41 | { |
34 | char *path; |
42 | char *path; |
35 | |
43 | |
36 | if (!cgit_query_repo) |
44 | if (!cgit_query_repo) |
37 | return 0; |
45 | return 0; |
38 | |
46 | |
39 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); |
47 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); |
40 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
48 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
41 | return 0; |
49 | return 0; |
42 | |
50 | |
43 | if (cgit_query_page) { |
51 | if (cgit_query_page) { |
44 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, |
52 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, |
45 | cgit_query_page); |
53 | cgit_query_page); |
46 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
54 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
47 | return 0; |
55 | return 0; |
48 | } |
56 | } |
49 | return 1; |
57 | return 1; |
50 | } |
58 | } |
51 | |
59 | |
52 | int cache_lock(struct cacheitem *item) |
60 | int cache_lock(struct cacheitem *item) |
53 | { |
61 | { |
54 | int ret; |
62 | int ret; |
55 | char *lockfile = fmt("%s.lock", item->name); |
63 | char *lockfile = fmt("%s.lock", item->name); |
56 | |
64 | |
57 | top: |
65 | top: |
58 | item->fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR|S_IWUSR); |
66 | item->fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR|S_IWUSR); |
59 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) |
67 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) |
60 | goto top; |
68 | goto top; |
61 | if (item->fd == NOLOCK && errno == EEXIST) { |
69 | if (item->fd == NOLOCK && errno == EEXIST) { |
62 | struct stat st; |
70 | struct stat st; |
63 | time_t t; |
71 | time_t t; |
64 | if (stat(lockfile, &st)) |
72 | if (stat(lockfile, &st)) |
65 | return ret; |
73 | return ret; |
66 | t = time(NULL); |
74 | t = time(NULL); |
67 | if (t-st.st_mtime > cgit_cache_max_create_time && |
75 | if (t-st.st_mtime > cgit_cache_max_create_time && |
68 | !unlink(lockfile)) |
76 | !unlink(lockfile)) |
69 | goto top; |
77 | goto top; |
70 | return 0; |
78 | return 0; |
71 | } |
79 | } |
72 | return (item->fd > 0); |
80 | return (item->fd > 0); |
73 | } |
81 | } |
74 | |
82 | |
75 | int cache_unlock(struct cacheitem *item) |
83 | int cache_unlock(struct cacheitem *item) |
76 | { |
84 | { |
77 | close(item->fd); |
85 | close(item->fd); |
78 | return (rename(fmt("%s.lock", item->name), item->name) == 0); |
86 | return (rename(fmt("%s.lock", item->name), item->name) == 0); |
79 | } |
87 | } |
80 | |
88 | |
81 | int cache_expired(struct cacheitem *item) |
89 | int cache_expired(struct cacheitem *item) |
82 | { |
90 | { |
83 | if (item->ttl < 0) |
91 | if (item->ttl < 0) |
84 | return 0; |
92 | return 0; |
85 | return item->st.st_mtime + item->ttl * 60 < time(NULL); |
93 | return item->st.st_mtime + item->ttl * 60 < time(NULL); |
86 | } |
94 | } |
|
|
diff --git a/cgit.c b/cgit.c index 09c857c..808ffe9 100644 --- a/ cgit.c+++ b/ cgit.c |
|
@@ -1,128 +1,136 @@ |
| |
1 | /* cgit.c: cgi for the git scm |
| |
2 | * |
| |
3 | * Copyright (C) 2006 Lars Hjemli |
| |
4 | * |
| |
5 | * Licensed under GNU General Public License v2 |
| |
6 | * (see COPYING for full license text) |
| |
7 | */ |
| |
8 | |
1 | #include "cgit.h" |
9 | #include "cgit.h" |
2 | |
10 | |
3 | static const char cgit_doctype[] = |
11 | static const char cgit_doctype[] = |
4 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" |
12 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" |
5 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; |
13 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; |
6 | |
14 | |
7 | static const char cgit_error[] = |
15 | static const char cgit_error[] = |
8 | "<div class='error'>%s</div>"; |
16 | "<div class='error'>%s</div>"; |
9 | |
17 | |
10 | static const char cgit_lib_error[] = |
18 | static const char cgit_lib_error[] = |
11 | "<div class='error'>%s: %s</div>"; |
19 | "<div class='error'>%s: %s</div>"; |
12 | |
20 | |
13 | int htmlfd = 0; |
21 | int htmlfd = 0; |
14 | |
22 | |
15 | char *cgit_root = "/usr/src/git"; |
23 | char *cgit_root = "/usr/src/git"; |
16 | char *cgit_root_title = "Git repository browser"; |
24 | char *cgit_root_title = "Git repository browser"; |
17 | char *cgit_css = "/cgit.css"; |
25 | char *cgit_css = "/cgit.css"; |
18 | char *cgit_logo = "/git-logo.png"; |
26 | char *cgit_logo = "/git-logo.png"; |
19 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
27 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
20 | char *cgit_virtual_root = NULL; |
28 | char *cgit_virtual_root = NULL; |
21 | |
29 | |
22 | char *cgit_cache_root = "/var/cache/cgit"; |
30 | char *cgit_cache_root = "/var/cache/cgit"; |
23 | |
31 | |
24 | int cgit_cache_root_ttl = 5; |
32 | int cgit_cache_root_ttl = 5; |
25 | int cgit_cache_repo_ttl = 5; |
33 | int cgit_cache_repo_ttl = 5; |
26 | int cgit_cache_dynamic_ttl = 5; |
34 | int cgit_cache_dynamic_ttl = 5; |
27 | int cgit_cache_static_ttl = -1; |
35 | int cgit_cache_static_ttl = -1; |
28 | int cgit_cache_max_create_time = 5; |
36 | int cgit_cache_max_create_time = 5; |
29 | |
37 | |
30 | char *cgit_repo_name = NULL; |
38 | char *cgit_repo_name = NULL; |
31 | char *cgit_repo_desc = NULL; |
39 | char *cgit_repo_desc = NULL; |
32 | char *cgit_repo_owner = NULL; |
40 | char *cgit_repo_owner = NULL; |
33 | |
41 | |
34 | int cgit_query_has_symref = 0; |
42 | int cgit_query_has_symref = 0; |
35 | int cgit_query_has_sha1 = 0; |
43 | int cgit_query_has_sha1 = 0; |
36 | |
44 | |
37 | char *cgit_querystring = NULL; |
45 | char *cgit_querystring = NULL; |
38 | char *cgit_query_repo = NULL; |
46 | char *cgit_query_repo = NULL; |
39 | char *cgit_query_page = NULL; |
47 | char *cgit_query_page = NULL; |
40 | char *cgit_query_head = NULL; |
48 | char *cgit_query_head = NULL; |
41 | char *cgit_query_sha1 = NULL; |
49 | char *cgit_query_sha1 = NULL; |
42 | |
50 | |
43 | struct cacheitem cacheitem; |
51 | struct cacheitem cacheitem; |
44 | |
52 | |
45 | int cgit_parse_query(char *txt, configfn fn) |
53 | int cgit_parse_query(char *txt, configfn fn) |
46 | { |
54 | { |
47 | char *t, *value = NULL, c; |
55 | char *t, *value = NULL, c; |
48 | |
56 | |
49 | if (!txt) |
57 | if (!txt) |
50 | return 0; |
58 | return 0; |
51 | |
59 | |
52 | t = txt = xstrdup(txt); |
60 | t = txt = xstrdup(txt); |
53 | |
61 | |
54 | while((c=*t) != '\0') { |
62 | while((c=*t) != '\0') { |
55 | if (c=='=') { |
63 | if (c=='=') { |
56 | *t = '\0'; |
64 | *t = '\0'; |
57 | value = t+1; |
65 | value = t+1; |
58 | } else if (c=='&') { |
66 | } else if (c=='&') { |
59 | *t = '\0'; |
67 | *t = '\0'; |
60 | (*fn)(txt, value); |
68 | (*fn)(txt, value); |
61 | txt = t+1; |
69 | txt = t+1; |
62 | value = NULL; |
70 | value = NULL; |
63 | } |
71 | } |
64 | t++; |
72 | t++; |
65 | } |
73 | } |
66 | if (t!=txt) |
74 | if (t!=txt) |
67 | (*fn)(txt, value); |
75 | (*fn)(txt, value); |
68 | return 0; |
76 | return 0; |
69 | } |
77 | } |
70 | |
78 | |
71 | void cgit_global_config_cb(const char *name, const char *value) |
79 | void cgit_global_config_cb(const char *name, const char *value) |
72 | { |
80 | { |
73 | if (!strcmp(name, "root")) |
81 | if (!strcmp(name, "root")) |
74 | cgit_root = xstrdup(value); |
82 | cgit_root = xstrdup(value); |
75 | else if (!strcmp(name, "root-title")) |
83 | else if (!strcmp(name, "root-title")) |
76 | cgit_root_title = xstrdup(value); |
84 | cgit_root_title = xstrdup(value); |
77 | else if (!strcmp(name, "css")) |
85 | else if (!strcmp(name, "css")) |
78 | cgit_css = xstrdup(value); |
86 | cgit_css = xstrdup(value); |
79 | else if (!strcmp(name, "logo")) |
87 | else if (!strcmp(name, "logo")) |
80 | cgit_logo = xstrdup(value); |
88 | cgit_logo = xstrdup(value); |
81 | else if (!strcmp(name, "logo-link")) |
89 | else if (!strcmp(name, "logo-link")) |
82 | cgit_logo_link = xstrdup(value); |
90 | cgit_logo_link = xstrdup(value); |
83 | else if (!strcmp(name, "virtual-root")) |
91 | else if (!strcmp(name, "virtual-root")) |
84 | cgit_virtual_root = xstrdup(value); |
92 | cgit_virtual_root = xstrdup(value); |
85 | } |
93 | } |
86 | |
94 | |
87 | void cgit_repo_config_cb(const char *name, const char *value) |
95 | void cgit_repo_config_cb(const char *name, const char *value) |
88 | { |
96 | { |
89 | if (!strcmp(name, "name")) |
97 | if (!strcmp(name, "name")) |
90 | cgit_repo_name = xstrdup(value); |
98 | cgit_repo_name = xstrdup(value); |
91 | else if (!strcmp(name, "desc")) |
99 | else if (!strcmp(name, "desc")) |
92 | cgit_repo_desc = xstrdup(value); |
100 | cgit_repo_desc = xstrdup(value); |
93 | else if (!strcmp(name, "owner")) |
101 | else if (!strcmp(name, "owner")) |
94 | cgit_repo_owner = xstrdup(value); |
102 | cgit_repo_owner = xstrdup(value); |
95 | } |
103 | } |
96 | |
104 | |
97 | void cgit_querystring_cb(const char *name, const char *value) |
105 | void cgit_querystring_cb(const char *name, const char *value) |
98 | { |
106 | { |
99 | if (!strcmp(name,"r")) |
107 | if (!strcmp(name,"r")) |
100 | cgit_query_repo = xstrdup(value); |
108 | cgit_query_repo = xstrdup(value); |
101 | else if (!strcmp(name, "p")) |
109 | else if (!strcmp(name, "p")) |
102 | cgit_query_page = xstrdup(value); |
110 | cgit_query_page = xstrdup(value); |
103 | else if (!strcmp(name, "h")) { |
111 | else if (!strcmp(name, "h")) { |
104 | cgit_query_head = xstrdup(value); |
112 | cgit_query_head = xstrdup(value); |
105 | cgit_query_has_symref = 1; |
113 | cgit_query_has_symref = 1; |
106 | } else if (!strcmp(name, "id")) { |
114 | } else if (!strcmp(name, "id")) { |
107 | cgit_query_sha1 = xstrdup(value); |
115 | cgit_query_sha1 = xstrdup(value); |
108 | cgit_query_has_sha1 = 1; |
116 | cgit_query_has_sha1 = 1; |
109 | } |
117 | } |
110 | } |
118 | } |
111 | |
119 | |
112 | char *cgit_repourl(const char *reponame) |
120 | char *cgit_repourl(const char *reponame) |
113 | { |
121 | { |
114 | if (cgit_virtual_root) { |
122 | if (cgit_virtual_root) { |
115 | return fmt("%s/%s/", cgit_virtual_root, reponame); |
123 | return fmt("%s/%s/", cgit_virtual_root, reponame); |
116 | } else { |
124 | } else { |
117 | return fmt("?r=%s", reponame); |
125 | return fmt("?r=%s", reponame); |
118 | } |
126 | } |
119 | } |
127 | } |
120 | |
128 | |
121 | char *cgit_pageurl(const char *reponame, const char *pagename, |
129 | char *cgit_pageurl(const char *reponame, const char *pagename, |
122 | const char *query) |
130 | const char *query) |
123 | { |
131 | { |
124 | if (cgit_virtual_root) { |
132 | if (cgit_virtual_root) { |
125 | return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame, |
133 | return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame, |
126 | pagename, query); |
134 | pagename, query); |
127 | } else { |
135 | } else { |
128 | return fmt("?r=%s&p=%s&%s", reponame, pagename, query); |
136 | return fmt("?r=%s&p=%s&%s", reponame, pagename, query); |
|
|
diff --git a/config.c b/config.c index ee49b62..871edf2 100644 --- a/ config.c+++ b/ config.c |
|
@@ -1,73 +1,81 @@ |
| |
1 | /* config.c: parsing of config files |
| |
2 | * |
| |
3 | * Copyright (C) 2006 Lars Hjemli |
| |
4 | * |
| |
5 | * Licensed under GNU General Public License v2 |
| |
6 | * (see COPYING for full license text) |
| |
7 | */ |
| |
8 | |
1 | #include "cgit.h" |
9 | #include "cgit.h" |
2 | |
10 | |
3 | int next_char(FILE *f) |
11 | int next_char(FILE *f) |
4 | { |
12 | { |
5 | int c = fgetc(f); |
13 | int c = fgetc(f); |
6 | if (c=='\r') { |
14 | if (c=='\r') { |
7 | c = fgetc(f); |
15 | c = fgetc(f); |
8 | if (c!='\n') { |
16 | if (c!='\n') { |
9 | ungetc(c, f); |
17 | ungetc(c, f); |
10 | c = '\r'; |
18 | c = '\r'; |
11 | } |
19 | } |
12 | } |
20 | } |
13 | return c; |
21 | return c; |
14 | } |
22 | } |
15 | |
23 | |
16 | void skip_line(FILE *f) |
24 | void skip_line(FILE *f) |
17 | { |
25 | { |
18 | int c; |
26 | int c; |
19 | |
27 | |
20 | while((c=next_char(f)) && c!='\n' && c!=EOF) |
28 | while((c=next_char(f)) && c!='\n' && c!=EOF) |
21 | ; |
29 | ; |
22 | } |
30 | } |
23 | |
31 | |
24 | int read_config_line(FILE *f, char *line, const char **value, int bufsize) |
32 | int read_config_line(FILE *f, char *line, const char **value, int bufsize) |
25 | { |
33 | { |
26 | int i = 0, isname = 0; |
34 | int i = 0, isname = 0; |
27 | |
35 | |
28 | *value = NULL; |
36 | *value = NULL; |
29 | while(i<bufsize-1) { |
37 | while(i<bufsize-1) { |
30 | int c = next_char(f); |
38 | int c = next_char(f); |
31 | if (!isname && (c=='#' || c==';')) { |
39 | if (!isname && (c=='#' || c==';')) { |
32 | skip_line(f); |
40 | skip_line(f); |
33 | continue; |
41 | continue; |
34 | } |
42 | } |
35 | if (!isname && isspace(c)) |
43 | if (!isname && isspace(c)) |
36 | continue; |
44 | continue; |
37 | |
45 | |
38 | if (c=='=' && !*value) { |
46 | if (c=='=' && !*value) { |
39 | line[i] = 0; |
47 | line[i] = 0; |
40 | *value = &line[i+1]; |
48 | *value = &line[i+1]; |
41 | } else if (c=='\n' && !isname) { |
49 | } else if (c=='\n' && !isname) { |
42 | i = 0; |
50 | i = 0; |
43 | continue; |
51 | continue; |
44 | } else if (c=='\n' || c==EOF) { |
52 | } else if (c=='\n' || c==EOF) { |
45 | line[i] = 0; |
53 | line[i] = 0; |
46 | break; |
54 | break; |
47 | } else { |
55 | } else { |
48 | line[i]=c; |
56 | line[i]=c; |
49 | } |
57 | } |
50 | isname = 1; |
58 | isname = 1; |
51 | i++; |
59 | i++; |
52 | } |
60 | } |
53 | line[i+1] = 0; |
61 | line[i+1] = 0; |
54 | return i; |
62 | return i; |
55 | } |
63 | } |
56 | |
64 | |
57 | int cgit_read_config(const char *filename, configfn fn) |
65 | int cgit_read_config(const char *filename, configfn fn) |
58 | { |
66 | { |
59 | int ret = 0, len; |
67 | int ret = 0, len; |
60 | char line[256]; |
68 | char line[256]; |
61 | const char *value; |
69 | const char *value; |
62 | FILE *f = fopen(filename, "r"); |
70 | FILE *f = fopen(filename, "r"); |
63 | |
71 | |
64 | if (!f) |
72 | if (!f) |
65 | return -1; |
73 | return -1; |
66 | |
74 | |
67 | while((len = read_config_line(f, line, &value, sizeof(line))) > 0) |
75 | while((len = read_config_line(f, line, &value, sizeof(line))) > 0) |
68 | (*fn)(line, value); |
76 | (*fn)(line, value); |
69 | |
77 | |
70 | fclose(f); |
78 | fclose(f); |
71 | return ret; |
79 | return ret; |
72 | } |
80 | } |
73 | |
81 | |
|
|
diff --git a/html.c b/html.c index bf1490f..fab67bd 100644 --- a/ html.c+++ b/ html.c |
|
@@ -1,102 +1,110 @@ |
| |
1 | /* html.c: helper functions for html output |
| |
2 | * |
| |
3 | * Copyright (C) 2006 Lars Hjemli |
| |
4 | * |
| |
5 | * Licensed under GNU General Public License v2 |
| |
6 | * (see COPYING for full license text) |
| |
7 | */ |
| |
8 | |
1 | #include "cgit.h" |
9 | #include "cgit.h" |
2 | |
10 | |
3 | char *fmt(const char *format, ...) |
11 | char *fmt(const char *format, ...) |
4 | { |
12 | { |
5 | static char buf[8][1024]; |
13 | static char buf[8][1024]; |
6 | static int bufidx; |
14 | static int bufidx; |
7 | int len; |
15 | int len; |
8 | va_list args; |
16 | va_list args; |
9 | |
17 | |
10 | bufidx++; |
18 | bufidx++; |
11 | bufidx &= 7; |
19 | bufidx &= 7; |
12 | |
20 | |
13 | va_start(args, format); |
21 | va_start(args, format); |
14 | len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args); |
22 | len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args); |
15 | va_end(args); |
23 | va_end(args); |
16 | if (len>sizeof(buf[bufidx])) |
24 | if (len>sizeof(buf[bufidx])) |
17 | die("[html.c] string truncated: %s", format); |
25 | die("[html.c] string truncated: %s", format); |
18 | return buf[bufidx]; |
26 | return buf[bufidx]; |
19 | } |
27 | } |
20 | |
28 | |
21 | void html(const char *txt) |
29 | void html(const char *txt) |
22 | { |
30 | { |
23 | write(htmlfd, txt, strlen(txt)); |
31 | write(htmlfd, txt, strlen(txt)); |
24 | } |
32 | } |
25 | |
33 | |
26 | void htmlf(const char *format, ...) |
34 | void htmlf(const char *format, ...) |
27 | { |
35 | { |
28 | static char buf[65536]; |
36 | static char buf[65536]; |
29 | va_list args; |
37 | va_list args; |
30 | |
38 | |
31 | va_start(args, format); |
39 | va_start(args, format); |
32 | vsnprintf(buf, sizeof(buf), format, args); |
40 | vsnprintf(buf, sizeof(buf), format, args); |
33 | va_end(args); |
41 | va_end(args); |
34 | html(buf); |
42 | html(buf); |
35 | } |
43 | } |
36 | |
44 | |
37 | void html_txt(char *txt) |
45 | void html_txt(char *txt) |
38 | { |
46 | { |
39 | char *t = txt; |
47 | char *t = txt; |
40 | while(*t){ |
48 | while(*t){ |
41 | int c = *t; |
49 | int c = *t; |
42 | if (c=='<' || c=='>' || c=='&') { |
50 | if (c=='<' || c=='>' || c=='&') { |
43 | *t = '\0'; |
51 | *t = '\0'; |
44 | html(txt); |
52 | html(txt); |
45 | *t = c; |
53 | *t = c; |
46 | if (c=='>') |
54 | if (c=='>') |
47 | html(">"); |
55 | html(">"); |
48 | else if (c=='<') |
56 | else if (c=='<') |
49 | html("<"); |
57 | html("<"); |
50 | else if (c=='&') |
58 | else if (c=='&') |
51 | html("&"); |
59 | html("&"); |
52 | txt = t+1; |
60 | txt = t+1; |
53 | } |
61 | } |
54 | t++; |
62 | t++; |
55 | } |
63 | } |
56 | if (t!=txt) |
64 | if (t!=txt) |
57 | html(txt); |
65 | html(txt); |
58 | } |
66 | } |
59 | |
67 | |
60 | |
68 | |
61 | void html_attr(char *txt) |
69 | void html_attr(char *txt) |
62 | { |
70 | { |
63 | char *t = txt; |
71 | char *t = txt; |
64 | while(*t){ |
72 | while(*t){ |
65 | int c = *t; |
73 | int c = *t; |
66 | if (c=='<' || c=='>' || c=='\'') { |
74 | if (c=='<' || c=='>' || c=='\'') { |
67 | *t = '\0'; |
75 | *t = '\0'; |
68 | html(txt); |
76 | html(txt); |
69 | *t = c; |
77 | *t = c; |
70 | if (c=='>') |
78 | if (c=='>') |
71 | html(">"); |
79 | html(">"); |
72 | else if (c=='<') |
80 | else if (c=='<') |
73 | html("<"); |
81 | html("<"); |
74 | else if (c=='\'') |
82 | else if (c=='\'') |
75 | html(""e;"); |
83 | html(""e;"); |
76 | txt = t+1; |
84 | txt = t+1; |
77 | } |
85 | } |
78 | t++; |
86 | t++; |
79 | } |
87 | } |
80 | if (t!=txt) |
88 | if (t!=txt) |
81 | html(txt); |
89 | html(txt); |
82 | } |
90 | } |
83 | |
91 | |
84 | void html_link_open(char *url, char *title, char *class) |
92 | void html_link_open(char *url, char *title, char *class) |
85 | { |
93 | { |
86 | html("<a href='"); |
94 | html("<a href='"); |
87 | html_attr(url); |
95 | html_attr(url); |
88 | if (title) { |
96 | if (title) { |
89 | html("' title='"); |
97 | html("' title='"); |
90 | html_attr(title); |
98 | html_attr(title); |
91 | } |
99 | } |
92 | if (class) { |
100 | if (class) { |
93 | html("' class='"); |
101 | html("' class='"); |
94 | html_attr(class); |
102 | html_attr(class); |
95 | } |
103 | } |
96 | html("'>"); |
104 | html("'>"); |
97 | } |
105 | } |
98 | |
106 | |
99 | void html_link_close(void) |
107 | void html_link_close(void) |
100 | { |
108 | { |
101 | html("</a>"); |
109 | html("</a>"); |
102 | } |
110 | } |
|