Compare commits

...

252 Commits

Author SHA1 Message Date
Samuel Lidén Borell 00ecfaadea config: make empty js= omit script tag
According to the cgitrc man page, an empty js= value should cause the
script tag to be omitted. But instead, a script tag with an empty URL
is emitted. The same applies to css. So, skip emitting a tag if the
specified string is empty.

Signed-off-by: Samuel Lidén Borell <samuel@kodafritt.se>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
Andy Green 907134b7a2 js: add dynamic age update
This patch updates the emitted "ages" dynamically on the client side.

After updating on completion of the document load, it sets a timer
to update according to the smallest age it found.  If there are any
ages listed in minutes, then it will update again in 10s.  When the
most recent age is in hours, it updates every 5m.  If days, then
every 30m and so on.

This keeps the cost of the dynamic updates at worst once per 10s.
The updates are done entirely on the client side without contact
with the server.

To make this work reliably, since parsing datetimes is unreliable in
browser js, the unix time is added as an attribute to all age spans.

To make that reliable cross-platform, the unix time is treated as a
uint64_t when it is formatted for printing.

The rules for display conversion of the age is aligned with the
existing server-side rules in ui-shared.h.

If the client or server-side time are not synchronized by ntpd etc,
ages shown on the client will not relate to the original ages computed
at the server.  The client updates the ages immediately when the
DOM has finished loading, so in the case the times at the server and
client are not aligned, this patch changes what the user sees on the
page to reflect patch age compared to client time.

If the server and client clocks are aligned, this patch makes no
difference to what is seen on the page.

Signed-off-by: Andy Green <andy@warmcat.com>
Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Andy Green aee39b4e9a config: add js
Just like the config allows setting css URL path, add a config for
setting the js URL path

Signed-off-by: Andy Green <andy@warmcat.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Andy Green 093ac96970 css: change to be a list
Without changing the default behaviour of including
/cgit.css if nothing declared, allow the "css" config
to be given multiple times listing one or more
alternative URL paths to be included in the document
head area.

Signed-off-by: Andy Green <andy@warmcat.com>
Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 91f25909b9 cgitrc: handle value "0" for max-repo-count
Setting max-repo-count to "0" makes cgit loop forever generating page
links. Make this a special value to show all repositories.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Hristo Venev 852cb3b0e2 cache: tolerate short writes in print_slot
sendfile() can return after a short read/write, so we may need to call
it more than once. As suggested in the manual page, we fall back to
read/write if sendfile fails with EINVAL or ENOSYS.

On the read/write path, use write_in_full which deals with short writes.

Signed-off-by: Hristo Venev <hristo@venev.name>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
John Keeping 4c520cefc9 global: use release_commit_memory()
Instead of calling two separate Git functions to free memory associated
with a commit object, use Git's wrapper which does this.  This also
counts as a potential future bug fix since release_commit_memory() also
resets the parsed state of the commit, meaning any attempt to use it in
the future will correctly fill out the fields again.

release_commit_memory() does not set parents to zero, so keep that for
additional safety in case CGit checks this without calling
parse_commit() again.

Signed-off-by: John Keeping <john@keeping.me.uk>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
John Keeping d071f28cfa css: reset font size for blame oid
In Firefox, the hashes in the blame UI are out of step with the line
number and content leading to ever increasing vertical misalignment.

This is caused by the .oid class setting font-size to 90%, so override
this back to 100% for the blame case, bringing the height of lines in
all three columns of the table back into step.

Signed-off-by: John Keeping <john@keeping.me.uk>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
John Keeping c1a1d23111 ui-blame: add a link to the parent commit in blame
When walking through the history, it is useful to quickly see the same
file at the previous revision, so add a link to do this.

It would be nice to link to the correct line with an additional
fragment, but this requires significantly more work so it can be done as
an enhancement later.  (ent->s_lno is mostly the right thing, but it is
the line number in the post-image of the target commit whereas the link
is to the parent of that commit, i.e. the pre-image of the target.)

Suggested-by: Alejandro Colomar <alx.manpages@gmail.com>
Signed-off-by: John Keeping <john@keeping.me.uk>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
Christian Hesse a0f6669bdb about: allow to give head from query
Reading the README from repository used to be limited to default
branch or a branch given in configuration. Let's allow a branch
from query if not specified explicitly.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Peter Prohaska ce2062d9e2 html: fix handling of null byte
A return value of `len` or more means that the output was truncated.

Signed-off-by: Peter Prohaska <pitrp@web.de>
Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
June McEnroe 4e4b30effb ui-atom: generate valid Atom feeds
Fixes several RFC 4287 violations:

> 4.1.1. The "atom:feed" Element
>    o  atom:feed elements MUST contain exactly one atom:id element.
>    o  atom:feed elements SHOULD contain one atom:link element with a rel
>       attribute value of "self".  This is the preferred URI for
>       retrieving Atom Feed Documents representing this Atom feed.
>    o  atom:feed elements MUST contain exactly one atom:updated element.

An atom:id element is generated from cgit_currentfullurl(), and an
atom:link element with a rel attribute of "self" is generated with
the same URL. An atom:updated element is generated from the date
of the first commit in the revision walk.

> 4.1.2.  The "atom:entry" Element
>    o  atom:entry elements MUST NOT contain more than one atom:content
>       element.

The second atom:content element with the type of "xhtml" is removed.

> 4.2.6.  The "atom:id" Element
>    Its content MUST be an IRI, as defined by [RFC3987].  Note that the
>    definition of "IRI" excludes relative references.  Though the IRI
>    might use a dereferencable scheme, Atom Processors MUST NOT assume it
>    can be dereferenced.

The atom:id elements for commits now use URNs in the "sha1" or
"sha256" namespaces. Although these are not registered URN namespaces,
they see use in the wild, for instance as part of magnet URIs.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
June McEnroe 3295155a0c ui-shared: use owner-filter for repo page headers
Previously it was only used if owners were displayed on the index.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
Chris Mayo e32f8416e8 ui-commit: use git raw note format
Currently a commit note is shown as:

    Notes

      Notes:
          <note text>

Change to:

    Notes
      <note text>

Signed-off-by: Chris Mayo <aklhfex@gmail.com>
Reviewed-by: Alyssa Ross <hi@alyssa.is>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
Chris Mayo afffc3e772 ui-repolist,ui-shared: remove redundant title on repo anchors
The title attribute was being set to the same value as the anchor
element text.

Signed-off-by: Chris Mayo <aklhfex@gmail.com>
Reviewed-by: Eric Wong <e@80x24.org>
Reviewed-by: Petr Vorel <petr.vorel@gmail.com>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
June McEnroe fd20a5475e ui-commit: show subject in commit page title
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
June McEnroe bcffc52366 ui-tree: show symlink targets in tree listing
Add links to symbolic link targets in tree listings, formatted like
"ls -l".  Path normalization collapses any ".." components of the link.

Also fix up memory link on error path.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
June McEnroe cc6d9cc7fc ui-tree,ui-blame: bail from blame if blob is binary
This avoids piping binary blobs through the source-filter. Also prevent
robots from crawling it, since it's expensive.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
1 year ago
Christian Hesse e10159691e git: update to v2.39.0
Update to git version v2.39.0, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 979cf4a753 git: update to v2.38.2
Update to git version v2.38.2, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 6ac984b51d git: update to v2.38.1
Update to git version v2.38.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 33efb5fec5 git: update to v2.38.0
Update to git version v2.38.0, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse e5c868f109 git: update to v2.37.3
Update to git version v2.37.3, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 43df01c10f git: update to v2.37.2
Update to git version v2.37.2, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 89ee517122 git: update to v2.37.1
Update to git version v2.37.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse 2486d70752 git: update to v2.37.0
Update to git version v2.37.0, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse bcdfb2197f git: update to v2.36.1
Update to git version v2.36.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
June McEnroe b9ff119549 shared: fix bad free in cgit_diff_tree
Since git commit 244c27242f44e6b88e3a381c90bde08d134c274b,

> diff.[ch]: have diff_free() call clear_pathspec(opts.pathspec)

calling diff_flush calls free(3) on opts.pathspec.items, so it can't
be a pointer to a stack variable.

Signed-off-by: Christian Hesse <mail@eworm.de>
1 year ago
Christian Hesse bb02e24ec2 git: update to v2.36.0
Update to git version v2.36.0, this requires changes for these
upstream commits:

* 95433eeed9eac439eb21eb30105354b15e71302e
  diff: add ability to insert additional headers for paths

Signed-off-by: Christian Hesse <mail@eworm.de>
2 years ago
Christian Hesse cc9b717c87 git: update to v2.35.3
Update to git version v2.35.3, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
2 years ago
Christian Hesse 9761994243 git: update to v2.35.2
Update to git version v2.35.2, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
2 years ago
Christian Hesse bbbaa29a96 git: update to v2.35.1
Update to git version v2.35.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
2 years ago
Christian Hesse 73e98c16e8 git: update to v2.35.0
Update to git version v2.35.0, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
2 years ago
Christian Hesse 11be5b8182 git: update to v2.34.1
Update to git version v2.34.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse b8f2b675df git: update to v2.34.0
Update to git version v2.34.0, this requires changes for these
upstream commits:

* abf897bacd2d36b9dbd07c70b4a2f97a084704ee
  string-list.[ch]: remove string_list_init() compatibility function

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse 45eff40655 git: update to v2.33.0
Update to git version v2.33.0, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse 5258c297ba git: update to v2.32.0
Update to git version v2.32.0, this requires changes for these
upstream commits:

* 47957485b3b731a7860e0554d2bd12c0dce1c75a
  tree.h API: simplify read_tree_recursive() signature

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse 6dbbffe015 git: update to v2.31.1
Update to git version v2.31.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse 62eb8db452 md2html: use proper formatting for hr
This addressed a non-existent background image and made the element
invisible. Drop the style and use something sane.

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse d889cae811 git: update to v2.31.0
Update to git version v2.31.0, this requires changes for these
upstream commits:

* 36a317929b8f0c67d77d54235f2d20751c576cbb
  refs: switch peel_ref() to peel_iterated_oid()

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse 4ffadc1e0c git: update to v2.30.1
Update to git version v2.30.1, no additional changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Todd Zullinger bd6f5683f6 tests: t0107: support older and/or non-GNU tar
The untar tests for various compression algorithms use shortcut options
from GNU tar to handle decompression.  These options may not be provided
by non-GNU tar nor even by slightly older GNU tar versions which ship on
many systems.

An example of the latter case is the --zstd option.  This was added in
GNU tar-1.32 (2019-02-23)¹.  This version of tar is not provided by
CentOS/RHEL, in particular.  In Debian, --zstd has been backported to
the tar-1.30 release.

Avoid the requirement on any specific implementations or versions of tar
by piping decompressed output to tar.  This is compatible with older GNU
tar releases as well as tar implementations from other vendors.  (It may
also be a slight benefit that this more closely matches what the
snapshot creation code does.)

¹ Technically, the --zstd option was first released in tar-1.31
  (2019-01-02), but this release was very short-lived and is no longer
  listed on the GNU Tar release page.

Signed-off-by: Todd Zullinger <tmz@pobox.com>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
3 years ago
Jason A. Donenfeld f69626c68e md2html: use sane_lists extension
This allows for cleaner nesting semantics and matches github more
closely.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
3 years ago
Christian Hesse cef27b670a git: update to v2.30.0
Update to git version v2.30.0, this requires changes for these
upstream commits:

* 88894aaeeae92e8cb41143cc2e045f50289dc790
  blame: simplify 'setup_scoreboard' interface

* 1fbfdf556f2abc708183caca53ae4e2881b46ae2
  banned.h: mark non-reentrant gmtime, etc as banned

Signed-off-by: Christian Hesse <mail@eworm.de>
3 years ago
Christian Hesse b1739247b1 git: update to v2.29.2
Update to git version v2.29.2.

No changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse fe99c76ee4 git: update to v2.29.1
Update to git version v2.29.1. No functional change, but we want latest
and greated version number, no? 😜

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse adcc4f822f tests: try with commit-graph
Git 2.24.0 enabled commit-graph by default and caused crashes without
necessary update. Let's test to work with commit-graph.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse a1039ab175 tests: do not copy snapshots to /tmp/
No idea why this was added... Possibly to inspect the snapshot manually?
Let's drop it.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse a4de0e810b global: replace hard coded hash length
With sha1 we had a guaranteed length of 40 hex chars. This changes now
that we have to support sha256 with 64 hex chars... Support both.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse 779631c6dc global: replace references to 'sha1' with 'oid'
For some time now sha1 is considered broken and upstream is working to
replace it with sha256. Replace all references to 'sha1' with 'oid',
just as upstream does.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse 629659d2cf git: update to v2.29.0
Update to git version v2.29.0, this requires changes for these
upstream commits:

* dbbcd44fb47347a3fdbee88ea21805b7f4ac0b98
  strvec: rename files from argv-array to strvec

* 873cd28a8b17ff21908c78c7929a7615f8c94992
  argv-array: rename to strvec

* d70a9eb611a9d242c1d26847d223b8677609305b
  strvec: rename struct fields

* 6a67c759489e1025665adf78326e9e0d0981bab5
  test-lib-functions: restrict test_must_fail usage

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse 205837d468 git: update to v2.28.0
Update to git version v2.28.0.

No changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse f780396c0a git: update to v2.27.0
Update to git version v2.27.0.

No changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse 0462f08d85 git: update to v2.26.0
Update to git version v2.26.0.

No changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Jason A. Donenfeld 55fa25adb0 Bump version
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
4 years ago
Jason A. Donenfeld 6a8d6d4b50 global: use proper accessors for maybe_tree
A previous commit changed ->tree to ->maybe_tree throughout, which may
have worked at the time, but wasn't safe, because maybe_tree is loaded
lazily. This manifested itself in crashes when using the "follow" log
feature. The proper fix is to use the correct contextual accessors
everytime we want access to maybe_tree. Thankfully, the commit.cocci
script takes care of creating mostly-correct patches that we could then
fix up, resulting in this commit here.

Fixes: 255b78f ("git: update to v2.18.0")
Reviewed-by: Christian Hesse <mail@eworm.de>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
4 years ago
Christian Hesse 892ba8c3cc ui-snapshot: add support for zstd compression
This patch adds support for zstd [0] compressed snapshots (*.tar.zst).
We enable multiple working threads (-T0), but keep default compression
level. The latter can be influenced by environment variable.

[0] https://www.zstd.net/

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse cc230bf044 tests: add tests for xz compressed snapshots
Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Hanspeter Portner 06671f4b21 ui-snapshot: add support for lzip compression
This patch adds support for lzip [1] compressed snapshots (*.tar.lz)

[1] https://www.nongnu.org/lzip/

Signed-off-by: Hanspeter Portner <dev@open-music-kontrollers.ch>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
4 years ago
Christian Hesse fde897b817 git: update to v2.25.1
Update to git version v2.25.1.

No changes required.
4 years ago
Christian Hesse 5e49023b01 tests: allow to skip git version tests
This allows to run tests non-tagged git checkout or when bisecting.

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Jason A. Donenfeld fa146ccabd Bump version
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
4 years ago
Christian Hesse bd68c98879 git: update to v2.25.0
Update to git version v2.25.0.

Upstream renamed 'init_display_notes()' to 'load_display_notes()' in
commit 1e6ed5441a61b5085978e0429691e2e2425f6846 ("notes: rename to
load_display_notes()").

Signed-off-by: Christian Hesse <mail@eworm.de>
4 years ago
Christian Hesse ca98c9e7bf tests: skip tests if strace is not functional
Chances are that strace is available but not functional due to
restricted permissions:

strace: test_ptrace_get_syscall_info: PTRACE_TRACEME: Operation not permitted
strace: ptrace(PTRACE_TRACEME, ...): Operation not permitted
+++ exited with 1 +++

Just skip the tests then.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse d8e5dd25a0 git: update to v2.24.1
Update to git version v2.24.1.

No changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse 583aa5d80e ui-repolist: do not return unsigned (negative) value
The function read_agefile() returns time_t, which is a signed datatime.
We should not return unsigned (negative) value here.

Reported-by: Johannes Stezenbach <js@linuxtv.org>
Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse bfabd4519c git: update to v2.24.0
Update to git version v2.24.0.

Never use get_cached_commit_buffer() directly, use repo_get_commit_buffer()
instead. The latter calls the former anyway. This fixes segmentation fault
when commit-graph is enabled and get_cached_commit_buffer() does not return
the expected result.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse 8fc0c81bbb git: update to v2.23.0
Update to git version v2.23.0.

No changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse 034e3c7d56 git: update to v2.22.0
Update to git version v2.22.0.

Upstream commit bce9db6d ("trace2: use system/global config for default
trace2 settings") caused a regression. We have to unset HOME and
XDG_CONFIG_HOME before early loading of config from trace2 code kicks in.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse e1ad15d368 ui-tree: allow per repository override for enable-blame
The blame operation can cause high cost in terms of CPU load for huge
repositories. Let's add a per repository override for enable-blame.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse 27a6d69ab3 tests: successfully validate rc versions
For testing versions the version string differs for git tag (v2.22.0-rc3)
and tarball file name (2.22.0.rc3). Let's fix validation for testing
versions.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse 985fba80d0 git: update to v2.21.0
Update to git version v2.21.0. Required changes follow upstream commits:

* 6a7895fd8a3bd409f2b71ffc355d5142172cc2a0
  (commit: prepare free_commit_buffer and release_commit_memory for
  any repo)

* e092073d643b17c82d72cf692fbfaea9c9796f11
  (tree.c: make read_tree*() take 'struct repository *')

Signed-off-by: Christian Hesse <mail@eworm.de>
Reviewed-by: John Keeping <john@keeping.me.uk>
5 years ago
Christian Hesse 68de710c1c ui-ssdiff: ban strncat()
Git version v2.21.0 marks strncat() as banned (commit
ace5707a803eda0f1dde3d776dc3729d3bc7759a), so replace it.

Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Christian Hesse ccba7eb9d0 global: make 'char *path' const where possible
Signed-off-by: Christian Hesse <mail@eworm.de>
5 years ago
Jason A. Donenfeld 54c407a74a ui-shared: restrict to 15 levels
Perhaps a more ideal version of this would be to not print breadcrumbs
at all for paths that don't exist in the given repo at the given oid.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reported-by: Fydor Wire Snark <wsnark@tuta.io>
5 years ago
Chris Mayo bd0293f570 ui-diff,ui-tag: don't use htmlf with non-formatted strings
Signed-off-by: Chris Mayo <aklhfex@gmail.com>
5 years ago
Chris Mayo 5bd7e9bc1b ui-ssdiff: resolve HTML5 validation errors
- Remove ids from anchor elements. They were unusable because they were
  duplicated between files and versions of files.
- Always close span, with html().
- Fix missing / on closing tr element in cgit_ssdiff_header_end().

Signed-off-by: Chris Mayo <aklhfex@gmail.com>
5 years ago
Jason A. Donenfeld 7d87cd3a21 filters: migrate from luacrypto to luaossl
luaossl has no upstream anymore and doesn't support OpenSSL 1.1,
whereas luaossl is quite active.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
5 years ago
Jason A. Donenfeld e23f63461f ui-shared: fix broken sizeof in title setting and rewrite
The old algorithm was totally incorrect. While we're at it, use «
instead of \, since it makes more sense.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
5 years ago
Christian Hesse 55ebd5e97c git: update to v2.20.0
Update to git version v2.20.0. Required changes follow upstream commits:

* 00436bf1b1c2a8fe6cf5d2c2457d419d683042f4
  (archive: initialize archivers earlier)

* 611e42a5980a3a9f8bb3b1b49c1abde63c7a191e
  (xdiff: provide a separate emit callback for hunks)

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Jason A. Donenfeld 441dac1d74 ui-blame: set repo for sb
Otherwise recent git complains and crashes with: "BUG: blame.c:1787:
repo is NULL".

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld 898b9e19e0 auth-filter: pass url with query string attached
Otherwise redirections come out wrong.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Christian Hesse a22855747e git: use xz compressed archive for download
Upstream will stop providing gz compressed source tarballs [0], so stop
using them.

[0] https://lists.zx2c4.com/pipermail/cgit/2018-November/004254.html

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 2c9f56f3e1 git: update to v2.19.1
Update to git version v2.19.1. Required changes follow upstream commits:

* commit: add repository argument to get_cached_commit_buffer
  (3ce85f7e5a41116145179f0fae2ce6d86558d099)

* commit: add repository argument to lookup_commit_reference
  (2122f6754c93be8f02bfb5704ed96c88fc9837a8)

* object: add repository argument to parse_object
  (109cd76dd3467bd05f8d2145b857006649741d5c)

* tag: add repository argument to deref_tag
  (a74093da5ed601a09fa158e5ba6f6f14c1142a3e)

* tag: add repository argument to lookup_tag
  (ce71efb713f97f476a2d2ab541a0c73f684a5db3)

* tree: add repository argument to lookup_tree
  (f86bcc7b2ce6cad68ba1a48a528e380c6126705e)

* archive.c: avoid access to the_index
  (b612ee202a48f129f81f8f6a5af6cf71d1a9caef)

* for_each_*_object: move declarations to object-store.h
  (0889aae1cd18c1804ba01c1a4229e516dfb9fe9b)

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse a96f2890f4 ui-ssdiff: ban strcat()
Git upstream bans strcat() with commit:

  banned.h: mark strcat() as banned
  1b11b64b815db62f93a04242e4aed5687a448748

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 0899eb644f ui-ssdiff: ban strncpy()
Git upstream bans strncpy() with commit:

  banned.h: mark strncpy() as banned
  e488b7aba743d23b830d239dcc33d9ca0745a9ad

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 2fc008d6de ui-shared: ban strcat()
Git upstream bans strcat() with commit:

  banned.h: mark strcat() as banned
  1b11b64b815db62f93a04242e4aed5687a448748

To avoid compiler warnings from gcc 8.1.x we get the hard way.

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse edb3403f00 ui-patch: ban sprintf()
Git upstream bans sprintf() with commit:

  banned.h: mark sprintf() as banned
  cc8fdaee1eeaf05d8dd55ff11f111b815f673c58

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 7f75647b55 ui-log: ban strncpy()
Git upstream bans strncpy() with commit:

  banned.h: mark strncpy() as banned
  e488b7aba743d23b830d239dcc33d9ca0745a9ad

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 71ba7187e5 ui-log: ban strcpy()
Git upstream bans strcpy() with commit:

  automatically ban strcpy()
  c8af66ab8ad7cd78557f0f9f5ef6a52fd46ee6dd

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 60a930044d parsing: ban sprintf()
Git upstream bans sprintf() with commit:

  banned.h: mark sprintf() as banned
  cc8fdaee1eeaf05d8dd55ff11f111b815f673c58

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 7cde5885d8 parsing: ban strncpy()
Git upstream bans strncpy() with commit:

  banned.h: mark strncpy() as banned
  e488b7aba743d23b830d239dcc33d9ca0745a9ad

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse b0fc647fe6 filters: generate anchor links from markdown
This makes the markdown filter generate anchor links for headings.

Signed-off-by: Christian Hesse <mail@eworm.de>
Tested-by: jean-christophe manciot <actionmystique@gmail.com>
6 years ago
Jason A. Donenfeld 824138e591 Bump version.
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld 53efaf30b5 clone: fix directory traversal
This was introduced in the initial version of this code, way back when
in 2008.

$ curl http://127.0.0.1/cgit/repo/objects/?path=../../../../../../../../../etc/passwd
root0:0:root:/root:/bin/sh
...

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reported-by: Jann Horn <jannh@google.com>
6 years ago
Konstantin Ryabitsev c679d90104 config: record repo.snapshot-prefix in the per-repo config
Even if we find snapshot-prefix in the repo configuration, we are not
writing it out into the rc- file, so setting the value does not have any
effect.

Signed-off-by: Konstantin Ryabitsev <konstantin@linuxfoundation.org>
6 years ago
Jason A. Donenfeld 77b6f83344 auth-filters: add simple file-based authentication scheme
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld 82856923bf auth-filters: use crypt() in simple-authentication
There's no use in giving a silly example to folks who will just copy it,
so instead try to do something slightly better.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld b73df8098f auth-filters: generate secret securely
This is much better than having the user generate it themselves.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld c4d23d02ec auth-filters: do not crash on nil username
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld 93a2c33051 auth-filter: do not write more than we've read
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld c3b5b5f648 auth-filters: do not use HMAC-SHA1
Though SHA1 is broken, HMAC-SHA1 is still fine. But let's not push our
luck; SHA256 is more sensible anyway.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld c132ef2462 Bump version.
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Todd Zullinger 5dec7f4a91 Update COPYING
The address of the Free Software Foundation has changed since the
license was added in 7640d90 ("Add license file and copyright notices",
2006-12-10).  Update the license file from gnu.org¹.

The only non-whitespace changes are the updated FSF address and two
references to the L in LGPL changed from Library to Lesser.

¹ https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt

Signed-off-by: Todd Zullinger <tmz@pobox.com>
6 years ago
Jason A. Donenfeld 089b29a7e1 css: use correct size in annotated decoration
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld 22583c4992 cgitrc.5: add local tar signature example
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld 08a2b1b8f8 Fix gcc 8.1.1 compiler warnings
CC ../shared.o
../shared.c: In function ‘expand_macro’:
../shared.c:487:3: warning: ‘strncpy’ specified bound depends on the length of the source argument [-Wstringop-overflow=]
   strncpy(name, value, len);
   ^~~~~~~~~~~~~~~~~~~~~~~~~
../shared.c:484:9: note: length computed here
   len = strlen(value);
         ^~~~~~~~~~~~~
../ui-shared.c: In function ‘cgit_repobasename’:
../ui-shared.c:136:2: warning: ‘strncpy’ specified bound 1024 equals destination size [-Wstringop-truncation]
  strncpy(rvbuf, reponame, sizeof(rvbuf));
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    CC ../ui-ssdiff.o
../ui-ssdiff.c: In function ‘replace_tabs’:
../ui-ssdiff.c:142:4: warning: ‘strncat’ output truncated copying between 1 and 8 bytes from a string of length 8 [-Wstringop-truncation]
    strncat(result, spaces, 8 - (strlen(result) % 8));
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jason A. Donenfeld c4167cbd65 cgitrc.5: document new signature notes
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Christian Hesse 7ba41963dd snapshot: support tar signature for compressed tar
This adds support for kernel.org style signatures where the uncompressed
tar archive is signed and compressed later. The signature is valid for
all tar* snapshots.

We have a filter which snapshots may be generated and downloaded. This has
to allow tar signatures now even if tar itself is not allowed. To simplify
things we allow all signatures.

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Jason A. Donenfeld b522a302c9 extra-head-content: introduce another option for meta tags
This is to support things like go-import meta tags, which are on a
per-repo basis.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
John Keeping c4fbb99cee Use string list strdup_strings for mimetypes
There's no need to do this manually with the string list API will do it
for us.

Signed-off-by: John Keeping <john@keeping.me.uk>
6 years ago
Andy Green 9086260329 manpage: fix sorting order
You maybe didn't know you had OCD until you saw an
alpha sorted list that has stuff out of order in it.

Signed-off-by: Andy Green <andy@warmcat.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
John Keeping b31e99887b cache: close race window when unlocking slots
We use POSIX advisory record locks to control access to cache slots, but
these have an unhelpful behaviour in that they are released when any
file descriptor referencing the file is closed by this process.

Mostly this is okay, since we know we won't be opening the lock file
anywhere else, but there is one place that it does matter: when we
restore stdout we dup2() over a file descriptor referring to the file,
thus closing that descriptor.

Since we restore stdout before unlocking the slot, this creates a window
during which the slot content can be overwritten.  The fix is reasonably
straightforward: simply restore stdout after unlocking the slot, but the
diff is a bit bigger because this requires us to move the temporary
stdout FD into struct cache_slot.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 255b78ff52 git: update to v2.18.0
Update to git version v2.18.0. Required changes follow upstream commits:

* Convert find_unique_abbrev* to struct object_id
  (aab9583f7b5ea5463eb3f653a0b4ecac7539dc94)
* sha1_file: convert read_sha1_file to struct object_id
  (b4f5aca40e6f77cbabcbf4ff003c3cf30a1830c8)
* sha1_file: convert sha1_object_info* to object_id
  (abef9020e3df87c441c9a3a95f592fce5fa49bb9)
* object-store: move packed_git and packed_git_mru to object store
  (a80d72db2a73174b3f22142eb2014b33696fd795)
* treewide: rename tree to maybe_tree
  (891435d55da80ca3654b19834481205be6bdfe33)

The changed data types required some of our own functions to be converted
to struct object_id:

  ls_item
  print_dir
  print_dir_entry
  print_object
  single_tree_cb
  walk_tree
  write_tree_link

And finally we use new upstream functions that were added for
struct object_id:

  hashcpy     -> oidcpy
  sha1_to_hex -> oid_to_hex

Signed-off-by: Christian Hesse <mail@eworm.de>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Christian Hesse 54d37dc154 global: remove functionality we deprecated for cgit v1.0
The man page states these were deprecated for v1.0. We are past v1.1,
so remove the functionality.

Signed-off-by: Christian Hesse <mail@eworm.de>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Christian Hesse 2f8648ff7f snapshot: strip bit from struct cgit_snapshot_format
We had a static bit value in struct cgit_snapshot_format. We do not rely
on it and things can be calculated on the fly. So strip it.

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 30a378b571 snapshot: support special value 'all' to enable all formats
Signed-off-by: Christian Hesse <mail@eworm.de>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
John Keeping c712d5ac43 snapshot: support archive signatures
Read signatures from the notes refs refs/notes/signatures/$FORMAT where
FORMAT is one of our archive formats ("tar", "tar.gz", ...).  The note
is expected to simply contain the signature content to be returned when
the snapshot "${filename}.asc" is requested, so the signature for
cgit-1.1.tar.xz can be stored against the v1.1 tag with:

	git notes --ref=refs/notes/signatures/tar.xz add -C "$(
		gpg --output - --armor --detach-sign cgit-1.1.tar.xz |
		git hash-object -w --stdin
	)" v1.1

and then downloaded by simply appending ".asc" to the archive URL.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping 71d14d9c98 ui-refs: use shared function to print tag downloads
cgit_compose_snapshot_prefix() is identical to print_tag_downloads(), so
remove the latter and use the function from ui-shared.c instead.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping e491eaa5df ui-shared: pass separator in to cgit_print_snapshot_links()
cgit_print_snapshot_links() is almost identical to
print_tag_downloads(), so let's extract the difference to a parameter in
preparation for removing print_tag_downloads() in the next commit.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping 5b1f42ffee ui-shared: use the same snapshot logic as ui-refs
Make snapshot links in the commit UI use the same prefix algorithm as
those in the summary UI, so that refs starting with the snapshot prefix
are used as-is rather than composed with the prefix repeated.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping 82aadcfc51 ui-shared: rename parameter to cgit_print_snapshot_links()
This is expected to be a ref not a hex object ID, so name it more
appropriately.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping 63da41a915 ui-shared: remove unused parameter
The "head" parameter to cgit_print_snapshot_links() is never used, so
remove it.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping f0047d2d94 ui-refs: remove unnecessary sanity check
There is no way for refinfo::refname to be null, and Git will prevent
zero-length refs so this check is unnecessary.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping 00ad47bbfa ui-snapshot: filter permitted snapshot requests
Currently the snapshots configuration option only filters which links
are displayed, not which snapshots may be generated and downloaded.
Apply the filter also to requests to ensure that the system policy is
enforced.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping c1572bb5ec Add "snapshot-prefix" repo configuration
Allow using a user-specified value for the prefix in snapshot files
instead of the repository basename.  For example, files downloaded from
the linux-stable.git repository should be named linux-$VERSION and not
linux-stable-$VERSION, which can be achieved by setting:

	repo.snapshot-prefix=linux

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping d85e8a9810 ui-snapshot: pass repo into get_ref_from_filename()
Prepare to allow a custom snapshot prefix.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
John Keeping bd1b281478 ui-shared: pass repo object to print_snapshot_links()
Both call sites of cgit_print_snapshot_links() use the same values for
the snapshot mask and repository name, which are derived from the
cgit_repo structure so let's pass in the structure and access the fields
directly.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 0bb34ef130 ui-log: highlight annotated tags in different color
Annotated tags have some extra information... Descriptive text or signature.
Highlighting annotated tags in a different color show what tag may be worth
clicking for extra information.

Signed-off-by: Christian Hesse <mail@eworm.de>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Christian Hesse e65ea965a0 print git version string in footer
This helps tracking what git version cgit uses. The security implications are
low as anybody can look up the version of our submodule anyway. The paranoid
can use a custom footer. :-p

On the other hand this brings potential security issues to the
administrators eyes...

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse fb804a3537 git: update to v2.17.1
Update to git version v2.17.1. Required changes:

* The function 'typename' has been renamed to 'type_name'
  (upstream commit debca9d2fe784193dc2d9f98b5edac605ddfefbb)

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Andy Green b759189574 ui-blame: free read_sha1_file() buffer after use
Signed-off-by: Andy Green <andy@warmcat.com>
Signed-off-by: John Keeping <john@keeping.me.uk>
6 years ago
Jon DeVree 26610aff34 ui-tag: Fix inconsistent capitalization
Way back in 2009 all of these were lower cased except this one
occurrence.

Signed-off-by: Jon DeVree <nuxi@vault24.org>
Signed-off-by: John Keeping <john@keeping.me.uk>
6 years ago
Andy Green 7708859c4d ui-tree: free read_sha1_file() buffer after use
Free up the buffer allocated in read_sha1_file()

Signed-off-by: Andy Green <andy@warmcat.com>
Signed-off-by: John Keeping <john@keeping.me.uk>
6 years ago
John Keeping 48f175083a Makefile: drive asciidoc directly for HTML output
This is mostly taken from Git's doc/Makefile, although simplified for
our use.  The output now uses Asciidoc's default CSS which I think looks
a bit nicer than the Docbook formatting; as a result of this we no
longer need our custom .css file.

A side effect of this change is that temporary files generated from the
HTML output no longer conflict with the manpage output format (because
any temporary HTML output files use names derived from the output
filename which includes .html).

Signed-off-by: John Keeping <john@keeping.me.uk>
6 years ago
Todd Zullinger 33414d7869 doc: use consistent id's when generating html files
The html documentation is generated using a2x which calls docbook tools
to do the work.  The generate.consistent.ids parameter ensures that when
the docbook stylesheet assigns an id value to an output element it is
consistent as long as the document structure has not changed.

Having consistent html files reduces frivolous changes between builds.
Distributions can more easily deploy multiple architecture builds and
compare changes between package versions.  End-users avoid needless
changes in files deployed or backed up.

The generate.consistent.ids parameter was added in docbook-xsl-1.77.0.
Older versions gracefully ignore the parameter, so we can pass the
parameter unconditionally.  Most distributions contain docbook-xsl newer
than 1.77.0.  This includes Fedora, Debian, Ubuntu, and RHEL/CentOS 7.
RHEL/CentOS 6 and Debian Wheezy (old stable) ship with an older version,
unsurprisingly.

Signed-off-by: Todd Zullinger <tmz@pobox.com>
6 years ago
Jason A. Donenfeld 03f6e34bb9 cgit: prepare repo before error pages
This fixes a crash when showing a list of all heads in the <select> box
in the header.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
6 years ago
Jeff Smith dbaee2672b ui-blame: Allow syntax highlighting
Place file contents into a single block so that syntax highlighting can
be applied in the usual fashion.  Place the alternating color bars
behind the file contents.  Force the default syntax highlighting
background to transparent.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Jeff Smith aafc42d808 ui-blame: Make each column into a single table cell
Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Jeff Smith 2b95c9d49c ui-blame: Break out emit_blame_entry into component methods
Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Jeff Smith 6b5b655f6d ui-blame: Distinguish hashes column from lines column
Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
6 years ago
Christian Hesse 1dd53e3a2f git: update to v2.16.0
Update to git version v2.16.0:

* refs: convert resolve_ref_unsafe to struct object_id
  (49e61479be913f67e66bb3fdf8de9475c41b58bd)
* diff: remove DIFF_OPT_SET macro
  (23dcf77f48feb49c54bad09210f093a799816334)
* log: add option to choose which refs to decorate
  (65516f586b69307f977cd67cc45513a296cabc25)
* diff: convert flags to be stored in bitfields
  (02f2f56bc377c287c411947d0e1482aac888f8db)

Signed-off-by: Christian Hesse <mail@eworm.de>
6 years ago
Christian Hesse 5d947ba3f0 git: update to v2.15.1
Update to git version v2.15.1: With commit 0abe14f6 prepare_packed_git()
moved to packfile.[ch].

Signed-off-by: Christian Hesse <mail@eworm.de>
Reviewed-by: John Keeping <john@keeping.me.uk>
7 years ago
Ville Skyttä 67d0f87050 global: spelling fixes
Signed-off-by: Ville Skyttä <ville.skytta@iki.fi>
7 years ago
Ville Skyttä 98abe5bb9e ui-shared: use type='search' for the search box
Signed-off-by: Ville Skyttä <ville.skytta@iki.fi>
7 years ago
Jason A. Donenfeld fd069b4ca0 filter: pipe_fh should be local
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
7 years ago
John Keeping 9d751e7eec parsing: don't clear existing state with empty input
Since commit c699866 (parsing: clear query path before starting,
2017-02-19), we clear the "page" variable simply by calling
cgit_parse_url() even if the URL is empty.  This breaks a URL like:

	.../cgit?p=about

which is generated when using the "root-readme" configuration option.

This happens because "page" is set to "about" when parsing the query
string before we handle the path (which is empty, but non-null).

It turns out that this is not the only case which is broken, but
specifying repository and page via query options has been broken since
before the commit mentioned above, for example:

	.../cgit?r=git&p=log

Fix both of these by allowing the previous state to persist if PATH_INFO
is empty, falling back to the query parameters if no path has been
requested.

Reported-by: Tom Ryder <tom@sanctum.geek.nz>
Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
Jeff Smith 1649afdc9b ui-tree: link to blame UI if enabled
Create links to the blame page.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
7 years ago
Jeff Smith c1cd290d1f ui-blame: add blame UI
Implement a page which provides the blame view of a specified file.

This feature is controlled by a new config variable, "enable-blame",
which is disabled by default.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
7 years ago
Jeff Smith f6ffe40d1a ui-shared: make a char* parameter const
All cgit_xxx_link functions take const char* for the 'name' parameter,
except for cgit_commit_link, which takes a char* and subsequently
modifies the contents.  Avoiding the content changes, and making it
const char* will avoid the need to make copies of const char* strings
being passed to cgit_commit_link.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
7 years ago
Jeff Smith 9337c7ee83 ui-tree: move set_title_from_path to ui-shared
The ui-blame code will also need to call set_title_from_path, so go
ahead and move it to ui-shared.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
7 years ago
Jeff Smith 70787254b2 html: html_ntxt with no ellipsis
For implementing a ui-blame page, there is need for a function that
outputs a selection from a block of text, transformed for HTML output,
but with no further modifications or additions.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
Reviewed-by: John Keeping <john@keeping.me.uk>
7 years ago
John Keeping 3b485cc542 cache: flush stdio before restoring FDs
As described in commit 2efb59e (ui-patch: Flush stdout after outputting
data, 2014-06-11), we need to ensure that stdout is flushed before
restoring the file descriptor when writing to the cache.  It turns out
that it's not just ui-patch that is affected by this but also raw diff
which writes to stdout internally.

Let's avoid risking more places doing this by ensuring that stdout is
flushed after writing in fill_slot().

Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
Daniel M. Weeks de29788338 Use https for submodule
The git protocol provides no transport security. https does provide
transport security and should be preferred by default. https is also
more likely than git to be permitted by firewalls in restricted
environments.

Signed-off-by: Daniel M. Weeks <dan@danweeks.net>
7 years ago
John Keeping 51cc456b77 ui-plain: print symlink content
We currently ignore symlinks in ui-plain, leading to a 404.  In ui-tree
we print the content of the blob (that is, the path to the target of the
link), so it makes sense to do the same here.

Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
John Keeping 113f4b8588 cgit: don't set vpath unless repo is set
After the previous two patches, this can be classified as a tidy up
rather than a bug fix, but I think it makes sense to group all of the
tests together before setting up the environment for the command to
execute.

Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
John Keeping c699866699 parsing: clear query path before starting
By specifying the "url" query parameter multiple times it is possible to
end up with ctx.qry.vpath set while ctx.repo is null, which triggers an
invalid code path from cgit_print_pageheader() while printing path
crumbs, resulting in a null dereference.

The previous patch fixed this segfault, but it makes no sense for us to
clear ctx.repo while leaving ctx.qry.path set to the previous value, so
let's just clear it here so that the last "url" parameter given takes
full effect rather than partially overriding the effect of the previous
value.

Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
John Keeping 1b4ef6783a ui-shared: don't print path crumbs without a repo
cgit_print_path_crumbs() can call repolink() which assumes that ctx.repo
is non-null.  Currently we don't have any commands that set want_vpath
without also setting want_repo so it shouldn't be possible to fail this
test, but the check in cgit.c is in the wrong order so it is possible to
specify a query string like "?p=log&path=foo/bar" to end up here without
a valid repository.

This was found by American fuzzy lop [0].

[0] http://lcamtuf.coredump.cx/afl/

Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
John Keeping 6d3c8bc37f ui-atom: properly escape delimiter in page link
If the delimiter here is '&' then it needs to be escaped for inclusion
in an attribute.  Use html_attrf() to ensure that this happens (we know
that hex won't need escaping, but this makes it clearer what's
happening.

Signed-off-by: John Keeping <john@keeping.me.uk>
7 years ago
Jeff Smith 86a6d358f7 git: update to v2.14
Numerous changes were made to git functions to use an object_id
structure rather than sending sha1 hashes as raw unsigned character
arrays.  The functions that affect cgit are: parse_object,
lookup_commit_reference, lookup_tag, lookup_tree, parse_tree_indirect,
diff_root_tree_sha1, diff_tree_sha1, and format_display_notes.

Commit b2141fc (config: don't include config.h by default) made it
necessary to that config.h be explicitly included when needed.

Commit 07a3d41 (grep: remove regflags from the public grep_opt API)
removed one way of specifying the ignore-case grep option.

Signed-off-by: Jeff Smith <whydoubt@gmail.com>
7 years ago
Christian Hesse 3d33b46df2 git: update to v2.13.4
Update to git version v2.13.4: With commit 8aee769f (pathspec: copy and free
owned memory) the definition of struct pathspec_item has changed with the
expectation that pathspecs will be managed dynamically. We work around this
a bit by setting up a static structure, but let's allocate the match string
to avoid needing to cast away const.

Updated a patch from John Keeping <john@keeping.me.uk> for git v2.12.1.
7 years ago
Lukas Fleischer 7ce19ba550 Update .mailmap with my new email address
Signed-off-by: Lukas Fleischer <lfleischer@lfos.de>
7 years ago
Lukas Fleischer 7ebdb30fdf Remove unused variable from sort_section()
Signed-off-by: Lukas Fleischer <lfleischer@lfos.de>
7 years ago
Jason A. Donenfeld 87c47488d0 ui-repolist: properly sort by age
When empty repos exist, comparing them against an existing repo with a
good mtime might, with particular qsort implementations, not sort
correctly, because of this brokenness:

   if (get_repo_modtime(r1, &t) && get_repo_modtime(r2, &t))

However, sorting by the age column works as expected, so anyway, to tidy
things up, we simply reuse that function.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
7 years ago
Lukas Fleischer be39d22328 ui-patch: fix crash when using path limit
The array passed to setup_revisions() must be NULL-terminated. Fixes a
regression introduced in 455b598 (ui-patch.c: Use log_tree_commit() to
generate diffs, 2013-08-20).

Reported-by: Florian Pritz <bluewind@xinu.at>
Signed-off-by: Lukas Fleischer <lfleischer@lfos.de>
7 years ago
Jason A. Donenfeld 5564a5d066 syntax-highlighting: replace invalid unicode with ? 7 years ago
Christian Hesse 91153fd02e git: update to v2.11.0
Update to git version v2.11.0. Function write_archive()
dropped argument (int setup_prefix).
8 years ago
Peter Colberg 2b993402c7 Link with -ldl on GNU Hurd
Debian GNU/Hurd uses the GNU C library.

Signed-off-by: Peter Colberg <peter@colberg.org>
8 years ago
John Keeping 5ccd965258 git: update to v2.10.2 again
The submodule was accidentally downgraded in commit 8e9ddd21 (Bump
version, 2016-11-23).  Restore v2.10.2 so it matches the makefile again.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
Jason A. Donenfeld 8e9ddd21a5 Bump version. 8 years ago
Christian Hesse 81509a228c css: highlight even table rows and skip empty rows
This is stolen from kernel.org css [0].

[0] https://git.kernel.org/cgit-korg-0.10.1.css
8 years ago
Christian Hesse 44f8c11c8d git: update to v2.10.2
Update to git version v2.10.2, no changes required.
8 years ago
Christian Hesse c330a2e5f8 ui-blog: fix oid handling
We have to use a pointer for walk_tree_ctx->matched_oid.

This fixes faulty commit 6e4b7b6776
(ui-blob: replace 'unsigned char sha1[20]' with 'struct object_id oid').
8 years ago
Christian Hesse 2d59e6a64e shared: remove unused function strlpart() 8 years ago
Christian Hesse 3e2e8f1c24 shared: remove unused function strrpart() 8 years ago
Christian Hesse 7fea585e25 ui-repolist: fix memory leak 8 years ago
Lukas Fleischer 32c27e8877 Use skip_prefix() to get rid of magic constants
Signed-off-by: Lukas Fleischer <lfleischer@lfos.de>
8 years ago
John Keeping 5fe88a9c81 patch: reapply path limit
This was originally applied added in commit eac1b67 (ui-patch: Apply
path limit to generated patch, 2010-06-10) but the ability to limit
patches to particular paths was lost in commit 455b598 (ui-patch.c: Use
log_tree_commit() to generate diffs, 2013-08-20).

The new output is slightly different from the original because Git's
diff infrastructure doesn't give us a way to insert an annotation
immediately after the "---" separator, so the commit has moved below the
diff stat.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
Christian Hesse c177379547 ui-repolist: fix memory leak 8 years ago
Christian Hesse d6a4730d04 git: update to v2.10.1
Update to git version v2.10.1, no changes required.
8 years ago
Christian Hesse 9dd3c5e93c ui-tree: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 28185ae40a ui-tag: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 406f593895 ui-snapshot: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 6bef566f99 ui-shared: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 073a8bb396 ui-plain: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 85793b8181 ui-patch: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 1a9a75d7c7 ui-log: replace get_sha1() with get_oid()
Data structures have been replaced already, so use correct function calls.
8 years ago
Christian Hesse 3a0fd5e6b8 ui-commit: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Christian Hesse 6e4b7b6776 ui-blob: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...

In addition replace memmove() with hashcpy().
8 years ago
Christian Hesse aee990b6a4 cgit: replace 'unsigned char sha1[20]' with 'struct object_id oid'
Upstream git is replacing 'unsigned char sha1[20]' with 'struct object_id
oid'. We have some code that can be changed independent from upstream. So
here we go...
8 years ago
Jason A. Donenfeld ef3108656b Makefile: remove extra space
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Lukas Fleischer 927b0ae30c Simplify http_parse_querystring()
Instead of reimplementing URL parameter parsing from scratch, use
url_decode_parameter_name() and url_decode_parameter_value() which are
already provided by Git.

Also, change the return type of http_parse_querystring() to void since
its only caller already ignores the return value.

Signed-off-by: Lukas Fleischer <lfleischer@lfos.de>
8 years ago
John Keeping e18a85b6a2 ui-tree: remove a fixed size buffer
As libgit.a moves away from using fixed size buffers, there is no
guarantee that PATH_MAX is sufficient for all of the paths in a Git
tree, so we should use a dynamically sized buffer here.

Coverity-Id: 141884
Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping f80b73fa20 ui-tag: clean up taginfo
Free the taginfo when we're done with it.  Also reduce the scope of a
couple of variables so that it's clear that this is the only path that
uses the taginfo structure.

Coverity-Id: 141883
Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping b19d889f6c shared: make cgit_free_taginfo() public
We will use this function from ui-tag.c in the next patch.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping d9dff37691 shared: remove return value from cgit_free_commitinfo()
This return value is never used and the function always returns NULL.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 000cf294c4 tree: allow skipping through single-child trees
If we have only a single element in a directory (for example in Java
package paths), display multiple directories in one go so that it is
possible to navigate directly to the first directory that contains
either files or multiple directories.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 7e67c64894 ui-ssdiff: fix decl-after-statement warnings
git.git's coding style avoids decl-after-statement and we generally try
to follow it but a few warnings have crept in recently.  Fix the one in
ui-ssdiff.c

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping bead27b730 ui-shared: fix decl-after-statement warnings
git.git's coding style avoids decl-after-statement and we generally try
to follow it but a few warnings have crept in recently.  Fix the ones in
ui-shared.c

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 35df710a1f configfile: fix EOF handling
Currently we can end up passing EOF to isspace(), which is in fact
libgit's sane_isspace which does:

	((sane_ctype[(unsigned char)(x)] & (GIT_SPACE)) != 0)

It is very unlikely that EOF cast to "unsigned char" will end up in a
character that has the GIT_SPACE bit set, but the standard only requires
that EOF be a negative integer, so it could access any value in the
sane_ctype array.

If it does end up returning true for isspace() then this loop will never
terminate, so handle EOF as a special value in the same way as the other
loops in this function.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
Christian Hesse 11695a58fd git: update to v2.10.0
Upstream continues to replace unsigned char *sha1 with struct
object_id old_oid. This makes the required changes.

The git lib has its own main function now. Rename our main function
to cmd_main, it is called from main then.
8 years ago
Richard Maw ff9893ac81 Fix qry.head leak on error
This is run soon before exiting so it wasn't leaked for long.

Signed-off-by: Richard Maw <richard.maw@gmail.com>
8 years ago
Christian Hesse d6b0332982 git: update to v2.9.1
Update to git version v2.9.1, no changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Peter Colberg 40fbefba05 Link with -ldl on GNU/kFreeBSD
GNU/kFreeBSD uses the FreeBSD kernel with the GNU C library.

Signed-off-by: Peter Colberg <peter@colberg.org>
8 years ago
Peter Colberg ccf79b3576 Fix spelling in man page
Signed-off-by: Peter Colberg <peter@colberg.org>
8 years ago
Eric Wong 590ba455d6 ui-shared: fix segfault when defbranch is NULL
Not sure if there's a better fix for this.  defbranch is
NULL here on my setup when a crawler hit an invalid URL,
causing strcmp to segfault.

Signed-off-by: Eric Wong <normalperson@yhbt.net>
8 years ago
Christian Hesse c19d983ed7 css: consistent use of empty lines
Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Christian Hesse 4fb49864db ui-log: color line changes
Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Lukas Fleischer 9984e7ab49 Avoid ambiguities when prettifying snapshot names
When composing snapshot file names for a tag with a prefix of the form
v[0-9] (resp. V[0-9]), the leading "v" (resp. "V") is stripped. This
leads to conflicts if a tag with the stripped name already exists or if
there are tags only differing in the capitalization of the leading "v".
Make sure we do not strip the "v" in these cases.

Reported-by: Juuso Lapinlampi <wub@partyvan.eu>
Signed-off-by: Lukas Fleischer <lfleischer@lfos.de>
8 years ago
Christian Hesse 1e039ada85 git: update to v2.9.0
Update to git version v2.9.0, no changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Kylie McClain 5062fbe7ec cgit.mk: Use $PKG_CONFIG
PKG_CONFIG is a variable dictated by autoconf standards; it should
be used if set.
8 years ago
Jason A. Donenfeld 7d51120440 md2html: use utf-8 and flush output buffer
Otherwise we get the classic Python UTF-8 errors, and the text is all
out of order. While we're at it, switch to python3 so we only have to
support one set of oddball semantics.

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Suggested-by: Daniel Campbell <dlcampbell@gmx.com>
8 years ago
Jason A. Donenfeld d88ec849c4 Hosted on HTTPS now 8 years ago
Jason A. Donenfeld a6572ce176 Bump version.
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Christian Hesse 41508c0911 git: update to v2.8.3
Update to git version v2.8.3, no changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Jason A. Donenfeld 21bf30b043 ui-diff: action='.' is not correct
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Jason A. Donenfeld c34e28835b forms: action should not be empty
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Juuso Lapinlampi 9afda36ed7 ui-shared: Remove a name attribute with an empty value
The name attribute is optional in an input element, but it must not be
an empty value.

See: https://html.spec.whatwg.org/#attr-fe-name
See: https://html.spec.whatwg.org/#the-input-element
8 years ago
Juuso Lapinlampi 8d05b398bb ui-shared: HTML-ize DOCTYPE and <html>
Get rid of the XHTML headers, bringing cgit slowly to the modern age of
HTML.
8 years ago
Juuso Lapinlampi 80f12b3e7e ui-shared: Simplify cgit_print_error_page() logic 8 years ago
Christian Hesse 86bf5b4791 git: update to v2.8.2
Update to git version v2.8.2.

* Upstream commit 1a0c8dfd89475d6bb09ddee8c019cf0ae5b3bdc2 (strbuf: give
  strbuf_getline() to the "most text friendly" variant) changed API.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Tim Nordell 59d8fa1a62 ui-log: Simplify decoration code
The decoration code inside of git returns the decoration type, so
utilize this to create the decoration spans.  Additionally, use
prettify_refname(...) to get the shorter name for the ref.

Signed-off-by: Tim Nordell <tim.nordell@logicpd.com>
8 years ago
Tim Nordell 499b23979c ui-log: Do not always emit decoration span
The decoration span does not need to be emited if there aren't
any decorations to show.  This modification saves slightly
on bandwidth.

Signed-off-by: Tim Nordell <tim.nordell@logicpd.com>
8 years ago
Matt Comben 39735d95ca Renamed repo-specific configuration for enable-html-serving in cgitrc.5.txt 8 years ago
Jason A. Donenfeld e9cbdf6463 ui-shared: redirect should not exit early for cache
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Jason A. Donenfeld 09a3aa5ae7 about: path_info might not be valid 8 years ago
Jason A. Donenfeld c424b5cb02 tabs: do not use target=_blank 8 years ago
Jason A. Donenfeld 46ff6e1993 css: fix indentation 8 years ago
Christian Hesse a0d22c391e css: use less blurry icon for external link
Your mileage may vary, but for me the old icon looks blurry. The new
one is character 0xf08e from OTF font awsome in size 10.
The icon color is black, gray level is adjusted via opacity.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Jason A. Donenfeld 1892cd9a60 md2html: Do syntax highlighting too 8 years ago
Christian Hesse a9e9dfc55f git: update to v2.7.2
Update to git version v2.7.2, no changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
Joe Anakata de6098be6a ui-plain: fix to show a repo's root directory listing in plain view
This is to fix the case of accessing http://host.com/cgit.cgi/repo.git/plain/

There is code here to make this case work (match_baselen is set to -1
for top-of-the-tree views) but the unsigned to signed comparison was
always false in this case, causing an empty directory listing without
this fix.

Signed-off-by: Joe Anakata <jea-signup-github@anakata.org>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Jason A. Donenfeld 94c02bbf73 cmd: redirect empty about/ to homepage or summary
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
Jason A. Donenfeld 5f2664f13c ui-shared: add homepage to tabs
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
8 years ago
John Keeping 75298209bf ui-atom: avoid DATE_STRFTIME
Git's DATE_STRFTIME ignores the timezone argument and just uses the
local timezone regardless of whether the "local" flag is set.

Since Atom accepts ISO8601 dates [1], we can use Git's
DATE_ISO8601_STRICT instead, which does get this right.  Additionally,
we never use the local timezone here so we can use the
date_mode_from_type() wrapper to simplify the code a bit.

[1] https://tools.ietf.org/html/rfc4287#section-3.3

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 9c15f3c695 Avoid DATE_STRFTIME for long/short dates
Git's DATE_STRFTIME ignores the timezone argument and just uses the
local timezone regardless of whether the "local" flag is set.

Since our existing FMT_LONGDATE and FMT_SHORTDATE are pretty-much
perfect matches to DATE_ISO8601 and DATE_SHORT, switch to taking a
date_mode_type directly in cgit_date_mode().

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping bdcbe0922d ui-stats: cast pointer before checking for zero
We abuse the "void *util" field as a counter and recently started to
cast it to a uintptr_t to avoid risking nasal demons by performing
arithmetic on a void pointer.

However, compilers are also known to do "interesting" things if they
know that a pointer is or isn't NULL.  Make this safer by checking if
the counter (after casting) is non-zero rather than checking if the
pointer is non-null.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
Jason A. Donenfeld a8b9ef8c1c ui-stats: if we're going to abuse void*, do it safely 8 years ago
Christian Hesse 85ec9f0211 git: update to v2.7.1
Update to git version v2.7.1, no changes required.

Signed-off-by: Christian Hesse <mail@eworm.de>
8 years ago
John Keeping 17c74eefa4 ui-shared: remove cgit_print_date()
There are no longer any users of this function.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping eb80b4edad ui-atom: use show_date directly for atom dates
This will allow us to remove cgit_print_date and use Git's show_date
consistently.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping e68c86e8c5 ui-shared: use show_date for footer timestamp
Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping f2a901d2e1 ui: show ages in the originator's timezone
This affects the tooltip showing the full time and the case when a date
is sufficiently old to be shown in full rather than as an offset.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 21dcf10386 ui-{commit,tag}: show dates in originator's timezone
This is done by switching to Git's show_date() function and the mode
given by cgit_date_mode().

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 360af46fac ui-shared: add cgit_date_mode()
This returns the correct mode value for use with Git's show_date() based
on the current CGit configuration and will be used in the following
patches.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 45c87ca1c3 parsing: add timezone to ident structures
This will allow us to mimic Git's behaviour of showing times in the
originator's timezone when displaying commits and tags.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 57ea1aa2a5 ui-shared: remove "format" from cgit_print_age()
We never use any format other than FMT_SHORTDATE, so move that into the
function.

Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
Jason A. Donenfeld 23f7dadaab ui-tree: put reverse path in title 8 years ago
Jason A. Donenfeld d3756bd7b0 syntax-highlighting: always use utf-8 to avoid ascii codec issues 8 years ago
John Keeping 33bc949a1e cache: don't check for match with no key
We call open_slot() from cache_ls() without a key since we simply want
to read the path out of the header.  Should the file happen to contain
an empty key then we end up calling memcmp() with NULL and a non-zero
length.  Fix this by assigning slot->match only if a key is set, which
is always will be in the code paths where we use slot->match.

Coverity-id: 13807
Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping 3fbfced740 cache: use size_t for string lengths
Avoid integer truncation on 64-bit systems.

Coverity-id: 13864
Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago
John Keeping baa5ad1f80 ui-log: handle parse_commit() errors
If parse_commit() fails, none of the fields in the commit structure will
have been populated so we will dereference NULL when accessing
item->tree.

There isn't much we can do about the error at this point, but if we
return true then we'll try parsing the commit again from print_commit()
and we can report an error to the user at that point.

Coverity-id: 13801
Signed-off-by: John Keeping <john@keeping.me.uk>
8 years ago

2
.gitmodules vendored

@ -1,3 +1,3 @@
[submodule "git"]
url = git://git.kernel.org/pub/scm/git/git.git
url = https://git.kernel.org/pub/scm/git/git.git
path = git

@ -5,6 +5,6 @@ Lars Hjemli <hjemli@gmail.com> <larsh@hal-2004.(none)>
Lars Hjemli <hjemli@gmail.com> <larsh@hatman.(none)>
Lars Hjemli <hjemli@gmail.com> <larsh@slackbox.hjemli.net>
Lars Hjemli <hjemli@gmail.com> <larsh@slaptop.hjemli.net>
Lukas Fleischer <cgit@cryptocrack.de> <cgit@crytocrack.de>
Lukas Fleischer <cgit@cryptocrack.de> <info@cryptocrack.de>
Lukas Fleischer <lfleischer@lfos.de> <cgit@cryptocrack.de>
Lukas Fleischer <lfleischer@lfos.de> <info@cryptocrack.de>
Stefan Bühler <source@stbuehler.de> <lighttpd@stbuehler.de>

@ -1,12 +1,12 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
@ -15,7 +15,7 @@ software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
@ -55,8 +55,8 @@ patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
@ -110,7 +110,7 @@ above, provided that you also meet all of these conditions:
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
@ -168,7 +168,7 @@ access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
@ -225,7 +225,7 @@ impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
@ -255,7 +255,7 @@ make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
@ -303,10 +303,9 @@ the "copyright" line and a pointer to where the full notice is found.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
@ -336,5 +335,5 @@ necessary. Here is a sample; alter the names:
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.

@ -1,6 +1,6 @@
all::
CGIT_VERSION = v0.12
CGIT_VERSION = v1.2.3
CGIT_SCRIPT_NAME = cgit.cgi
CGIT_SCRIPT_PATH = /var/www/htdocs/cgit
CGIT_DATA_PATH = $(CGIT_SCRIPT_PATH)
@ -14,8 +14,8 @@ htmldir = $(docdir)
pdfdir = $(docdir)
mandir = $(prefix)/share/man
SHA1_HEADER = <openssl/sha.h>
GIT_VER = 2.7.0
GIT_URL = https://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.gz
GIT_VER = 2.39.0
GIT_URL = https://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.xz
INSTALL = install
COPYTREE = cp -r
MAN5_TXT = $(wildcard *.5.txt)
@ -24,6 +24,12 @@ DOC_MAN5 = $(patsubst %.txt,%,$(MAN5_TXT))
DOC_HTML = $(patsubst %.txt,%.html,$(MAN_TXT))
DOC_PDF = $(patsubst %.txt,%.pdf,$(MAN_TXT))
ASCIIDOC = asciidoc
ASCIIDOC_EXTRA =
ASCIIDOC_HTML = xhtml11
ASCIIDOC_COMMON = $(ASCIIDOC) $(ASCIIDOC_EXTRA)
TXT_TO_HTML = $(ASCIIDOC_COMMON) -b $(ASCIIDOC_HTML)
# Define NO_C99_FORMAT if your formatted IO functions (printf/scanf et.al.)
# do not support the 'size specifiers' introduced by C99, namely ll, hh,
# j, z, t. (representing long long int, char, intmax_t, size_t, ptrdiff_t).
@ -81,11 +87,12 @@ install: all
$(INSTALL) -m 0755 cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
$(INSTALL) -m 0755 -d $(DESTDIR)$(CGIT_DATA_PATH)
$(INSTALL) -m 0644 cgit.css $(DESTDIR)$(CGIT_DATA_PATH)/cgit.css
$(INSTALL) -m 0644 cgit.js $(DESTDIR)$(CGIT_DATA_PATH)/cgit.js
$(INSTALL) -m 0644 cgit.png $(DESTDIR)$(CGIT_DATA_PATH)/cgit.png
$(INSTALL) -m 0644 favicon.ico $(DESTDIR)$(CGIT_DATA_PATH)/favicon.ico
$(INSTALL) -m 0644 robots.txt $(DESTDIR)$(CGIT_DATA_PATH)/robots.txt
$(INSTALL) -m 0755 -d $(DESTDIR)$(filterdir)
$(COPYTREE) filters/* $(DESTDIR)$(filterdir)
$(COPYTREE) filters/* $(DESTDIR)$(filterdir)
install-doc: install-man install-html install-pdf
@ -134,7 +141,8 @@ doc-pdf: $(DOC_PDF)
a2x -f manpage $<
$(DOC_HTML): %.html : %.txt
a2x -f xhtml --stylesheet=cgit-doc.css $<
$(TXT_TO_HTML) -o $@+ $< && \
mv $@+ $@
$(DOC_PDF): %.pdf : %.txt
a2x -f pdf cgitrc.5.txt
@ -150,7 +158,7 @@ clean-doc:
$(RM) cgitrc.5 cgitrc.5.html cgitrc.5.pdf cgitrc.5.xml cgitrc.5.fo
get-git:
curl -L $(GIT_URL) | tar -xzf - && rm -rf git && mv git-$(GIT_VER) git
curl -L $(GIT_URL) | tar -xJf - && rm -rf git && mv git-$(GIT_VER) git
tags:
$(QUIET_TAGS)find . -name '*.[ch]' | xargs ctags

@ -92,8 +92,8 @@ the HTTP headers `Modified` and `Expires`.
Online presence
---------------
* The cgit homepage is hosted by cgit at <http://git.zx2c4.com/cgit/about/>
* The cgit homepage is hosted by cgit at <https://git.zx2c4.com/cgit/about/>
* Patches, bug reports, discussions and support should go to the cgit
mailing list: <cgit@lists.zx2c4.com>. To sign up, visit
<http://lists.zx2c4.com/mailman/listinfo/cgit>
<https://lists.zx2c4.com/mailman/listinfo/cgit>

@ -24,11 +24,12 @@
struct cache_slot {
const char *key;
int keylen;
size_t keylen;
int ttl;
cache_fill_fn fn;
int cache_fd;
int lock_fd;
int stdout_fd;
const char *cache_name;
const char *lock_name;
int match;
@ -44,7 +45,7 @@ struct cache_slot {
static int open_slot(struct cache_slot *slot)
{
char *bufz;
int bufkeylen = -1;
ssize_t bufkeylen = -1;
slot->cache_fd = open(slot->cache_name, O_RDONLY);
if (slot->cache_fd == -1)
@ -61,8 +62,9 @@ static int open_slot(struct cache_slot *slot)
if (bufz)
bufkeylen = bufz - slot->buf;
slot->match = bufkeylen == slot->keylen &&
!memcmp(slot->key, slot->buf, bufkeylen + 1);
if (slot->key)
slot->match = bufkeylen == slot->keylen &&
!memcmp(slot->key, slot->buf, bufkeylen + 1);
return 0;
}
@ -83,40 +85,45 @@ static int close_slot(struct cache_slot *slot)
/* Print the content of the active cache slot (but skip the key). */
static int print_slot(struct cache_slot *slot)
{
off_t off;
#ifdef HAVE_LINUX_SENDFILE
off_t start_off;
int ret;
off_t size;
#endif
off = slot->keylen + 1;
start_off = slot->keylen + 1;
#ifdef HAVE_LINUX_SENDFILE
size = slot->cache_st.st_size;
do {
ret = sendfile(STDOUT_FILENO, slot->cache_fd, &start_off,
slot->cache_st.st_size - start_off);
ssize_t ret;
ret = sendfile(STDOUT_FILENO, slot->cache_fd, &off, size - off);
if (ret < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
/* Fall back to read/write on EINVAL or ENOSYS */
if (errno == EINVAL || errno == ENOSYS)
break;
return errno;
}
return 0;
if (off == size)
return 0;
} while (1);
#else
ssize_t i, j;
#endif
i = lseek(slot->cache_fd, slot->keylen + 1, SEEK_SET);
if (i != slot->keylen + 1)
if (lseek(slot->cache_fd, off, SEEK_SET) != off)
return errno;
do {
i = j = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));
if (i > 0)
j = xwrite(STDOUT_FILENO, slot->buf, i);
} while (i > 0 && j == i);
if (i < 0 || j != i)
return errno;
else
return 0;
#endif
ssize_t ret;
ret = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));
if (ret < 0)
return errno;
if (ret == 0)
return 0;
if (write_in_full(STDOUT_FILENO, slot->buf, ret) < 0)
return errno;
} while (1);
}
/* Check if the slot has expired */
@ -196,6 +203,13 @@ static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
else
err = unlink(slot->lock_name);
/* Restore stdout and close the temporary FD. */
if (slot->stdout_fd >= 0) {
dup2(slot->stdout_fd, STDOUT_FILENO);
close(slot->stdout_fd);
slot->stdout_fd = -1;
}
if (err)
return errno;
@ -207,36 +221,24 @@ static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
*/
static int fill_slot(struct cache_slot *slot)
{
int tmp;
/* Preserve stdout */
tmp = dup(STDOUT_FILENO);
if (tmp == -1)
slot->stdout_fd = dup(STDOUT_FILENO);
if (slot->stdout_fd == -1)
return errno;
/* Redirect stdout to lockfile */
if (dup2(slot->lock_fd, STDOUT_FILENO) == -1) {
close(tmp);
if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
return errno;
}
/* Generate cache content */
slot->fn();
/* update stat info */
if (fstat(slot->lock_fd, &slot->cache_st)) {
close(tmp);
/* Make sure any buffered data is flushed to the file */
if (fflush(stdout))
return errno;
}
/* Restore stdout */
if (dup2(tmp, STDOUT_FILENO) == -1) {
close(tmp);
return errno;
}
/* Close the temporary filedescriptor */
if (close(tmp))
/* update stat info */
if (fstat(slot->lock_fd, &slot->cache_st))
return errno;
return 0;
@ -311,7 +313,7 @@ static int process_slot(struct cache_slot *slot)
/* If the cache slot does not exist (or its key doesn't match the
* current key), lets try to create a new cache slot for this
* request. If this fails (for whatever reason), lets just generate
* the content without caching it and fool the caller to belive
* the content without caching it and fool the caller to believe
* everything worked out (but print a warning on stdout).
*/
@ -386,6 +388,7 @@ int cache_process(int size, const char *path, const char *key, int ttl,
strbuf_addstr(&lockname, ".lock");
slot.fn = fn;
slot.ttl = ttl;
slot.stdout_fd = -1;
slot.cache_name = filename.buf;
slot.lock_name = lockname.buf;
slot.key = key;
@ -403,12 +406,12 @@ int cache_process(int size, const char *path, const char *key, int ttl,
static char *sprintftime(const char *format, time_t time)
{
static char buf[64];
struct tm *tm;
struct tm tm;
if (!time)
return NULL;
tm = gmtime(&time);
strftime(buf, sizeof(buf)-1, format, tm);
gmtime_r(&time, &tm);
strftime(buf, sizeof(buf)-1, format, &tm);
return buf;
}

@ -19,7 +19,7 @@ typedef void (*cache_fill_fn)(void);
* fn content generator function for this key
*
* Return value
* 0 indicates success, everyting else is an error
* 0 indicates success, everything else is an error
*/
extern int cache_process(int size, const char *path, const char *key, int ttl,
cache_fill_fn fn);

@ -1,3 +0,0 @@
div.variablelist dt {
margin-top: 1em;
}

203
cgit.c

@ -19,11 +19,21 @@
const char *cgit_version = CGIT_VERSION;
__attribute__((constructor))
static void constructor_environment()
{
/* Do not look in /etc/ for gitconfig and gitattributes. */
setenv("GIT_CONFIG_NOSYSTEM", "1", 1);
setenv("GIT_ATTR_NOSYSTEM", "1", 1);
unsetenv("HOME");
unsetenv("XDG_CONFIG_HOME");
}
static void add_mimetype(const char *name, const char *value)
{
struct string_list_item *item;
item = string_list_insert(&ctx.cfg.mimetypes, xstrdup(name));
item = string_list_insert(&ctx.cfg.mimetypes, name);
item->util = xstrdup(value);
}
@ -31,6 +41,7 @@ static void process_cached_repolist(const char *path);
static void repo_config(struct cgit_repo *repo, const char *name, const char *value)
{
const char *path;
struct string_list_item *item;
if (!strcmp(name, "name"))
@ -41,10 +52,16 @@ static void repo_config(struct cgit_repo *repo, const char *name, const char *va
repo->desc = xstrdup(value);
else if (!strcmp(name, "owner"))
repo->owner = xstrdup(value);
else if (!strcmp(name, "homepage"))
repo->homepage = xstrdup(value);
else if (!strcmp(name, "defbranch"))
repo->defbranch = xstrdup(value);
else if (!strcmp(name, "extra-head-content"))
repo->extra_head_content = xstrdup(value);
else if (!strcmp(name, "snapshots"))
repo->snapshots = ctx.cfg.snapshots & cgit_parse_snapshots_mask(value);
else if (!strcmp(name, "enable-blame"))
repo->enable_blame = atoi(value);
else if (!strcmp(name, "enable-commit-graph"))
repo->enable_commit_graph = atoi(value);
else if (!strcmp(name, "enable-log-filecount"))
@ -71,11 +88,13 @@ static void repo_config(struct cgit_repo *repo, const char *name, const char *va
repo->max_stats = cgit_find_stats_period(value, NULL);
else if (!strcmp(name, "module-link"))
repo->module_link= xstrdup(value);
else if (starts_with(name, "module-link.")) {
item = string_list_append(&repo->submodules, xstrdup(name + 12));
else if (skip_prefix(name, "module-link.", &path)) {
item = string_list_append(&repo->submodules, xstrdup(path));
item->util = xstrdup(value);
} else if (!strcmp(name, "section"))
repo->section = xstrdup(value);
else if (!strcmp(name, "snapshot-prefix"))
repo->snapshot_prefix = xstrdup(value);
else if (!strcmp(name, "readme") && value != NULL) {
if (repo->readme.items == ctx.cfg.readme.items)
memset(&repo->readme, 0, sizeof(repo->readme));
@ -104,14 +123,16 @@ static void repo_config(struct cgit_repo *repo, const char *name, const char *va
static void config_cb(const char *name, const char *value)
{
if (!strcmp(name, "section") || !strcmp(name, "repo.group"))
const char *arg;
if (!strcmp(name, "section"))
ctx.cfg.section = xstrdup(value);
else if (!strcmp(name, "repo.url"))
ctx.repo = cgit_add_repo(value);
else if (ctx.repo && !strcmp(name, "repo.path"))
ctx.repo->path = trim_end(value, '/');
else if (ctx.repo && starts_with(name, "repo."))
repo_config(ctx.repo, name + 5, value);
else if (ctx.repo && skip_prefix(name, "repo.", &arg))
repo_config(ctx.repo, arg, value);
else if (!strcmp(name, "readme"))
string_list_append(&ctx.cfg.readme, xstrdup(value));
else if (!strcmp(name, "root-title"))
@ -121,7 +142,9 @@ static void config_cb(const char *name, const char *value)
else if (!strcmp(name, "root-readme"))
ctx.cfg.root_readme = xstrdup(value);
else if (!strcmp(name, "css"))
ctx.cfg.css = xstrdup(value);
string_list_append(&ctx.cfg.css, xstrdup(value));
else if (!strcmp(name, "js"))
string_list_append(&ctx.cfg.js, xstrdup(value));
else if (!strcmp(name, "favicon"))
ctx.cfg.favicon = xstrdup(value);
else if (!strcmp(name, "footer"))
@ -132,20 +155,14 @@ static void config_cb(const char *name, const char *value)
ctx.cfg.header = xstrdup(value);
else if (!strcmp(name, "logo"))
ctx.cfg.logo = xstrdup(value);
else if (!strcmp(name, "index-header"))
ctx.cfg.index_header = xstrdup(value);
else if (!strcmp(name, "index-info"))
ctx.cfg.index_info = xstrdup(value);
else if (!strcmp(name, "logo-link"))
ctx.cfg.logo_link = xstrdup(value);
else if (!strcmp(name, "module-link"))
ctx.cfg.module_link = xstrdup(value);
else if (!strcmp(name, "strict-export"))
ctx.cfg.strict_export = xstrdup(value);
else if (!strcmp(name, "virtual-root")) {
else if (!strcmp(name, "virtual-root"))
ctx.cfg.virtual_root = ensure_end(value, '/');
} else if (!strcmp(name, "nocache"))
ctx.cfg.nocache = atoi(value);
else if (!strcmp(name, "noplainemail"))
ctx.cfg.noplainemail = atoi(value);
else if (!strcmp(name, "noheader"))
@ -162,6 +179,8 @@ static void config_cb(const char *name, const char *value)
ctx.cfg.enable_index_links = atoi(value);
else if (!strcmp(name, "enable-index-owner"))
ctx.cfg.enable_index_owner = atoi(value);
else if (!strcmp(name, "enable-blame"))
ctx.cfg.enable_blame = atoi(value);
else if (!strcmp(name, "enable-commit-graph"))
ctx.cfg.enable_commit_graph = atoi(value);
else if (!strcmp(name, "enable-log-filecount"))
@ -220,14 +239,16 @@ static void config_cb(const char *name, const char *value)
ctx.cfg.max_repodesc_len = atoi(value);
else if (!strcmp(name, "max-blob-size"))
ctx.cfg.max_blob_size = atoi(value);
else if (!strcmp(name, "max-repo-count"))
else if (!strcmp(name, "max-repo-count")) {
ctx.cfg.max_repo_count = atoi(value);
else if (!strcmp(name, "max-commit-count"))
if (ctx.cfg.max_repo_count <= 0)
ctx.cfg.max_repo_count = INT_MAX;
} else if (!strcmp(name, "max-commit-count"))
ctx.cfg.max_commit_count = atoi(value);
else if (!strcmp(name, "project-list"))
ctx.cfg.project_list = xstrdup(expand_macros(value));
else if (!strcmp(name, "scan-path"))
if (!ctx.cfg.nocache && ctx.cfg.cache_size)
if (ctx.cfg.cache_size)
process_cached_repolist(expand_macros(value));
else if (ctx.cfg.project_list)
scan_projects(expand_macros(value),
@ -278,8 +299,8 @@ static void config_cb(const char *name, const char *value)
ctx.cfg.branch_sort = 1;
if (!strcmp(value, "name"))
ctx.cfg.branch_sort = 0;
} else if (starts_with(name, "mimetype."))
add_mimetype(name + 9, value);
} else if (skip_prefix(name, "mimetype.", &arg))
add_mimetype(arg, value);
else if (!strcmp(name, "include"))
parse_configfile(expand_macros(value), config_cb);
}
@ -307,11 +328,11 @@ static void querystring_cb(const char *name, const char *value)
ctx.qry.head = xstrdup(value);
ctx.qry.has_symref = 1;
} else if (!strcmp(name, "id")) {
ctx.qry.sha1 = xstrdup(value);
ctx.qry.has_sha1 = 1;
ctx.qry.oid = xstrdup(value);
ctx.qry.has_oid = 1;
} else if (!strcmp(name, "id2")) {
ctx.qry.sha2 = xstrdup(value);
ctx.qry.has_sha1 = 1;
ctx.qry.oid2 = xstrdup(value);
ctx.qry.has_oid = 1;
} else if (!strcmp(name, "ofs")) {
ctx.qry.ofs = atoi(value);
} else if (!strcmp(name, "path")) {
@ -346,7 +367,6 @@ static void prepare_context(void)
{
memset(&ctx, 0, sizeof(ctx));
ctx.cfg.agefile = "info/web/last-modified";
ctx.cfg.nocache = 0;
ctx.cfg.cache_size = 0;
ctx.cfg.cache_max_create_time = 5;
ctx.cfg.cache_root = CGIT_CACHE_ROOT;
@ -360,7 +380,6 @@ static void prepare_context(void)
ctx.cfg.case_sensitive_sort = 1;
ctx.cfg.branch_sort = 0;
ctx.cfg.commit_sort = 0;
ctx.cfg.css = "/cgit.css";
ctx.cfg.logo = "/cgit.png";
ctx.cfg.favicon = "/favicon.ico";
ctx.cfg.local_time = 0;
@ -412,7 +431,7 @@ static void prepare_context(void)
ctx.page.modified = time(NULL);
ctx.page.expires = ctx.page.modified;
ctx.page.etag = NULL;
memset(&ctx.cfg.mimetypes, 0, sizeof(struct string_list));
string_list_init_dup(&ctx.cfg.mimetypes);
if (ctx.env.script_name)
ctx.cfg.script_name = xstrdup(ctx.env.script_name);
if (ctx.env.query_string)
@ -468,14 +487,15 @@ static char *find_default_branch(struct cgit_repo *repo)
static char *guess_defbranch(void)
{
const char *ref;
unsigned char sha1[20];
const char *ref, *refname;
struct object_id oid;
ref = resolve_ref_unsafe("HEAD", 0, sha1, NULL);
if (!ref || !starts_with(ref, "refs/heads/"))
ref = resolve_ref_unsafe("HEAD", 0, &oid, NULL);
if (!ref || !skip_prefix(ref, "refs/heads/", &refname))
return "master";
return xstrdup(ref + 11);
return xstrdup(refname);
}
/* The caller must free filename and ref after calling this. */
static inline void parse_readme(const char *readme, char **filename, char **ref, struct cgit_repo *repo)
{
@ -490,9 +510,11 @@ static inline void parse_readme(const char *readme, char **filename, char **ref,
/* Check if the readme is tracked in the git repo. */
colon = strchr(readme, ':');
if (colon && strlen(colon) > 1) {
/* If it starts with a colon, we want to use
* the default branch */
if (colon == readme && repo->defbranch)
/* If it starts with a colon, we want to use head given
* from query or the default branch */
if (colon == readme && ctx.qry.head)
*ref = xstrdup(ctx.qry.head);
else if (colon == readme && repo->defbranch)
*ref = xstrdup(repo->defbranch);
else
*ref = xstrndup(readme, colon - readme);
@ -553,26 +575,22 @@ static void print_no_repo_clone_urls(const char *url)
html("</a></td></tr>\n");
}
static int prepare_repo_cmd(void)
static void prepare_repo_env(int *nongit)
{
unsigned char sha1[20];
int nongit = 0;
int rc;
/* The path to the git repository. */
setenv("GIT_DIR", ctx.repo->path, 1);
/* Do not look in /etc/ for gitconfig and gitattributes. */
setenv("GIT_CONFIG_NOSYSTEM", "1", 1);
setenv("GIT_ATTR_NOSYSTEM", "1", 1);
unsetenv("HOME");
unsetenv("XDG_CONFIG_HOME");
/* Setup the git directory and initialize the notes system. Both of these
* load local configuration from the git repository, so we do them both while
* the HOME variables are unset. */
setup_git_directory_gently(&nongit);
init_display_notes(NULL);
setup_git_directory_gently(nongit);
load_display_notes(NULL);
}
static int prepare_repo_cmd(int nongit)
{
struct object_id oid;
int rc;
if (nongit) {
const char *name = ctx.repo->name;
@ -613,12 +631,12 @@ static int prepare_repo_cmd(void)
return 1;
}
if (get_sha1(ctx.qry.head, sha1)) {
char *tmp = xstrdup(ctx.qry.head);
ctx.qry.head = ctx.repo->defbranch;
if (get_oid(ctx.qry.head, &oid)) {
char *old_head = ctx.qry.head;
ctx.qry.head = xstrdup(ctx.repo->defbranch);
cgit_print_error_page(404, "Not found",
"Invalid branch: %s", tmp);
free(tmp);
"Invalid branch: %s", old_head);
free(old_head);
return 1;
}
string_list_sort(&ctx.repo->submodules);
@ -639,7 +657,7 @@ static inline void open_auth_filter(const char *function)
ctx.env.https ? ctx.env.https : "",
ctx.qry.repo ? ctx.qry.repo : "",
ctx.qry.page ? ctx.qry.page : "",
ctx.qry.url ? ctx.qry.url : "",
cgit_currentfullurl(),
cgit_loginurl());
}
@ -653,13 +671,13 @@ static inline void open_auth_filter(const char *function)
static inline void authenticate_post(void)
{
char buffer[MAX_AUTHENTICATION_POST_BYTES];
unsigned int len;
ssize_t len;
open_auth_filter("authenticate-post");
len = ctx.env.content_length;
if (len > MAX_AUTHENTICATION_POST_BYTES)
len = MAX_AUTHENTICATION_POST_BYTES;
if (read(STDIN_FILENO, buffer, len) < 0)
if ((len = read(STDIN_FILENO, buffer, len)) < 0)
die_errno("Could not read POST from stdin");
if (write(STDOUT_FILENO, buffer, len) < 0)
die_errno("Could not write POST to stdout");
@ -692,6 +710,7 @@ static inline void authenticate_cookie(void)
static void process_request(void)
{
struct cgit_cmd *cmd;
int nongit = 0;
/* If we're not yet authenticated, no matter what page we're on,
* display the authentication body from the auth_filter. This should
@ -707,6 +726,9 @@ static void process_request(void)
return;
}
if (ctx.repo)
prepare_repo_env(&nongit);
cmd = cgit_get_cmd();
if (!cmd) {
ctx.page.title = "cgit error";
@ -720,19 +742,19 @@ static void process_request(void)
return;
}
/* If cmd->want_vpath is set, assume ctx.qry.path contains a "virtual"
* in-project path limit to be made available at ctx.qry.vpath.
* Otherwise, no path limit is in effect (ctx.qry.vpath = NULL).
*/
ctx.qry.vpath = cmd->want_vpath ? ctx.qry.path : NULL;
if (cmd->want_repo && !ctx.repo) {
cgit_print_error_page(400, "Bad request",
"No repository selected");
return;
}
if (ctx.repo && prepare_repo_cmd())
/* If cmd->want_vpath is set, assume ctx.qry.path contains a "virtual"
* in-project path limit to be made available at ctx.qry.vpath.
* Otherwise, no path limit is in effect (ctx.qry.vpath = NULL).
*/
ctx.qry.vpath = cmd->want_vpath ? ctx.qry.path : NULL;
if (ctx.repo && prepare_repo_cmd(nongit))
return;
cmd->fn();
@ -750,7 +772,7 @@ static char *build_snapshot_setting(int bitmap)
struct strbuf result = STRBUF_INIT;
for (f = cgit_snapshot_formats; f->suffix; f++) {
if (f->bit & bitmap) {
if (cgit_snapshot_format_bit(f) & bitmap) {
if (result.len)
strbuf_addch(&result, ' ');
strbuf_addstr(&result, f->suffix);
@ -789,12 +811,18 @@ static void print_repo(FILE *f, struct cgit_repo *repo)
}
if (repo->defbranch)
fprintf(f, "repo.defbranch=%s\n", repo->defbranch);
if (repo->extra_head_content)
fprintf(f, "repo.extra-head-content=%s\n", repo->extra_head_content);
if (repo->module_link)
fprintf(f, "repo.module-link=%s\n", repo->module_link);
if (repo->section)
fprintf(f, "repo.section=%s\n", repo->section);
if (repo->homepage)
fprintf(f, "repo.homepage=%s\n", repo->homepage);
if (repo->clone_url)
fprintf(f, "repo.clone-url=%s\n", repo->clone_url);
fprintf(f, "repo.enable-blame=%d\n",
repo->enable_blame);
fprintf(f, "repo.enable-commit-graph=%d\n",
repo->enable_commit_graph);
fprintf(f, "repo.enable-log-filecount=%d\n",
@ -816,6 +844,8 @@ static void print_repo(FILE *f, struct cgit_repo *repo)
fprintf(f, "repo.snapshots=%s\n", tmp ? tmp : "");
free(tmp);
}
if (repo->snapshot_prefix)
fprintf(f, "repo.snapshot-prefix=%s\n", repo->snapshot_prefix);
if (repo->max_stats != ctx.cfg.max_stats)
fprintf(f, "repo.max-stats=%s\n",
cgit_find_stats_periodname(repo->max_stats));
@ -933,11 +963,12 @@ out:
static void cgit_parse_args(int argc, const char **argv)
{
int i;
const char *arg;
int scan = 0;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "--version")) {
printf("CGit %s | http://git.zx2c4.com/cgit/\n\nCompiled in features:\n", CGIT_VERSION);
printf("CGit %s | https://git.zx2c4.com/cgit/\n\nCompiled in features:\n", CGIT_VERSION);
#ifdef NO_LUA
printf("[-] ");
#else
@ -953,28 +984,26 @@ static void cgit_parse_args(int argc, const char **argv)
exit(0);
}
if (starts_with(argv[i], "--cache=")) {
ctx.cfg.cache_root = xstrdup(argv[i] + 8);
} else if (!strcmp(argv[i], "--nocache")) {
ctx.cfg.nocache = 1;
if (skip_prefix(argv[i], "--cache=", &arg)) {
ctx.cfg.cache_root = xstrdup(arg);
} else if (!strcmp(argv[i], "--nohttp")) {
ctx.env.no_http = "1";
} else if (starts_with(argv[i], "--query=")) {
ctx.qry.raw = xstrdup(argv[i] + 8);
} else if (starts_with(argv[i], "--repo=")) {
ctx.qry.repo = xstrdup(argv[i] + 7);
} else if (starts_with(argv[i], "--page=")) {
ctx.qry.page = xstrdup(argv[i] + 7);
} else if (starts_with(argv[i], "--head=")) {
ctx.qry.head = xstrdup(argv[i] + 7);
} else if (skip_prefix(argv[i], "--query=", &arg)) {
ctx.qry.raw = xstrdup(arg);
} else if (skip_prefix(argv[i], "--repo=", &arg)) {
ctx.qry.repo = xstrdup(arg);
} else if (skip_prefix(argv[i], "--page=", &arg)) {
ctx.qry.page = xstrdup(arg);
} else if (skip_prefix(argv[i], "--head=", &arg)) {
ctx.qry.head = xstrdup(arg);
ctx.qry.has_symref = 1;
} else if (starts_with(argv[i], "--sha1=")) {
ctx.qry.sha1 = xstrdup(argv[i] + 7);
ctx.qry.has_sha1 = 1;
} else if (starts_with(argv[i], "--ofs=")) {
ctx.qry.ofs = atoi(argv[i] + 6);
} else if (starts_with(argv[i], "--scan-tree=") ||
starts_with(argv[i], "--scan-path=")) {
} else if (skip_prefix(argv[i], "--oid=", &arg)) {
ctx.qry.oid = xstrdup(arg);
ctx.qry.has_oid = 1;
} else if (skip_prefix(argv[i], "--ofs=", &arg)) {
ctx.qry.ofs = atoi(arg);
} else if (skip_prefix(argv[i], "--scan-tree=", &arg) ||
skip_prefix(argv[i], "--scan-path=", &arg)) {
/*
* HACK: The global snapshot bit mask defines the set
* of allowed snapshot formats, but the config file
@ -988,7 +1017,7 @@ static void cgit_parse_args(int argc, const char **argv)
*/
ctx.cfg.snapshots = 0xFF;
scan++;
scan_tree(argv[i] + 12, repo_config);
scan_tree(arg, repo_config);
}
}
if (scan) {
@ -1013,7 +1042,7 @@ static int calc_ttl(void)
if (!strcmp(ctx.qry.page, "snapshot"))
return ctx.cfg.cache_snapshot_ttl;
if (ctx.qry.has_sha1)
if (ctx.qry.has_oid)
return ctx.cfg.cache_static_ttl;
if (ctx.qry.has_symref)
@ -1022,7 +1051,7 @@ static int calc_ttl(void)
return ctx.cfg.cache_repo_ttl;
}
int main(int argc, const char **argv)
int cmd_main(int argc, const char **argv)
{
const char *path;
int err, ttl;
@ -1077,8 +1106,6 @@ int main(int argc, const char **argv)
else
ctx.page.expires += ttl * 60;
if (!ctx.env.authenticated || (ctx.env.request_method && !strcmp(ctx.env.request_method, "HEAD")))
ctx.cfg.nocache = 1;
if (ctx.cfg.nocache)
ctx.cfg.cache_size = 0;
err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
ctx.qry.raw, ttl, process_request);

@ -18,7 +18,7 @@ div#cgit a:hover {
}
div#cgit table {
border-collapse: collapse;
border-collapse: collapse;
}
div#cgit table#header {
@ -85,6 +85,12 @@ div#cgit table.tabs td a.active {
background-color: #ccc;
}
div#cgit table.tabs a[href^="http://"]:after, div#cgit table.tabs a[href^="https://"]:after {
content: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAAmJLR0QA/4ePzL8AAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfgAhcJDQY+gm2TAAAAHWlUWHRDb21tZW50AAAAAABDcmVhdGVkIHdpdGggR0lNUGQuZQcAAABbSURBVAhbY2BABs4MU4CwhYHBh2Erww4wrGFQZHjI8B8IgUIscJWyDHcggltQhI4zGDCcRwhChPggHIggP1QoAVmQkSETrGoHsiAEsACtBYN0oDAMbgU6EBcAAL2eHUt4XUU4AAAAAElFTkSuQmCC);
opacity: 0.5;
margin: 0 0 0 5px;
}
div#cgit table.tabs td.form {
text-align: right;
}
@ -128,14 +134,34 @@ div#cgit table.list tr.logheader {
background: #eee;
}
div#cgit table.list tr:nth-child(even) {
background: #f7f7f7;
}
div#cgit table.list tr:nth-child(odd) {
background: white;
}
div#cgit table.list tr:hover {
background: #eee;
}
div#cgit table.list tr.nohover {
background: white;
}
div#cgit table.list tr.nohover:hover {
background: white;
}
div#cgit table.list tr.nohover-highlight:hover:nth-child(even) {
background: #f7f7f7;
}
div#cgit table.list tr.nohover-highlight:hover:nth-child(odd) {
background: white;
}
div#cgit table.list th {
font-weight: bold;
/* color: #888;
@ -274,6 +300,7 @@ div#cgit table.blob {
border-top: solid 1px black;
}
div#cgit table.blob td.hashes,
div#cgit table.blob td.lines {
margin: 0; padding: 0 0 0 0.5em;
vertical-align: top;
@ -303,6 +330,43 @@ div#cgit table.ssdiff td.lineno a:hover {
color: black;
}
div#cgit table.blame td.hashes,
div#cgit table.blame td.lines,
div#cgit table.blame td.linenumbers {
padding: 0;
}
div#cgit table.blame td.hashes div.alt,
div#cgit table.blame td.lines div.alt {
padding: 0 0.5em 0 0.5em;
}
div#cgit table.blame td.linenumbers div.alt {
padding: 0 0.5em 0 0;
}
div#cgit table.blame div.alt:nth-child(even) {
background: #eee;
}
div#cgit table.blame div.alt:nth-child(odd) {
background: white;
}
div#cgit table.blame td.lines > div {
position: relative;
}
div#cgit table.blame td.lines > div > pre {
padding: 0 0 0 0.5em;
position: absolute;
top: 0;
}
div#cgit table.blame .oid {
font-size: 100%;
}
div#cgit table.bin-blob {
margin-top: 0.5em;
border: solid 1px black;
@ -501,7 +565,7 @@ div#cgit table.diff td div.del {
color: red;
}
div#cgit .sha1 {
div#cgit .oid {
font-family: monospace;
font-size: 90%;
}
@ -584,19 +648,31 @@ div#cgit span.age-months {
div#cgit span.age-years {
color: #bbb;
}
div#cgit span.insertions {
color: #080;
}
div#cgit span.deletions {
color: #800;
}
div#cgit div.footer {
margin-top: 0.5em;
text-align: center;
font-size: 80%;
color: #ccc;
}
div#cgit div.footer a {
color: #ccc;
text-decoration: none;
}
div#cgit div.footer a:hover {
text-decoration: underline;
}
div#cgit a.branch-deco {
color: #000;
margin: 0px 0.5em;
@ -604,6 +680,7 @@ div#cgit a.branch-deco {
background-color: #88ff88;
border: solid 1px #007700;
}
div#cgit a.tag-deco {
color: #000;
margin: 0px 0.5em;
@ -611,6 +688,15 @@ div#cgit a.tag-deco {
background-color: #ffff88;
border: solid 1px #777700;
}
div#cgit a.tag-annotated-deco {
color: #000;
margin: 0px 0.5em;
padding: 0px 0.25em;
background-color: #ffcc88;
border: solid 1px #777700;
}
div#cgit a.remote-deco {
color: #000;
margin: 0px 0.5em;
@ -618,6 +704,7 @@ div#cgit a.remote-deco {
background-color: #ccccff;
border: solid 1px #000077;
}
div#cgit a.deco {
color: #000;
margin: 0px 0.5em;
@ -628,6 +715,7 @@ div#cgit a.deco {
div#cgit div.commit-subject a.branch-deco,
div#cgit div.commit-subject a.tag-deco,
div#cgit div.commit-subject a.tag-annotated-deco,
div#cgit div.commit-subject a.remote-deco,
div#cgit div.commit-subject a.deco {
margin-left: 1em;
@ -797,9 +885,9 @@ div#cgit table.ssdiff td.head div.head {
div#cgit table.ssdiff td.foot {
border-top: solid 1px #aaa;
border-left: none;
border-right: none;
border-bottom: none;
border-left: none;
border-right: none;
border-bottom: none;
}
div#cgit table.ssdiff td.space {

@ -8,12 +8,13 @@
#include <cache.h>
#include <grep.h>
#include <object.h>
#include <object-store.h>
#include <tree.h>
#include <commit.h>
#include <tag.h>
#include <diff.h>
#include <diffcore.h>
#include <argv-array.h>
#include <strvec.h>
#include <refs.h>
#include <revision.h>
#include <log-tree.h>
@ -24,18 +25,12 @@
#include <utf8.h>
#include <notes.h>
#include <graph.h>
#include <inttypes.h>
/* Add isgraph(x) to Git's sane ctype support (see git-compat-util.h) */
#undef isgraph
#define isgraph(x) (isprint((x)) && !isspace((x)))
/*
* Dateformats used on misc. pages
*/
#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)"
#define FMT_SHORTDATE "%Y-%m-%d"
#define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ"
/*
* Limits used for relative dates
@ -53,6 +48,8 @@
*/
#define PAGE_ENCODING "UTF-8"
#define BIT(x) (1U << (x))
typedef void (*configfn)(const char *name, const char *value);
typedef void (*filepair_fn)(struct diff_filepair *pair);
typedef void (*linediff_fn)(char *line, int len);
@ -78,7 +75,6 @@ struct cgit_exec_filter {
char *cmd;
char **argv;
int old_stdout;
int pipe_fh[2];
int pid;
};
@ -87,7 +83,9 @@ struct cgit_repo {
char *name;
char *path;
char *desc;
char *extra_head_content;
char *owner;
char *homepage;
char *defbranch;
char *module_link;
struct string_list readme;
@ -95,7 +93,9 @@ struct cgit_repo {
char *clone_url;
char *logo;
char *logo_link;
char *snapshot_prefix;
int snapshots;
int enable_blame;
int enable_commit_graph;
int enable_log_filecount;
int enable_log_linecount;
@ -130,9 +130,11 @@ struct commitinfo {
char *author;
char *author_email;
unsigned long author_date;
int author_tz;
char *committer;
char *committer_email;
unsigned long committer_date;
int committer_tz;
char *subject;
char *msg;
char *msg_encoding;
@ -142,6 +144,7 @@ struct taginfo {
char *tagger;
char *tagger_email;
unsigned long tagger_date;
int tagger_tz;
char *msg;
};
@ -162,7 +165,7 @@ struct reflist {
struct cgit_query {
int has_symref;
int has_sha1;
int has_oid;
int has_difftype;
char *raw;
char *repo;
@ -170,8 +173,8 @@ struct cgit_query {
char *search;
char *grep;
char *head;
char *sha1;
char *sha2;
char *oid;
char *oid2;
char *path;
char *name;
char *url;
@ -193,19 +196,17 @@ struct cgit_config {
char *cache_root;
char *clone_prefix;
char *clone_url;
char *css;
char *favicon;
char *footer;
char *head_include;
char *header;
char *index_header;
char *index_info;
char *logo;
char *logo_link;
char *mimetype_file;
char *module_link;
char *project_list;
struct string_list readme;
struct string_list css;
char *robots;
char *root_title;
char *root_desc;
@ -231,6 +232,7 @@ struct cgit_config {
int enable_http_clone;
int enable_index_links;
int enable_index_owner;
int enable_blame;
int enable_commit_graph;
int enable_log_filecount;
int enable_log_linecount;
@ -248,7 +250,6 @@ struct cgit_config {
int max_repodesc_len;
int max_blob_size;
int max_stats;
int nocache;
int noplainemail;
int noheader;
int renamelimit;
@ -264,6 +265,7 @@ struct cgit_config {
int branch_sort;
int commit_sort;
struct string_list mimetypes;
struct string_list js;
struct cgit_filter *about_filter;
struct cgit_filter *commit_filter;
struct cgit_filter *source_filter;
@ -316,7 +318,6 @@ struct cgit_snapshot_format {
const char *suffix;
const char *mimetype;
write_archive_fn_t write_func;
int bit;
};
extern const char *cgit_version;
@ -336,8 +337,6 @@ extern int chk_non_negative(int result, char *msg);
extern char *trim_end(const char *str, char c);
extern char *ensure_end(const char *str, char c);
extern char *strlpart(char *txt, int maxlen);
extern char *strrpart(char *txt, int maxlen);
extern void strbuf_ensure_end(struct strbuf *sb, char c);
@ -346,19 +345,20 @@ extern void cgit_free_reflist_inner(struct reflist *list);
extern int cgit_refs_cb(const char *refname, const struct object_id *oid,
int flags, void *cb_data);
extern void *cgit_free_commitinfo(struct commitinfo *info);
extern void cgit_free_commitinfo(struct commitinfo *info);
extern void cgit_free_taginfo(struct taginfo *info);
void cgit_diff_tree_cb(struct diff_queue_struct *q,
struct diff_options *options, void *data);
extern int cgit_diff_files(const unsigned char *old_sha1,
const unsigned char *new_sha1,
extern int cgit_diff_files(const struct object_id *old_oid,
const struct object_id *new_oid,
unsigned long *old_size, unsigned long *new_size,
int *binary, int context, int ignorews,
linediff_fn fn);
extern void cgit_diff_tree(const unsigned char *old_sha1,
const unsigned char *new_sha1,
extern void cgit_diff_tree(const struct object_id *old_oid,
const struct object_id *new_oid,
filepair_fn fn, const char *prefix, int ignorews);
extern void cgit_diff_commit(struct commit *commit, filepair_fn fn,
@ -377,6 +377,9 @@ extern void cgit_parse_url(const char *url);
extern const char *cgit_repobasename(const char *reponame);
extern int cgit_parse_snapshots_mask(const char *str);
extern const struct object_id *cgit_snapshot_get_sig(const char *ref,
const struct cgit_snapshot_format *f);
extern const unsigned cgit_snapshot_format_bit(const struct cgit_snapshot_format *f);
extern int cgit_open_filter(struct cgit_filter *filter, ...);
extern int cgit_close_filter(struct cgit_filter *filter);

@ -0,0 +1,68 @@
/* cgit.js: javacript functions for cgit
*
* Copyright (C) 2006-2018 cgit Development Team <cgit@lists.zx2c4.com>
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
*/
(function () {
/* This follows the logic and suffixes used in ui-shared.c */
var age_classes = [ "age-mins", "age-hours", "age-days", "age-weeks", "age-months", "age-years" ];
var age_suffix = [ "min.", "hours", "days", "weeks", "months", "years", "years" ];
var age_next = [ 60, 3600, 24 * 3600, 7 * 24 * 3600, 30 * 24 * 3600, 365 * 24 * 3600, 365 * 24 * 3600 ];
var age_limit = [ 7200, 24 * 7200, 7 * 24 * 7200, 30 * 24 * 7200, 365 * 25 * 7200, 365 * 25 * 7200 ];
var update_next = [ 10, 5 * 60, 1800, 24 * 3600, 24 * 3600, 24 * 3600, 24 * 3600 ];
function render_age(e, age) {
var t, n;
for (n = 0; n < age_classes.length; n++)
if (age < age_limit[n])
break;
t = Math.round(age / age_next[n]) + " " + age_suffix[n];
if (e.textContent != t) {
e.textContent = t;
if (n == age_classes.length)
n--;
if (e.className != age_classes[n])
e.className = age_classes[n];
}
}
function aging() {
var n, next = 24 * 3600,
now_ut = Math.round((new Date().getTime() / 1000));
for (n = 0; n < age_classes.length; n++) {
var m, elems = document.getElementsByClassName(age_classes[n]);
if (elems.length && update_next[n] < next)
next = update_next[n];
for (m = 0; m < elems.length; m++) {
var age = now_ut - elems[m].getAttribute("data-ut");
render_age(elems[m], age);
}
}
/*
* We only need to come back when the age might have changed.
* Eg, if everything is counted in hours already, once per
* 5 minutes is accurate enough.
*/
window.setTimeout(aging, next * 1000);
}
document.addEventListener("DOMContentLoaded", function() {
/* we can do the aging on DOM content load since no layout dependency */
aging();
}, false);
})();

@ -21,6 +21,8 @@ CGIT_CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'
CGIT_CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'
CGIT_CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"'
PKG_CONFIG ?= pkg-config
ifdef NO_C99_FORMAT
CFLAGS += -DNO_C99_FORMAT
endif
@ -31,7 +33,7 @@ ifdef NO_LUA
else
ifeq ($(LUA_PKGCONFIG),)
LUA_PKGCONFIG := $(shell for pc in luajit lua lua5.2 lua5.1; do \
pkg-config --exists $$pc 2>/dev/null && echo $$pc && break; \
$(PKG_CONFIG) --exists $$pc 2>/dev/null && echo $$pc && break; \
done)
LUA_MODE := autodetected
else
@ -39,8 +41,8 @@ else
endif
ifneq ($(LUA_PKGCONFIG),)
LUA_MESSAGE := linking with $(LUA_MODE) $(LUA_PKGCONFIG)
LUA_LIBS := $(shell pkg-config --libs $(LUA_PKGCONFIG) 2>/dev/null)
LUA_CFLAGS := $(shell pkg-config --cflags $(LUA_PKGCONFIG) 2>/dev/null)
LUA_LIBS := $(shell $(PKG_CONFIG) --libs $(LUA_PKGCONFIG) 2>/dev/null)
LUA_CFLAGS := $(shell $(PKG_CONFIG) --cflags $(LUA_PKGCONFIG) 2>/dev/null)
CGIT_LIBS += $(LUA_LIBS)
CGIT_CFLAGS += $(LUA_CFLAGS)
else
@ -51,8 +53,8 @@ endif
endif
# Add -ldl to linker flags on non-BSD systems.
ifeq ($(findstring BSD,$(uname_S)),)
# Add -ldl to linker flags on systems that commonly use GNU libc.
ifneq (,$(filter $(uname_S),Linux GNU GNU/kFreeBSD))
CGIT_LIBS += -ldl
endif
@ -75,6 +77,7 @@ CGIT_OBJ_NAMES += parsing.o
CGIT_OBJ_NAMES += scan-tree.o
CGIT_OBJ_NAMES += shared.o
CGIT_OBJ_NAMES += ui-atom.o
CGIT_OBJ_NAMES += ui-blame.o
CGIT_OBJ_NAMES += ui-blob.o
CGIT_OBJ_NAMES += ui-clone.o
CGIT_OBJ_NAMES += ui-commit.o

@ -54,14 +54,10 @@ branch-sort::
list, and when set to "name" enables ordering by branch name. Default
value: "name".
cache-root::
Path used to store the cgit cache entries. Default value:
"/var/cache/cgit". See also: "MACRO EXPANSION".
cache-static-ttl::
cache-about-ttl::
Number which specifies the time-to-live, in minutes, for the cached
version of repository pages accessed with a fixed SHA1. See also:
"CACHE". Default value: -1".
version of the repository about page. See also: "CACHE". Default
value: "15".
cache-dynamic-ttl::
Number which specifies the time-to-live, in minutes, for the cached
@ -73,6 +69,10 @@ cache-repo-ttl::
version of the repository summary page. See also: "CACHE". Default
value: "5".
cache-root::
Path used to store the cgit cache entries. Default value:
"/var/cache/cgit". See also: "MACRO EXPANSION".
cache-root-ttl::
Number which specifies the time-to-live, in minutes, for the cached
version of the repository index page. See also: "CACHE". Default
@ -83,22 +83,22 @@ cache-scanrc-ttl::
of scanning a path for git repositories. See also: "CACHE". Default
value: "15".
cache-about-ttl::
Number which specifies the time-to-live, in minutes, for the cached
version of the repository about page. See also: "CACHE". Default
value: "15".
cache-snapshot-ttl::
Number which specifies the time-to-live, in minutes, for the cached
version of snapshots. See also: "CACHE". Default value: "5".
case-sensitive-sort::
Sort items in the repo list case sensitively. Default value: "1".
See also: repository-sort, section-sort.
cache-size::
The maximum number of entries in the cgit cache. When set to "0",
caching is disabled. See also: "CACHE". Default value: "0"
case-sensitive-sort::
Sort items in the repo list case sensitively. Default value: "1".
See also: repository-sort, section-sort.
cache-snapshot-ttl::
Number which specifies the time-to-live, in minutes, for the cached
version of snapshots. See also: "CACHE". Default value: "5".
cache-static-ttl::
Number which specifies the time-to-live, in minutes, for the cached
version of repository pages accessed with a fixed SHA1. See also:
"CACHE". Default value: -1".
clone-prefix::
Space-separated list of common prefixes which, when combined with a
@ -126,7 +126,8 @@ commit-sort::
css::
Url which specifies the css document to include in all cgit pages.
Default value: "/cgit.css".
Default value: "/cgit.css". May be given multiple times, each
css URL path is added in the head section of the document in turn.
email-filter::
Specifies a command which will be invoked to format names and email
@ -141,6 +142,11 @@ embedded::
suitable for embedding in other html pages. Default value: none. See
also: "noheader".
enable-blame::
Flag which, when set to "1", will allow cgit to provide a "blame" page
for files, and will make it generate links to that page in appropriate
places. Default value: "0".
enable-commit-graph::
Flag which, when set to "1", will make cgit print an ASCII-art commit
history graph to the left of the commit messages in the repository
@ -154,12 +160,29 @@ enable-follow-links::
Flag which, when set to "1", allows users to follow a file in the log
view. Default value: "0".
enable-git-config::
Flag which, when set to "1", will allow cgit to use git config to set
any repo specific settings. This option is used in conjunction with
"scan-path", and must be defined prior, to augment repo-specific
settings. The keys gitweb.owner, gitweb.category, gitweb.description,
and gitweb.homepage will map to the cgit keys repo.owner, repo.section,
repo.desc, and repo.homepage respectively. All git config keys that begin
with "cgit." will be mapped to the corresponding "repo." key in cgit.
Default value: "0". See also: scan-path, section-from-path.
enable-http-clone::
If set to "1", cgit will act as an dumb HTTP endpoint for git clones.
If set to "1", cgit will act as a dumb HTTP endpoint for git clones.
You can add "http://$HTTP_HOST$SCRIPT_NAME/$CGIT_REPO_URL" to clone-url
to expose this feature. If you use an alternate way of serving git
repositories, you may wish to disable this. Default value: "1".
enable-html-serving::
Flag which, when set to "1", will allow the /plain handler to serve
mimetype headers that result in the file being treated as HTML by the
browser. When set to "0", such file types are returned instead as
text/plain or application/octet-stream. Default value: "0". See also:
"repo.enable-html-serving".
enable-index-links::
Flag which, when set to "1", will make cgit generate extra links for
each repo in the repository index (specifically, to the "summary",
@ -190,27 +213,10 @@ enable-subject-links::
in commit view. Default value: "0". See also:
"repo.enable-subject-links".
enable-html-serving::
Flag which, when set to "1", will allow the /plain handler to serve
mimetype headers that result in the file being treated as HTML by the
browser. When set to "0", such file types are returned instead as
text/plain or application/octet-stream. Default value: "0". See also:
"repo.enable-html-serving".
enable-tree-linenumbers::
Flag which, when set to "1", will make cgit generate linenumber links
for plaintext blobs printed in the tree view. Default value: "1".
enable-git-config::
Flag which, when set to "1", will allow cgit to use git config to set
any repo specific settings. This option is used in conjunction with
"scan-path", and must be defined prior, to augment repo-specific
settings. The keys gitweb.owner, gitweb.category, and gitweb.description
will map to the cgit keys repo.owner, repo.section, and repo.desc,
respectively. All git config keys that begin with "cgit." will be mapped
to the corresponding "repo." key in cgit. Default value: "0". See also:
scan-path, section-from-path.
favicon::
Url used as link to a shortcut icon for cgit. It is suggested to use
the value "/favicon.ico" since certain browsers will ignore other
@ -233,17 +239,10 @@ include::
Name of a configfile to include before the rest of the current config-
file is parsed. Default value: none. See also: "MACRO EXPANSION".
index-header::
The content of the file specified with this option will be included
verbatim above the repository index. This setting is deprecated, and
will not be supported by cgit-1.0 (use root-readme instead). Default
value: none.
index-info::
The content of the file specified with this option will be included
verbatim below the heading on the repository index page. This setting
is deprecated, and will not be supported by cgit-1.0 (use root-desc
instead). Default value: none.
js::
Url which specifies the javascript script document to include in all cgit
pages. Default value: "/cgit.js". Setting this to an empty string will
disable generation of the link to this file in the head section.
local-time::
Flag which, if set to "1", makes cgit print commit and tag times in the
@ -258,19 +257,14 @@ logo-link::
calculated url of the repository index page will be used. Default
value: none.
owner-filter::
Specifies a command which will be invoked to format the Owner
column of the main page. The command will get the owner on STDIN,
and the STDOUT from the command will be included verbatim in the
table. This can be used to link to additional context such as an
owners home page. When active this filter is used instead of the
default owner query url. Default value: none.
See also: "FILTER API".
max-atom-items::
Specifies the number of items to display in atom feeds view. Default
value: "10".
max-blob-size::
Specifies the maximum size of a blob to display HTML for in KBytes.
Default value: "0" (limit disabled).
max-commit-count::
Specifies the number of entries to list per page in "log" view. Default
value: "50".
@ -281,16 +275,13 @@ max-message-length::
max-repo-count::
Specifies the number of entries to list per page on the repository
index page. Default value: "50".
index page. The value "0" shows all repositories without limitation.
Default value: "50".
max-repodesc-length::
Specifies the maximum number of repo description characters to display
on the repository index page. Default value: "80".
max-blob-size::
Specifies the maximum size of a blob to display HTML for in KBytes.
Default value: "0" (limit disabled).
max-stats::
Set the default maximum statistics period. Valid values are "week",
"month", "quarter" and "year". If unspecified, statistics are
@ -318,11 +309,6 @@ module-link::
formatstring are the path and SHA1 of the submodule commit. Default
value: none.
nocache::
If set to the value "1" caching will be disabled. This settings is
deprecated, and will not be honored starting with cgit-1.0. Default
value: "0".
noplainemail::
If set to "1" showing full author email addresses will be disabled.
Default value: "0".
@ -331,6 +317,15 @@ noheader::
Flag which, when set to "1", will make cgit omit the standard header
on all pages. Default value: none. See also: "embedded".
owner-filter::
Specifies a command which will be invoked to format the Owner
column of the main page. The command will get the owner on STDIN,
and the STDOUT from the command will be included verbatim in the
table. This can be used to link to additional context such as an
owners home page. When active this filter is used instead of the
default owner query url. Default value: none.
See also: "FILTER API".
project-list::
A list of subdirectories inside of scan-path, relative to it, that
should loaded as git repositories. This must be defined prior to
@ -354,10 +349,6 @@ renamelimit::
"-1" uses the compiletime value in git (for further info, look at
`man git-diff`). Default value: "-1".
repo.group::
Legacy alias for "section". This option is deprecated and will not be
supported in cgit-1.0.
repository-sort::
The way in which repositories in each section are sorted. Valid values
are "name" for sorting by the repo name or "age" for sorting by the
@ -423,8 +414,12 @@ side-by-side-diffs::
snapshots::
Text which specifies the default set of snapshot formats that cgit
generates links for. The value is a space-separated list of zero or
more of the values "tar", "tar.gz", "tar.bz2", "tar.xz" and "zip".
Default value: none.
more of the values "tar", "tar.gz", "tar.bz2", "tar.lz", "tar.xz",
"tar.zst" and "zip". The special value "all" enables all snapshot
formats. Default value: none.
All compressors use default settings. Some settings can be influenced
with environment variables, for example set ZSTD_CLEVEL=10 in web
server environment for higher (but slower) zstd compression.
source-filter::
Specifies a command which will be invoked to format plaintext blobs
@ -500,10 +495,18 @@ repo.email-filter::
Override the default email-filter. Default value: none. See also:
"enable-filter-overrides". See also: "FILTER API".
repo.enable-blame::
A flag which can be used to disable the global setting
`enable-blame'. Default value: none.
repo.enable-commit-graph::
A flag which can be used to disable the global setting
`enable-commit-graph'. Default value: none.
repo.enable-html-serving::
A flag which can be used to override the global setting
`enable-html-serving`. Default value: none.
repo.enable-log-filecount::
A flag which can be used to disable the global setting
`enable-log-filecount'. Default value: none.
@ -520,15 +523,18 @@ repo.enable-subject-links::
A flag which can be used to override the global setting
`enable-subject-links'. Default value: none.
enable-html-serving::
A flag which can be used to override the global setting
`enable-html-serving`. Default value: none.
repo.extra-head-content::
This value will be added verbatim to the head section of each page
displayed for this repo. Default value: none.
repo.hide::
Flag which, when set to "1", hides the repository from the repository
index. The repository can still be accessed by providing a direct path.
Default value: "0". See also: "repo.ignore".
repo.homepage::
The value to show as repository homepage. Default value: none.
repo.ignore::
Flag which, when set to "1", ignores the repository. The repository
is not shown in the index and cannot be accessed by providing a direct
@ -543,10 +549,6 @@ repo.logo-link::
calculated url of the repository index page will be used. Default
value: global logo-link.
repo.owner-filter::
Override the default owner-filter. Default value: none. See also:
"enable-filter-overrides". See also: "FILTER API".
repo.module-link::
Text which will be used as the formatstring for a hyperlink when a
submodule is printed in a directory listing. The arguments for the
@ -571,6 +573,10 @@ repo.owner::
A value used to identify the owner of the repository. Default value:
none.
repo.owner-filter::
Override the default owner-filter. Default value: none. See also:
"enable-filter-overrides". See also: "FILTER API".
repo.path::
An absolute path to the repository directory. For non-bare repositories
this is the .git-directory. Default value: none.
@ -580,20 +586,27 @@ repo.readme::
verbatim as the "About" page for this repo. You may also specify a
git refspec by head or by hash by prepending the refspec followed by
a colon. For example, "master:docs/readme.mkd". If the value begins
with a colon, i.e. ":docs/readme.rst", the default branch of the
repository will be used. Sharing any file will expose that entire
directory tree to the "/about/PATH" endpoints, so be sure that there
are no non-public files located in the same directory as the readme
file. Default value: <readme>.
with a colon, i.e. ":docs/readme.rst", the head giving in query or
the default branch of the repository will be used. Sharing any file
will expose that entire directory tree to the "/about/PATH" endpoints,
so be sure that there are no non-public files located in the same
directory as the readme file. Default value: <readme>.
repo.section::
Override the current section name for this repository. Default value:
none.
repo.snapshots::
A mask of snapshot formats for this repo that cgit generates links for,
restricted by the global "snapshots" setting. Default value:
<snapshots>.
repo.section::
Override the current section name for this repository. Default value:
none.
repo.snapshot-prefix::
Prefix to use for snapshot links instead of the repository basename.
For example, the "linux-stable" repository may wish to set this to
"linux" so that snapshots are in the format "linux-3.15.4" instead
of "linux-stable-3.15.4". Default value: <empty> meaning to use
the repository basename.
repo.source-filter::
Override the default source-filter. Default value: none. See also:
@ -667,30 +680,6 @@ about filter::
The about text that is to be filtered is available on standard input
and the filtered text is expected on standard output.
commit filter::
This filter is given no arguments. The commit message text that is to
be filtered is available on standard input and the filtered text is
expected on standard output.
email filter::
This filter is given two parameters: the email address of the relevent
author and a string indicating the originating page. The filter will
then receive the text string to format on standard input and is
expected to write to standard output the formatted text to be included
in the page.
owner filter::
This filter is given no arguments. The owner text is avilable on
standard input and the filter is expected to write to standard
output. The output is included in the Owner column.
source filter::
This filter is given a single parameter: the filename of the source
file to filter. The filter can use the filename to determine (for
example) the syntax highlighting mode. The contents of the source
file that is to be filtered is available on standard input and the
filtered contents is expected on standard output.
auth filter::
The authentication filter receives 12 parameters:
- filter action, explained below, which specifies which action the
@ -717,6 +706,30 @@ auth filter::
Please see `filters/simple-authentication.lua` for a clear example
script that may be modified.
commit filter::
This filter is given no arguments. The commit message text that is to
be filtered is available on standard input and the filtered text is
expected on standard output.
email filter::
This filter is given two parameters: the email address of the relevant
author and a string indicating the originating page. The filter will
then receive the text string to format on standard input and is
expected to write to standard output the formatted text to be included
in the page.
owner filter::
This filter is given no arguments. The owner text is available on
standard input and the filter is expected to write to standard
output. The output is included in the Owner column.
source filter::
This filter is given a single parameter: the filename of the source
file to filter. The filter can use the filename to determine (for
example) the syntax highlighting mode. The contents of the source
file that is to be filtered is available on standard input and the
filtered contents is expected on standard output.
All filters are handed the following environment variables:
@ -760,7 +773,7 @@ the environment variables defined in "FILTER API":
CACHE
------
-----
All cache ttl values are in minutes. Negative ttl values indicate that a page
type will never expire, and thus the first time a URL is accessed, the result
@ -768,6 +781,33 @@ will be cached indefinitely, even if the underlying git repository changes.
Conversely, when a ttl value is zero, the cache is disabled for that
particular page type, and the page type is never cached.
SIGNATURES
----------
Cgit can host .asc signatures corresponding to various snapshot formats,
through use of git notes. For example, the following command may be used to
add a signature to a .tar.xz archive:
git notes --ref=refs/notes/signatures/tar.xz add -C "$(
gpg --output - --armor --detach-sign cgit-1.1.tar.xz |
git hash-object -w --stdin
)" v1.1
If it is instead desirable to attach a signature of the underlying .tar, this
will be linked, as a special case, beside a .tar.* link that does not have its
own signature. For example, a signature of a tarball of the latest tag might
be added with a similar command:
tag="$(git describe --abbrev=0)"
git notes --ref=refs/notes/signatures/tar add -C "$(
git archive --format tar --prefix "cgit-${tag#v}/" "$tag" |
gpg --output - --armor --detach-sign |
git hash-object -w --stdin
)" "$tag"
Since git-archive(1) is expected to produce stable output between versions,
this allows one to generate a long-term signature of the contents of a given
tag.
EXAMPLE CGITRC FILE
-------------------
@ -796,6 +836,10 @@ enable-http-clone=1
enable-index-links=1
# Enable blame page and create links to it from tree page
enable-blame=1
# Enable ASCII art commit history graph on the log pages
enable-commit-graph=1

44
cmd.c

@ -1,6 +1,6 @@
/* cmd.c: the cgit command dispatcher
*
* Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
* Copyright (C) 2006-2017 cgit Development Team <cgit@lists.zx2c4.com>
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
@ -11,6 +11,7 @@
#include "cache.h"
#include "ui-shared.h"
#include "ui-atom.h"
#include "ui-blame.h"
#include "ui-blob.h"
#include "ui-clone.h"
#include "ui-commit.h"
@ -39,38 +40,56 @@ static void atom_fn(void)
static void about_fn(void)
{
if (ctx.repo) {
size_t path_info_len = ctx.env.path_info ? strlen(ctx.env.path_info) : 0;
if (!ctx.qry.path &&
ctx.qry.url[strlen(ctx.qry.url) - 1] != '/' &&
ctx.env.path_info[strlen(ctx.env.path_info) - 1] != '/') {
(!path_info_len || ctx.env.path_info[path_info_len - 1] != '/')) {
char *currenturl = cgit_currenturl();
char *redirect = fmtalloc("%s/", currenturl);
cgit_redirect(redirect, true);
free(currenturl);
free(redirect);
} else
} else if (ctx.repo->readme.nr)
cgit_print_repo_readme(ctx.qry.path);
else if (ctx.repo->homepage)
cgit_redirect(ctx.repo->homepage, false);
else {
char *currenturl = cgit_currenturl();
char *redirect = fmtalloc("%s../", currenturl);
cgit_redirect(redirect, false);
free(currenturl);
free(redirect);
}
} else
cgit_print_site_readme();
}
static void blame_fn(void)
{
if (ctx.repo->enable_blame)
cgit_print_blame();
else
cgit_print_error_page(403, "Forbidden", "Blame is disabled");
}
static void blob_fn(void)
{
cgit_print_blob(ctx.qry.sha1, ctx.qry.path, ctx.qry.head, 0);
cgit_print_blob(ctx.qry.oid, ctx.qry.path, ctx.qry.head, 0);
}
static void commit_fn(void)
{
cgit_print_commit(ctx.qry.sha1, ctx.qry.path);
cgit_print_commit(ctx.qry.oid, ctx.qry.path);
}
static void diff_fn(void)
{
cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1, 0);
cgit_print_diff(ctx.qry.oid, ctx.qry.oid2, ctx.qry.path, 1, 0);
}
static void rawdiff_fn(void)
{
cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1, 1);
cgit_print_diff(ctx.qry.oid, ctx.qry.oid2, ctx.qry.path, 1, 1);
}
static void info_fn(void)
@ -80,7 +99,7 @@ static void info_fn(void)
static void log_fn(void)
{
cgit_print_log(ctx.qry.sha1, ctx.qry.ofs, ctx.cfg.max_commit_count,
cgit_print_log(ctx.qry.oid, ctx.qry.ofs, ctx.cfg.max_commit_count,
ctx.qry.grep, ctx.qry.search, ctx.qry.path, 1,
ctx.repo->enable_commit_graph,
ctx.repo->commit_sort);
@ -106,7 +125,7 @@ static void repolist_fn(void)
static void patch_fn(void)
{
cgit_print_patch(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path);
cgit_print_patch(ctx.qry.oid, ctx.qry.oid2, ctx.qry.path);
}
static void plain_fn(void)
@ -121,7 +140,7 @@ static void refs_fn(void)
static void snapshot_fn(void)
{
cgit_print_snapshot(ctx.qry.head, ctx.qry.sha1, ctx.qry.path,
cgit_print_snapshot(ctx.qry.head, ctx.qry.oid, ctx.qry.path,
ctx.qry.nohead);
}
@ -137,12 +156,12 @@ static void summary_fn(void)
static void tag_fn(void)
{
cgit_print_tag(ctx.qry.sha1);
cgit_print_tag(ctx.qry.oid);
}
static void tree_fn(void)
{
cgit_print_tree(ctx.qry.sha1, ctx.qry.path);
cgit_print_tree(ctx.qry.oid, ctx.qry.path);
}
#define def_cmd(name, want_repo, want_vpath, is_clone) \
@ -154,6 +173,7 @@ struct cgit_cmd *cgit_get_cmd(void)
def_cmd(HEAD, 1, 0, 1),
def_cmd(atom, 1, 0, 0),
def_cmd(about, 0, 0, 0),
def_cmd(blame, 1, 1, 0),
def_cmd(blob, 1, 0, 0),
def_cmd(commit, 1, 1, 0),
def_cmd(diff, 1, 1, 0),

@ -39,7 +39,9 @@ static int read_config_line(FILE *f, struct strbuf *name, struct strbuf *value)
/* Skip comments and preceding spaces. */
for(;;) {
if (c == '#' || c == ';')
if (c == EOF)
return 0;
else if (c == '#' || c == ';')
skip_line(f);
else if (!isspace(c))
break;

@ -42,6 +42,7 @@ void cgit_cleanup_filters(void)
static int open_exec_filter(struct cgit_filter *base, va_list ap)
{
struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
int pipe_fh[2];
int i;
for (i = 0; i < filter->base.argument_count; i++)
@ -49,19 +50,19 @@ static int open_exec_filter(struct cgit_filter *base, va_list ap)
filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
"Unable to duplicate STDOUT");
chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess");
chk_zero(pipe(pipe_fh), "Unable to create pipe to subprocess");
filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
if (filter->pid == 0) {
close(filter->pipe_fh[1]);
chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO),
close(pipe_fh[1]);
chk_non_negative(dup2(pipe_fh[0], STDIN_FILENO),
"Unable to use pipe as STDIN");
execvp(filter->cmd, filter->argv);
die_errno("Unable to exec subprocess %s", filter->cmd);
}
close(filter->pipe_fh[0]);
chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO),
close(pipe_fh[0]);
chk_non_negative(dup2(pipe_fh[1], STDOUT_FILENO),
"Unable to use pipe as STDOUT");
close(filter->pipe_fh[1]);
close(pipe_fh[1]);
return 0;
}

@ -19,7 +19,7 @@ regex=''
# This expression generates links to commits referenced by their SHA1.
regex=$regex'
s|\b([0-9a-fA-F]{7,40})\b|<a href="./?id=\1">\1</a>|g'
s|\b([0-9a-fA-F]{7,64})\b|<a href="./?id=\1">\1</a>|g'
# This expression generates links to a fictional bugtracker.
regex=$regex'

@ -3,15 +3,24 @@
-- prefix in filters. It is much faster than the corresponding python script.
--
-- Requirements:
-- luacrypto >= 0.3
-- <http://mkottman.github.io/luacrypto/>
-- luaossl
-- <http://25thandclement.com/~william/projects/luaossl.html>
--
local crypto = require("crypto")
local digest = require("openssl.digest")
function md5_hex(input)
local b = digest.new("md5"):final(input)
local x = ""
for i = 1, #b do
x = x .. string.format("%.2x", string.byte(b, i))
end
return x
end
function filter_open(email, page)
buffer = ""
md5 = crypto.digest("md5", email:sub(2, -2):lower())
md5 = md5_hex(email:sub(2, -2):lower())
end
function filter_close()

@ -3,15 +3,24 @@
-- prefix in filters.
--
-- Requirements:
-- luacrypto >= 0.3
-- <http://mkottman.github.io/luacrypto/>
-- luaossl
-- <http://25thandclement.com/~william/projects/luaossl.html>
--
local crypto = require("crypto")
local digest = require("openssl.digest")
function md5_hex(input)
local b = digest.new("md5"):final(input)
local x = ""
for i = 1, #b do
x = x .. string.format("%.2x", string.byte(b, i))
end
return x
end
function filter_open(email, page)
buffer = ""
md5 = crypto.digest("md5", email:sub(2, -2):lower())
md5 = md5_hex(email:sub(2, -2):lower())
end
function filter_close()

@ -0,0 +1,359 @@
-- This script may be used with the auth-filter.
--
-- Requirements:
-- luaossl
-- <http://25thandclement.com/~william/projects/luaossl.html>
-- luaposix
-- <https://github.com/luaposix/luaposix>
--
local sysstat = require("posix.sys.stat")
local unistd = require("posix.unistd")
local rand = require("openssl.rand")
local hmac = require("openssl.hmac")
-- This file should contain a series of lines in the form of:
-- username1:hash1
-- username2:hash2
-- username3:hash3
-- ...
-- Hashes can be generated using something like `mkpasswd -m sha-512 -R 300000`.
-- This file should not be world-readable.
local users_filename = "/etc/cgit-auth/users"
-- This file should contain a series of lines in the form of:
-- groupname1:username1,username2,username3,...
-- ...
local groups_filename = "/etc/cgit-auth/groups"
-- This file should contain a series of lines in the form of:
-- reponame1:groupname1,groupname2,groupname3,...
-- ...
local repos_filename = "/etc/cgit-auth/repos"
-- Set this to a path this script can write to for storing a persistent
-- cookie secret, which should not be world-readable.
local secret_filename = "/var/cache/cgit/auth-secret"
--
--
-- Authentication functions follow below. Swap these out if you want different authentication semantics.
--
--
-- Looks up a hash for a given user.
function lookup_hash(user)
local line
for line in io.lines(users_filename) do
local u, h = string.match(line, "(.-):(.+)")
if u:lower() == user:lower() then
return h
end
end
return nil
end
-- Looks up users for a given repo.
function lookup_users(repo)
local users = nil
local groups = nil
local line, group, user
for line in io.lines(repos_filename) do
local r, g = string.match(line, "(.-):(.+)")
if r == repo then
groups = { }
for group in string.gmatch(g, "([^,]+)") do
groups[group:lower()] = true
end
break
end
end
if groups == nil then
return nil
end
for line in io.lines(groups_filename) do
local g, u = string.match(line, "(.-):(.+)")
if groups[g:lower()] then
if users == nil then
users = { }
end
for user in string.gmatch(u, "([^,]+)") do
users[user:lower()] = true
end
end
end
return users
end
-- Sets HTTP cookie headers based on post and sets up redirection.
function authenticate_post()
local hash = lookup_hash(post["username"])
local redirect = validate_value("redirect", post["redirect"])
if redirect == nil then
not_found()
return 0
end
redirect_to(redirect)
if hash == nil or hash ~= unistd.crypt(post["password"], hash) then
set_cookie("cgitauth", "")
else
-- One week expiration time
local username = secure_value("username", post["username"], os.time() + 604800)
set_cookie("cgitauth", username)
end
html("\n")
return 0
end
-- Returns 1 if the cookie is valid and 0 if it is not.
function authenticate_cookie()
accepted_users = lookup_users(cgit["repo"])
if accepted_users == nil then
-- We return as valid if the repo is not protected.
return 1
end
local username = validate_value("username", get_cookie(http["cookie"], "cgitauth"))
if username == nil or not accepted_users[username:lower()] then
return 0
else
return 1
end
end
-- Prints the html for the login form.
function body()
html("<h2>Authentication Required</h2>")
html("<form method='post' action='")
html_attr(cgit["login"])
html("'>")
html("<input type='hidden' name='redirect' value='")
html_attr(secure_value("redirect", cgit["url"], 0))
html("' />")
html("<table>")
html("<tr><td><label for='username'>Username:</label></td><td><input id='username' name='username' autofocus /></td></tr>")
html("<tr><td><label for='password'>Password:</label></td><td><input id='password' name='password' type='password' /></td></tr>")
html("<tr><td colspan='2'><input value='Login' type='submit' /></td></tr>")
html("</table></form>")
return 0
end
--
--
-- Wrapper around filter API, exposing the http table, the cgit table, and the post table to the above functions.
--
--
local actions = {}
actions["authenticate-post"] = authenticate_post
actions["authenticate-cookie"] = authenticate_cookie
actions["body"] = body
function filter_open(...)
action = actions[select(1, ...)]
http = {}
http["cookie"] = select(2, ...)
http["method"] = select(3, ...)
http["query"] = select(4, ...)
http["referer"] = select(5, ...)
http["path"] = select(6, ...)
http["host"] = select(7, ...)
http["https"] = select(8, ...)
cgit = {}
cgit["repo"] = select(9, ...)
cgit["page"] = select(10, ...)
cgit["url"] = select(11, ...)
cgit["login"] = select(12, ...)
end
function filter_close()
return action()
end
function filter_write(str)
post = parse_qs(str)
end
--
--
-- Utility functions based on keplerproject/wsapi.
--
--
function url_decode(str)
if not str then
return ""
end
str = string.gsub(str, "+", " ")
str = string.gsub(str, "%%(%x%x)", function(h) return string.char(tonumber(h, 16)) end)
str = string.gsub(str, "\r\n", "\n")
return str
end
function url_encode(str)
if not str then
return ""
end
str = string.gsub(str, "\n", "\r\n")
str = string.gsub(str, "([^%w ])", function(c) return string.format("%%%02X", string.byte(c)) end)
str = string.gsub(str, " ", "+")
return str
end
function parse_qs(qs)
local tab = {}
for key, val in string.gmatch(qs, "([^&=]+)=([^&=]*)&?") do
tab[url_decode(key)] = url_decode(val)
end
return tab
end
function get_cookie(cookies, name)
cookies = string.gsub(";" .. cookies .. ";", "%s*;%s*", ";")
return url_decode(string.match(cookies, ";" .. name .. "=(.-);"))
end
function tohex(b)
local x = ""
for i = 1, #b do
x = x .. string.format("%.2x", string.byte(b, i))
end
return x
end
--
--
-- Cookie construction and validation helpers.
--
--
local secret = nil
-- Loads a secret from a file, creates a secret, or returns one from memory.
function get_secret()
if secret ~= nil then
return secret
end
local secret_file = io.open(secret_filename, "r")
if secret_file == nil then
local old_umask = sysstat.umask(63)
local temporary_filename = secret_filename .. ".tmp." .. tohex(rand.bytes(16))
local temporary_file = io.open(temporary_filename, "w")
if temporary_file == nil then
os.exit(177)
end
temporary_file:write(tohex(rand.bytes(32)))
temporary_file:close()
unistd.link(temporary_filename, secret_filename) -- Intentionally fails in the case that another process is doing the same.
unistd.unlink(temporary_filename)
sysstat.umask(old_umask)
secret_file = io.open(secret_filename, "r")
end
if secret_file == nil then
os.exit(177)
end
secret = secret_file:read()
secret_file:close()
if secret:len() ~= 64 then
os.exit(177)
end
return secret
end
-- Returns value of cookie if cookie is valid. Otherwise returns nil.
function validate_value(expected_field, cookie)
local i = 0
local value = ""
local field = ""
local expiration = 0
local salt = ""
local chmac = ""
if cookie == nil or cookie:len() < 3 or cookie:sub(1, 1) == "|" then
return nil
end
for component in string.gmatch(cookie, "[^|]+") do
if i == 0 then
field = component
elseif i == 1 then
value = component
elseif i == 2 then
expiration = tonumber(component)
if expiration == nil then
expiration = -1
end
elseif i == 3 then
salt = component
elseif i == 4 then
chmac = component
else
break
end
i = i + 1
end
if chmac == nil or chmac:len() == 0 then
return nil
end
-- Lua hashes strings, so these comparisons are time invariant.
if chmac ~= tohex(hmac.new(get_secret(), "sha256"):final(field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt)) then
return nil
end
if expiration == -1 or (expiration ~= 0 and expiration <= os.time()) then
return nil
end
if url_decode(field) ~= expected_field then
return nil
end
return url_decode(value)
end
function secure_value(field, value, expiration)
if value == nil or value:len() <= 0 then
return ""
end
local authstr = ""
local salt = tohex(rand.bytes(16))
value = url_encode(value)
field = url_encode(field)
authstr = field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt
authstr = authstr .. "|" .. tohex(hmac.new(get_secret(), "sha256"):final(authstr))
return authstr
end
function set_cookie(cookie, value)
html("Set-Cookie: " .. cookie .. "=" .. value .. "; HttpOnly")
if http["https"] == "yes" or http["https"] == "on" or http["https"] == "1" then
html("; secure")
end
html("\n")
end
function redirect_to(url)
html("Status: 302 Redirect\n")
html("Cache-Control: no-cache, no-store\n")
html("Location: " .. url .. "\n")
end
function not_found()
html("Status: 404 Not Found\n")
html("Cache-Control: no-cache, no-store\n\n")
end

@ -1,12 +1,18 @@
-- This script may be used with the auth-filter. Be sure to configure it as you wish.
--
-- Requirements:
-- luacrypto >= 0.3
-- <http://mkottman.github.io/luacrypto/>
-- luaossl
-- <http://25thandclement.com/~william/projects/luaossl.html>
-- lualdap >= 1.2
-- <http://git.zx2c4.com/lualdap/about/>
-- <https://git.zx2c4.com/lualdap/about/>
-- luaposix
-- <https://github.com/luaposix/luaposix>
--
local sysstat = require("posix.sys.stat")
local unistd = require("posix.unistd")
local lualdap = require("lualdap")
local rand = require("openssl.rand")
local hmac = require("openssl.hmac")
--
--
@ -21,11 +27,9 @@ local protected_repos = {
portage = "dev"
}
-- All cookies will be authenticated based on this secret. Make it something
-- totally random and impossible to guess. It should be large.
local secret = "BE SURE TO CUSTOMIZE THIS STRING TO SOMETHING BIG AND RANDOM"
-- Set this to a path this script can write to for storing a persistent
-- cookie secret, which should be guarded.
local secret_filename = "/var/cache/cgit/auth-secret"
--
@ -102,11 +106,9 @@ end
--
--
local lualdap = require("lualdap")
function gentoo_ldap_user_groups(username, password)
-- Ensure the user is alphanumeric
if username:match("%W") then
if username == nil or username:match("%W") then
return nil
end
@ -224,6 +226,13 @@ function get_cookie(cookies, name)
return string.match(cookies, ";" .. name .. "=(.-);")
end
function tohex(b)
local x = ""
for i = 1, #b do
x = x .. string.format("%.2x", string.byte(b, i))
end
return x
end
--
--
@ -231,7 +240,38 @@ end
--
--
local crypto = require("crypto")
local secret = nil
-- Loads a secret from a file, creates a secret, or returns one from memory.
function get_secret()
if secret ~= nil then
return secret
end
local secret_file = io.open(secret_filename, "r")
if secret_file == nil then
local old_umask = sysstat.umask(63)
local temporary_filename = secret_filename .. ".tmp." .. tohex(rand.bytes(16))
local temporary_file = io.open(temporary_filename, "w")
if temporary_file == nil then
os.exit(177)
end
temporary_file:write(tohex(rand.bytes(32)))
temporary_file:close()
unistd.link(temporary_filename, secret_filename) -- Intentionally fails in the case that another process is doing the same.
unistd.unlink(temporary_filename)
sysstat.umask(old_umask)
secret_file = io.open(secret_filename, "r")
end
if secret_file == nil then
os.exit(177)
end
secret = secret_file:read()
secret_file:close()
if secret:len() ~= 64 then
os.exit(177)
end
return secret
end
-- Returns value of cookie if cookie is valid. Otherwise returns nil.
function validate_value(expected_field, cookie)
@ -240,7 +280,7 @@ function validate_value(expected_field, cookie)
local field = ""
local expiration = 0
local salt = ""
local hmac = ""
local chmac = ""
if cookie == nil or cookie:len() < 3 or cookie:sub(1, 1) == "|" then
return nil
@ -259,19 +299,19 @@ function validate_value(expected_field, cookie)
elseif i == 3 then
salt = component
elseif i == 4 then
hmac = component
chmac = component
else
break
end
i = i + 1
end
if hmac == nil or hmac:len() == 0 then
if chmac == nil or chmac:len() == 0 then
return nil
end
-- Lua hashes strings, so these comparisons are time invariant.
if hmac ~= crypto.hmac.digest("sha1", field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt, secret) then
if chmac ~= tohex(hmac.new(get_secret(), "sha256"):final(field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt)) then
return nil
end
@ -292,11 +332,11 @@ function secure_value(field, value, expiration)
end
local authstr = ""
local salt = crypto.hex(crypto.rand.bytes(16))
local salt = tohex(rand.bytes(16))
value = url_encode(value)
field = url_encode(field)
authstr = field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt
authstr = authstr .. "|" .. crypto.hmac.digest("sha1", authstr, secret)
authstr = authstr .. "|" .. tohex(hmac.new(get_secret(), "sha256"):final(authstr))
return authstr
end

@ -1,6 +1,12 @@
#!/usr/bin/env python
#!/usr/bin/env python3
import markdown
print('''
import sys
import io
from pygments.formatters import HtmlFormatter
from markdown.extensions.toc import TocExtension
sys.stdin = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8')
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
sys.stdout.write('''
<style>
.markdown-body {
font-size: 14px;
@ -43,10 +49,14 @@ print('''
line-height: 1;
padding-left: 0;
margin-left: -22px;
top: 15%}
top: 15%;
}
.markdown-body h1:hover a.anchor .mini-icon-link, .markdown-body h2:hover a.anchor .mini-icon-link, .markdown-body h3:hover a.anchor .mini-icon-link, .markdown-body h4:hover a.anchor .mini-icon-link, .markdown-body h5:hover a.anchor .mini-icon-link, .markdown-body h6:hover a.anchor .mini-icon-link {
display: inline-block;
}
div#cgit .markdown-body h1 a.toclink, div#cgit .markdown-body h2 a.toclink, div#cgit .markdown-body h3 a.toclink, div#cgit .markdown-body h4 a.toclink, div#cgit .markdown-body h5 a.toclink, div#cgit .markdown-body h6 a.toclink {
color: black;
}
.markdown-body h1 tt, .markdown-body h1 code, .markdown-body h2 tt, .markdown-body h2 code, .markdown-body h3 tt, .markdown-body h3 code, .markdown-body h4 tt, .markdown-body h4 code, .markdown-body h5 tt, .markdown-body h5 code, .markdown-body h6 tt, .markdown-body h6 code {
font-size: inherit;
}
@ -76,11 +86,7 @@ print('''
margin: 15px 0;
}
.markdown-body hr {
background: transparent url("/dirty-shade.png") repeat-x 0 0;
border: 0 none;
color: #ccc;
height: 4px;
padding: 0;
border: 2px solid #ccc;
}
.markdown-body>h2:first-child, .markdown-body>h1:first-child, .markdown-body>h1:first-child+h2, .markdown-body>h3:first-child, .markdown-body>h4:first-child, .markdown-body>h5:first-child, .markdown-body>h6:first-child {
margin-top: 0;
@ -277,9 +283,22 @@ print('''
background-color: transparent;
border: none;
}
''')
sys.stdout.write(HtmlFormatter(style='pastie').get_style_defs('.highlight'))
sys.stdout.write('''
</style>
''')
print("<div class='markdown-body'>")
sys.stdout.write("<div class='markdown-body'>")
sys.stdout.flush()
# Note: you may want to run this through bleach for sanitization
markdown.markdownFromFile(output_format="html5")
print("</div>")
markdown.markdownFromFile(
output_format="html5",
extensions=[
"markdown.extensions.fenced_code",
"markdown.extensions.codehilite",
"markdown.extensions.tables",
"markdown.extensions.sane_lists",
TocExtension(anchorlink=True)],
extension_configs={
"markdown.extensions.codehilite":{"css_class":"highlight"}})
sys.stdout.write("</div>")

@ -1,10 +1,15 @@
-- This script may be used with the auth-filter. Be sure to configure it as you wish.
--
-- Requirements:
-- luacrypto >= 0.3
-- <http://mkottman.github.io/luacrypto/>
-- luaossl
-- <http://25thandclement.com/~william/projects/luaossl.html>
-- luaposix
-- <https://github.com/luaposix/luaposix>
--
local sysstat = require("posix.sys.stat")
local unistd = require("posix.unistd")
local rand = require("openssl.rand")
local hmac = require("openssl.hmac")
--
--
@ -18,24 +23,16 @@ local protected_repos = {
qt = { jason = true, bob = true }
}
-- Please note that, in production, you'll want to replace this simple lookup
-- table with either a table of salted and hashed passwords (using something
-- smart like scrypt), or replace this table lookup with an external support,
-- such as consulting your system's pam / shadow system, or an external
-- database, or an external validating web service. For testing, or for
-- extremely low-security usage, you may be able, however, to get away with
-- compromising on hardcoding the passwords in cleartext, as we have done here.
-- A list of users and hashes, generated with `mkpasswd -m sha-512 -R 300000`.
local users = {
jason = "secretpassword",
laurent = "s3cr3t",
bob = "ilikelua"
jason = "$6$rounds=300000$YYJct3n/o.ruYK$HhpSeuCuW1fJkpvMZOZzVizeLsBKcGA/aF2UPuV5v60JyH2MVSG6P511UMTj2F3H75.IT2HIlnvXzNb60FcZH1",
laurent = "$6$rounds=300000$dP0KNHwYb3JKigT$pN/LG7rWxQ4HniFtx5wKyJXBJUKP7R01zTNZ0qSK/aivw8ywGAOdfYiIQFqFhZFtVGvr11/7an.nesvm8iJUi.",
bob = "$6$rounds=300000$jCLCCt6LUpTz$PI1vvd1yaVYcCzqH8QAJFcJ60b6W/6sjcOsU7mAkNo7IE8FRGW1vkjF8I/T5jt/auv5ODLb1L4S2s.CAyZyUC"
}
-- All cookies will be authenticated based on this secret. Make it something
-- totally random and impossible to guess. It should be large.
local secret = "BE SURE TO CUSTOMIZE THIS STRING TO SOMETHING BIG AND RANDOM"
-- Set this to a path this script can write to for storing a persistent
-- cookie secret, which should be guarded.
local secret_filename = "/var/cache/cgit/auth-secret"
--
--
@ -45,7 +42,7 @@ local secret = "BE SURE TO CUSTOMIZE THIS STRING TO SOMETHING BIG AND RANDOM"
-- Sets HTTP cookie headers based on post and sets up redirection.
function authenticate_post()
local password = users[post["username"]]
local hash = users[post["username"]]
local redirect = validate_value("redirect", post["redirect"])
if redirect == nil then
@ -55,8 +52,7 @@ function authenticate_post()
redirect_to(redirect)
-- Lua hashes strings, so these comparisons are time invariant.
if password == nil or password ~= post["password"] then
if hash == nil or hash ~= unistd.crypt(post["password"], hash) then
set_cookie("cgitauth", "")
else
-- One week expiration time
@ -184,6 +180,13 @@ function get_cookie(cookies, name)
return url_decode(string.match(cookies, ";" .. name .. "=(.-);"))
end
function tohex(b)
local x = ""
for i = 1, #b do
x = x .. string.format("%.2x", string.byte(b, i))
end
return x
end
--
--
@ -191,7 +194,38 @@ end
--
--
local crypto = require("crypto")
local secret = nil
-- Loads a secret from a file, creates a secret, or returns one from memory.
function get_secret()
if secret ~= nil then
return secret
end
local secret_file = io.open(secret_filename, "r")
if secret_file == nil then
local old_umask = sysstat.umask(63)
local temporary_filename = secret_filename .. ".tmp." .. tohex(rand.bytes(16))
local temporary_file = io.open(temporary_filename, "w")
if temporary_file == nil then
os.exit(177)
end
temporary_file:write(tohex(rand.bytes(32)))
temporary_file:close()
unistd.link(temporary_filename, secret_filename) -- Intentionally fails in the case that another process is doing the same.
unistd.unlink(temporary_filename)
sysstat.umask(old_umask)
secret_file = io.open(secret_filename, "r")
end
if secret_file == nil then
os.exit(177)
end
secret = secret_file:read()
secret_file:close()
if secret:len() ~= 64 then
os.exit(177)
end
return secret
end
-- Returns value of cookie if cookie is valid. Otherwise returns nil.
function validate_value(expected_field, cookie)
@ -200,7 +234,7 @@ function validate_value(expected_field, cookie)
local field = ""
local expiration = 0
local salt = ""
local hmac = ""
local chmac = ""
if cookie == nil or cookie:len() < 3 or cookie:sub(1, 1) == "|" then
return nil
@ -219,19 +253,19 @@ function validate_value(expected_field, cookie)
elseif i == 3 then
salt = component
elseif i == 4 then
hmac = component
chmac = component
else
break
end
i = i + 1
end
if hmac == nil or hmac:len() == 0 then
if chmac == nil or chmac:len() == 0 then
return nil
end
-- Lua hashes strings, so these comparisons are time invariant.
if hmac ~= crypto.hmac.digest("sha1", field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt, secret) then
if chmac ~= tohex(hmac.new(get_secret(), "sha256"):final(field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt)) then
return nil
end
@ -252,11 +286,11 @@ function secure_value(field, value, expiration)
end
local authstr = ""
local salt = crypto.hex(crypto.rand.bytes(16))
local salt = tohex(rand.bytes(16))
value = url_encode(value)
field = url_encode(field)
authstr = field .. "|" .. value .. "|" .. tostring(expiration) .. "|" .. salt
authstr = authstr .. "|" .. crypto.hmac.digest("sha1", authstr, secret)
authstr = authstr .. "|" .. tohex(hmac.new(get_secret(), "sha256"):final(authstr))
return authstr
end

@ -21,6 +21,7 @@
import sys
import io
from pygments import highlight
from pygments.util import ClassNotFound
from pygments.lexers import TextLexer
@ -29,9 +30,11 @@ from pygments.lexers import guess_lexer_for_filename
from pygments.formatters import HtmlFormatter
sys.stdin = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8', errors='replace')
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
data = sys.stdin.read()
filename = sys.argv[1]
formatter = HtmlFormatter(style='pastie')
formatter = HtmlFormatter(style='pastie', nobackground=True)
try:
lexer = guess_lexer_for_filename(filename, data)

@ -1,6 +1,6 @@
#!/bin/sh
# This script can be used to implement syntax highlighting in the cgit
# tree-view by refering to this file with the source-filter or repo.source-
# tree-view by referring to this file with the source-filter or repo.source-
# filter options in cgitrc.
#
# This script requires a shell supporting the ${var##pattern} syntax.

2
git

@ -1 +1 @@
Subproject commit 754884255bb580df159e58defa81cdd30b5c430c
Subproject commit c48035d29b4e524aed3a32f0403676f0d9128863

100
html.c

@ -8,6 +8,7 @@
#include "cgit.h"
#include "html.h"
#include "url.h"
/* Percent-encoding of each character, except: a-zA-Z0-9!$()*,./:;@- */
static const char* url_escape_table[256] = {
@ -58,7 +59,7 @@ char *fmt(const char *format, ...)
va_start(args, format);
len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args);
va_end(args);
if (len > sizeof(buf[bufidx])) {
if (len >= sizeof(buf[bufidx])) {
fprintf(stderr, "[html.c] string truncated: %s\n", format);
exit(1);
}
@ -123,29 +124,20 @@ void html_vtxtf(const char *format, va_list ap)
void html_txt(const char *txt)
{
const char *t = txt;
while (t && *t) {
int c = *t;
if (c == '<' || c == '>' || c == '&') {
html_raw(txt, t - txt);
if (c == '>')
html("&gt;");
else if (c == '<')
html("&lt;");
else if (c == '&')
html("&amp;");
txt = t + 1;
}
t++;
}
if (t != txt)
html(txt);
if (txt)
html_ntxt(txt, strlen(txt));
}
void html_ntxt(int len, const char *txt)
ssize_t html_ntxt(const char *txt, size_t len)
{
const char *t = txt;
while (t && *t && len--) {
ssize_t slen;
if (len > SSIZE_MAX)
return -1;
slen = (ssize_t) len;
while (t && *t && slen--) {
int c = *t;
if (c == '<' || c == '>' || c == '&') {
html_raw(txt, t - txt);
@ -161,8 +153,7 @@ void html_ntxt(int len, const char *txt)
}
if (t != txt)
html_raw(txt, t - txt);
if (len < 0)
html("...");
return slen;
}
void html_attrf(const char *fmt, ...)
@ -337,64 +328,17 @@ int html_include(const char *filename)
return 0;
}
static int hextoint(char c)
void http_parse_querystring(const char *txt, void (*fn)(const char *name, const char *value))
{
if (c >= 'a' && c <= 'f')
return 10 + c - 'a';
else if (c >= 'A' && c <= 'F')
return 10 + c - 'A';
else if (c >= '0' && c <= '9')
return c - '0';
else
return -1;
}
static char *convert_query_hexchar(char *txt)
{
int d1, d2, n;
n = strlen(txt);
if (n < 3) {
*txt = '\0';
return txt-1;
}
d1 = hextoint(*(txt + 1));
d2 = hextoint(*(txt + 2));
if (d1 < 0 || d2 < 0) {
memmove(txt, txt + 3, n - 2);
return txt-1;
} else {
*txt = d1 * 16 + d2;
memmove(txt + 1, txt + 3, n - 2);
return txt;
}
}
const char *t = txt;
int http_parse_querystring(const char *txt_, void (*fn)(const char *name, const char *value))
{
char *o, *t, *txt, *value = NULL, c;
if (!txt_)
return 0;
o = t = txt = xstrdup(txt_);
while ((c=*t) != '\0') {
if (c == '=') {
*t = '\0';
value = t + 1;
} else if (c == '+') {
*t = ' ';
} else if (c == '%') {
t = convert_query_hexchar(t);
} else if (c == '&') {
*t = '\0';
(*fn)(txt, value);
txt = t + 1;
value = NULL;
while (t && *t) {
char *name = url_decode_parameter_name(&t);
if (*name) {
char *value = url_decode_parameter_value(&t);
fn(name, value);
free(value);
}
t++;
free(name);
}
if (t != txt)
(*fn)(txt, value);
free(o);
return 0;
}

@ -19,7 +19,7 @@ __attribute__((format (printf,1,2)))
extern void html_attrf(const char *format,...);
extern void html_txt(const char *txt);
extern void html_ntxt(int len, const char *txt);
extern ssize_t html_ntxt(const char *txt, size_t len);
extern void html_attr(const char *txt);
extern void html_url_path(const char *txt);
extern void html_url_arg(const char *txt);
@ -32,6 +32,6 @@ extern void html_link_close(void);
extern void html_fileperm(unsigned short mode);
extern int html_include(const char *filename);
extern int http_parse_querystring(const char *txt, void (*fn)(const char *name, const char *value));
extern void http_parse_querystring(const char *txt, void (*fn)(const char *name, const char *value));
#endif /* HTML_H */

@ -20,10 +20,10 @@ void cgit_parse_url(const char *url)
char *c, *cmd, *p;
struct cgit_repo *repo;
ctx.repo = NULL;
if (!url || url[0] == '\0')
return;
ctx.qry.page = NULL;
ctx.repo = cgit_get_repoinfo(url);
if (ctx.repo) {
ctx.qry.repo = ctx.repo->url;
@ -53,7 +53,6 @@ void cgit_parse_url(const char *url)
}
if (cmd[1])
ctx.qry.page = xstrdup(cmd + 1);
return;
}
}
@ -64,12 +63,11 @@ static char *substr(const char *head, const char *tail)
if (tail < head)
return xstrdup("");
buf = xmalloc(tail - head + 1);
strncpy(buf, head, tail - head);
buf[tail - head] = '\0';
strlcpy(buf, head, tail - head + 1);
return buf;
}
static void parse_user(const char *t, char **name, char **email, unsigned long *date)
static void parse_user(const char *t, char **name, char **email, unsigned long *date, int *tz)
{
struct ident_split ident;
unsigned email_len;
@ -79,10 +77,12 @@ static void parse_user(const char *t, char **name, char **email, unsigned long *
email_len = ident.mail_end - ident.mail_begin;
*email = xmalloc(strlen("<") + email_len + strlen(">") + 1);
sprintf(*email, "<%.*s>", email_len, ident.mail_begin);
xsnprintf(*email, email_len + 3, "<%.*s>", email_len, ident.mail_begin);
if (ident.date_begin)
*date = strtoul(ident.date_begin, NULL, 10);
if (ident.tz_begin)
*tz = atoi(ident.tz_begin);
}
}
@ -127,9 +127,8 @@ static int end_of_header(const char *p)
struct commitinfo *cgit_parse_commit(struct commit *commit)
{
const int sha1hex_len = 40;
struct commitinfo *ret;
const char *p = get_cached_commit_buffer(commit, NULL);
const char *p = repo_get_commit_buffer(the_repository, commit, NULL);
const char *t;
ret = xcalloc(1, sizeof(struct commitinfo));
@ -140,20 +139,20 @@ struct commitinfo *cgit_parse_commit(struct commit *commit)
if (!skip_prefix(p, "tree ", &p))
die("Bad commit: %s", oid_to_hex(&commit->object.oid));
p += sha1hex_len + 1;
p += the_hash_algo->hexsz + 1;
while (skip_prefix(p, "parent ", &p))
p += sha1hex_len + 1;
p += the_hash_algo->hexsz + 1;
if (p && skip_prefix(p, "author ", &p)) {
parse_user(p, &ret->author, &ret->author_email,
&ret->author_date);
&ret->author_date, &ret->author_tz);
p = next_header_line(p);
}
if (p && skip_prefix(p, "committer ", &p)) {
parse_user(p, &ret->committer, &ret->committer_email,
&ret->committer_date);
&ret->committer_date, &ret->committer_tz);
p = next_header_line(p);
}
@ -199,7 +198,7 @@ struct taginfo *cgit_parse_tag(struct tag *tag)
const char *p;
struct taginfo *ret = NULL;
data = read_sha1_file(tag->object.oid.hash, &type, &size);
data = read_object_file(&tag->object.oid, &type, &size);
if (!data || type != OBJ_TAG)
goto cleanup;
@ -208,7 +207,7 @@ struct taginfo *cgit_parse_tag(struct tag *tag)
for (p = data; !end_of_header(p); p = next_header_line(p)) {
if (skip_prefix(p, "tagger ", &p)) {
parse_user(p, &ret->tagger, &ret->tagger_email,
&ret->tagger_date);
&ret->tagger_date, &ret->tagger_tz);
}
}

@ -1,3 +1,4 @@
User-agent: *
Disallow: /*/snapshot/*
Disallow: /*/blame/*
Allow: /

@ -10,6 +10,7 @@
#include "scan-tree.h"
#include "configfile.h"
#include "html.h"
#include <config.h>
/* return 1 if path contains a objects/ directory and a HEAD file */
static int is_git_dir(const char *path)
@ -48,21 +49,25 @@ out:
static struct cgit_repo *repo;
static repo_config_fn config_fn;
static void repo_config(const char *name, const char *value)
static void scan_tree_repo_config(const char *name, const char *value)
{
config_fn(repo, name, value);
}
static int gitconfig_config(const char *key, const char *value, void *cb)
{
const char *name;
if (!strcmp(key, "gitweb.owner"))
config_fn(repo, "owner", value);
else if (!strcmp(key, "gitweb.description"))
config_fn(repo, "desc", value);
else if (!strcmp(key, "gitweb.category"))
config_fn(repo, "section", value);
else if (starts_with(key, "cgit."))
config_fn(repo, key + 5, value);
else if (!strcmp(key, "gitweb.homepage"))
config_fn(repo, "homepage", value);
else if (skip_prefix(key, "cgit.", &name))
config_fn(repo, name, value);
return 0;
}
@ -174,7 +179,7 @@ static void add_repo(const char *base, struct strbuf *path, repo_config_fn fn)
strbuf_addstr(path, "cgitrc");
if (!stat(path->buf, &st))
parse_configfile(path->buf, &repo_config);
parse_configfile(path->buf, &scan_tree_repo_config);
strbuf_release(&rel);
}
@ -244,7 +249,7 @@ void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn
projectsfile, strerror(errno), errno);
return;
}
while (strbuf_getline(&line, projects, '\n') != EOF) {
while (strbuf_getline(&line, projects) != EOF) {
if (!line.len)
continue;
strbuf_insert(&line, 0, "/", 1);

@ -53,9 +53,12 @@ struct cgit_repo *cgit_add_repo(const char *url)
ret->name = ret->url;
ret->path = NULL;
ret->desc = cgit_default_repo_desc;
ret->extra_head_content = NULL;
ret->owner = NULL;
ret->homepage = NULL;
ret->section = ctx.cfg.section;
ret->snapshots = ctx.cfg.snapshots;
ret->enable_blame = ctx.cfg.enable_blame;
ret->enable_commit_graph = ctx.cfg.enable_commit_graph;
ret->enable_log_filecount = ctx.cfg.enable_log_filecount;
ret->enable_log_linecount = ctx.cfg.enable_log_linecount;
@ -94,7 +97,7 @@ struct cgit_repo *cgit_get_repoinfo(const char *url)
return NULL;
}
void *cgit_free_commitinfo(struct commitinfo *info)
void cgit_free_commitinfo(struct commitinfo *info)
{
free(info->author);
free(info->author_email);
@ -104,7 +107,6 @@ void *cgit_free_commitinfo(struct commitinfo *info)
free(info->msg);
free(info->msg_encoding);
free(info);
return NULL;
}
char *trim_end(const char *str, char c)
@ -142,37 +144,6 @@ void strbuf_ensure_end(struct strbuf *sb, char c)
strbuf_addch(sb, c);
}
char *strlpart(char *txt, int maxlen)
{
char *result;
if (!txt)
return txt;
if (strlen(txt) <= maxlen)
return txt;
result = xmalloc(maxlen + 1);
memcpy(result, txt, maxlen - 3);
result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.';
result[maxlen] = '\0';
return result;
}
char *strrpart(char *txt, int maxlen)
{
char *result;
if (!txt)
return txt;
if (strlen(txt) <= maxlen)
return txt;
result = xmalloc(maxlen + 1);
memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3);
result[0] = result[1] = result[2] = '.';
return result;
}
void cgit_add_ref(struct reflist *list, struct refinfo *ref)
{
size_t size;
@ -191,7 +162,7 @@ static struct refinfo *cgit_mk_refinfo(const char *refname, const struct object_
ref = xmalloc(sizeof (struct refinfo));
ref->refname = xstrdup(refname);
ref->object = parse_object(oid->hash);
ref->object = parse_object(the_repository, oid);
switch (ref->object->type) {
case OBJ_TAG:
ref->tag = cgit_parse_tag((struct tag *)ref->object);
@ -203,7 +174,7 @@ static struct refinfo *cgit_mk_refinfo(const char *refname, const struct object_
return ref;
}
static void cgit_free_taginfo(struct taginfo *tag)
void cgit_free_taginfo(struct taginfo *tag)
{
if (tag->tagger)
free(tag->tagger);
@ -262,15 +233,15 @@ void cgit_diff_tree_cb(struct diff_queue_struct *q,
}
}
static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
static int load_mmfile(mmfile_t *file, const struct object_id *oid)
{
enum object_type type;
if (is_null_sha1(sha1)) {
if (is_null_oid(oid)) {
file->ptr = (char *)"";
file->size = 0;
} else {
file->ptr = read_sha1_file(sha1, &type,
file->ptr = read_object_file(oid, &type,
(unsigned long *)&file->size);
}
return 1;
@ -321,8 +292,8 @@ static int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
return 0;
}
int cgit_diff_files(const unsigned char *old_sha1,
const unsigned char *new_sha1, unsigned long *old_size,
int cgit_diff_files(const struct object_id *old_oid,
const struct object_id *new_oid, unsigned long *old_size,
unsigned long *new_size, int *binary, int context,
int ignorews, linediff_fn fn)
{
@ -331,7 +302,7 @@ int cgit_diff_files(const unsigned char *old_sha1,
xdemitconf_t emit_params;
xdemitcb_t emit_cb;
if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
if (!load_mmfile(&file1, old_oid) || !load_mmfile(&file2, new_oid))
return 1;
*old_size = file1.size;
@ -355,7 +326,7 @@ int cgit_diff_files(const unsigned char *old_sha1,
diff_params.flags |= XDF_IGNORE_WHITESPACE;
emit_params.ctxlen = context > 0 ? context : 3;
emit_params.flags = XDL_EMIT_FUNCNAMES;
emit_cb.outf = filediff_cb;
emit_cb.out_line = filediff_cb;
emit_cb.priv = fn;
xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
if (file1.size)
@ -365,46 +336,46 @@ int cgit_diff_files(const unsigned char *old_sha1,
return 0;
}
void cgit_diff_tree(const unsigned char *old_sha1,
const unsigned char *new_sha1,
void cgit_diff_tree(const struct object_id *old_oid,
const struct object_id *new_oid,
filepair_fn fn, const char *prefix, int ignorews)
{
struct diff_options opt;
struct pathspec_item item;
struct pathspec_item *item;
memset(&item, 0, sizeof(item));
diff_setup(&opt);
opt.output_format = DIFF_FORMAT_CALLBACK;
opt.detect_rename = 1;
opt.rename_limit = ctx.cfg.renamelimit;
DIFF_OPT_SET(&opt, RECURSIVE);
opt.flags.recursive = 1;
if (ignorews)
DIFF_XDL_SET(&opt, IGNORE_WHITESPACE);
opt.format_callback = cgit_diff_tree_cb;
opt.format_callback_data = fn;
if (prefix) {
item.match = prefix;
item.len = strlen(prefix);
item = xcalloc(1, sizeof(*item));
item->match = xstrdup(prefix);
item->len = strlen(prefix);
opt.pathspec.nr = 1;
opt.pathspec.items = &item;
opt.pathspec.items = item;
}
diff_setup_done(&opt);
if (old_sha1 && !is_null_sha1(old_sha1))
diff_tree_sha1(old_sha1, new_sha1, "", &opt);
if (old_oid && !is_null_oid(old_oid))
diff_tree_oid(old_oid, new_oid, "", &opt);
else
diff_root_tree_sha1(new_sha1, "", &opt);
diff_root_tree_oid(new_oid, "", &opt);
diffcore_std(&opt);
diff_flush(&opt);
}
void cgit_diff_commit(struct commit *commit, filepair_fn fn, const char *prefix)
{
unsigned char *old_sha1 = NULL;
const struct object_id *old_oid = NULL;
if (commit->parents)
old_sha1 = commit->parents->item->object.oid.hash;
cgit_diff_tree(old_sha1, commit->object.oid.hash, fn, prefix,
old_oid = &commit->parents->item->object.oid;
cgit_diff_tree(old_oid, &commit->object.oid, fn, prefix,
ctx.qry.ignorews);
}
@ -419,6 +390,9 @@ int cgit_parse_snapshots_mask(const char *str)
if (atoi(str))
return 1;
if (strcmp(str, "all") == 0)
return INT_MAX;
string_list_split(&tokens, str, ' ', -1);
string_list_remove_empty_items(&tokens, 0);
@ -426,7 +400,7 @@ int cgit_parse_snapshots_mask(const char *str)
for (f = cgit_snapshot_formats; f->suffix; f++) {
if (!strcmp(item->string, f->suffix) ||
!strcmp(item->string, f->suffix + 1)) {
rv |= f->bit;
rv |= cgit_snapshot_format_bit(f);
break;
}
}
@ -501,15 +475,16 @@ static int is_token_char(char c)
static char *expand_macro(char *name, int maxlength)
{
char *value;
int len;
size_t len;
len = 0;
value = getenv(name);
if (value) {
len = strlen(value);
len = strlen(value) + 1;
if (len > maxlength)
len = maxlength;
strncpy(name, value, len);
strlcpy(name, value, len);
--len;
}
return name + len;
}

@ -80,13 +80,17 @@ mkrepo() {
git commit -m "commit $n"
n=$(expr $n + 1)
done
if test "$3" = "testplus"
then
case "$3" in
testplus)
echo "hello" >a+b
git add a+b
git commit -m "add a+b"
git branch "1+2"
fi
;;
commit-graph)
git commit-graph write
;;
esac
)
}
@ -95,7 +99,7 @@ setup_repos()
rm -rf cache
mkdir -p cache
mkrepo repos/foo 5 >/dev/null
mkrepo repos/bar 50 >/dev/null
mkrepo repos/bar 50 commit-graph >/dev/null
mkrepo repos/foo+bar 10 testplus >/dev/null
mkrepo "repos/with space" 2 >/dev/null
mkrepo repos/filter 5 testplus >/dev/null
@ -104,7 +108,7 @@ virtual-root=/
cache-root=$PWD/cache
cache-size=1021
snapshots=tar.gz tar.bz zip
snapshots=tar.gz tar.bz tar.lz tar.xz tar.zst zip
enable-log-filecount=1
enable-log-linecount=1
summary-log=5

@ -1,5 +1,9 @@
#!/bin/sh
if [ "${CGIT_TEST_NO_GIT_VERSION}" = "YesPlease" ]; then
exit 0
fi
test_description='Check Git version is correct'
CGIT_TEST_NO_CREATE_REPOS=YesPlease
. ./setup.sh
@ -29,11 +33,11 @@ test_expect_success 'test submodule version matches Makefile' '
else
(
cd ../.. &&
sm_sha1=$(git ls-files --stage -- git |
sm_oid=$(git ls-files --stage -- git |
sed -e "s/^[0-9]* \\([0-9a-f]*\\) [0-9] .*$/\\1/") &&
cd git &&
git describe --match "v[0-9]*" $sm_sha1
) | sed -e "s/^v//" >sm_version &&
git describe --match "v[0-9]*" $sm_oid
) | sed -e "s/^v//" -e "s/-/./" >sm_version &&
test_cmp sm_version makefile_version
fi
'

@ -25,7 +25,7 @@ test_expect_success 'get root commit' '
'
test_expect_success 'root commit contains diffstat' '
grep "<a href=./foo/diff/file-1.id=[0-9a-f]\{40\}.>file-1</a>" tmp
grep "<a href=./foo/diff/file-1.id=[0-9a-f]\{40,64\}.>file-1</a>" tmp
'
test_expect_success 'root commit contains diff' '

@ -25,7 +25,7 @@ test_expect_success 'verify gzip format' '
test_expect_success 'untar' '
rm -rf master &&
tar -xzf master.tar.gz
gzip -dc master.tar.gz | tar -xf -
'
test_expect_success 'count files' '
@ -38,6 +38,129 @@ test_expect_success 'verify untarred file-5' '
test_line_count = 1 master/file-5
'
if test -n "$(which lzip 2>/dev/null)"; then
test_set_prereq LZIP
else
say 'Skipping LZIP validation tests: lzip not found'
fi
test_expect_success LZIP 'get foo/snapshot/master.tar.lz' '
cgit_url "foo/snapshot/master.tar.lz" >tmp
'
test_expect_success LZIP 'check html headers' '
head -n 1 tmp |
grep "Content-Type: application/x-lzip" &&
head -n 2 tmp |
grep "Content-Disposition: inline; filename=.master.tar.lz."
'
test_expect_success LZIP 'strip off the header lines' '
strip_headers <tmp >master.tar.lz
'
test_expect_success LZIP 'verify lzip format' '
lzip --test master.tar.lz
'
test_expect_success LZIP 'untar' '
rm -rf master &&
lzip -dc master.tar.lz | tar -xf -
'
test_expect_success LZIP 'count files' '
ls master/ >output &&
test_line_count = 5 output
'
test_expect_success LZIP 'verify untarred file-5' '
grep "^5$" master/file-5 &&
test_line_count = 1 master/file-5
'
if test -n "$(which xz 2>/dev/null)"; then
test_set_prereq XZ
else
say 'Skipping XZ validation tests: xz not found'
fi
test_expect_success XZ 'get foo/snapshot/master.tar.xz' '
cgit_url "foo/snapshot/master.tar.xz" >tmp
'
test_expect_success XZ 'check html headers' '
head -n 1 tmp |
grep "Content-Type: application/x-xz" &&
head -n 2 tmp |
grep "Content-Disposition: inline; filename=.master.tar.xz."
'
test_expect_success XZ 'strip off the header lines' '
strip_headers <tmp >master.tar.xz
'
test_expect_success XZ 'verify xz format' '
xz --test master.tar.xz
'
test_expect_success XZ 'untar' '
rm -rf master &&
xz -dc master.tar.xz | tar -xf -
'
test_expect_success XZ 'count files' '
ls master/ >output &&
test_line_count = 5 output
'
test_expect_success XZ 'verify untarred file-5' '
grep "^5$" master/file-5 &&
test_line_count = 1 master/file-5
'
if test -n "$(which zstd 2>/dev/null)"; then
test_set_prereq ZSTD
else
say 'Skipping ZSTD validation tests: zstd not found'
fi
test_expect_success ZSTD 'get foo/snapshot/master.tar.zst' '
cgit_url "foo/snapshot/master.tar.zst" >tmp
'
test_expect_success ZSTD 'check html headers' '
head -n 1 tmp |
grep "Content-Type: application/x-zstd" &&
head -n 2 tmp |
grep "Content-Disposition: inline; filename=.master.tar.zst."
'
test_expect_success ZSTD 'strip off the header lines' '
strip_headers <tmp >master.tar.zst
'
test_expect_success ZSTD 'verify zstd format' '
zstd --test master.tar.zst
'
test_expect_success ZSTD 'untar' '
rm -rf master &&
zstd -dc master.tar.zst | tar -xf -
'
test_expect_success ZSTD 'count files' '
ls master/ >output &&
test_line_count = 5 output
'
test_expect_success ZSTD 'verify untarred file-5' '
grep "^5$" master/file-5 &&
test_line_count = 1 master/file-5
'
test_expect_success 'get foo/snapshot/master.zip' '
cgit_url "foo/snapshot/master.zip" >tmp
'

@ -9,17 +9,23 @@ test -n "$(which strace 2>/dev/null)" || {
exit
}
strace true 2>/dev/null || {
skip_all='Skipping access validation tests: strace not functional'
test_done
exit
}
test_no_home_access () {
non_existant_path="/path/to/some/place/that/does/not/possibly/exist"
while test -d "$non_existant_path"; do
non_existant_path="$non_existant_path/$(date +%N)"
non_existent_path="/path/to/some/place/that/does/not/possibly/exist"
while test -d "$non_existent_path"; do
non_existent_path="$non_existent_path/$(date +%N)"
done &&
strace \
-E HOME="$non_existant_path" \
-E HOME="$non_existent_path" \
-E CGIT_CONFIG="$PWD/cgitrc" \
-E QUERY_STRING="url=$1" \
-e access -f -o strace.out cgit &&
test_must_fail grep "$non_existant_path" strace.out
! grep "$non_existent_path" strace.out
}
test_no_home_access_success() {

@ -25,7 +25,8 @@ static void add_entry(struct commit *commit, const char *host)
html_txt(info->subject);
html("</title>\n");
html("<updated>");
cgit_print_date(info->committer_date, FMT_ATOMDATE, 0);
html_txt(show_date(info->committer_date, 0,
date_mode_from_type(DATE_ISO8601_STRICT)));
html("</updated>\n");
html("<author>\n");
if (info->author) {
@ -50,7 +51,8 @@ static void add_entry(struct commit *commit, const char *host)
}
html("</author>\n");
html("<published>");
cgit_print_date(info->author_date, FMT_ATOMDATE, 0);
html_txt(show_date(info->author_date, 0,
date_mode_from_type(DATE_ISO8601_STRICT)));
html("</published>\n");
if (host) {
char *pageurl;
@ -61,33 +63,29 @@ static void add_entry(struct commit *commit, const char *host)
html_attr(pageurl);
if (ctx.cfg.virtual_root)
delim = '?';
htmlf("%cid=%s", delim, hex);
html_attrf("%cid=%s", delim, hex);
html("'/>\n");
free(pageurl);
}
htmlf("<id>%s</id>\n", hex);
html("<id>");
html_txtf("urn:%s:%s", the_hash_algo->name, hex);
html("</id>\n");
html("<content type='text'>\n");
html_txt(info->msg);
html("</content>\n");
html("<content type='xhtml'>\n");
html("<div xmlns='http://www.w3.org/1999/xhtml'>\n");
html("<pre>\n");
html_txt(info->msg);
html("</pre>\n");
html("</div>\n");
html("</content>\n");
html("</entry>\n");
cgit_free_commitinfo(info);
}
void cgit_print_atom(char *tip, char *path, int max_count)
void cgit_print_atom(char *tip, const char *path, int max_count)
{
char *host;
const char *argv[] = {NULL, tip, NULL, NULL, NULL};
struct commit *commit;
struct rev_info rev;
int argc = 2;
bool first = true;
if (ctx.qry.show_all)
argv[1] = "--all";
@ -128,18 +126,30 @@ void cgit_print_atom(char *tip, char *path, int max_count)
html_txt(ctx.repo->desc);
html("</subtitle>\n");
if (host) {
char *fullurl = cgit_currentfullurl();
char *repourl = cgit_repourl(ctx.repo->url);
html("<id>");
html_txtf("%s%s%s", cgit_httpscheme(), host, fullurl);
html("</id>\n");
html("<link rel='self' href='");
html_attrf("%s%s%s", cgit_httpscheme(), host, fullurl);
html("'/>\n");
html("<link rel='alternate' type='text/html' href='");
html(cgit_httpscheme());
html_attr(host);
html_attr(repourl);
html_attrf("%s%s%s", cgit_httpscheme(), host, repourl);
html("'/>\n");
free(fullurl);
free(repourl);
}
while ((commit = get_revision(&rev)) != NULL) {
if (first) {
html("<updated>");
html_txt(show_date(commit->date, 0,
date_mode_from_type(DATE_ISO8601_STRICT)));
html("</updated>\n");
first = false;
}
add_entry(commit, host);
free_commit_buffer(commit);
free_commit_list(commit->parents);
release_commit_memory(the_repository->parsed_objects, commit);
commit->parents = NULL;
}
html("</feed>\n");

@ -1,6 +1,6 @@
#ifndef UI_ATOM_H
#define UI_ATOM_H
extern void cgit_print_atom(char *tip, char *path, int max_count);
extern void cgit_print_atom(char *tip, const char *path, int max_count);
#endif

@ -0,0 +1,315 @@
/* ui-blame.c: functions for blame output
*
* Copyright (C) 2006-2017 cgit Development Team <cgit@lists.zx2c4.com>
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
*/
#include "cgit.h"
#include "ui-blame.h"
#include "html.h"
#include "ui-shared.h"
#include "strvec.h"
#include "blame.h"
static char *emit_suspect_detail(struct blame_origin *suspect)
{
struct commitinfo *info;
struct strbuf detail = STRBUF_INIT;
info = cgit_parse_commit(suspect->commit);
strbuf_addf(&detail, "author %s", info->author);
if (!ctx.cfg.noplainemail)
strbuf_addf(&detail, " %s", info->author_email);
strbuf_addf(&detail, " %s\n",
show_date(info->author_date, info->author_tz,
cgit_date_mode(DATE_ISO8601)));
strbuf_addf(&detail, "committer %s", info->committer);
if (!ctx.cfg.noplainemail)
strbuf_addf(&detail, " %s", info->committer_email);
strbuf_addf(&detail, " %s\n\n",
show_date(info->committer_date, info->committer_tz,
cgit_date_mode(DATE_ISO8601)));
strbuf_addstr(&detail, info->subject);
cgit_free_commitinfo(info);
return strbuf_detach(&detail, NULL);
}
static void emit_blame_entry_hash(struct blame_entry *ent)
{
struct blame_origin *suspect = ent->suspect;
struct object_id *oid = &suspect->commit->object.oid;
unsigned long line = 0;
char *detail = emit_suspect_detail(suspect);
html("<span class='oid'>");
cgit_commit_link(find_unique_abbrev(oid, DEFAULT_ABBREV), detail,
NULL, ctx.qry.head, oid_to_hex(oid), suspect->path);
html("</span>");
free(detail);
if (!parse_commit(suspect->commit) && suspect->commit->parents) {
struct commit *parent = suspect->commit->parents->item;
html(" ");
cgit_blame_link("^", "Blame the previous revision", NULL,
ctx.qry.head, oid_to_hex(&parent->object.oid),
suspect->path);
}
while (line++ < ent->num_lines)
html("\n");
}
static void emit_blame_entry_linenumber(struct blame_entry *ent)
{
const char *numberfmt = "<a id='n%1$d' href='#n%1$d'>%1$d</a>\n";
unsigned long lineno = ent->lno;
while (lineno < ent->lno + ent->num_lines)
htmlf(numberfmt, ++lineno);
}
static void emit_blame_entry_line_background(struct blame_scoreboard *sb,
struct blame_entry *ent)
{
unsigned long line;
size_t len, maxlen = 2;
const char* pos, *endpos;
for (line = ent->lno; line < ent->lno + ent->num_lines; line++) {
html("\n");
pos = blame_nth_line(sb, line);
endpos = blame_nth_line(sb, line + 1);
len = 0;
while (pos < endpos) {
len++;
if (*pos++ == '\t')
len = (len + 7) & ~7;
}
if (len > maxlen)
maxlen = len;
}
for (len = 0; len < maxlen - 1; len++)
html(" ");
}
struct walk_tree_context {
char *curr_rev;
int match_baselen;
int state;
};
static void print_object(const struct object_id *oid, const char *path,
const char *basename, const char *rev)
{
enum object_type type;
char *buf;
unsigned long size;
struct strvec rev_argv = STRVEC_INIT;
struct rev_info revs;
struct blame_scoreboard sb;
struct blame_origin *o;
struct blame_entry *ent = NULL;
type = oid_object_info(the_repository, oid, &size);
if (type == OBJ_BAD) {
cgit_print_error_page(404, "Not found", "Bad object name: %s",
oid_to_hex(oid));
return;
}
buf = read_object_file(oid, &type, &size);
if (!buf) {
cgit_print_error_page(500, "Internal server error",
"Error reading object %s", oid_to_hex(oid));
return;
}
strvec_push(&rev_argv, "blame");
strvec_push(&rev_argv, rev);
init_revisions(&revs, NULL);
revs.diffopt.flags.allow_textconv = 1;
setup_revisions(rev_argv.nr, rev_argv.v, &revs, NULL);
init_scoreboard(&sb);
sb.revs = &revs;
sb.repo = the_repository;
sb.path = path;
setup_scoreboard(&sb, &o);
o->suspects = blame_entry_prepend(NULL, 0, sb.num_lines, o);
prio_queue_put(&sb.commits, o->commit);
blame_origin_decref(o);
sb.ent = NULL;
sb.path = path;
assign_blame(&sb, 0);
blame_sort_final(&sb);
blame_coalesce(&sb);
cgit_set_title_from_path(path);
cgit_print_layout_start();
htmlf("blob: %s (", oid_to_hex(oid));
cgit_plain_link("plain", NULL, NULL, ctx.qry.head, rev, path);
html(") (");
cgit_tree_link("tree", NULL, NULL, ctx.qry.head, rev, path);
html(")\n");
if (buffer_is_binary(buf, size)) {
html("<div class='error'>blob is binary.</div>");
goto cleanup;
}
if (ctx.cfg.max_blob_size && size / 1024 > ctx.cfg.max_blob_size) {
htmlf("<div class='error'>blob size (%ldKB)"
" exceeds display size limit (%dKB).</div>",
size / 1024, ctx.cfg.max_blob_size);
goto cleanup;
}
html("<table class='blame blob'>\n<tr>\n");
/* Commit hashes */
html("<td class='hashes'>");
for (ent = sb.ent; ent; ent = ent->next) {
html("<div class='alt'><pre>");
emit_blame_entry_hash(ent);
html("</pre></div>");
}
html("</td>\n");
/* Line numbers */
if (ctx.cfg.enable_tree_linenumbers) {
html("<td class='linenumbers'>");
for (ent = sb.ent; ent; ent = ent->next) {
html("<div class='alt'><pre>");
emit_blame_entry_linenumber(ent);
html("</pre></div>");
}
html("</td>\n");
}
html("<td class='lines'><div>");
/* Colored bars behind lines */
html("<div>");
for (ent = sb.ent; ent; ) {
struct blame_entry *e = ent->next;
html("<div class='alt'><pre>");
emit_blame_entry_line_background(&sb, ent);
html("</pre></div>");
free(ent);
ent = e;
}
html("</div>");
free((void *)sb.final_buf);
/* Lines */
html("<pre><code>");
if (ctx.repo->source_filter) {
char *filter_arg = xstrdup(basename);
cgit_open_filter(ctx.repo->source_filter, filter_arg);
html_raw(buf, size);
cgit_close_filter(ctx.repo->source_filter);
free(filter_arg);
} else {
html_txt(buf);
}
html("</code></pre>");
html("</div></td>\n");
html("</tr>\n</table>\n");
cgit_print_layout_end();
cleanup:
free(buf);
}
static int walk_tree(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, void *cbdata)
{
struct walk_tree_context *walk_tree_ctx = cbdata;
if (base->len == walk_tree_ctx->match_baselen) {
if (S_ISREG(mode)) {
struct strbuf buffer = STRBUF_INIT;
strbuf_addbuf(&buffer, base);
strbuf_addstr(&buffer, pathname);
print_object(oid, buffer.buf, pathname,
walk_tree_ctx->curr_rev);
strbuf_release(&buffer);
walk_tree_ctx->state = 1;
} else if (S_ISDIR(mode)) {
walk_tree_ctx->state = 2;
}
} else if (base->len < INT_MAX
&& (int)base->len > walk_tree_ctx->match_baselen) {
walk_tree_ctx->state = 2;
} else if (S_ISDIR(mode)) {
return READ_TREE_RECURSIVE;
}
return 0;
}
static int basedir_len(const char *path)
{
char *p = strrchr(path, '/');
if (p)
return p - path + 1;
return 0;
}
void cgit_print_blame(void)
{
const char *rev = ctx.qry.oid;
struct object_id oid;
struct commit *commit;
struct pathspec_item path_items = {
.match = ctx.qry.path,
.len = ctx.qry.path ? strlen(ctx.qry.path) : 0
};
struct pathspec paths = {
.nr = 1,
.items = &path_items
};
struct walk_tree_context walk_tree_ctx = {
.state = 0
};
if (!rev)
rev = ctx.qry.head;
if (get_oid(rev, &oid)) {
cgit_print_error_page(404, "Not found",
"Invalid revision name: %s", rev);
return;
}
commit = lookup_commit_reference(the_repository, &oid);
if (!commit || parse_commit(commit)) {
cgit_print_error_page(404, "Not found",
"Invalid commit reference: %s", rev);
return;
}
walk_tree_ctx.curr_rev = xstrdup(rev);
walk_tree_ctx.match_baselen = (path_items.match) ?
basedir_len(path_items.match) : -1;
read_tree(the_repository, repo_get_commit_tree(the_repository, commit),
&paths, walk_tree, &walk_tree_ctx);
if (!walk_tree_ctx.state)
cgit_print_error_page(404, "Not found", "Not found");
else if (walk_tree_ctx.state == 2)
cgit_print_error_page(404, "No blame for folders",
"Blame is not available for folders.");
free(walk_tree_ctx.curr_rev);
}

@ -0,0 +1,6 @@
#ifndef UI_BLAME_H
#define UI_BLAME_H
extern void cgit_print_blame(void);
#endif /* UI_BLAME_H */

@ -13,13 +13,13 @@
struct walk_tree_context {
const char *match_path;
unsigned char *matched_sha1;
struct object_id *matched_oid;
unsigned int found_path:1;
unsigned int file_only:1;
};
static int walk_tree(const unsigned char *sha1, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *cbdata)
static int walk_tree(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, void *cbdata)
{
struct walk_tree_context *walk_tree_ctx = cbdata;
@ -28,17 +28,17 @@ static int walk_tree(const unsigned char *sha1, struct strbuf *base,
if (strncmp(base->buf, walk_tree_ctx->match_path, base->len)
|| strcmp(walk_tree_ctx->match_path + base->len, pathname))
return READ_TREE_RECURSIVE;
memmove(walk_tree_ctx->matched_sha1, sha1, 20);
oidcpy(walk_tree_ctx->matched_oid, oid);
walk_tree_ctx->found_path = 1;
return 0;
}
int cgit_ref_path_exists(const char *path, const char *ref, int file_only)
{
unsigned char sha1[20];
struct object_id oid;
unsigned long size;
struct pathspec_item path_items = {
.match = path,
.match = xstrdup(path),
.len = strlen(path)
};
struct pathspec paths = {
@ -47,22 +47,27 @@ int cgit_ref_path_exists(const char *path, const char *ref, int file_only)
};
struct walk_tree_context walk_tree_ctx = {
.match_path = path,
.matched_sha1 = sha1,
.matched_oid = &oid,
.found_path = 0,
.file_only = file_only
};
if (get_sha1(ref, sha1))
return 0;
if (sha1_object_info(sha1, &size) != OBJ_COMMIT)
return 0;
read_tree_recursive(lookup_commit_reference(sha1)->tree, "", 0, 0, &paths, walk_tree, &walk_tree_ctx);
if (get_oid(ref, &oid))
goto done;
if (oid_object_info(the_repository, &oid, &size) != OBJ_COMMIT)
goto done;
read_tree(the_repository,
repo_get_commit_tree(the_repository, lookup_commit_reference(the_repository, &oid)),
&paths, walk_tree, &walk_tree_ctx);
done:
free(path_items.match);
return walk_tree_ctx.found_path;
}
int cgit_print_file(char *path, const char *head, int file_only)
{
unsigned char sha1[20];
struct object_id oid;
enum object_type type;
char *buf;
unsigned long size;
@ -77,24 +82,25 @@ int cgit_print_file(char *path, const char *head, int file_only)
};
struct walk_tree_context walk_tree_ctx = {
.match_path = path,
.matched_sha1 = sha1,
.matched_oid = &oid,
.found_path = 0,
.file_only = file_only
};
if (get_sha1(head, sha1))
if (get_oid(head, &oid))
return -1;
type = sha1_object_info(sha1, &size);
type = oid_object_info(the_repository, &oid, &size);
if (type == OBJ_COMMIT) {
commit = lookup_commit_reference(sha1);
read_tree_recursive(commit->tree, "", 0, 0, &paths, walk_tree, &walk_tree_ctx);
commit = lookup_commit_reference(the_repository, &oid);
read_tree(the_repository, repo_get_commit_tree(the_repository, commit),
&paths, walk_tree, &walk_tree_ctx);
if (!walk_tree_ctx.found_path)
return -1;
type = sha1_object_info(sha1, &size);
type = oid_object_info(the_repository, &oid, &size);
}
if (type == OBJ_BAD)
return -1;
buf = read_sha1_file(sha1, &type, &size);
buf = read_object_file(&oid, &type, &size);
if (!buf)
return -1;
buf[size] = '\0';
@ -105,7 +111,7 @@ int cgit_print_file(char *path, const char *head, int file_only)
void cgit_print_blob(const char *hex, char *path, const char *head, int file_only)
{
unsigned char sha1[20];
struct object_id oid;
enum object_type type;
char *buf;
unsigned long size;
@ -120,31 +126,32 @@ void cgit_print_blob(const char *hex, char *path, const char *head, int file_onl
};
struct walk_tree_context walk_tree_ctx = {
.match_path = path,
.matched_sha1 = sha1,
.matched_oid = &oid,
.found_path = 0,
.file_only = file_only
};
if (hex) {
if (get_sha1_hex(hex, sha1)) {
if (get_oid_hex(hex, &oid)) {
cgit_print_error_page(400, "Bad request",
"Bad hex value: %s", hex);
return;
}
} else {
if (get_sha1(head, sha1)) {
if (get_oid(head, &oid)) {
cgit_print_error_page(404, "Not found",
"Bad ref: %s", head);
return;
}
}
type = sha1_object_info(sha1, &size);
type = oid_object_info(the_repository, &oid, &size);
if ((!hex) && type == OBJ_COMMIT && path) {
commit = lookup_commit_reference(sha1);
read_tree_recursive(commit->tree, "", 0, 0, &paths, walk_tree, &walk_tree_ctx);
type = sha1_object_info(sha1,&size);
commit = lookup_commit_reference(the_repository, &oid);
read_tree(the_repository, repo_get_commit_tree(the_repository, commit),
&paths, walk_tree, &walk_tree_ctx);
type = oid_object_info(the_repository, &oid, &size);
}
if (type == OBJ_BAD) {
@ -153,7 +160,7 @@ void cgit_print_blob(const char *hex, char *path, const char *head, int file_onl
return;
}
buf = read_sha1_file(sha1, &type, &size);
buf = read_object_file(&oid, &type, &size);
if (!buf) {
cgit_print_error_page(500, "Internal server error",
"Error reading object %s", hex);

@ -11,18 +11,20 @@
#include "ui-clone.h"
#include "html.h"
#include "ui-shared.h"
#include "packfile.h"
#include "object-store.h"
static int print_ref_info(const char *refname, const struct object_id *oid,
int flags, void *cb_data)
{
struct object *obj;
if (!(obj = parse_object(oid->hash)))
if (!(obj = parse_object(the_repository, oid)))
return 0;
htmlf("%s\t%s\n", oid_to_hex(oid), refname);
if (obj->type == OBJ_TAG) {
if (!(obj = deref_tag(obj, refname, 0)))
if (!(obj = deref_tag(the_repository, obj, refname, 0)))
return 0;
htmlf("%s\t%s^{}\n", oid_to_hex(&obj->oid), refname);
}
@ -37,8 +39,8 @@ static void print_pack_info(void)
ctx.page.mimetype = "text/plain";
ctx.page.filename = "objects/info/packs";
cgit_print_http_headers();
prepare_packed_git();
for (pack = packed_git; pack; pack = pack->next) {
reprepare_packed_git(the_repository);
for (pack = get_packed_git(the_repository); pack; pack = pack->next) {
if (pack->pack_local) {
offset = strrchr(pack->pack_name, '/');
if (offset && offset[1] != '\0')
@ -90,17 +92,32 @@ void cgit_clone_info(void)
void cgit_clone_objects(void)
{
if (!ctx.qry.path) {
cgit_print_error_page(400, "Bad request", "Bad request");
return;
}
char *p;
if (!ctx.qry.path)
goto err;
if (!strcmp(ctx.qry.path, "info/packs")) {
print_pack_info();
return;
}
/* Avoid directory traversal by forbidding "..", but also work around
* other funny business by just specifying a fairly strict format. For
* example, now we don't have to stress out about the Cygwin port.
*/
for (p = ctx.qry.path; *p; ++p) {
if (*p == '.' && *(p + 1) == '.')
goto err;
if (!isalnum(*p) && *p != '/' && *p != '.' && *p != '-')
goto err;
}
send_file(git_path("objects/%s", ctx.qry.path));
return;
err:
cgit_print_error_page(400, "Bad request", "Bad request");
}
void cgit_clone_head(void)

@ -19,19 +19,19 @@ void cgit_print_commit(char *hex, const char *prefix)
struct commitinfo *info, *parent_info;
struct commit_list *p;
struct strbuf notes = STRBUF_INIT;
unsigned char sha1[20];
struct object_id oid;
char *tmp, *tmp2;
int parents = 0;
if (!hex)
hex = ctx.qry.head;
if (get_sha1(hex, sha1)) {
if (get_oid(hex, &oid)) {
cgit_print_error_page(400, "Bad request",
"Bad object id: %s", hex);
return;
}
commit = lookup_commit_reference(sha1);
commit = lookup_commit_reference(the_repository, &oid);
if (!commit) {
cgit_print_error_page(404, "Not found",
"Bad commit reference: %s", hex);
@ -39,10 +39,11 @@ void cgit_print_commit(char *hex, const char *prefix)
}
info = cgit_parse_commit(commit);
format_display_notes(sha1, &notes, PAGE_ENCODING, 0);
format_display_notes(&oid, &notes, PAGE_ENCODING, 1);
load_ref_decorations(DECORATE_FULL_REFS);
load_ref_decorations(NULL, DECORATE_FULL_REFS);
ctx.page.title = fmtalloc("%s - %s", info->subject, ctx.page.title);
cgit_print_layout_start();
cgit_print_diff_ctrls();
html("<table summary='commit info' class='commit-info'>\n");
@ -55,7 +56,8 @@ void cgit_print_commit(char *hex, const char *prefix)
}
cgit_close_filter(ctx.repo->email_filter);
html("</td><td class='right'>");
cgit_print_date(info->author_date, FMT_LONGDATE, ctx.cfg.local_time);
html_txt(show_date(info->author_date, info->author_tz,
cgit_date_mode(DATE_ISO8601)));
html("</td></tr>\n");
html("<tr><th>committer</th><td>");
cgit_open_filter(ctx.repo->email_filter, info->committer_email, "commit");
@ -66,17 +68,18 @@ void cgit_print_commit(char *hex, const char *prefix)
}
cgit_close_filter(ctx.repo->email_filter);
html("</td><td class='right'>");
cgit_print_date(info->committer_date, FMT_LONGDATE, ctx.cfg.local_time);
html_txt(show_date(info->committer_date, info->committer_tz,
cgit_date_mode(DATE_ISO8601)));
html("</td></tr>\n");
html("<tr><th>commit</th><td colspan='2' class='sha1'>");
html("<tr><th>commit</th><td colspan='2' class='oid'>");
tmp = oid_to_hex(&commit->object.oid);
cgit_commit_link(tmp, NULL, NULL, ctx.qry.head, tmp, prefix);
html(" (");
cgit_patch_link("patch", NULL, NULL, NULL, tmp, prefix);
html(")</td></tr>\n");
html("<tr><th>tree</th><td colspan='2' class='sha1'>");
html("<tr><th>tree</th><td colspan='2' class='oid'>");
tmp = xstrdup(hex);
cgit_tree_link(oid_to_hex(&commit->tree->object.oid), NULL, NULL,
cgit_tree_link(oid_to_hex(get_commit_tree_oid(commit)), NULL, NULL,
ctx.qry.head, tmp, NULL);
if (prefix) {
html(" /");
@ -85,7 +88,7 @@ void cgit_print_commit(char *hex, const char *prefix)
free(tmp);
html("</td></tr>\n");
for (p = commit->parents; p; p = p->next) {
parent = lookup_commit_reference(p->item->object.oid.hash);
parent = lookup_commit_reference(the_repository, &p->item->object.oid);
if (!parent) {
html("<tr><td colspan='3'>");
cgit_print_error("Error reading parent commit");
@ -93,7 +96,7 @@ void cgit_print_commit(char *hex, const char *prefix)
continue;
}
html("<tr><th>parent</th>"
"<td colspan='2' class='sha1'>");
"<td colspan='2' class='oid'>");
tmp = tmp2 = oid_to_hex(&p->item->object.oid);
if (ctx.repo->enable_subject_links) {
parent_info = cgit_parse_commit(parent);
@ -107,9 +110,8 @@ void cgit_print_commit(char *hex, const char *prefix)
parents++;
}
if (ctx.repo->snapshots) {
html("<tr><th>download</th><td colspan='2' class='sha1'>");
cgit_print_snapshot_links(ctx.qry.repo, ctx.qry.head,
hex, ctx.repo->snapshots);
html("<tr><th>download</th><td colspan='2' class='oid'>");
cgit_print_snapshot_links(ctx.repo, hex, "<br/>");
html("</td></tr>");
}
html("</table>\n");
@ -138,7 +140,7 @@ void cgit_print_commit(char *hex, const char *prefix)
tmp = oid_to_hex(&commit->parents->item->object.oid);
else
tmp = NULL;
cgit_print_diff(ctx.qry.sha1, tmp, prefix, 0, 0);
cgit_print_diff(ctx.qry.oid, tmp, prefix, 0, 0);
}
strbuf_release(&notes);
cgit_free_commitinfo(info);

@ -12,8 +12,8 @@
#include "ui-shared.h"
#include "ui-ssdiff.h"
unsigned char old_rev_sha1[20];
unsigned char new_rev_sha1[20];
struct object_id old_rev_oid[1];
struct object_id new_rev_oid[1];
static int files, slots;
static int total_adds, total_rems, max_changes;
@ -21,8 +21,8 @@ static int lines_added, lines_removed;
static struct fileinfo {
char status;
unsigned char old_sha1[20];
unsigned char new_sha1[20];
struct object_id old_oid[1];
struct object_id new_oid[1];
unsigned short old_mode;
unsigned short new_mode;
char *old_path;
@ -82,23 +82,23 @@ static void print_fileinfo(struct fileinfo *info)
}
html("<tr>");
htmlf("<td class='mode'>");
if (is_null_sha1(info->new_sha1)) {
html("<td class='mode'>");
if (is_null_oid(info->new_oid)) {
cgit_print_filemode(info->old_mode);
} else {
cgit_print_filemode(info->new_mode);
}
if (info->old_mode != info->new_mode &&
!is_null_sha1(info->old_sha1) &&
!is_null_sha1(info->new_sha1)) {
!is_null_oid(info->old_oid) &&
!is_null_oid(info->new_oid)) {
html("<span class='modechange'>[");
cgit_print_filemode(info->old_mode);
html("]</span>");
}
htmlf("</td><td class='%s'>", class);
cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1,
ctx.qry.sha2, info->new_path);
cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.oid,
ctx.qry.oid2, info->new_path);
if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) {
htmlf(" (%s from ",
info->status == DIFF_STATUS_COPIED ? "copied" : "renamed");
@ -160,7 +160,7 @@ static void inspect_filepair(struct diff_filepair *pair)
files++;
lines_added = 0;
lines_removed = 0;
cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size,
cgit_diff_files(&pair->one->oid, &pair->two->oid, &old_size, &new_size,
&binary, 0, ctx.qry.ignorews, count_diff_lines);
if (files >= slots) {
if (slots == 0)
@ -170,8 +170,8 @@ static void inspect_filepair(struct diff_filepair *pair)
items = xrealloc(items, slots * sizeof(struct fileinfo));
}
items[files-1].status = pair->status;
hashcpy(items[files-1].old_sha1, pair->one->sha1);
hashcpy(items[files-1].new_sha1, pair->two->sha1);
oidcpy(items[files-1].old_oid, &pair->one->oid);
oidcpy(items[files-1].new_oid, &pair->two->oid);
items[files-1].old_mode = pair->one->mode;
items[files-1].new_mode = pair->two->mode;
items[files-1].old_path = xstrdup(pair->one->path);
@ -187,15 +187,15 @@ static void inspect_filepair(struct diff_filepair *pair)
total_rems += lines_removed;
}
static void cgit_print_diffstat(const unsigned char *old_sha1,
const unsigned char *new_sha1,
static void cgit_print_diffstat(const struct object_id *old_oid,
const struct object_id *new_oid,
const char *prefix)
{
int i;
html("<div class='diffstat-header'>");
cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1,
ctx.qry.sha2, NULL);
cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.oid,
ctx.qry.oid2, NULL);
if (prefix) {
html(" (limited to '");
html_txt(prefix);
@ -204,7 +204,7 @@ static void cgit_print_diffstat(const unsigned char *old_sha1,
html("</div>");
html("<table summary='diffstat' class='diffstat'>");
max_changes = 0;
cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, prefix,
cgit_diff_tree(old_oid, new_oid, inspect_filepair, prefix,
ctx.qry.ignorews);
for (i = 0; i<files; i++)
print_fileinfo(&items[i]);
@ -238,8 +238,8 @@ static void print_line(char *line, int len)
line[len-1] = c;
}
static void header(unsigned char *sha1, char *path1, int mode1,
unsigned char *sha2, char *path2, int mode2)
static void header(const struct object_id *oid1, char *path1, int mode1,
const struct object_id *oid2, char *path2, int mode2)
{
char *abbrev1, *abbrev2;
int subproject;
@ -258,8 +258,8 @@ static void header(unsigned char *sha1, char *path1, int mode1,
htmlf("<br/>deleted file mode %.6o", mode1);
if (!subproject) {
abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV));
abbrev1 = xstrdup(find_unique_abbrev(oid1, DEFAULT_ABBREV));
abbrev2 = xstrdup(find_unique_abbrev(oid2, DEFAULT_ABBREV));
htmlf("<br/>index %s..%s", abbrev1, abbrev2);
free(abbrev1);
free(abbrev2);
@ -268,24 +268,24 @@ static void header(unsigned char *sha1, char *path1, int mode1,
if (mode2 != mode1)
htmlf("..%.6o", mode2);
}
if (is_null_sha1(sha1)) {
if (is_null_oid(oid1)) {
path1 = "dev/null";
html("<br/>--- /");
} else
html("<br/>--- a/");
if (mode1 != 0)
cgit_tree_link(path1, NULL, NULL, ctx.qry.head,
sha1_to_hex(old_rev_sha1), path1);
oid_to_hex(old_rev_oid), path1);
else
html_txt(path1);
if (is_null_sha1(sha2)) {
if (is_null_oid(oid2)) {
path2 = "dev/null";
html("<br/>+++ /");
} else
html("<br/>+++ b/");
if (mode2 != 0)
cgit_tree_link(path2, NULL, NULL, ctx.qry.head,
sha1_to_hex(new_rev_sha1), path2);
oid_to_hex(new_rev_oid), path2);
else
html_txt(path2);
}
@ -307,20 +307,20 @@ static void filepair_cb(struct diff_filepair *pair)
cgit_ssdiff_header_begin();
print_line_fn = cgit_ssdiff_line_cb;
}
header(pair->one->sha1, pair->one->path, pair->one->mode,
pair->two->sha1, pair->two->path, pair->two->mode);
header(&pair->one->oid, pair->one->path, pair->one->mode,
&pair->two->oid, pair->two->path, pair->two->mode);
if (use_ssdiff)
cgit_ssdiff_header_end();
if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) {
if (S_ISGITLINK(pair->one->mode))
print_line_fn(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
print_line_fn(fmt("-Subproject %s", oid_to_hex(&pair->one->oid)), 52);
if (S_ISGITLINK(pair->two->mode))
print_line_fn(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
print_line_fn(fmt("+Subproject %s", oid_to_hex(&pair->two->oid)), 52);
if (use_ssdiff)
cgit_ssdiff_footer();
return;
}
if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
if (cgit_diff_files(&pair->one->oid, &pair->two->oid, &old_size,
&new_size, &binary, ctx.qry.context,
ctx.qry.ignorews, print_line_fn))
cgit_print_error("Error running diff");
@ -340,7 +340,7 @@ void cgit_print_diff_ctrls(void)
html("<div class='cgit-panel'>");
html("<b>diff options</b>");
html("<form method='get' action='.'>");
html("<form method='get'>");
cgit_add_hidden_formfields(1, 0, ctx.qry.page);
html("<table>");
html("<tr><td colspan='2'/></tr>");
@ -385,7 +385,7 @@ void cgit_print_diff(const char *new_rev, const char *old_rev,
const char *prefix, int show_ctrls, int raw)
{
struct commit *commit, *commit2;
const unsigned char *old_tree_sha1, *new_tree_sha1;
const struct object_id *old_tree_oid, *new_tree_oid;
diff_type difftype;
/*
@ -402,41 +402,41 @@ void cgit_print_diff(const char *new_rev, const char *old_rev,
if (!new_rev)
new_rev = ctx.qry.head;
if (get_sha1(new_rev, new_rev_sha1)) {
if (get_oid(new_rev, new_rev_oid)) {
cgit_print_error_page(404, "Not found",
"Bad object name: %s", new_rev);
return;
}
commit = lookup_commit_reference(new_rev_sha1);
commit = lookup_commit_reference(the_repository, new_rev_oid);
if (!commit || parse_commit(commit)) {
cgit_print_error_page(404, "Not found",
"Bad commit: %s", sha1_to_hex(new_rev_sha1));
"Bad commit: %s", oid_to_hex(new_rev_oid));
return;
}
new_tree_sha1 = commit->tree->object.oid.hash;
new_tree_oid = get_commit_tree_oid(commit);
if (old_rev) {
if (get_sha1(old_rev, old_rev_sha1)) {
if (get_oid(old_rev, old_rev_oid)) {
cgit_print_error_page(404, "Not found",
"Bad object name: %s", old_rev);
return;
}
} else if (commit->parents && commit->parents->item) {
hashcpy(old_rev_sha1, commit->parents->item->object.oid.hash);
oidcpy(old_rev_oid, &commit->parents->item->object.oid);
} else {
hashclr(old_rev_sha1);
oidclr(old_rev_oid);
}
if (!is_null_sha1(old_rev_sha1)) {
commit2 = lookup_commit_reference(old_rev_sha1);
if (!is_null_oid(old_rev_oid)) {
commit2 = lookup_commit_reference(the_repository, old_rev_oid);
if (!commit2 || parse_commit(commit2)) {
cgit_print_error_page(404, "Not found",
"Bad commit: %s", sha1_to_hex(old_rev_sha1));
"Bad commit: %s", oid_to_hex(old_rev_oid));
return;
}
old_tree_sha1 = commit2->tree->object.oid.hash;
old_tree_oid = get_commit_tree_oid(commit2);
} else {
old_tree_sha1 = NULL;
old_tree_oid = NULL;
}
if (raw) {
@ -444,16 +444,16 @@ void cgit_print_diff(const char *new_rev, const char *old_rev,
diff_setup(&diffopt);
diffopt.output_format = DIFF_FORMAT_PATCH;
DIFF_OPT_SET(&diffopt, RECURSIVE);
diffopt.flags.recursive = 1;
diff_setup_done(&diffopt);
ctx.page.mimetype = "text/plain";
cgit_print_http_headers();
if (old_tree_sha1) {
diff_tree_sha1(old_tree_sha1, new_tree_sha1, "",
if (old_tree_oid) {
diff_tree_oid(old_tree_oid, new_tree_oid, "",
&diffopt);
} else {
diff_root_tree_sha1(new_tree_sha1, "", &diffopt);
diff_root_tree_oid(new_tree_oid, "", &diffopt);
}
diffcore_std(&diffopt);
diff_flush(&diffopt);
@ -479,7 +479,7 @@ void cgit_print_diff(const char *new_rev, const char *old_rev,
if (difftype == DIFF_STATONLY)
ctx.qry.difftype = ctx.cfg.difftype;
cgit_print_diffstat(old_rev_sha1, new_rev_sha1, prefix);
cgit_print_diffstat(old_rev_oid, new_rev_oid, prefix);
if (difftype == DIFF_STATONLY)
return;
@ -490,7 +490,7 @@ void cgit_print_diff(const char *new_rev, const char *old_rev,
html("<table summary='diff' class='diff'>");
html("<tr><td>");
}
cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix,
cgit_diff_tree(old_rev_oid, new_rev_oid, filepair_cb, prefix,
ctx.qry.ignorews);
if (!use_ssdiff)
html("</td></tr>");

@ -9,7 +9,7 @@ extern void cgit_print_diff(const char *new_hex, const char *old_hex,
extern struct diff_filespec *cgit_get_current_old_file(void);
extern struct diff_filespec *cgit_get_current_new_file(void);
extern unsigned char old_rev_sha1[20];
extern unsigned char new_rev_sha1[20];
extern struct object_id old_rev_oid[1];
extern struct object_id new_rev_oid[1];
#endif /* UI_DIFF_H */

@ -10,7 +10,7 @@
#include "ui-log.h"
#include "html.h"
#include "ui-shared.h"
#include "argv-array.h"
#include "strvec.h"
static int files, add_lines, rem_lines, lines_counted;
@ -49,7 +49,7 @@ static void inspect_files(struct diff_filepair *pair)
files++;
if (ctx.repo->enable_log_linecount)
cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
cgit_diff_files(&pair->one->oid, &pair->two->oid, &old_size,
&new_size, &binary, 0, ctx.qry.ignorews,
count_lines);
}
@ -61,38 +61,43 @@ void show_commit_decorations(struct commit *commit)
buf[sizeof(buf) - 1] = 0;
deco = get_name_decoration(&commit->object);
if (!deco)
return;
html("<span class='decoration'>");
while (deco) {
if (starts_with(deco->name, "refs/heads/")) {
strncpy(buf, deco->name + 11, sizeof(buf) - 1);
struct object_id oid_tag, peeled;
int is_annotated = 0;
strlcpy(buf, prettify_refname(deco->name), sizeof(buf));
switch(deco->type) {
case DECORATION_NONE:
/* If the git-core doesn't recognize it,
* don't display anything. */
break;
case DECORATION_REF_LOCAL:
cgit_log_link(buf, NULL, "branch-deco", buf, NULL,
ctx.qry.vpath, 0, NULL, NULL,
ctx.qry.showmsg, 0);
}
else if (starts_with(deco->name, "tag: refs/tags/")) {
strncpy(buf, deco->name + 15, sizeof(buf) - 1);
cgit_tag_link(buf, NULL, "tag-deco", buf);
}
else if (starts_with(deco->name, "refs/tags/")) {
strncpy(buf, deco->name + 10, sizeof(buf) - 1);
cgit_tag_link(buf, NULL, "tag-deco", buf);
}
else if (starts_with(deco->name, "refs/remotes/")) {
ctx.qry.vpath, 0, NULL, NULL,
ctx.qry.showmsg, 0);
break;
case DECORATION_REF_TAG:
if (!read_ref(deco->name, &oid_tag) && !peel_iterated_oid(&oid_tag, &peeled))
is_annotated = !oideq(&oid_tag, &peeled);
cgit_tag_link(buf, NULL, is_annotated ? "tag-annotated-deco" : "tag-deco", buf);
break;
case DECORATION_REF_REMOTE:
if (!ctx.repo->enable_remote_branches)
goto next;
strncpy(buf, deco->name + 13, sizeof(buf) - 1);
break;
cgit_log_link(buf, NULL, "remote-deco", NULL,
oid_to_hex(&commit->object.oid),
ctx.qry.vpath, 0, NULL, NULL,
ctx.qry.showmsg, 0);
}
else {
strncpy(buf, deco->name, sizeof(buf) - 1);
oid_to_hex(&commit->object.oid),
ctx.qry.vpath, 0, NULL, NULL,
ctx.qry.showmsg, 0);
break;
default:
cgit_commit_link(buf, NULL, "deco", ctx.qry.head,
oid_to_hex(&commit->object.oid),
ctx.qry.vpath);
oid_to_hex(&commit->object.oid),
ctx.qry.vpath);
break;
}
next:
deco = deco->next;
}
html("</span>");
@ -119,8 +124,7 @@ static int show_commit(struct commit *commit, struct rev_info *revs)
struct commit_list *parents = commit->parents;
struct commit *parent;
int found = 0, saved_fmt;
unsigned saved_flags = revs->diffopt.flags;
struct diff_flags saved_flags = revs->diffopt.flags;
/* Always show if we're not in "follow" mode with a single file. */
if (!ctx.qry.follow)
@ -141,19 +145,21 @@ static int show_commit(struct commit *commit, struct rev_info *revs)
/* When we get here we have precisely one parent. */
parent = parents->item;
parse_commit(parent);
/* If we can't parse the commit, let print_commit() report an error. */
if (parse_commit(parent))
return 1;
files = 0;
add_lines = 0;
rem_lines = 0;
DIFF_OPT_SET(&revs->diffopt, RECURSIVE);
diff_tree_sha1(parent->tree->object.oid.hash,
commit->tree->object.oid.hash,
"", &revs->diffopt);
revs->diffopt.flags.recursive = 1;
diff_tree_oid(get_commit_tree_oid(parent),
get_commit_tree_oid(commit),
"", &revs->diffopt);
diffcore_std(&revs->diffopt);
found = !diff_queue_is_empty();
found = !diff_queue_is_empty(&revs->diffopt);
saved_fmt = revs->diffopt.output_format;
revs->diffopt.output_format = DIFF_FORMAT_CALLBACK;
revs->diffopt.format_callback = cgit_diff_tree_cb;
@ -202,7 +208,7 @@ static void print_commit(struct commit *commit, struct rev_info *revs)
}
else {
html("<td>");
cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
cgit_print_age(info->committer_date, info->committer_tz, TM_WEEK * 2);
html("</td>");
}
@ -229,7 +235,7 @@ static void print_commit(struct commit *commit, struct rev_info *revs)
strbuf_add(&msgbuf, "\n\n", 2);
/* Place wrap_symbol at position i in info->subject */
strcpy(info->subject + i, wrap_symbol);
strlcpy(info->subject + i, wrap_symbol, subject_len - i + 1);
}
}
cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,
@ -242,7 +248,7 @@ static void print_commit(struct commit *commit, struct rev_info *revs)
if (revs->graph) {
html("</td><td>");
cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
cgit_print_age(info->committer_date, info->committer_tz, TM_WEEK * 2);
}
if (!lines_counted && (ctx.repo->enable_log_filecount ||
@ -256,12 +262,14 @@ static void print_commit(struct commit *commit, struct rev_info *revs)
if (ctx.repo->enable_log_filecount)
htmlf("</td><td>%d", files);
if (ctx.repo->enable_log_linecount)
htmlf("</td><td>-%d/+%d", rem_lines, add_lines);
htmlf("</td><td><span class='deletions'>-%d</span>/"
"<span class='insertions'>+%d</span>", rem_lines, add_lines);
html("</td></tr>\n");
if (revs->graph || ctx.qry.showmsg) { /* Print a second table row */
html("<tr class='nohover'>");
if ((revs->graph && !graph_is_commit_finished(revs->graph))
|| ctx.qry.showmsg) { /* Print a second table row */
html("<tr class='nohover-highlight'>");
if (ctx.qry.showmsg) {
/* Concatenate commit message + notes in msgbuf */
@ -269,7 +277,7 @@ static void print_commit(struct commit *commit, struct rev_info *revs)
strbuf_addstr(&msgbuf, info->msg);
strbuf_addch(&msgbuf, '\n');
}
format_display_notes(commit->object.oid.hash,
format_display_notes(&commit->object.oid,
&msgbuf, PAGE_ENCODING, 0);
strbuf_addch(&msgbuf, '\n');
strbuf_ltrim(&msgbuf);
@ -322,7 +330,7 @@ static const char *disambiguate_ref(const char *ref, int *must_free_result)
struct strbuf longref = STRBUF_INIT;
strbuf_addf(&longref, "refs/heads/%s", ref);
if (get_sha1(longref.buf, oid.hash) == 0) {
if (get_oid(longref.buf, &oid) == 0) {
*must_free_result = 1;
return strbuf_detach(&longref, NULL);
}
@ -355,27 +363,27 @@ static char *next_token(char **src)
}
void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern,
char *path, int pager, int commit_graph, int commit_sort)
const char *path, int pager, int commit_graph, int commit_sort)
{
struct rev_info rev;
struct commit *commit;
struct argv_array rev_argv = ARGV_ARRAY_INIT;
struct strvec rev_argv = STRVEC_INIT;
int i, columns = commit_graph ? 4 : 3;
int must_free_tip = 0;
/* rev_argv.argv[0] will be ignored by setup_revisions */
argv_array_push(&rev_argv, "log_rev_setup");
strvec_push(&rev_argv, "log_rev_setup");
if (!tip)
tip = ctx.qry.head;
tip = disambiguate_ref(tip, &must_free_tip);
argv_array_push(&rev_argv, tip);
strvec_push(&rev_argv, tip);
if (grep && pattern && *pattern) {
pattern = xstrdup(pattern);
if (!strcmp(grep, "grep") || !strcmp(grep, "author") ||
!strcmp(grep, "committer")) {
argv_array_pushf(&rev_argv, "--%s=%s", grep, pattern);
strvec_pushf(&rev_argv, "--%s=%s", grep, pattern);
} else if (!strcmp(grep, "range")) {
char *arg;
/* Split the pattern at whitespace and add each token
@ -383,14 +391,14 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
* rev-list options. Also, replace the previously
* pushed tip (it's no longer relevant).
*/
argv_array_pop(&rev_argv);
strvec_pop(&rev_argv);
while ((arg = next_token(&pattern))) {
if (*arg == '-') {
fprintf(stderr, "Bad range expr: %s\n",
arg);
break;
}
argv_array_push(&rev_argv, arg);
strvec_push(&rev_argv, arg);
}
}
}
@ -405,22 +413,22 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
}
if (commit_graph && !ctx.qry.follow) {
argv_array_push(&rev_argv, "--graph");
argv_array_push(&rev_argv, "--color");
strvec_push(&rev_argv, "--graph");
strvec_push(&rev_argv, "--color");
graph_set_column_colors(column_colors_html,
COLUMN_COLORS_HTML_MAX);
}
if (commit_sort == 1)
argv_array_push(&rev_argv, "--date-order");
strvec_push(&rev_argv, "--date-order");
else if (commit_sort == 2)
argv_array_push(&rev_argv, "--topo-order");
strvec_push(&rev_argv, "--topo-order");
if (path && ctx.qry.follow)
argv_array_push(&rev_argv, "--follow");
argv_array_push(&rev_argv, "--");
strvec_push(&rev_argv, "--follow");
strvec_push(&rev_argv, "--");
if (path)
argv_array_push(&rev_argv, path);
strvec_push(&rev_argv, path);
init_revisions(&rev, NULL);
rev.abbrev = DEFAULT_ABBREV;
@ -429,10 +437,10 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
rev.show_root_diff = 0;
rev.ignore_missing = 1;
rev.simplify_history = 1;
setup_revisions(rev_argv.argc, rev_argv.argv, &rev, NULL);
load_ref_decorations(DECORATE_FULL_REFS);
setup_revisions(rev_argv.nr, rev_argv.v, &rev, NULL);
load_ref_decorations(NULL, DECORATE_FULL_REFS);
rev.show_decorations = 1;
rev.grep_filter.regflags |= REG_ICASE;
rev.grep_filter.ignore_case = 1;
rev.diffopt.detect_rename = 1;
rev.diffopt.rename_limit = ctx.cfg.renamelimit;
@ -456,7 +464,7 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
if (pager) {
html(" (");
cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL,
NULL, ctx.qry.head, ctx.qry.sha1,
NULL, ctx.qry.head, ctx.qry.oid,
ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep,
ctx.qry.search, ctx.qry.showmsg ? 0 : 1,
ctx.qry.follow);
@ -481,8 +489,7 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; /* nop */) {
if (show_commit(commit, &rev))
i++;
free_commit_buffer(commit);
free_commit_list(commit->parents);
release_commit_memory(the_repository->parsed_objects, commit);
commit->parents = NULL;
}
@ -503,8 +510,7 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
i++;
print_commit(commit, &rev);
}
free_commit_buffer(commit);
free_commit_list(commit->parents);
release_commit_memory(the_repository->parsed_objects, commit);
commit->parents = NULL;
}
if (pager) {
@ -512,7 +518,7 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
if (ofs > 0) {
html("<li>");
cgit_log_link("[prev]", NULL, NULL, ctx.qry.head,
ctx.qry.sha1, ctx.qry.vpath,
ctx.qry.oid, ctx.qry.vpath,
ofs - cnt, ctx.qry.grep,
ctx.qry.search, ctx.qry.showmsg,
ctx.qry.follow);
@ -521,7 +527,7 @@ void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern
if ((commit = get_revision(&rev)) != NULL) {
html("<li>");
cgit_log_link("[next]", NULL, NULL, ctx.qry.head,
ctx.qry.sha1, ctx.qry.vpath,
ctx.qry.oid, ctx.qry.vpath,
ofs + cnt, ctx.qry.grep,
ctx.qry.search, ctx.qry.showmsg,
ctx.qry.follow);

@ -2,7 +2,7 @@
#define UI_LOG_H
extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep,
char *pattern, char *path, int pager,
char *pattern, const char *path, int pager,
int commit_graph, int commit_sort);
extern void show_commit_decorations(struct commit *commit);

@ -11,25 +11,32 @@
#include "html.h"
#include "ui-shared.h"
/* two commit hashes with two dots in between and termination */
#define REV_RANGE_LEN 2 * GIT_MAX_HEXSZ + 3
void cgit_print_patch(const char *new_rev, const char *old_rev,
const char *prefix)
{
struct rev_info rev;
struct commit *commit;
unsigned char new_rev_sha1[20], old_rev_sha1[20];
char rev_range[2 * 40 + 3];
char *rev_argv[] = { NULL, "--reverse", "--format=email", rev_range };
struct object_id new_rev_oid, old_rev_oid;
char rev_range[REV_RANGE_LEN];
const char *rev_argv[] = { NULL, "--reverse", "--format=email", rev_range, "--", prefix, NULL };
int rev_argc = ARRAY_SIZE(rev_argv) - 1;
char *patchname;
if (!prefix)
rev_argc--;
if (!new_rev)
new_rev = ctx.qry.head;
if (get_sha1(new_rev, new_rev_sha1)) {
if (get_oid(new_rev, &new_rev_oid)) {
cgit_print_error_page(404, "Not found",
"Bad object id: %s", new_rev);
return;
}
commit = lookup_commit_reference(new_rev_sha1);
commit = lookup_commit_reference(the_repository, &new_rev_oid);
if (!commit) {
cgit_print_error_page(404, "Not found",
"Bad commit reference: %s", new_rev);
@ -37,27 +44,27 @@ void cgit_print_patch(const char *new_rev, const char *old_rev,
}
if (old_rev) {
if (get_sha1(old_rev, old_rev_sha1)) {
if (get_oid(old_rev, &old_rev_oid)) {
cgit_print_error_page(404, "Not found",
"Bad object id: %s", old_rev);
return;
}
if (!lookup_commit_reference(old_rev_sha1)) {
if (!lookup_commit_reference(the_repository, &old_rev_oid)) {
cgit_print_error_page(404, "Not found",
"Bad commit reference: %s", old_rev);
return;
}
} else if (commit->parents && commit->parents->item) {
hashcpy(old_rev_sha1, commit->parents->item->object.oid.hash);
oidcpy(&old_rev_oid, &commit->parents->item->object.oid);
} else {
hashclr(old_rev_sha1);
oidclr(&old_rev_oid);
}
if (is_null_sha1(old_rev_sha1)) {
memcpy(rev_range, sha1_to_hex(new_rev_sha1), 41);
if (is_null_oid(&old_rev_oid)) {
memcpy(rev_range, oid_to_hex(&new_rev_oid), the_hash_algo->hexsz + 1);
} else {
sprintf(rev_range, "%s..%s", sha1_to_hex(old_rev_sha1),
sha1_to_hex(new_rev_sha1));
xsnprintf(rev_range, REV_RANGE_LEN, "%s..%s", oid_to_hex(&old_rev_oid),
oid_to_hex(&new_rev_oid));
}
patchname = fmt("%s.patch", rev_range);
@ -79,14 +86,13 @@ void cgit_print_patch(const char *new_rev, const char *old_rev,
rev.max_parents = 1;
rev.diffopt.output_format |= DIFF_FORMAT_DIFFSTAT |
DIFF_FORMAT_PATCH | DIFF_FORMAT_SUMMARY;
setup_revisions(ARRAY_SIZE(rev_argv), (const char **)rev_argv, &rev,
NULL);
if (prefix)
rev.diffopt.stat_sep = fmt("(limited to '%s')\n\n", prefix);
setup_revisions(rev_argc, rev_argv, &rev, NULL);
prepare_revision_walk(&rev);
while ((commit = get_revision(&rev)) != NULL) {
log_tree_commit(&rev, commit);
printf("-- \ncgit %s\n\n", cgit_version);
}
fflush(stdout);
}

@ -16,19 +16,19 @@ struct walk_tree_context {
int match;
};
static int print_object(const unsigned char *sha1, const char *path)
static int print_object(const struct object_id *oid, const char *path)
{
enum object_type type;
char *buf, *mimetype;
unsigned long size;
type = sha1_object_info(sha1, &size);
type = oid_object_info(the_repository, oid, &size);
if (type == OBJ_BAD) {
cgit_print_error_page(404, "Not found", "Not found");
return 0;
}
buf = read_sha1_file(sha1, &type, &size);
buf = read_object_file(oid, &type, &size);
if (!buf) {
cgit_print_error_page(404, "Not found", "Not found");
return 0;
@ -57,7 +57,7 @@ static int print_object(const unsigned char *sha1, const char *path)
}
ctx.page.filename = path;
ctx.page.size = size;
ctx.page.etag = sha1_to_hex(sha1);
ctx.page.etag = oid_to_hex(oid);
cgit_print_http_headers();
html_raw(buf, size);
free(mimetype);
@ -73,7 +73,7 @@ static char *buildpath(const char *base, int baselen, const char *path)
return fmtalloc("%.*s/", baselen, base);
}
static void print_dir(const unsigned char *sha1, const char *base,
static void print_dir(const struct object_id *oid, const char *base,
int baselen, const char *path)
{
char *fullpath, *slash;
@ -81,7 +81,7 @@ static void print_dir(const unsigned char *sha1, const char *base,
fullpath = buildpath(base, baselen, path);
slash = (fullpath[0] == '/' ? "" : "/");
ctx.page.etag = sha1_to_hex(sha1);
ctx.page.etag = oid_to_hex(oid);
cgit_print_http_headers();
htmlf("<html><head><title>%s", slash);
html_txt(fullpath);
@ -99,14 +99,14 @@ static void print_dir(const unsigned char *sha1, const char *base,
fullpath = NULL;
}
html("<li>");
cgit_plain_link("../", NULL, NULL, ctx.qry.head, ctx.qry.sha1,
cgit_plain_link("../", NULL, NULL, ctx.qry.head, ctx.qry.oid,
fullpath);
html("</li>\n");
}
free(fullpath);
}
static void print_dir_entry(const unsigned char *sha1, const char *base,
static void print_dir_entry(const struct object_id *oid, const char *base,
int baselen, const char *path, unsigned mode)
{
char *fullpath;
@ -116,9 +116,9 @@ static void print_dir_entry(const unsigned char *sha1, const char *base,
fullpath[strlen(fullpath) - 1] = 0;
html(" <li>");
if (S_ISGITLINK(mode)) {
cgit_submodule_link(NULL, fullpath, sha1_to_hex(sha1));
cgit_submodule_link(NULL, fullpath, oid_to_hex(oid));
} else
cgit_plain_link(path, NULL, NULL, ctx.qry.head, ctx.qry.sha1,
cgit_plain_link(path, NULL, NULL, ctx.qry.head, ctx.qry.oid,
fullpath);
html("</li>\n");
free(fullpath);
@ -129,22 +129,22 @@ static void print_dir_tail(void)
html(" </ul>\n</body></html>\n");
}
static int walk_tree(const unsigned char *sha1, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *cbdata)
static int walk_tree(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, void *cbdata)
{
struct walk_tree_context *walk_tree_ctx = cbdata;
if (base->len == walk_tree_ctx->match_baselen) {
if (S_ISREG(mode)) {
if (print_object(sha1, pathname))
if (S_ISREG(mode) || S_ISLNK(mode)) {
if (print_object(oid, pathname))
walk_tree_ctx->match = 1;
} else if (S_ISDIR(mode)) {
print_dir(sha1, base->buf, base->len, pathname);
print_dir(oid, base->buf, base->len, pathname);
walk_tree_ctx->match = 2;
return READ_TREE_RECURSIVE;
}
} else if (base->len > walk_tree_ctx->match_baselen) {
print_dir_entry(sha1, base->buf, base->len, pathname, mode);
} else if (base->len < INT_MAX && (int)base->len > walk_tree_ctx->match_baselen) {
print_dir_entry(oid, base->buf, base->len, pathname, mode);
walk_tree_ctx->match = 2;
} else if (S_ISDIR(mode)) {
return READ_TREE_RECURSIVE;
@ -163,8 +163,8 @@ static int basedir_len(const char *path)
void cgit_print_plain(void)
{
const char *rev = ctx.qry.sha1;
unsigned char sha1[20];
const char *rev = ctx.qry.oid;
struct object_id oid;
struct commit *commit;
struct pathspec_item path_items = {
.match = ctx.qry.path,
@ -181,11 +181,11 @@ void cgit_print_plain(void)
if (!rev)
rev = ctx.qry.head;
if (get_sha1(rev, sha1)) {
if (get_oid(rev, &oid)) {
cgit_print_error_page(404, "Not found", "Not found");
return;
}
commit = lookup_commit_reference(sha1);
commit = lookup_commit_reference(the_repository, &oid);
if (!commit || parse_commit(commit)) {
cgit_print_error_page(404, "Not found", "Not found");
return;
@ -193,12 +193,13 @@ void cgit_print_plain(void)
if (!path_items.match) {
path_items.match = "";
walk_tree_ctx.match_baselen = -1;
print_dir(commit->tree->object.oid.hash, "", 0, "");
print_dir(get_commit_tree_oid(commit), "", 0, "");
walk_tree_ctx.match = 2;
}
else
walk_tree_ctx.match_baselen = basedir_len(path_items.match);
read_tree_recursive(commit->tree, "", 0, 0, &paths, walk_tree, &walk_tree_ctx);
read_tree(the_repository, repo_get_commit_tree(the_repository, commit),
&paths, walk_tree, &walk_tree_ctx);
if (!walk_tree_ctx.match)
cgit_print_error_page(404, "Not found", "Not found");
else if (walk_tree_ctx.match == 2)

@ -73,7 +73,7 @@ static int print_branch(struct refinfo *ref)
html_txt(info->author);
cgit_close_filter(ctx.repo->email_filter);
html("</td><td colspan='2'>");
cgit_print_age(info->commit->date, -1, NULL);
cgit_print_age(info->committer_date, info->committer_tz, -1);
} else {
html("</td><td></td><td>");
cgit_object_link(ref->object);
@ -90,40 +90,6 @@ static void print_tag_header(void)
"<th class='left' colspan='2'>Age</th></tr>\n");
}
static void print_tag_downloads(const struct cgit_repo *repo, const char *ref)
{
const struct cgit_snapshot_format* f;
struct strbuf filename = STRBUF_INIT;
const char *basename;
int free_ref = 0;
if (!ref || strlen(ref) < 1)
return;
basename = cgit_repobasename(repo->url);
if (!starts_with(ref, basename)) {
if ((ref[0] == 'v' || ref[0] == 'V') && isdigit(ref[1]))
ref++;
if (isdigit(ref[0])) {
ref = fmtalloc("%s-%s", basename, ref);
free_ref = 1;
}
}
for (f = cgit_snapshot_formats; f->suffix; f++) {
if (!(repo->snapshots & f->bit))
continue;
strbuf_reset(&filename);
strbuf_addf(&filename, "%s%s", ref, f->suffix);
cgit_snapshot_link(filename.buf, NULL, NULL, NULL, NULL, filename.buf);
html("&nbsp;&nbsp;");
}
if (free_ref)
free((char *)ref);
strbuf_release(&filename);
}
static int print_tag(struct refinfo *ref)
{
struct tag *tag = NULL;
@ -143,7 +109,7 @@ static int print_tag(struct refinfo *ref)
cgit_tag_link(name, NULL, NULL, name);
html("</td><td>");
if (ctx.repo->snapshots && (obj->type == OBJ_COMMIT))
print_tag_downloads(ctx.repo, name);
cgit_print_snapshot_links(ctx.repo, name, "&nbsp;&nbsp;");
else
cgit_object_link(obj);
html("</td><td>");
@ -161,16 +127,16 @@ static int print_tag(struct refinfo *ref)
html("</td><td colspan='2'>");
if (info) {
if (info->tagger_date > 0)
cgit_print_age(info->tagger_date, -1, NULL);
cgit_print_age(info->tagger_date, info->tagger_tz, -1);
} else if (ref->object->type == OBJ_COMMIT) {
cgit_print_age(ref->commit->commit->date, -1, NULL);
cgit_print_age(ref->commit->commit->date, 0, -1);
}
html("</td></tr>\n");
return 0;
}
static void print_refs_link(char *path)
static void print_refs_link(const char *path)
{
html("<tr class='nohover'><td colspan='5'>");
cgit_refs_link("[...]", NULL, NULL, ctx.qry.head, NULL, path);

@ -11,7 +11,7 @@
#include "html.h"
#include "ui-shared.h"
static time_t read_agefile(char *path)
static time_t read_agefile(const char *path)
{
time_t result;
size_t size;
@ -20,7 +20,7 @@ static time_t read_agefile(char *path)
if (readfile(path, &buf, &size)) {
free(buf);
return -1;
return 0;
}
if (parse_date(buf, &date_buf) == 0)
@ -79,7 +79,7 @@ static void print_modtime(struct cgit_repo *repo)
{
time_t t;
if (get_repo_modtime(repo, &t))
cgit_print_age(t, -1, NULL);
cgit_print_age(t, 0, -1);
}
static int is_match(struct cgit_repo *repo)
@ -184,27 +184,6 @@ static int cmp(const char *s1, const char *s2)
return 0;
}
static int sort_section(const void *a, const void *b)
{
const struct cgit_repo *r1 = a;
const struct cgit_repo *r2 = b;
int result;
time_t t;
result = cmp(r1->section, r2->section);
if (!result) {
if (!strcmp(ctx.cfg.repository_sort, "age")) {
// get_repo_modtime caches the value in r->mtime, so we don't
// have to worry about inefficiencies here.
if (get_repo_modtime(r1, &t) && get_repo_modtime(r2, &t))
result = r2->mtime - r1->mtime;
}
if (!result)
result = cmp(r1->name, r2->name);
}
return result;
}
static int sort_name(const void *a, const void *b)
{
const struct cgit_repo *r1 = a;
@ -241,6 +220,22 @@ static int sort_idle(const void *a, const void *b)
return t2 - t1;
}
static int sort_section(const void *a, const void *b)
{
const struct cgit_repo *r1 = a;
const struct cgit_repo *r2 = b;
int result;
result = cmp(r1->section, r2->section);
if (!result) {
if (!strcmp(ctx.cfg.repository_sort, "age"))
result = sort_idle(r1, r2);
if (!result)
result = cmp(r1->name, r2->name);
}
return result;
}
struct sortcolumn {
const char *name;
int (*fn)(const void *a, const void *b);
@ -275,6 +270,7 @@ void cgit_print_repolist(void)
int i, columns = 3, hits = 0, header = 0;
char *last_section = NULL;
char *section;
char *repourl;
int sorted = 0;
if (!any_repos_visible()) {
@ -292,9 +288,6 @@ void cgit_print_repolist(void)
cgit_print_docstart();
cgit_print_pageheader();
if (ctx.cfg.index_header)
html_include(ctx.cfg.index_header);
if (ctx.qry.sort)
sorted = sort_repolist(ctx.qry.sort);
else if (ctx.cfg.section_sort)
@ -320,7 +313,7 @@ void cgit_print_repolist(void)
(last_section != NULL && section == NULL) ||
(last_section != NULL && section != NULL &&
strcmp(section, last_section)))) {
htmlf("<tr class='nohover'><td colspan='%d' class='reposection'>",
htmlf("<tr class='nohover-highlight'><td colspan='%d' class='reposection'>",
columns);
html_txt(section);
html("</td></tr>");
@ -328,10 +321,13 @@ void cgit_print_repolist(void)
}
htmlf("<tr><td class='%s'>",
!sorted && section ? "sublevel-repo" : "toplevel-repo");
cgit_summary_link(ctx.repo->name, ctx.repo->name, NULL, NULL);
cgit_summary_link(ctx.repo->name, NULL, NULL, NULL);
html("</td><td>");
html_link_open(cgit_repourl(ctx.repo->url), NULL, NULL);
html_ntxt(ctx.cfg.max_repodesc_len, ctx.repo->desc);
repourl = cgit_repourl(ctx.repo->url);
html_link_open(repourl, NULL, NULL);
free(repourl);
if (html_ntxt(ctx.repo->desc, ctx.cfg.max_repodesc_len) < 0)
html("...");
html_link_close();
html("</td><td>");
if (ctx.cfg.enable_index_owner) {
@ -340,13 +336,15 @@ void cgit_print_repolist(void)
html_txt(ctx.repo->owner);
cgit_close_filter(ctx.repo->owner_filter);
} else {
char *currenturl = cgit_currenturl();
html("<a href='");
html_attr(cgit_currenturl());
html_attr(currenturl);
html("?q=");
html_url_arg(ctx.repo->owner);
html("'>");
html_txt(ctx.repo->owner);
html("</a>");
free(currenturl);
}
html("</td><td>");
}

@ -1,6 +1,6 @@
/* ui-shared.c: common web output functions
*
* Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
* Copyright (C) 2006-2017 cgit Development Team <cgit@lists.zx2c4.com>
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
@ -10,10 +10,10 @@
#include "ui-shared.h"
#include "cmd.h"
#include "html.h"
#include "version.h"
static const char cgit_doctype[] =
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
"<!DOCTYPE html>\n";
static char *http_date(time_t t)
{
@ -22,10 +22,11 @@ static char *http_date(time_t t)
static char month[][4] =
{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
struct tm *tm = gmtime(&t);
return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
tm->tm_mday, month[tm->tm_mon], 1900 + tm->tm_year,
tm->tm_hour, tm->tm_min, tm->tm_sec);
struct tm tm;
gmtime_r(&t, &tm);
return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm.tm_wday],
tm.tm_mday, month[tm.tm_mon], 1900 + tm.tm_year,
tm.tm_hour, tm.tm_min, tm.tm_sec);
}
void cgit_print_error(const char *fmt, ...)
@ -67,15 +68,49 @@ char *cgit_hosturl(void)
char *cgit_currenturl(void)
{
if (!ctx.qry.url)
return xstrdup(cgit_rooturl());
const char *root = cgit_rooturl();
size_t len = strlen(root);
if (len && root[len - 1] == '/')
if (!ctx.qry.url)
return xstrdup(root);
if (root[0] && root[strlen(root) - 1] == '/')
return fmtalloc("%s%s", root, ctx.qry.url);
return fmtalloc("%s/%s", root, ctx.qry.url);
}
char *cgit_currentfullurl(void)
{
const char *root = cgit_rooturl();
const char *orig_query = ctx.env.query_string ? ctx.env.query_string : "";
size_t len = strlen(orig_query);
char *query = xmalloc(len + 2), *start_url, *ret;
/* Remove all url=... parts from query string */
memcpy(query + 1, orig_query, len + 1);
query[0] = '?';
start_url = query;
while ((start_url = strstr(start_url, "url=")) != NULL) {
if (start_url[-1] == '?' || start_url[-1] == '&') {
const char *end_url = strchr(start_url, '&');
if (end_url)
memmove(start_url, end_url + 1, strlen(end_url));
else
start_url[0] = '\0';
} else
++start_url;
}
if (!query[1])
query[0] = '\0';
if (!ctx.qry.url)
ret = fmtalloc("%s%s", root, query);
else if (root[0] && root[strlen(root) - 1] == '/')
ret = fmtalloc("%s%s%s", root, ctx.qry.url, query);
else
ret = fmtalloc("%s/%s%s", root, ctx.qry.url, query);
free(query);
return ret;
}
const char *cgit_rooturl(void)
{
if (ctx.cfg.virtual_root)
@ -132,25 +167,38 @@ const char *cgit_repobasename(const char *reponame)
static char rvbuf[1024];
int p;
const char *rv;
strncpy(rvbuf, reponame, sizeof(rvbuf));
if (rvbuf[sizeof(rvbuf)-1])
size_t len;
len = strlcpy(rvbuf, reponame, sizeof(rvbuf));
if (len >= sizeof(rvbuf))
die("cgit_repobasename: truncated repository name '%s'", reponame);
p = strlen(rvbuf)-1;
p = len - 1;
/* strip trailing slashes */
while (p && rvbuf[p] == '/') rvbuf[p--] = 0;
while (p && rvbuf[p] == '/')
rvbuf[p--] = '\0';
/* strip trailing .git */
if (p >= 3 && starts_with(&rvbuf[p-3], ".git")) {
p -= 3; rvbuf[p--] = 0;
p -= 3;
rvbuf[p--] = '\0';
}
/* strip more trailing slashes if any */
while ( p && rvbuf[p] == '/') rvbuf[p--] = 0;
while (p && rvbuf[p] == '/')
rvbuf[p--] = '\0';
/* find last slash in the remaining string */
rv = strrchr(rvbuf,'/');
rv = strrchr(rvbuf, '/');
if (rv)
return ++rv;
return rvbuf;
}
const char *cgit_snapshot_prefix(const struct cgit_repo *repo)
{
if (repo->snapshot_prefix)
return repo->snapshot_prefix;
return cgit_repobasename(repo->url);
}
static void site_url(const char *page, const char *search, const char *sort, int ofs, int always_root)
{
char *delim = "?";
@ -254,7 +302,7 @@ static char *repolink(const char *title, const char *class, const char *page,
}
delim = "&amp;";
}
if (head && strcmp(head, ctx.repo->defbranch)) {
if (head && ctx.repo->defbranch && strcmp(head, ctx.repo->defbranch)) {
html(delim);
html("h=");
html_url_arg(head);
@ -304,6 +352,12 @@ void cgit_plain_link(const char *name, const char *title, const char *class,
reporevlink("plain", name, title, class, head, rev, path);
}
void cgit_blame_link(const char *name, const char *title, const char *class,
const char *head, const char *rev, const char *path)
{
reporevlink("blame", name, title, class, head, rev, path);
}
void cgit_log_link(const char *name, const char *title, const char *class,
const char *head, const char *rev, const char *path,
int ofs, const char *grep, const char *pattern, int showmsg,
@ -347,16 +401,9 @@ void cgit_log_link(const char *name, const char *title, const char *class,
html("</a>");
}
void cgit_commit_link(char *name, const char *title, const char *class,
void cgit_commit_link(const char *name, const char *title, const char *class,
const char *head, const char *rev, const char *path)
{
if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
name[ctx.cfg.max_msg_len] = '\0';
name[ctx.cfg.max_msg_len - 1] = '.';
name[ctx.cfg.max_msg_len - 2] = '.';
name[ctx.cfg.max_msg_len - 3] = '.';
}
char *delim;
delim = repolink(title, class, "commit", head, path);
@ -387,9 +434,13 @@ void cgit_commit_link(char *name, const char *title, const char *class,
html("follow=1");
}
html("'>");
if (name[0] != '\0')
html_txt(name);
else
if (name[0] != '\0') {
if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
html_ntxt(name, ctx.cfg.max_msg_len - 3);
html("...");
} else
html_txt(name);
} else
html_txt("(no commit message)");
html("</a>");
}
@ -471,41 +522,45 @@ static void cgit_self_link(char *name, const char *title, const char *class)
else if (!strcmp(ctx.qry.page, "summary"))
cgit_summary_link(name, title, class, ctx.qry.head);
else if (!strcmp(ctx.qry.page, "tag"))
cgit_tag_link(name, title, class, ctx.qry.has_sha1 ?
ctx.qry.sha1 : ctx.qry.head);
cgit_tag_link(name, title, class, ctx.qry.has_oid ?
ctx.qry.oid : ctx.qry.head);
else if (!strcmp(ctx.qry.page, "tree"))
cgit_tree_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "plain"))
cgit_plain_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "blame"))
cgit_blame_link(name, title, class, ctx.qry.head,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "log"))
cgit_log_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path, ctx.qry.ofs,
ctx.qry.grep, ctx.qry.search,
ctx.qry.showmsg, ctx.qry.follow);
else if (!strcmp(ctx.qry.page, "commit"))
cgit_commit_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "patch"))
cgit_patch_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "refs"))
cgit_refs_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "snapshot"))
cgit_snapshot_link(name, title, class, ctx.qry.head,
ctx.qry.has_sha1 ? ctx.qry.sha1 : NULL,
ctx.qry.has_oid ? ctx.qry.oid : NULL,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "diff"))
cgit_diff_link(name, title, class, ctx.qry.head,
ctx.qry.sha1, ctx.qry.sha2,
ctx.qry.oid, ctx.qry.oid2,
ctx.qry.path);
else if (!strcmp(ctx.qry.page, "stats"))
cgit_stats_link(name, title, class, ctx.qry.head,
@ -538,7 +593,7 @@ void cgit_object_link(struct object *obj)
page = "tag";
else
page = "blob";
name = fmt("%s %s...", typename(obj->type), shortrev);
name = fmt("%s %s...", type_name(obj->type), shortrev);
reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
}
@ -607,35 +662,23 @@ void cgit_submodule_link(const char *class, char *path, const char *rev)
path[len - 1] = tail;
}
static const char *fmt_date(time_t secs, const char *format, int local_time)
{
static char buf[64];
struct tm *time;
if (!secs)
return "";
if (local_time)
time = localtime(&secs);
else
time = gmtime(&secs);
strftime(buf, sizeof(buf)-1, format, time);
return buf;
}
void cgit_print_date(time_t secs, const char *format, int local_time)
const struct date_mode *cgit_date_mode(enum date_mode_type type)
{
html_txt(fmt_date(secs, format, local_time));
static struct date_mode mode;
mode.type = type;
mode.local = ctx.cfg.local_time;
return &mode;
}
static void print_rel_date(time_t t, double value,
static void print_rel_date(time_t t, int tz, double value,
const char *class, const char *suffix)
{
htmlf("<span class='%s' title='", class);
html_attr(fmt_date(t, FMT_LONGDATE, ctx.cfg.local_time));
htmlf("<span class='%s' data-ut='%" PRIu64 "' title='", class, (uint64_t)t);
html_attr(show_date(t, tz, cgit_date_mode(DATE_ISO8601)));
htmlf("'>%.0f %s</span>", value, suffix);
}
void cgit_print_age(time_t t, time_t max_relative, const char *format)
void cgit_print_age(time_t t, int tz, time_t max_relative)
{
time_t now, secs;
@ -648,34 +691,34 @@ void cgit_print_age(time_t t, time_t max_relative, const char *format)
if (secs > max_relative && max_relative >= 0) {
html("<span title='");
html_attr(fmt_date(t, FMT_LONGDATE, ctx.cfg.local_time));
html_attr(show_date(t, tz, cgit_date_mode(DATE_ISO8601)));
html("'>");
cgit_print_date(t, format, ctx.cfg.local_time);
html_txt(show_date(t, tz, cgit_date_mode(DATE_SHORT)));
html("</span>");
return;
}
if (secs < TM_HOUR * 2) {
print_rel_date(t, secs * 1.0 / TM_MIN, "age-mins", "min.");
print_rel_date(t, tz, secs * 1.0 / TM_MIN, "age-mins", "min.");
return;
}
if (secs < TM_DAY * 2) {
print_rel_date(t, secs * 1.0 / TM_HOUR, "age-hours", "hours");
print_rel_date(t, tz, secs * 1.0 / TM_HOUR, "age-hours", "hours");
return;
}
if (secs < TM_WEEK * 2) {
print_rel_date(t, secs * 1.0 / TM_DAY, "age-days", "days");
print_rel_date(t, tz, secs * 1.0 / TM_DAY, "age-days", "days");
return;
}
if (secs < TM_MONTH * 2) {
print_rel_date(t, secs * 1.0 / TM_WEEK, "age-weeks", "weeks");
print_rel_date(t, tz, secs * 1.0 / TM_WEEK, "age-weeks", "weeks");
return;
}
if (secs < TM_YEAR * 2) {
print_rel_date(t, secs * 1.0 / TM_MONTH, "age-months", "months");
print_rel_date(t, tz, secs * 1.0 / TM_MONTH, "age-months", "months");
return;
}
print_rel_date(t, secs * 1.0 / TM_YEAR, "age-years", "years");
print_rel_date(t, tz, secs * 1.0 / TM_YEAR, "age-years", "years");
}
void cgit_print_http_headers(void)
@ -714,7 +757,6 @@ void cgit_redirect(const char *url, bool permanent)
html("Location: ");
html_url_path(url);
html("\n\n");
exit(0);
}
static void print_rel_vcs_link(const char *url)
@ -726,17 +768,50 @@ static void print_rel_vcs_link(const char *url)
html(" Git repository'/>\n");
}
static int emit_css_link(struct string_list_item *s, void *arg)
{
/* Do not emit anything if css= is specified. */
if (s && *s->string == '\0')
return 0;
html("<link rel='stylesheet' type='text/css' href='");
if (s)
html_attr(s->string);
else
html_attr((const char *)arg);
html("'/>\n");
return 0;
}
static int emit_js_link(struct string_list_item *s, void *arg)
{
/* Do not emit anything if js= is specified. */
if (s && *s->string == '\0')
return 0;
html("<script type='text/javascript' src='");
if (s)
html_attr(s->string);
else
html_attr((const char *)arg);
html("'></script>\n");
return 0;
}
void cgit_print_docstart(void)
{
char *host = cgit_hosturl();
if (ctx.cfg.embedded) {
if (ctx.cfg.header)
html_include(ctx.cfg.header);
return;
}
char *host = cgit_hosturl();
html(cgit_doctype);
html("<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' lang='en'>\n");
html("<html lang='en'>\n");
html("<head>\n");
html("<title>");
html_txt(ctx.page.title);
@ -744,9 +819,17 @@ void cgit_print_docstart(void)
htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version);
if (ctx.cfg.robots && *ctx.cfg.robots)
htmlf("<meta name='robots' content='%s'/>\n", ctx.cfg.robots);
html("<link rel='stylesheet' type='text/css' href='");
html_attr(ctx.cfg.css);
html("'/>\n");
if (ctx.cfg.css.items)
for_each_string_list(&ctx.cfg.css, emit_css_link, NULL);
else
emit_css_link(NULL, "/cgit.css");
if (ctx.cfg.js.items)
for_each_string_list(&ctx.cfg.js, emit_js_link, NULL);
else
emit_js_link(NULL, "/cgit.js");
if (ctx.cfg.favicon) {
html("<link rel='shortcut icon' href='");
html_attr(ctx.cfg.favicon);
@ -771,6 +854,8 @@ void cgit_print_docstart(void)
cgit_add_clone_urls(print_rel_vcs_link);
if (ctx.cfg.head_include)
html_include(ctx.cfg.head_include);
if (ctx.repo && ctx.repo->extra_head_content)
html(ctx.repo->extra_head_content);
html("</head>\n");
html("<body>\n");
if (ctx.cfg.header)
@ -790,9 +875,9 @@ void cgit_print_docend(void)
if (ctx.cfg.footer)
html_include(ctx.cfg.footer);
else {
htmlf("<div class='footer'>generated by <a href='http://git.zx2c4.com/cgit/about/'>cgit %s</a> at ",
cgit_version);
cgit_print_date(time(NULL), FMT_LONGDATE, ctx.cfg.local_time);
htmlf("<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit %s</a> "
"(<a href='https://git-scm.com/'>git %s</a>) at ", cgit_version, git_version_string);
html_txt(show_date(time(NULL), 0, cgit_date_mode(DATE_ISO8601)));
html("</div>\n");
}
html("</div> <!-- id=cgit -->\n");
@ -805,13 +890,11 @@ void cgit_print_error_page(int code, const char *msg, const char *fmt, ...)
ctx.page.expires = ctx.cfg.cache_dynamic_ttl;
ctx.page.status = code;
ctx.page.statusmsg = msg;
cgit_print_http_headers();
cgit_print_docstart();
cgit_print_pageheader();
cgit_print_layout_start();
va_start(ap, fmt);
cgit_vprint_error(fmt, ap);
va_end(ap);
cgit_print_docend();
cgit_print_layout_end();
}
void cgit_print_layout_start(void)
@ -876,10 +959,10 @@ void cgit_add_hidden_formfields(int incl_head, int incl_search,
strcmp(ctx.qry.head, ctx.repo->defbranch))
html_hidden("h", ctx.qry.head);
if (ctx.qry.sha1)
html_hidden("id", ctx.qry.sha1);
if (ctx.qry.sha2)
html_hidden("id2", ctx.qry.sha2);
if (ctx.qry.oid)
html_hidden("id", ctx.qry.oid);
if (ctx.qry.oid2)
html_hidden("id2", ctx.qry.oid2);
if (ctx.qry.showmsg)
html_hidden("showmsg", "1");
@ -903,12 +986,13 @@ static void cgit_print_path_crumbs(char *path)
{
char *old_path = ctx.qry.path;
char *p = path, *q, *end = path + strlen(path);
int levels = 0;
ctx.qry.path = NULL;
cgit_self_link("root", NULL, NULL);
ctx.qry.path = p = path;
while (p < end) {
if (!(q = strchr(p, '/')))
if (!(q = strchr(p, '/')) || levels > 15)
q = end;
*q = '\0';
html_txt("/");
@ -916,6 +1000,7 @@ static void cgit_print_path_crumbs(char *path)
if (q < end)
*q = '/';
p = q + 1;
++levels;
}
ctx.qry.path = old_path;
}
@ -950,17 +1035,17 @@ static void print_header(void)
if (ctx.repo) {
cgit_index_link("index", NULL, NULL, NULL, NULL, 0, 1);
html(" : ");
cgit_summary_link(ctx.repo->name, ctx.repo->name, NULL, NULL);
cgit_summary_link(ctx.repo->name, NULL, NULL, NULL);
if (ctx.env.authenticated) {
html("</td><td class='form'>");
html("<form method='get' action=''>\n");
html("<form method='get'>\n");
cgit_add_hidden_formfields(0, 1, ctx.qry.page);
html("<select name='h' onchange='this.form.submit();'>\n");
for_each_branch_ref(print_branch_option, ctx.qry.head);
if (ctx.repo->enable_remote_branches)
for_each_remote_ref(print_branch_option, ctx.qry.head);
html("</select> ");
html("<input type='submit' name='' value='switch'/>");
html("<input type='submit' value='switch'/>");
html("</form>");
}
} else
@ -971,12 +1056,16 @@ static void print_header(void)
if (ctx.repo) {
html_txt(ctx.repo->desc);
html("</td><td class='sub right'>");
html_txt(ctx.repo->owner);
if (ctx.repo->owner_filter) {
cgit_open_filter(ctx.repo->owner_filter);
html_txt(ctx.repo->owner);
cgit_close_filter(ctx.repo->owner_filter);
} else {
html_txt(ctx.repo->owner);
}
} else {
if (ctx.cfg.root_desc)
html_txt(ctx.cfg.root_desc);
else if (ctx.cfg.index_info)
html_include(ctx.cfg.index_info);
}
html("</td></tr></table>\n");
}
@ -996,19 +1085,28 @@ void cgit_print_pageheader(void)
cgit_summary_link("summary", NULL, hc("summary"),
ctx.qry.head);
cgit_refs_link("refs", NULL, hc("refs"), ctx.qry.head,
ctx.qry.sha1, NULL);
ctx.qry.oid, NULL);
cgit_log_link("log", NULL, hc("log"), ctx.qry.head,
NULL, ctx.qry.vpath, 0, NULL, NULL,
ctx.qry.showmsg, ctx.qry.follow);
cgit_tree_link("tree", NULL, hc("tree"), ctx.qry.head,
ctx.qry.sha1, ctx.qry.vpath);
if (ctx.qry.page && !strcmp(ctx.qry.page, "blame"))
cgit_blame_link("blame", NULL, hc("blame"), ctx.qry.head,
ctx.qry.oid, ctx.qry.vpath);
else
cgit_tree_link("tree", NULL, hc("tree"), ctx.qry.head,
ctx.qry.oid, ctx.qry.vpath);
cgit_commit_link("commit", NULL, hc("commit"),
ctx.qry.head, ctx.qry.sha1, ctx.qry.vpath);
ctx.qry.head, ctx.qry.oid, ctx.qry.vpath);
cgit_diff_link("diff", NULL, hc("diff"), ctx.qry.head,
ctx.qry.sha1, ctx.qry.sha2, ctx.qry.vpath);
ctx.qry.oid, ctx.qry.oid2, ctx.qry.vpath);
if (ctx.repo->max_stats)
cgit_stats_link("stats", NULL, hc("stats"),
ctx.qry.head, ctx.qry.vpath);
if (ctx.repo->homepage) {
html("<a href='");
html_attr(ctx.repo->homepage);
html("'>homepage</a>");
}
html("</td><td class='form'>");
html("<form class='right' method='get' action='");
if (ctx.cfg.virtual_root) {
@ -1025,7 +1123,7 @@ void cgit_print_pageheader(void)
html_option("committer", "committer", ctx.qry.grep);
html_option("range", "range", ctx.qry.grep);
html("</select>\n");
html("<input class='txt' type='text' size='10' name='q' value='");
html("<input class='txt' type='search' size='10' name='q' value='");
html_attr(ctx.qry.search);
html("'/>\n");
html("<input type='submit' value='search'/>\n");
@ -1040,7 +1138,7 @@ void cgit_print_pageheader(void)
html("<form method='get' action='");
html_attr(currenturl);
html("'>\n");
html("<input type='text' name='q' size='10' value='");
html("<input type='search' name='q' size='10' value='");
html_attr(ctx.qry.search);
html("'/>\n");
html("<input type='submit' value='search'/>\n");
@ -1048,7 +1146,7 @@ void cgit_print_pageheader(void)
free(currenturl);
}
html("</td></tr></table>\n");
if (ctx.env.authenticated && ctx.qry.vpath) {
if (ctx.env.authenticated && ctx.repo && ctx.qry.vpath) {
html("<div class='path'>");
html("path: ");
cgit_print_path_crumbs(ctx.qry.vpath);
@ -1080,27 +1178,80 @@ void cgit_print_filemode(unsigned short mode)
html_fileperm(mode);
}
void cgit_print_snapshot_links(const char *repo, const char *head,
const char *hex, int snapshots)
void cgit_compose_snapshot_prefix(struct strbuf *filename, const char *base,
const char *ref)
{
struct object_id oid;
/*
* Prettify snapshot names by stripping leading "v" or "V" if the tag
* name starts with {v,V}[0-9] and the prettify mapping is injective,
* i.e. each stripped tag can be inverted without ambiguities.
*/
if (get_oid(fmt("refs/tags/%s", ref), &oid) == 0 &&
(ref[0] == 'v' || ref[0] == 'V') && isdigit(ref[1]) &&
((get_oid(fmt("refs/tags/%s", ref + 1), &oid) == 0) +
(get_oid(fmt("refs/tags/v%s", ref + 1), &oid) == 0) +
(get_oid(fmt("refs/tags/V%s", ref + 1), &oid) == 0) == 1))
ref++;
strbuf_addf(filename, "%s-%s", base, ref);
}
void cgit_print_snapshot_links(const struct cgit_repo *repo, const char *ref,
const char *separator)
{
const struct cgit_snapshot_format* f;
const struct cgit_snapshot_format *f;
struct strbuf filename = STRBUF_INIT;
const char *basename;
size_t prefixlen;
unsigned char sha1[20];
if (get_sha1(fmt("refs/tags/%s", hex), sha1) == 0 &&
(hex[0] == 'v' || hex[0] == 'V') && isdigit(hex[1]))
hex++;
strbuf_addf(&filename, "%s-%s", cgit_repobasename(repo), hex);
basename = cgit_snapshot_prefix(repo);
if (starts_with(ref, basename))
strbuf_addstr(&filename, ref);
else
cgit_compose_snapshot_prefix(&filename, basename, ref);
prefixlen = filename.len;
for (f = cgit_snapshot_formats; f->suffix; f++) {
if (!(snapshots & f->bit))
if (!(repo->snapshots & cgit_snapshot_format_bit(f)))
continue;
strbuf_setlen(&filename, prefixlen);
strbuf_addstr(&filename, f->suffix);
cgit_snapshot_link(filename.buf, NULL, NULL, NULL, NULL,
filename.buf);
html("<br/>");
if (cgit_snapshot_get_sig(ref, f)) {
strbuf_addstr(&filename, ".asc");
html(" (");
cgit_snapshot_link("sig", NULL, NULL, NULL, NULL,
filename.buf);
html(")");
} else if (starts_with(f->suffix, ".tar") && cgit_snapshot_get_sig(ref, &cgit_snapshot_formats[0])) {
strbuf_setlen(&filename, strlen(filename.buf) - strlen(f->suffix));
strbuf_addstr(&filename, ".tar.asc");
html(" (");
cgit_snapshot_link("sig", NULL, NULL, NULL, NULL,
filename.buf);
html(")");
}
html(separator);
}
strbuf_release(&filename);
}
void cgit_set_title_from_path(const char *path)
{
struct strbuf sb = STRBUF_INIT;
const char *slash, *last_slash;
if (!path)
return;
for (last_slash = path + strlen(path); (slash = memrchr(path, '/', last_slash - path)) != NULL; last_slash = slash) {
strbuf_add(&sb, slash + 1, last_slash - slash - 1);
strbuf_addstr(&sb, " \xc2\xab ");
}
strbuf_add(&sb, path, last_slash - path);
strbuf_addf(&sb, " - %s", ctx.page.title);
ctx.page.title = strbuf_detach(&sb, NULL);
}

@ -5,6 +5,7 @@ extern const char *cgit_httpscheme(void);
extern char *cgit_hosturl(void);
extern const char *cgit_rooturl(void);
extern char *cgit_currenturl(void);
extern char *cgit_currentfullurl(void);
extern const char *cgit_loginurl(void);
extern char *cgit_repourl(const char *reponame);
extern char *cgit_fileurl(const char *reponame, const char *pagename,
@ -26,11 +27,14 @@ extern void cgit_tree_link(const char *name, const char *title,
extern void cgit_plain_link(const char *name, const char *title,
const char *class, const char *head,
const char *rev, const char *path);
extern void cgit_blame_link(const char *name, const char *title,
const char *class, const char *head,
const char *rev, const char *path);
extern void cgit_log_link(const char *name, const char *title,
const char *class, const char *head, const char *rev,
const char *path, int ofs, const char *grep,
const char *pattern, int showmsg, int follow);
extern void cgit_commit_link(char *name, const char *title,
extern void cgit_commit_link(const char *name, const char *title,
const char *class, const char *head,
const char *rev, const char *path);
extern void cgit_patch_link(const char *name, const char *title,
@ -61,8 +65,8 @@ __attribute__((format (printf,1,2)))
extern void cgit_print_error(const char *fmt, ...);
__attribute__((format (printf,1,0)))
extern void cgit_vprint_error(const char *fmt, va_list ap);
extern void cgit_print_date(time_t secs, const char *format, int local_time);
extern void cgit_print_age(time_t t, time_t max_relative, const char *format);
extern const struct date_mode *cgit_date_mode(enum date_mode_type type);
extern void cgit_print_age(time_t t, int tz, time_t max_relative);
extern void cgit_print_http_headers(void);
extern void cgit_redirect(const char *url, bool permanent);
extern void cgit_print_docstart(void);
@ -71,8 +75,13 @@ __attribute__((format (printf,3,4)))
extern void cgit_print_error_page(int code, const char *msg, const char *fmt, ...);
extern void cgit_print_pageheader(void);
extern void cgit_print_filemode(unsigned short mode);
extern void cgit_print_snapshot_links(const char *repo, const char *head,
const char *hex, int snapshots);
extern void cgit_compose_snapshot_prefix(struct strbuf *filename,
const char *base, const char *ref);
extern void cgit_print_snapshot_links(const struct cgit_repo *repo,
const char *ref, const char *separator);
extern const char *cgit_snapshot_prefix(const struct cgit_repo *repo);
extern void cgit_add_hidden_formfields(int incl_head, int incl_search,
const char *page);
extern void cgit_set_title_from_path(const char *path);
#endif /* UI_SHARED_H */

@ -13,32 +13,32 @@
static int write_archive_type(const char *format, const char *hex, const char *prefix)
{
struct argv_array argv = ARGV_ARRAY_INIT;
struct strvec argv = STRVEC_INIT;
const char **nargv;
int result;
argv_array_push(&argv, "snapshot");
argv_array_push(&argv, format);
strvec_push(&argv, "snapshot");
strvec_push(&argv, format);
if (prefix) {
struct strbuf buf = STRBUF_INIT;
strbuf_addstr(&buf, prefix);
strbuf_addch(&buf, '/');
argv_array_push(&argv, "--prefix");
argv_array_push(&argv, buf.buf);
strvec_push(&argv, "--prefix");
strvec_push(&argv, buf.buf);
strbuf_release(&buf);
}
argv_array_push(&argv, hex);
strvec_push(&argv, hex);
/*
* Now we need to copy the pointers to arguments into a new
* structure because write_archive will rearrange its arguments
* which may result in duplicated/missing entries causing leaks
* or double-frees in argv_array_clear.
* or double-frees in strvec_clear.
*/
nargv = xmalloc(sizeof(char *) * (argv.argc + 1));
/* argv_array guarantees a trailing NULL entry. */
memcpy(nargv, argv.argv, sizeof(char *) * (argv.argc + 1));
nargv = xmalloc(sizeof(char *) * (argv.nr + 1));
/* strvec guarantees a trailing NULL entry. */
memcpy(nargv, argv.v, sizeof(char *) * (argv.nr + 1));
result = write_archive(argv.argc, nargv, NULL, 1, NULL, 0);
argv_array_clear(&argv);
result = write_archive(argv.nr, nargv, NULL, the_repository, NULL, 0);
strvec_clear(&argv);
free(nargv);
return result;
}
@ -79,21 +79,61 @@ static int write_tar_bzip2_archive(const char *hex, const char *prefix)
return write_compressed_tar_archive(hex, prefix, argv);
}
static int write_tar_lzip_archive(const char *hex, const char *prefix)
{
char *argv[] = { "lzip", NULL };
return write_compressed_tar_archive(hex, prefix, argv);
}
static int write_tar_xz_archive(const char *hex, const char *prefix)
{
char *argv[] = { "xz", NULL };
return write_compressed_tar_archive(hex, prefix, argv);
}
static int write_tar_zstd_archive(const char *hex, const char *prefix)
{
char *argv[] = { "zstd", "-T0", NULL };
return write_compressed_tar_archive(hex, prefix, argv);
}
const struct cgit_snapshot_format cgit_snapshot_formats[] = {
{ ".zip", "application/x-zip", write_zip_archive, 0x01 },
{ ".tar.gz", "application/x-gzip", write_tar_gzip_archive, 0x02 },
{ ".tar.bz2", "application/x-bzip2", write_tar_bzip2_archive, 0x04 },
{ ".tar", "application/x-tar", write_tar_archive, 0x08 },
{ ".tar.xz", "application/x-xz", write_tar_xz_archive, 0x10 },
/* .tar must remain the 0 index */
{ ".tar", "application/x-tar", write_tar_archive },
{ ".tar.gz", "application/x-gzip", write_tar_gzip_archive },
{ ".tar.bz2", "application/x-bzip2", write_tar_bzip2_archive },
{ ".tar.lz", "application/x-lzip", write_tar_lzip_archive },
{ ".tar.xz", "application/x-xz", write_tar_xz_archive },
{ ".tar.zst", "application/x-zstd", write_tar_zstd_archive },
{ ".zip", "application/x-zip", write_zip_archive },
{ NULL }
};
static struct notes_tree snapshot_sig_notes[ARRAY_SIZE(cgit_snapshot_formats)];
const struct object_id *cgit_snapshot_get_sig(const char *ref,
const struct cgit_snapshot_format *f)
{
struct notes_tree *tree;
struct object_id oid;
if (get_oid(ref, &oid))
return NULL;
tree = &snapshot_sig_notes[f - &cgit_snapshot_formats[0]];
if (!tree->initialized) {
struct strbuf notes_ref = STRBUF_INIT;
strbuf_addf(&notes_ref, "refs/notes/signatures/%s",
f->suffix + 1);
init_notes(tree, notes_ref.buf, combine_notes_ignore, 0);
strbuf_release(&notes_ref);
}
return get_note(tree, &oid);
}
static const struct cgit_snapshot_format *get_format(const char *filename)
{
const struct cgit_snapshot_format *fmt;
@ -105,30 +145,69 @@ static const struct cgit_snapshot_format *get_format(const char *filename)
return NULL;
}
const unsigned cgit_snapshot_format_bit(const struct cgit_snapshot_format *f)
{
return BIT(f - &cgit_snapshot_formats[0]);
}
static int make_snapshot(const struct cgit_snapshot_format *format,
const char *hex, const char *prefix,
const char *filename)
{
unsigned char sha1[20];
struct object_id oid;
if (get_sha1(hex, sha1)) {
if (get_oid(hex, &oid)) {
cgit_print_error_page(404, "Not found",
"Bad object id: %s", hex);
return 1;
}
if (!lookup_commit_reference(sha1)) {
if (!lookup_commit_reference(the_repository, &oid)) {
cgit_print_error_page(400, "Bad request",
"Not a commit reference: %s", hex);
return 1;
}
ctx.page.etag = sha1_to_hex(sha1);
ctx.page.etag = oid_to_hex(&oid);
ctx.page.mimetype = xstrdup(format->mimetype);
ctx.page.filename = xstrdup(filename);
cgit_print_http_headers();
init_archivers();
format->write_func(hex, prefix);
return 0;
}
static int write_sig(const struct cgit_snapshot_format *format,
const char *hex, const char *archive,
const char *filename)
{
const struct object_id *note = cgit_snapshot_get_sig(hex, format);
enum object_type type;
unsigned long size;
char *buf;
if (!note) {
cgit_print_error_page(404, "Not found",
"No signature for %s", archive);
return 0;
}
buf = read_object_file(note, &type, &size);
if (!buf) {
cgit_print_error_page(404, "Not found", "Not found");
return 0;
}
html("X-Content-Type-Options: nosniff\n");
html("Content-Security-Policy: default-src 'none'\n");
ctx.page.etag = oid_to_hex(note);
ctx.page.mimetype = xstrdup("application/pgp-signature");
ctx.page.filename = xstrdup(filename);
cgit_print_http_headers();
html_raw(buf, size);
free(buf);
return 0;
}
/* Try to guess the requested revision from the requested snapshot name.
* First the format extension is stripped, e.g. "cgit-0.7.2.tar.gz" become
* "cgit-0.7.2". If this is a valid commit object name we've got a winner.
@ -139,21 +218,22 @@ static int make_snapshot(const struct cgit_snapshot_format *format,
* pending a 'v' or a 'V' to the remaining snapshot name ("0.7.2" ->
* "v0.7.2") gives us something valid.
*/
static const char *get_ref_from_filename(const char *url, const char *filename,
static const char *get_ref_from_filename(const struct cgit_repo *repo,
const char *filename,
const struct cgit_snapshot_format *format)
{
const char *reponame;
unsigned char sha1[20];
struct object_id oid;
struct strbuf snapshot = STRBUF_INIT;
int result = 1;
strbuf_addstr(&snapshot, filename);
strbuf_setlen(&snapshot, snapshot.len - strlen(format->suffix));
if (get_sha1(snapshot.buf, sha1) == 0)
if (get_oid(snapshot.buf, &oid) == 0)
goto out;
reponame = cgit_repobasename(url);
reponame = cgit_snapshot_prefix(repo);
if (starts_with(snapshot.buf, reponame)) {
const char *new_start = snapshot.buf;
new_start += strlen(reponame);
@ -162,15 +242,15 @@ static const char *get_ref_from_filename(const char *url, const char *filename,
strbuf_splice(&snapshot, 0, new_start - snapshot.buf, "", 0);
}
if (get_sha1(snapshot.buf, sha1) == 0)
if (get_oid(snapshot.buf, &oid) == 0)
goto out;
strbuf_insert(&snapshot, 0, "v", 1);
if (get_sha1(snapshot.buf, sha1) == 0)
if (get_oid(snapshot.buf, &oid) == 0)
goto out;
strbuf_splice(&snapshot, 0, 1, "V", 1);
if (get_sha1(snapshot.buf, sha1) == 0)
if (get_oid(snapshot.buf, &oid) == 0)
goto out;
result = 0;
@ -184,6 +264,8 @@ void cgit_print_snapshot(const char *head, const char *hex,
const char *filename, int dwim)
{
const struct cgit_snapshot_format* f;
const char *sig_filename = NULL;
char *adj_filename = NULL;
char *prefix = NULL;
if (!filename) {
@ -192,15 +274,24 @@ void cgit_print_snapshot(const char *head, const char *hex,
return;
}
if (ends_with(filename, ".asc")) {
sig_filename = filename;
/* Strip ".asc" from filename for common format processing */
adj_filename = xstrdup(filename);
adj_filename[strlen(adj_filename) - 4] = '\0';
filename = adj_filename;
}
f = get_format(filename);
if (!f) {
if (!f || (!sig_filename && !(ctx.repo->snapshots & cgit_snapshot_format_bit(f)))) {
cgit_print_error_page(400, "Bad request",
"Unsupported snapshot format: %s", filename);
return;
}
if (!hex && dwim) {
hex = get_ref_from_filename(ctx.repo->url, filename, f);
hex = get_ref_from_filename(ctx.repo, filename, f);
if (hex == NULL) {
cgit_print_error_page(404, "Not found", "Not found");
return;
@ -213,8 +304,13 @@ void cgit_print_snapshot(const char *head, const char *hex,
hex = head;
if (!prefix)
prefix = xstrdup(cgit_repobasename(ctx.repo->url));
prefix = xstrdup(cgit_snapshot_prefix(ctx.repo));
if (sig_filename)
write_sig(f, hex, filename, sig_filename);
else
make_snapshot(f, hex, prefix, filename);
make_snapshot(f, hex, prefix, filename);
free(prefix);
free(adj_filename);
}

@ -92,7 +92,7 @@ static char *longest_common_subsequence(char *A, char *B)
static int line_from_hunk(char *line, char type)
{
char *buf1, *buf2;
int len;
int len, res;
buf1 = strchr(line, type);
if (buf1 == NULL)
@ -103,9 +103,8 @@ static int line_from_hunk(char *line, char type)
return 0;
len = buf2 - buf1;
buf2 = xmalloc(len + 1);
strncpy(buf2, buf1, len);
buf2[len] = '\0';
int res = atoi(buf2);
strlcpy(buf2, buf1, len + 1);
res = atoi(buf2);
free(buf2);
return res;
}
@ -114,11 +113,11 @@ static char *replace_tabs(char *line)
{
char *prev_buf = line;
char *cur_buf;
int linelen = strlen(line);
size_t linelen = strlen(line);
int n_tabs = 0;
int i;
char *result;
char *spaces = " ";
size_t result_len;
if (linelen == 0) {
result = xmalloc(1);
@ -126,20 +125,26 @@ static char *replace_tabs(char *line)
return result;
}
for (i = 0; i < linelen; i++)
for (i = 0; i < linelen; i++) {
if (line[i] == '\t')
n_tabs += 1;
result = xmalloc(linelen + n_tabs * 8 + 1);
}
result_len = linelen + n_tabs * 8;
result = xmalloc(result_len + 1);
result[0] = '\0';
while (1) {
for (;;) {
cur_buf = strchr(prev_buf, '\t');
if (!cur_buf) {
strcat(result, prev_buf);
linelen = strlen(result);
strlcpy(&result[linelen], prev_buf, result_len - linelen + 1);
break;
} else {
strncat(result, prev_buf, cur_buf - prev_buf);
strncat(result, spaces, 8 - (strlen(result) % 8));
linelen = strlen(result);
strlcpy(&result[linelen], prev_buf, cur_buf - prev_buf + 1);
linelen = strlen(result);
memset(&result[linelen], ' ', 8 - (linelen % 8));
result[linelen + 8 - (linelen % 8)] = '\0';
}
prev_buf = cur_buf + 1;
}
@ -204,11 +209,13 @@ static void print_part_with_lcs(char *class, char *line, char *lcs)
}
} else if (line[i] == lcs[j]) {
same = 1;
htmlf("</span>");
html("</span>");
j += 1;
}
html_txt(c);
}
if (!same)
html("</span>");
}
static void print_ssdiff_line(char *class,
@ -229,11 +236,11 @@ static void print_ssdiff_line(char *class,
if (old_line_no > 0) {
struct diff_filespec *old_file = cgit_get_current_old_file();
char *lineno_str = fmt("n%d", old_line_no);
char *id_str = fmt("id=%s#%s", is_null_sha1(old_file->sha1)?"HEAD":sha1_to_hex(old_rev_sha1), lineno_str);
char *id_str = fmt("id=%s#%s", is_null_oid(&old_file->oid)?"HEAD":oid_to_hex(old_rev_oid), lineno_str);
char *fileurl = cgit_fileurl(ctx.repo->url, "tree", old_file->path, id_str);
html("<td class='lineno'><a href='");
html(fileurl);
htmlf("' id='%s'>%s</a>", lineno_str, lineno_str + 1);
htmlf("'>%s</a>", lineno_str + 1);
html("</td>");
htmlf("<td class='%s'>", class);
free(fileurl);
@ -252,11 +259,11 @@ static void print_ssdiff_line(char *class,
if (new_line_no > 0) {
struct diff_filespec *new_file = cgit_get_current_new_file();
char *lineno_str = fmt("n%d", new_line_no);
char *id_str = fmt("id=%s#%s", is_null_sha1(new_file->sha1)?"HEAD":sha1_to_hex(new_rev_sha1), lineno_str);
char *id_str = fmt("id=%s#%s", is_null_oid(&new_file->oid)?"HEAD":oid_to_hex(new_rev_oid), lineno_str);
char *fileurl = cgit_fileurl(ctx.repo->url, "tree", new_file->path, id_str);
html("<td class='lineno'><a href='");
html(fileurl);
htmlf("' id='%s'>%s</a>", lineno_str, lineno_str + 1);
htmlf("'>%s</a>", lineno_str + 1);
html("</td>");
htmlf("<td class='%s'>", class);
free(fileurl);
@ -402,7 +409,7 @@ void cgit_ssdiff_header_begin(void)
void cgit_ssdiff_header_end(void)
{
html("</td><tr>");
html("</td></tr>");
}
void cgit_ssdiff_footer(void)

@ -3,12 +3,6 @@
#include "html.h"
#include "ui-shared.h"
#ifdef NO_C99_FORMAT
#define SZ_FMT "%u"
#else
#define SZ_FMT "%zu"
#endif
struct authorstat {
long total;
struct string_list list;
@ -172,8 +166,9 @@ static void add_commit(struct string_list *authors, struct commit *commit,
struct authorstat *authorstat;
struct string_list *items;
char *tmp;
struct tm *date;
struct tm date;
time_t t;
uintptr_t *counter;
info = cgit_parse_commit(commit);
tmp = xstrdup(info->author);
@ -185,13 +180,15 @@ static void add_commit(struct string_list *authors, struct commit *commit,
authorstat = author->util;
items = &authorstat->list;
t = info->committer_date;
date = gmtime(&t);
period->trunc(date);
tmp = xstrdup(period->pretty(date));
gmtime_r(&t, &date);
period->trunc(&date);
tmp = xstrdup(period->pretty(&date));
item = string_list_insert(items, tmp);
if (item->util)
counter = (uintptr_t *)&item->util;
if (*counter)
free(tmp);
item->util++;
(*counter)++;
authorstat->total++;
cgit_free_commitinfo(info);
}
@ -218,15 +215,15 @@ static struct string_list collect_stats(const struct cgit_period *period)
int argc = 3;
time_t now;
long i;
struct tm *tm;
struct tm tm;
char tmp[11];
time(&now);
tm = gmtime(&now);
period->trunc(tm);
gmtime_r(&now, &tm);
period->trunc(&tm);
for (i = 1; i < period->count; i++)
period->dec(tm);
strftime(tmp, sizeof(tmp), "%Y-%m-%d", tm);
period->dec(&tm);
strftime(tmp, sizeof(tmp), "%Y-%m-%d", &tm);
argv[2] = xstrdup(fmt("--since=%s", tmp));
if (ctx.qry.path) {
argv[3] = "--";
@ -244,8 +241,7 @@ static struct string_list collect_stats(const struct cgit_period *period)
memset(&authors, 0, sizeof(authors));
while ((commit = get_revision(&rev)) != NULL) {
add_commit(&authors, commit, period);
free_commit_buffer(commit);
free_commit_list(commit->parents);
release_commit_memory(the_repository->parsed_objects, commit);
commit->parents = NULL;
}
return authors;
@ -264,21 +260,21 @@ static void print_combined_authorrow(struct string_list *authors, int from,
struct string_list_item *date;
time_t now;
long i, j, total, subtotal;
struct tm *tm;
struct tm tm;
char *tmp;
time(&now);
tm = gmtime(&now);
period->trunc(tm);
gmtime_r(&now, &tm);
period->trunc(&tm);
for (i = 1; i < period->count; i++)
period->dec(tm);
period->dec(&tm);
total = 0;
htmlf("<tr><td class='%s'>%s</td>", leftclass,
fmt(name, to - from + 1));
for (j = 0; j < period->count; j++) {
tmp = period->pretty(tm);
period->inc(tm);
tmp = period->pretty(&tm);
period->inc(&tm);
subtotal = 0;
for (i = from; i <= to; i++) {
author = &authors->items[i];
@ -286,7 +282,7 @@ static void print_combined_authorrow(struct string_list *authors, int from,
items = &authorstat->list;
date = string_list_lookup(items, tmp);
if (date)
subtotal += (size_t)date->util;
subtotal += (uintptr_t)date->util;
}
htmlf("<td class='%s'>%ld</td>", centerclass, subtotal);
total += subtotal;
@ -303,20 +299,20 @@ static void print_authors(struct string_list *authors, int top,
struct string_list_item *date;
time_t now;
long i, j, total;
struct tm *tm;
struct tm tm;
char *tmp;
time(&now);
tm = gmtime(&now);
period->trunc(tm);
gmtime_r(&now, &tm);
period->trunc(&tm);
for (i = 1; i < period->count; i++)
period->dec(tm);
period->dec(&tm);
html("<table class='stats'><tr><th>Author</th>");
for (j = 0; j < period->count; j++) {
tmp = period->pretty(tm);
tmp = period->pretty(&tm);
htmlf("<th>%s</th>", tmp);
period->inc(tm);
period->inc(&tm);
}
html("<th>Total</th></tr>\n");
@ -332,16 +328,16 @@ static void print_authors(struct string_list *authors, int top,
items = &authorstat->list;
total = 0;
for (j = 0; j < period->count; j++)
period->dec(tm);
period->dec(&tm);
for (j = 0; j < period->count; j++) {
tmp = period->pretty(tm);
period->inc(tm);
tmp = period->pretty(&tm);
period->inc(&tm);
date = string_list_lookup(items, tmp);
if (!date)
html("<td>0</td>");
else {
htmlf("<td>"SZ_FMT"</td>", (size_t)date->util);
total += (size_t)date->util;
htmlf("<td>%lu</td>", (uintptr_t)date->util);
total += (uintptr_t)date->util;
}
}
htmlf("<td class='sum'>%ld</td></tr>", total);
@ -392,7 +388,7 @@ void cgit_show_stats(void)
cgit_print_layout_start();
html("<div class='cgit-panel'>");
html("<b>stat options</b>");
html("<form method='get' action=''>");
html("<form method='get'>");
cgit_add_hidden_formfields(1, 0, "stats");
html("<table><tr><td colspan='2'/></tr>");
if (ctx.repo->max_stats > 1) {

@ -99,7 +99,7 @@ static char* append_readme_path(const char *filename, const char *ref, const cha
return full_path;
}
void cgit_print_repo_readme(char *path)
void cgit_print_repo_readme(const char *path)
{
char *filename, *ref, *mimetype;
int free_filename = 0;

@ -2,6 +2,6 @@
#define UI_SUMMARY_H
extern void cgit_print_summary(void);
extern void cgit_print_repo_readme(char *path);
extern void cgit_print_repo_readme(const char *path);
#endif /* UI_SUMMARY_H */

@ -33,37 +33,37 @@ static void print_tag_content(char *buf)
static void print_download_links(char *revname)
{
html("<tr><th>download</th><td class='sha1'>");
cgit_print_snapshot_links(ctx.qry.repo, ctx.qry.head,
revname, ctx.repo->snapshots);
html("<tr><th>download</th><td class='oid'>");
cgit_print_snapshot_links(ctx.repo, revname, "<br/>");
html("</td></tr>");
}
void cgit_print_tag(char *revname)
{
struct strbuf fullref = STRBUF_INIT;
unsigned char sha1[20];
struct object_id oid;
struct object *obj;
struct tag *tag;
struct taginfo *info;
if (!revname)
revname = ctx.qry.head;
strbuf_addf(&fullref, "refs/tags/%s", revname);
if (get_sha1(fullref.buf, sha1)) {
if (get_oid(fullref.buf, &oid)) {
cgit_print_error_page(404, "Not found",
"Bad tag reference: %s", revname);
goto cleanup;
}
obj = parse_object(sha1);
obj = parse_object(the_repository, &oid);
if (!obj) {
cgit_print_error_page(500, "Internal server error",
"Bad object id: %s", sha1_to_hex(sha1));
"Bad object id: %s", oid_to_hex(&oid));
goto cleanup;
}
if (obj->type == OBJ_TAG) {
tag = lookup_tag(sha1);
struct tag *tag;
struct taginfo *info;
tag = lookup_tag(the_repository, &oid);
if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) {
cgit_print_error_page(500, "Internal server error",
"Bad tag object: %s", revname);
@ -71,12 +71,13 @@ void cgit_print_tag(char *revname)
}
cgit_print_layout_start();
html("<table class='commit-info'>\n");
htmlf("<tr><td>tag name</td><td>");
html("<tr><td>tag name</td><td>");
html_txt(revname);
htmlf(" (%s)</td></tr>\n", sha1_to_hex(sha1));
htmlf(" (%s)</td></tr>\n", oid_to_hex(&oid));
if (info->tagger_date > 0) {
html("<tr><td>tag date</td><td>");
cgit_print_date(info->tagger_date, FMT_LONGDATE, ctx.cfg.local_time);
html_txt(show_date(info->tagger_date, info->tagger_tz,
cgit_date_mode(DATE_ISO8601)));
html("</td></tr>\n");
}
if (info->tagger) {
@ -90,7 +91,7 @@ void cgit_print_tag(char *revname)
cgit_close_filter(ctx.repo->email_filter);
html("</td></tr>\n");
}
html("<tr><td>tagged object</td><td class='sha1'>");
html("<tr><td>tagged object</td><td class='oid'>");
cgit_object_link(tag->tagged);
html("</td></tr>\n");
if (ctx.repo->snapshots)
@ -98,13 +99,14 @@ void cgit_print_tag(char *revname)
html("</table>\n");
print_tag_content(info->msg);
cgit_print_layout_end();
cgit_free_taginfo(info);
} else {
cgit_print_layout_start();
html("<table class='commit-info'>\n");
htmlf("<tr><td>tag name</td><td>");
html("<tr><td>tag name</td><td>");
html_txt(revname);
html("</td></tr>\n");
html("<tr><td>Tagged object</td><td class='sha1'>");
html("<tr><td>tagged object</td><td class='oid'>");
cgit_object_link(obj);
html("</td></tr>\n");
if (ctx.repo->snapshots)

@ -1,6 +1,6 @@
/* ui-tree.c: functions for tree output
*
* Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
* Copyright (C) 2006-2017 cgit Development Team <cgit@lists.zx2c4.com>
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
@ -84,30 +84,39 @@ static void print_binary_buffer(char *buf, unsigned long size)
html("</table>\n");
}
static void print_object(const unsigned char *sha1, char *path, const char *basename, const char *rev)
static void print_object(const struct object_id *oid, const char *path, const char *basename, const char *rev)
{
enum object_type type;
char *buf;
unsigned long size;
bool is_binary;
type = sha1_object_info(sha1, &size);
type = oid_object_info(the_repository, oid, &size);
if (type == OBJ_BAD) {
cgit_print_error_page(404, "Not found",
"Bad object name: %s", sha1_to_hex(sha1));
"Bad object name: %s", oid_to_hex(oid));
return;
}
buf = read_sha1_file(sha1, &type, &size);
buf = read_object_file(oid, &type, &size);
if (!buf) {
cgit_print_error_page(500, "Internal server error",
"Error reading object %s", sha1_to_hex(sha1));
"Error reading object %s", oid_to_hex(oid));
return;
}
is_binary = buffer_is_binary(buf, size);
cgit_set_title_from_path(path);
cgit_print_layout_start();
htmlf("blob: %s (", sha1_to_hex(sha1));
htmlf("blob: %s (", oid_to_hex(oid));
cgit_plain_link("plain", NULL, NULL, ctx.qry.head,
rev, path);
if (ctx.repo->enable_blame && !is_binary) {
html(") (");
cgit_blame_link("blame", NULL, NULL, ctx.qry.head,
rev, path);
}
html(")\n");
if (ctx.cfg.max_blob_size && size / 1024 > ctx.cfg.max_blob_size) {
@ -116,35 +125,102 @@ static void print_object(const unsigned char *sha1, char *path, const char *base
return;
}
if (buffer_is_binary(buf, size))
if (is_binary)
print_binary_buffer(buf, size);
else
print_text_buffer(basename, buf, size);
free(buf);
}
struct single_tree_ctx {
struct strbuf *path;
struct object_id oid;
char *name;
size_t count;
};
static int single_tree_cb(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, void *cbdata)
{
struct single_tree_ctx *ctx = cbdata;
if (++ctx->count > 1)
return -1;
if (!S_ISDIR(mode)) {
ctx->count = 2;
return -1;
}
ctx->name = xstrdup(pathname);
oidcpy(&ctx->oid, oid);
strbuf_addf(ctx->path, "/%s", pathname);
return 0;
}
static int ls_item(const unsigned char *sha1, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *cbdata)
static void write_tree_link(const struct object_id *oid, char *name,
char *rev, struct strbuf *fullpath)
{
size_t initial_length = fullpath->len;
struct tree *tree;
struct single_tree_ctx tree_ctx = {
.path = fullpath,
.count = 1,
};
struct pathspec paths = {
.nr = 0
};
oidcpy(&tree_ctx.oid, oid);
while (tree_ctx.count == 1) {
cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, rev,
fullpath->buf);
tree = lookup_tree(the_repository, &tree_ctx.oid);
if (!tree)
return;
free(tree_ctx.name);
tree_ctx.name = NULL;
tree_ctx.count = 0;
read_tree(the_repository, tree, &paths, single_tree_cb, &tree_ctx);
if (tree_ctx.count != 1)
break;
html(" / ");
name = tree_ctx.name;
}
strbuf_setlen(fullpath, initial_length);
}
static int ls_item(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, void *cbdata)
{
struct walk_tree_context *walk_tree_ctx = cbdata;
char *name;
struct strbuf fullpath = STRBUF_INIT;
struct strbuf linkpath = STRBUF_INIT;
struct strbuf class = STRBUF_INIT;
enum object_type type;
unsigned long size = 0;
char *buf;
name = xstrdup(pathname);
strbuf_addf(&fullpath, "%s%s%s", ctx.qry.path ? ctx.qry.path : "",
ctx.qry.path ? "/" : "", name);
if (!S_ISGITLINK(mode)) {
type = sha1_object_info(sha1, &size);
type = oid_object_info(the_repository, oid, &size);
if (type == OBJ_BAD) {
htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
name,
sha1_to_hex(sha1));
free(name);
return 0;
oid_to_hex(oid));
goto cleanup;
}
}
@ -152,10 +228,10 @@ static int ls_item(const unsigned char *sha1, struct strbuf *base,
cgit_print_filemode(mode);
html("</td><td>");
if (S_ISGITLINK(mode)) {
cgit_submodule_link("ls-mod", fullpath.buf, sha1_to_hex(sha1));
cgit_submodule_link("ls-mod", fullpath.buf, oid_to_hex(oid));
} else if (S_ISDIR(mode)) {
cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head,
walk_tree_ctx->curr_rev, fullpath.buf);
write_tree_link(oid, name, walk_tree_ctx->curr_rev,
&fullpath);
} else {
char *ext = strrchr(name, '.');
strbuf_addstr(&class, "ls-blob");
@ -164,6 +240,21 @@ static int ls_item(const unsigned char *sha1, struct strbuf *base,
cgit_tree_link(name, NULL, class.buf, ctx.qry.head,
walk_tree_ctx->curr_rev, fullpath.buf);
}
if (S_ISLNK(mode)) {
html(" -> ");
buf = read_object_file(oid, &type, &size);
if (!buf) {
htmlf("Error reading object: %s", oid_to_hex(oid));
goto cleanup;
}
strbuf_addbuf(&linkpath, &fullpath);
strbuf_addf(&linkpath, "/../%s", buf);
strbuf_normalize_path(&linkpath);
cgit_tree_link(buf, NULL, class.buf, ctx.qry.head,
walk_tree_ctx->curr_rev, linkpath.buf);
free(buf);
strbuf_release(&linkpath);
}
htmlf("</td><td class='ls-size'>%li</td>", size);
html("<td>");
@ -176,7 +267,12 @@ static int ls_item(const unsigned char *sha1, struct strbuf *base,
if (!S_ISGITLINK(mode))
cgit_plain_link("plain", NULL, "button", ctx.qry.head,
walk_tree_ctx->curr_rev, fullpath.buf);
if (!S_ISDIR(mode) && ctx.repo->enable_blame)
cgit_blame_link("blame", NULL, "button", ctx.qry.head,
walk_tree_ctx->curr_rev, fullpath.buf);
html("</td></tr>\n");
cleanup:
free(name);
strbuf_release(&fullpath);
strbuf_release(&class);
@ -201,49 +297,53 @@ static void ls_tail(void)
cgit_print_layout_end();
}
static void ls_tree(const unsigned char *sha1, char *path, struct walk_tree_context *walk_tree_ctx)
static void ls_tree(const struct object_id *oid, const char *path, struct walk_tree_context *walk_tree_ctx)
{
struct tree *tree;
struct pathspec paths = {
.nr = 0
};
tree = parse_tree_indirect(sha1);
tree = parse_tree_indirect(oid);
if (!tree) {
cgit_print_error_page(404, "Not found",
"Not a tree object: %s", sha1_to_hex(sha1));
"Not a tree object: %s", oid_to_hex(oid));
return;
}
ls_head();
read_tree_recursive(tree, "", 0, 1, &paths, ls_item, walk_tree_ctx);
read_tree(the_repository, tree, &paths, ls_item, walk_tree_ctx);
ls_tail();
}
static int walk_tree(const unsigned char *sha1, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *cbdata)
static int walk_tree(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, void *cbdata)
{
struct walk_tree_context *walk_tree_ctx = cbdata;
static char buffer[PATH_MAX];
if (walk_tree_ctx->state == 0) {
memcpy(buffer, base->buf, base->len);
strcpy(buffer + base->len, pathname);
if (strcmp(walk_tree_ctx->match_path, buffer))
struct strbuf buffer = STRBUF_INIT;
strbuf_addbuf(&buffer, base);
strbuf_addstr(&buffer, pathname);
if (strcmp(walk_tree_ctx->match_path, buffer.buf))
return READ_TREE_RECURSIVE;
if (S_ISDIR(mode)) {
walk_tree_ctx->state = 1;
cgit_set_title_from_path(buffer.buf);
strbuf_release(&buffer);
ls_head();
return READ_TREE_RECURSIVE;
} else {
walk_tree_ctx->state = 2;
print_object(sha1, buffer, pathname, walk_tree_ctx->curr_rev);
print_object(oid, buffer.buf, pathname, walk_tree_ctx->curr_rev);
strbuf_release(&buffer);
return 0;
}
}
ls_item(sha1, base, pathname, mode, stage, walk_tree_ctx);
ls_item(oid, base, pathname, mode, walk_tree_ctx);
return 0;
}
@ -254,7 +354,7 @@ static int walk_tree(const unsigned char *sha1, struct strbuf *base,
*/
void cgit_print_tree(const char *rev, char *path)
{
unsigned char sha1[20];
struct object_id oid;
struct commit *commit;
struct pathspec_item path_items = {
.match = path,
@ -272,12 +372,12 @@ void cgit_print_tree(const char *rev, char *path)
if (!rev)
rev = ctx.qry.head;
if (get_sha1(rev, sha1)) {
if (get_oid(rev, &oid)) {
cgit_print_error_page(404, "Not found",
"Invalid revision name: %s", rev);
return;
}
commit = lookup_commit_reference(sha1);
commit = lookup_commit_reference(the_repository, &oid);
if (!commit || parse_commit(commit)) {
cgit_print_error_page(404, "Not found",
"Invalid commit reference: %s", rev);
@ -287,11 +387,12 @@ void cgit_print_tree(const char *rev, char *path)
walk_tree_ctx.curr_rev = xstrdup(rev);
if (path == NULL) {
ls_tree(commit->tree->object.oid.hash, NULL, &walk_tree_ctx);
ls_tree(get_commit_tree_oid(commit), NULL, &walk_tree_ctx);
goto cleanup;
}
read_tree_recursive(commit->tree, "", 0, 0, &paths, walk_tree, &walk_tree_ctx);
read_tree(the_repository, repo_get_commit_tree(the_repository, commit),
&paths, walk_tree, &walk_tree_ctx);
if (walk_tree_ctx.state == 1)
ls_tail();
else if (walk_tree_ctx.state == 2)

Loading…
Cancel
Save