+cgit

+git

+ with:

+ submodules: true

+ - name: Build container artifacts

+ env:

+ ALPINE_IMAGE: docker.io/library/alpine:3.22.1@sha256:4bcff63911fcb4448bd4fdacec207030997caf25e9bea4045fa6c8c44de311d1

+ run: |

+ docker run --rm \

+ --volume "$PWD:/src" \

+ --workdir /src \

+ --env "HOST_UID=$(id -u)" \

+ --env "HOST_GID=$(id -g)" \

+ "$ALPINE_IMAGE" sh -euxc '

+ apk add --no-cache \

+ build-base=0.5-r3 \

+ cargo=1.87.0-r1 \

+ rust=1.87.0-r1 \

+ zlib-dev=1.3.2-r0

+ scripts/build-artifacts.sh "${{ matrix.arch }}"

+ chown -R "$HOST_UID:$HOST_GID" .container

+ '

+

+ - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0

+ with:

+ name: binary-${{ matrix.arch }}

+ path: .container/binary-${{ matrix.arch }}/

+ if-no-files-found: error

+

+ - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0

+ with:

+ name: binary-amd64

+ path: .container/binary-amd64

+ - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0

+ with:

+ pattern: binary-*

+ path: .container

+/.container

+# SPDX-FileCopyrightText: 2026 Nikolay Govorov

+# SPDX-License-Identifier: AGPL-3.0-or-later

+

+[submodule "git"]

+ path = git

+ url = https://git.kernel.org/pub/scm/git/git.git

+ARG TARGETARCH

+ org.opencontainers.image.description="Tiny Git server in a box" \

+COPY --chown=root:root --chmod=0755 \

+ .container/binary-${TARGETARCH}/gilti \

+ .container/binary-${TARGETARCH}/gilti-cgit \

+ .container/binary-${TARGETARCH}/gilti-ssh \

+ /usr/local/bin/

+COPY --chown=root:root \

+ .container/binary-${TARGETARCH}/cgit.css \

+ .container/binary-${TARGETARCH}/cgit.js \

+ .container/binary-${TARGETARCH}/cgit.png \

+ .container/binary-${TARGETARCH}/favicon.ico \

+ /usr/share/webapps/cgit/

+COPY --chown=root:root \

+ .container/binary-${TARGETARCH}/COPYING.cgit.txt \

+ .container/binary-${TARGETARCH}/COPYING.git.txt \

+ /usr/share/doc/gilti-cgit/

+COPY --chown=root:root --chmod=0755 scripts/entrypoint.sh /usr/local/bin/gilti-entrypoint

+RUN /usr/local/bin/gilti --check && \

+GNU GENERAL PUBLIC LICENSE

+Version 2, June 1991

+

+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

+

+The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free 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 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 price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

+

+To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.

+

+For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.

+

+We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.

+

+Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.

+

+Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any 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.

+

+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

+

+0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you".

+

+Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.

+

+1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.

+

+You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

+

+2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:

+

+ a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.

+

+ b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.

+

+ c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this 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 themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

+

+Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.

+

+In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.

+

+3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:

+

+ a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

+

+ b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

+

+ c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)

+

+The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

+

+If distribution of executable or object code is made by offering 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 void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

+

+5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.

+

+6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.

+

+7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

+

+If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

+

+It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot 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 may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.

+

+9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.

+

+Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.

+

+10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes 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

+

+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 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

+

+12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY 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

+

+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 free software which everyone can redistribute and change under these terms.

+

+To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.

+

+ one line to give the program's name and an idea of what it does. Copyright (C) yyyy name of author

+

+ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

+

+ This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Also add information on how to contact you by electronic and paper mail.

+

+If the program is interactive, make it output a short notice like this when it starts in an interactive mode:

+

+ Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.

+

+The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.

+

+You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:

+

+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.

+

+signature of Ty Coon, 1 April 1989 Ty Coon, President of Vice

+docker pull ghcr.io/dimidiumlabs/gilti:nightly

+ ghcr.io/dimidiumlabs/gilti:nightly

+Initialize the Git source used to build cgit, provision tools, and run static checks:

+git submodule update --init

+The CI matrix builds architecture-specific Alpine artifacts before assembling

+the image; the Dockerfile does not compile source code. Linux packages are

+intentionally not produced. Gilti's release artifacts are a multi-platform OCI

+image and an OCI Helm chart.

+

+[[annotations]]

+path = [

+ "cgit/cgit.png",

+ "cgit/favicon.ico",

+]

+SPDX-FileCopyrightText = "cgit Development Team <cgit@lists.zx2c4.com>"

+SPDX-License-Identifier = "GPL-2.0-only"

+ GNU GENERAL PUBLIC LICENSE

+ Version 2, June 1991

+

+ 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

+

+ The licenses for most software are designed to take away your

+freedom to share and change it. By contrast, the GNU General Public

+License is intended to guarantee your freedom to share and change free

+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 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

+price. Our General Public Licenses are designed to make sure that you

+have the freedom to distribute copies of free software (and charge for

+this service if you wish), that you receive source code or can get it

+if you want it, that you can change the software or use pieces of it

+in new free programs; and that you know you can do these things.

+

+ To protect your rights, we need to make restrictions that forbid

+anyone to deny you these rights or to ask you to surrender the rights.

+These restrictions translate to certain responsibilities for you if you

+distribute copies of the software, or if you modify it.

+

+ For example, if you distribute copies of such a program, whether

+gratis or for a fee, you must give the recipients all the rights that

+you have. You must make sure that they, too, receive or can get the

+source code. And you must show them these terms so they know their

+rights.

+

+ We protect your rights with two steps: (1) copyright the software, and

+(2) offer you this license which gives you legal permission to copy,

+distribute and/or modify the software.

+

+ Also, for each author's protection and ours, we want to make certain

+that everyone understands that there is no warranty for this free

+software. If the software is modified by someone else and passed on, we

+want its recipients to know that what they have is not the original, so

+that any problems introduced by others will not reflect on the original

+authors' reputations.

+

+ Finally, any free program is threatened constantly by software

+patents. We wish to avoid the danger that redistributors of a free

+program will individually obtain patent licenses, in effect making the

+program proprietary. To prevent this, we have made it clear that any

+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

+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

+

+ 0. This License applies to any program or other work which contains

+a notice placed by the copyright holder saying it may be distributed

+under the terms of this General Public License. The "Program", below,

+refers to any such program or work, and a "work based on the Program"

+means either the Program or any derivative work under copyright law:

+that is to say, a work containing the Program or a portion of it,

+either verbatim or with modifications and/or translated into another

+language. (Hereinafter, translation is included without limitation in

+the term "modification".) Each licensee is addressed as "you".

+

+Activities other than copying, distribution and modification are not

+covered by this License; they are outside its scope. The act of

+running the Program is not restricted, and the output from the Program

+is covered only if its contents constitute a work based on the

+Program (independent of having been made by running the Program).

+Whether that is true depends on what the Program does.

+

+ 1. You may copy and distribute verbatim copies of the Program's

+source code as you receive it, in any medium, provided that you

+conspicuously and appropriately publish on each copy an appropriate

+copyright notice and disclaimer of warranty; keep intact all the

+notices that refer to this License and to the absence of any warranty;

+and give any other recipients of the Program a copy of this License

+along with the Program.

+

+You may charge a fee for the physical act of transferring a copy, and

+you may at your option offer warranty protection in exchange for a fee.

+

+ 2. You may modify your copy or copies of the Program or any portion

+of it, thus forming a work based on the Program, and copy and

+distribute such modifications or work under the terms of Section 1

+above, provided that you also meet all of these conditions:

+

+ a) You must cause the modified files to carry prominent notices

+ stating that you changed the files and the date of any change.

+

+ b) You must cause any work that you distribute or publish, that in

+ whole or in part contains or is derived from the Program or any

+ part thereof, to be licensed as a whole at no charge to all third

+ parties under the terms of this License.

+

+ c) If the modified program normally reads commands interactively

+ when run, you must cause it, when started running for such

+ interactive use in the most ordinary way, to print or display an

+ announcement including an appropriate copyright notice and a

+ notice that there is no warranty (or else, saying that you provide

+ a warranty) and that users may redistribute the program under

+ these conditions, and telling the user how to view a copy of this

+ 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

+themselves, then this License, and its terms, do not apply to those

+sections when you distribute them as separate works. But when you

+distribute the same sections as part of a whole which is a work based

+on the Program, the distribution of the whole must be on the terms of

+this License, whose permissions for other licensees extend to the

+entire whole, and thus to each and every part regardless of who wrote it.

+

+Thus, it is not the intent of this section to claim rights or contest

+your rights to work written entirely by you; rather, the intent is to

+exercise the right to control the distribution of derivative or

+collective works based on the Program.

+

+In addition, mere aggregation of another work not based on the Program

+with the Program (or with a work based on the Program) on a volume of

+a storage or distribution medium does not bring the other work under

+the scope of this License.

+

+ 3. You may copy and distribute the Program (or a work based on it,

+under Section 2) in object code or executable form under the terms of

+Sections 1 and 2 above provided that you also do one of the following:

+

+ a) Accompany it with the complete corresponding machine-readable

+ source code, which must be distributed under the terms of Sections

+ 1 and 2 above on a medium customarily used for software interchange; or,

+

+ b) Accompany it with a written offer, valid for at least three

+ years, to give any third party, for a charge no more than your

+ cost of physically performing source distribution, a complete

+ machine-readable copy of the corresponding source code, to be

+ distributed under the terms of Sections 1 and 2 above on a medium

+ customarily used for software interchange; or,

+

+ c) Accompany it with the information you received as to the offer

+ to distribute corresponding source code. (This alternative is

+ allowed only for noncommercial distribution and only if you

+ received the program in object code or executable form with such

+ an offer, in accord with Subsection b above.)

+

+The source code for a work means the preferred form of the work for

+making modifications to it. For an executable work, complete source

+code means all the source code for all modules it contains, plus any

+associated interface definition files, plus the scripts used to

+control compilation and installation of the executable. However, as a

+special exception, the source code distributed need not include

+anything that is normally distributed (in either source or binary

+form) with the major components (compiler, kernel, and so on) of the

+operating system on which the executable runs, unless that component

+itself accompanies the executable.

+

+If distribution of executable or object code is made by offering

+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

+void, and will automatically terminate your rights under this License.

+However, parties who have received copies, or rights, from you under

+this License will not have their licenses terminated so long as such

+parties remain in full compliance.

+

+ 5. You are not required to accept this License, since you have not

+signed it. However, nothing else grants you permission to modify or

+distribute the Program or its derivative works. These actions are

+prohibited by law if you do not accept this License. Therefore, by

+modifying or distributing the Program (or any work based on the

+Program), you indicate your acceptance of this License to do so, and

+all its terms and conditions for copying, distributing or modifying

+the Program or works based on it.

+

+ 6. Each time you redistribute the Program (or any work based on the

+Program), the recipient automatically receives a license from the

+original licensor to copy, distribute or modify the Program subject to

+these terms and conditions. You may not impose any further

+restrictions on the recipients' exercise of the rights granted herein.

+You are not responsible for enforcing compliance by third parties to

+this License.

+

+ 7. If, as a consequence of a court judgment or allegation of patent

+infringement or for any other reason (not limited to patent issues),

+conditions are imposed on you (whether by court order, agreement or

+otherwise) that contradict the conditions of this License, they do not

+excuse you from the conditions of this License. If you cannot

+distribute so as to satisfy simultaneously your obligations under this

+License and any other pertinent obligations, then as a consequence you

+may not distribute the Program at all. For example, if a patent

+license would not permit royalty-free redistribution of the Program by

+all those who receive copies directly or indirectly through you, then

+the only way you could satisfy both it and this License would be to

+refrain entirely from distribution of the Program.

+

+If any portion of this section is held invalid or unenforceable under

+any particular circumstance, the balance of the section is intended to

+apply and the section as a whole is intended to apply in other

+circumstances.

+

+It is not the purpose of this section to induce you to infringe any

+patents or other property right claims or to contest validity of any

+such claims; this section has the sole purpose of protecting the

+integrity of the free software distribution system, which is

+implemented by public license practices. Many people have made

+generous contributions to the wide range of software distributed

+through that system in reliance on consistent application of that

+system; it is up to the author/donor to decide if he or she is willing

+to distribute software through any other system and a licensee cannot

+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

+may add an explicit geographical distribution limitation excluding

+those countries, so that distribution is permitted only in or among

+countries not thus excluded. In such case, this License incorporates

+the limitation as if written in the body of this License.

+

+ 9. The Free Software Foundation may publish revised and/or new versions

+of the General Public License from time to time. Such new versions will

+be similar in spirit to the present version, but may differ in detail to

+address new problems or concerns.

+

+Each version is given a distinguishing version number. If the Program

+specifies a version number of this License which applies to it and "any

+later version", you have the option of following the terms and conditions

+either of that version or of any later version published by the Free

+Software Foundation. If the Program does not specify a version number of

+this License, you may choose any version ever published by the Free Software

+Foundation.

+

+ 10. If you wish to incorporate parts of the Program into other free

+programs whose distribution conditions are different, write to the author

+to ask for permission. For software which is copyrighted by the Free

+Software Foundation, write to the Free Software Foundation; we sometimes

+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

+

+ 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

+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES

+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED

+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS

+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE

+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,

+REPAIR OR CORRECTION.

+

+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR

+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,

+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING

+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED

+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY

+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

+

+ 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

+free software which everyone can redistribute and change under these terms.

+

+ To do so, attach the following notices to the program. It is safest

+to attach them to the start of each source file to most effectively

+convey the exclusion of warranty; and each file should have at least

+the "copyright" line and a pointer to where the full notice is found.

+

+ <one line to give the program's name and a brief idea of what it does.>

+ Copyright (C) <year> <name of author>

+

+ This program is free software; you can redistribute it and/or modify

+ it under the terms of the GNU General Public License as published by

+ the Free Software Foundation; either version 2 of the License, or

+ (at your option) any later version.

+

+ This program is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ 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.,

+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+

+Also add information on how to contact you by electronic and paper mail.

+

+If the program is interactive, make it output a short notice like this

+when it starts in an interactive mode:

+

+ Gnomovision version 69, Copyright (C) year name of author

+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.

+ This is free software, and you are welcome to redistribute it

+ under certain conditions; type `show c' for details.

+

+The hypothetical commands `show w' and `show c' should show the appropriate

+parts of the General Public License. Of course, the commands you use may

+be called something other than `show w' and `show c'; they could even be

+mouse-clicks or menu items--whatever suits your program.

+

+You should also get your employer (if you work as a programmer) or your

+school, if any, to sign a "copyright disclaimer" for the program, if

+necessary. Here is a sample; alter the names:

+

+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program

+ `Gnomovision' (which makes passes at compilers) written by James Hacker.

+

+ <signature of Ty Coon>, 1 April 1989

+ Ty Coon, President of Vice

+

+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 Lesser General

+Public License instead of this License.

+# SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+# SPDX-FileCopyrightText: 2026 Nikolay Govorov

+# SPDX-License-Identifier: GPL-2.0-only

+

+# Run from Git's source directory so cgit can reuse Git's build variables,

+# compatibility layer, and static libraries.

+include Makefile

+

+CGIT_PREFIX = ../

+CGIT_VERSION = v1.3.1

+CGIT_SCRIPT_NAME = gilti-cgit

+CGIT_CONFIG = /etc/cgitrc

+CACHE_ROOT = /var/cache/cgit

+

+CGIT_CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'

+CGIT_CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'

+CGIT_CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"'

+CGIT_CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"'

+CGIT_CFLAGS += -DNO_LUA

+

+ifeq ($(uname_S),Linux)

+ CGIT_CFLAGS += -DHAVE_LINUX_SENDFILE

+ CGIT_LIBS += -ldl

+endif

+

+CGIT_OBJS := $(patsubst %.c,%.o,$(wildcard $(CGIT_PREFIX)*.c))

+cgit_dep_files := $(foreach f,$(CGIT_OBJS),$(dir $(f)).depend/$(notdir $(f)).d)

+-include $(wildcard $(cgit_dep_files))

+

+$(CGIT_PREFIX).depend:

+ @mkdir -p $@

+

+$(CGIT_OBJS): %.o: %.c GIT-CFLAGS $(CGIT_PREFIX)Makefile | $(CGIT_PREFIX).depend

+ $(QUIET_CC)$(CC) -o $*.o -c $(dep_args) $(ALL_CFLAGS) $(EXTRA_CPPFLAGS) $(CGIT_CFLAGS) $<

+

+$(CGIT_PREFIX)cgit: $(CGIT_OBJS) GIT-LDFLAGS $(GITLIBS)

+ $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS) $(CGIT_LIBS)

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* cache.c: cache management

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ *

+ *

+ * The cache is just a directory structure where each file is a cache slot,

+ * and each filename is based on the hash of some key (e.g. the cgit url).

+ * Each file contains the full key followed by the cached content for that

+ * key.

+ *

+ */

+

+#include "cgit.h"

+#include "cache.h"

+#include "html.h"

+#ifdef HAVE_LINUX_SENDFILE

+#include <sys/sendfile.h>

+#endif

+

+#define CACHE_BUFSIZE (1024 * 4)

+

+struct cache_slot {

+ const char *key;

+ 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;

+ struct stat cache_st;

+ int bufsize;

+ char buf[CACHE_BUFSIZE];

+};

+

+/* Open an existing cache slot and fill the cache buffer with

+ * (part of) the content of the cache file. Return 0 on success

+ * and errno otherwise.

+ */

+static int open_slot(struct cache_slot *slot)

+{

+ char *bufz;

+ ssize_t bufkeylen = -1;

+

+ slot->cache_fd = open(slot->cache_name, O_RDONLY);

+ if (slot->cache_fd == -1)

+ return errno;

+

+ if (fstat(slot->cache_fd, &slot->cache_st))

+ return errno;

+

+ slot->bufsize = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));

+ if (slot->bufsize < 0)

+ return errno;

+

+ bufz = memchr(slot->buf, 0, slot->bufsize);

+ if (bufz)

+ bufkeylen = bufz - slot->buf;

+

+ if (slot->key)

+ slot->match = bufkeylen == slot->keylen &&

+ !memcmp(slot->key, slot->buf, bufkeylen + 1);

+

+ return 0;

+}

+

+/* Close the active cache slot */

+static int close_slot(struct cache_slot *slot)

+{

+ int err = 0;

+ if (slot->cache_fd > 0) {

+ if (close(slot->cache_fd))

+ err = errno;

+ else

+ slot->cache_fd = -1;

+ }

+ return err;

+}

+

+/* 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 size;

+#endif

+

+ off = slot->keylen + 1;

+

+#ifdef HAVE_LINUX_SENDFILE

+ size = slot->cache_st.st_size;

+

+ do {

+ 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;

+ }

+ if (off == size)

+ return 0;

+ } while (1);

+#endif

+

+ if (lseek(slot->cache_fd, off, SEEK_SET) != off)

+ return errno;

+

+ do {

+ 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 */

+static int is_expired(struct cache_slot *slot)

+{

+ if (slot->ttl < 0)

+ return 0;

+ else

+ return slot->cache_st.st_mtime + slot->ttl * 60 < time(NULL);

+}

+

+/* Check if the slot has been modified since we opened it.

+ * NB: If stat() fails, we pretend the file is modified.

+ */

+static int is_modified(struct cache_slot *slot)

+{

+ struct stat st;

+

+ if (stat(slot->cache_name, &st))

+ return 1;

+ return (st.st_ino != slot->cache_st.st_ino ||

+ st.st_mtime != slot->cache_st.st_mtime ||

+ st.st_size != slot->cache_st.st_size);

+}

+

+/* Close an open lockfile */

+static int close_lock(struct cache_slot *slot)

+{

+ int err = 0;

+ if (slot->lock_fd > 0) {

+ if (close(slot->lock_fd))

+ err = errno;

+ else

+ slot->lock_fd = -1;

+ }

+ return err;

+}

+

+/* Create a lockfile used to store the generated content for a cache

+ * slot, and write the slot key + \0 into it.

+ * Returns 0 on success and errno otherwise.

+ */

+static int lock_slot(struct cache_slot *slot)

+{

+ struct flock lock = {

+ .l_type = F_WRLCK,

+ .l_whence = SEEK_SET,

+ .l_start = 0,

+ .l_len = 0,

+ };

+

+ slot->lock_fd = open(slot->lock_name, O_RDWR | O_CREAT,

+ S_IRUSR | S_IWUSR);

+ if (slot->lock_fd == -1)

+ return errno;

+ if (fcntl(slot->lock_fd, F_SETLK, &lock) < 0) {

+ int saved_errno = errno;

+ close(slot->lock_fd);

+ slot->lock_fd = -1;

+ return saved_errno;

+ }

+ if (ftruncate(slot->lock_fd, 0) < 0)

+ return errno;

+ if (xwrite(slot->lock_fd, slot->key, slot->keylen + 1) < 0)

+ return errno;

+ return 0;

+}

+

+/* Release the current lockfile. If `replace_old_slot` is set the

+ * lockfile replaces the old cache slot, otherwise the lockfile is

+ * just deleted.

+ */

+static int unlock_slot(struct cache_slot *slot, int replace_old_slot)

+{

+ int err;

+

+ if (replace_old_slot)

+ err = rename(slot->lock_name, slot->cache_name);

+ 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;

+

+ return 0;

+}

+

+/* Generate the content for the current cache slot by redirecting

+ * stdout to the lock-fd and invoking the callback function

+ */

+static int fill_slot(struct cache_slot *slot)

+{

+ /* Preserve stdout */

+ 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)

+ return errno;

+

+ /* Generate cache content */

+ slot->fn();

+

+ /* Make sure any buffered data is flushed to the file */

+ if (fflush(stdout))

+ return errno;

+

+ /* update stat info */

+ if (fstat(slot->lock_fd, &slot->cache_st))

+ return errno;

+

+ return 0;

+}

+

+/* Crude implementation of 32-bit FNV-1 hash algorithm,

+ * see http://www.isthe.com/chongo/tech/comp/fnv/ for details

+ * about the magic numbers.

+ */

+#define FNV_OFFSET 0x811c9dc5

+#define FNV_PRIME 0x01000193

+

+unsigned long hash_str(const char *str)

+{

+ unsigned long h = FNV_OFFSET;

+ unsigned char *s = (unsigned char *)str;

+

+ if (!s)

+ return h;

+

+ while (*s) {

+ h *= FNV_PRIME;

+ h ^= *s++;

+ }

+ return h;

+}

+

+static int process_slot(struct cache_slot *slot)

+{

+ int err;

+

+ err = open_slot(slot);

+ if (!err && slot->match) {

+ if (is_expired(slot)) {

+ if (!lock_slot(slot)) {

+ /* If the cachefile has been replaced between

+ * `open_slot` and `lock_slot`, we'll just

+ * serve the stale content from the original

+ * cachefile. This way we avoid pruning the

+ * newly generated slot. The same code-path

+ * is chosen if fill_slot() fails for some

+ * reason.

+ *

+ * TODO? check if the new slot contains the

+ * same key as the old one, since we would

+ * prefer to serve the newest content.

+ * This will require us to open yet another

+ * file-descriptor and read and compare the

+ * key from the new file, so for now we're

+ * lazy and just ignore the new file.

+ */

+ if (is_modified(slot) || fill_slot(slot)) {

+ unlock_slot(slot, 0);

+ close_lock(slot);

+ } else {

+ close_slot(slot);

+ unlock_slot(slot, 1);

+ slot->cache_fd = slot->lock_fd;

+ }

+ }

+ }

+ if ((err = print_slot(slot)) != 0) {

+ cache_log("[cgit] error printing cache %s: %s (%d)\n",

+ slot->cache_name,

+ strerror(err),

+ err);

+ }

+ close_slot(slot);

+ return err;

+ }

+

+ /* 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 believe

+ * everything worked out (but print a warning on stdout).

+ */

+

+ close_slot(slot);

+ if ((err = lock_slot(slot)) != 0) {

+ cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",

+ slot->lock_name, strerror(err), err);

+ slot->fn();

+ return 0;

+ }

+

+ if ((err = fill_slot(slot)) != 0) {

+ cache_log("[cgit] Unable to fill slot %s: %s (%d)\n",

+ slot->lock_name, strerror(err), err);

+ unlock_slot(slot, 0);

+ close_lock(slot);

+ slot->fn();

+ return 0;

+ }

+ // We've got a valid cache slot in the lock file, which

+ // is about to replace the old cache slot. But if we

+ // release the lockfile and then try to open the new cache

+ // slot, we might get a race condition with a concurrent

+ // writer for the same cache slot (with a different key).

+ // Lets avoid such a race by just printing the content of

+ // the lock file.

+ slot->cache_fd = slot->lock_fd;

+ unlock_slot(slot, 1);

+ if ((err = print_slot(slot)) != 0) {

+ cache_log("[cgit] error printing cache %s: %s (%d)\n",

+ slot->cache_name,

+ strerror(err),

+ err);

+ }

+ close_slot(slot);

+ return err;

+}

+

+/* Print cached content to stdout, generate the content if necessary. */

+int cache_process(int size, const char *path, const char *key, int ttl,

+ cache_fill_fn fn)

+{

+ unsigned long hash;

+ int i;

+ struct strbuf filename = STRBUF_INIT;

+ struct strbuf lockname = STRBUF_INIT;

+ struct cache_slot slot;

+ int result;

+

+ /* If the cache is disabled, just generate the content */

+ if (size <= 0 || ttl == 0) {

+ fn();

+ return 0;

+ }

+

+ /* Verify input, calculate filenames */

+ if (!path) {

+ cache_log("[cgit] Cache path not specified, caching is disabled\n");

+ fn();

+ return 0;

+ }

+ if (!key)

+ key = "";

+ hash = hash_str(key) % size;

+ strbuf_addstr(&filename, path);

+ strbuf_ensure_end(&filename, '/');

+ for (i = 0; i < 8; i++) {

+ strbuf_addf(&filename, "%x", (unsigned char)(hash & 0xf));

+ hash >>= 4;

+ }

+ strbuf_addbuf(&lockname, &filename);

+ 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;

+ slot.keylen = strlen(key);

+ result = process_slot(&slot);

+

+ strbuf_release(&filename);

+ strbuf_release(&lockname);

+ return result;

+}

+

+/* Return a strftime formatted date/time

+ * NB: the result from this function is to shared memory

+ */

+static char *sprintftime(const char *format, time_t time)

+{

+ static char buf[64];

+ struct tm tm;

+

+ if (!time)

+ return NULL;

+ gmtime_r(&time, &tm);

+ strftime(buf, sizeof(buf)-1, format, &tm);

+ return buf;

+}

+

+int cache_ls(const char *path)

+{

+ DIR *dir;

+ struct dirent *ent;

+ int err = 0;

+ struct cache_slot slot = { NULL };

+ struct strbuf fullname = STRBUF_INIT;

+ size_t prefixlen;

+

+ if (!path) {

+ cache_log("[cgit] cache path not specified\n");

+ return -1;

+ }

+ dir = opendir(path);

+ if (!dir) {

+ err = errno;

+ cache_log("[cgit] unable to open path %s: %s (%d)\n",

+ path, strerror(err), err);

+ return err;

+ }

+ strbuf_addstr(&fullname, path);

+ strbuf_ensure_end(&fullname, '/');

+ prefixlen = fullname.len;

+ while ((ent = readdir(dir)) != NULL) {

+ if (strlen(ent->d_name) != 8)

+ continue;

+ strbuf_setlen(&fullname, prefixlen);

+ strbuf_addstr(&fullname, ent->d_name);

+ slot.cache_name = fullname.buf;

+ if ((err = open_slot(&slot)) != 0) {

+ cache_log("[cgit] unable to open path %s: %s (%d)\n",

+ fullname.buf, strerror(err), err);

+ continue;

+ }

+ htmlf("%s %s %10"PRIuMAX" %s\n",

+ fullname.buf,

+ sprintftime("%Y-%m-%d %H:%M:%S",

+ slot.cache_st.st_mtime),

+ (uintmax_t)slot.cache_st.st_size,

+ slot.buf);

+ close_slot(&slot);

+ }

+ closedir(dir);

+ strbuf_release(&fullname);

+ return 0;

+}

+

+/* Print a message to stdout */

+void cache_log(const char *format, ...)

+{

+ va_list args;

+ va_start(args, format);

+ vfprintf(stderr, format, args);

+ va_end(args);

+}

+

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/*

+ * Since git has it's own cache.h which we include,

+ * lets test on CGIT_CACHE_H to avoid confusion

+ */

+

+#ifndef CGIT_CACHE_H

+#define CGIT_CACHE_H

+

+typedef void (*cache_fill_fn)(void);

+

+

+/* Print cached content to stdout, generate the content if necessary.

+ *

+ * Parameters

+ * size max number of cache files

+ * path directory used to store cache files

+ * key the key used to lookup cache files

+ * ttl max cache time in seconds for this key

+ * fn content generator function for this key

+ *

+ * Return value

+ * 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);

+

+

+/* List info about all cache entries on stdout */

+extern int cache_ls(const char *path);

+

+/* Print a message to stdout */

+__attribute__((format (printf,1,2)))

+extern void cache_log(const char *format, ...);

+

+extern unsigned long hash_str(const char *str);

+

+#endif /* CGIT_CACHE_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* cgit.c: cgi for the git scm

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+#include "cache.h"

+#include "cmd.h"

+#include "configfile.h"

+#include "html.h"

+#include "ui-shared.h"

+#include "ui-stats.h"

+#include "ui-blob.h"

+#include "ui-summary.h"

+#include "scan-tree.h"

+

+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, name);

+ item->util = xstrdup(value);

+}

+

+static void process_cached_repolist(const char *path);

+

+void cgit_repo_config(struct cgit_repo *repo, const char *name, const char *value)

+{

+ const char *path;

+ struct string_list_item *item;

+

+ if (!strcmp(name, "name"))

+ repo->name = strdup_first_line(value);

+ else if (!strcmp(name, "clone-url"))

+ repo->clone_url = strdup_first_line(value);

+ else if (!strcmp(name, "desc"))

+ repo->desc = strdup_first_line(value);

+ else if (!strcmp(name, "owner"))

+ repo->owner = strdup_first_line(value);

+ else if (!strcmp(name, "homepage"))

+ repo->homepage = strdup_first_line(value);

+ else if (!strcmp(name, "defbranch"))

+ repo->defbranch = strdup_first_line(value);

+ else if (!strcmp(name, "extra-head-content"))

+ repo->extra_head_content = strdup_first_line(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-follow-links"))

+ repo->enable_follow_links = atoi(value);

+ else if (!strcmp(name, "enable-log-filecount"))

+ repo->enable_log_filecount = atoi(value);

+ else if (!strcmp(name, "enable-log-linecount"))

+ repo->enable_log_linecount = atoi(value);

+ else if (!strcmp(name, "enable-remote-branches"))

+ repo->enable_remote_branches = atoi(value);

+ else if (!strcmp(name, "enable-subject-links"))

+ repo->enable_subject_links = atoi(value);

+ else if (!strcmp(name, "enable-html-serving"))

+ repo->enable_html_serving = atoi(value);

+ else if (!strcmp(name, "branch-sort")) {

+ if (!strcmp(value, "age"))

+ repo->branch_sort = 1;

+ if (!strcmp(value, "name"))

+ repo->branch_sort = 0;

+ } else if (!strcmp(name, "commit-sort")) {

+ if (!strcmp(value, "date"))

+ repo->commit_sort = 1;

+ if (!strcmp(value, "topo"))

+ repo->commit_sort = 2;

+ } else if (!strcmp(name, "max-stats"))

+ repo->max_stats = cgit_find_stats_period(value, NULL);

+ else if (!strcmp(name, "module-link"))

+ repo->module_link= strdup_first_line(value);

+ else if (skip_prefix(name, "module-link.", &path)) {

+ item = string_list_append(&repo->submodules, strdup_first_line(path));

+ item->util = strdup_first_line(value);

+ } else if (!strcmp(name, "section"))

+ repo->section = strdup_first_line(value);

+ else if (!strcmp(name, "snapshot-prefix"))

+ repo->snapshot_prefix = strdup_first_line(value);

+ else if (!strcmp(name, "readme") && value != NULL) {

+ if (repo->readme.items == ctx.cfg.readme.items)

+ memset(&repo->readme, 0, sizeof(repo->readme));

+ string_list_append(&repo->readme, strdup_first_line(value));

+ } else if (!strcmp(name, "logo") && value != NULL)

+ repo->logo = strdup_first_line(value);

+ else if (!strcmp(name, "logo-link") && value != NULL)

+ repo->logo_link = strdup_first_line(value);

+ else if (!strcmp(name, "hide"))

+ repo->hide = atoi(value);

+ else if (!strcmp(name, "ignore"))

+ repo->ignore = atoi(value);

+ else if (ctx.cfg.enable_filter_overrides) {

+ if (!strcmp(name, "about-filter"))

+ repo->about_filter = cgit_new_filter(value, ABOUT);

+ else if (!strcmp(name, "commit-filter"))

+ repo->commit_filter = cgit_new_filter(value, COMMIT);

+ else if (!strcmp(name, "source-filter"))

+ repo->source_filter = cgit_new_filter(value, SOURCE);

+ else if (!strcmp(name, "email-filter"))

+ repo->email_filter = cgit_new_filter(value, EMAIL);

+ else if (!strcmp(name, "owner-filter"))

+ repo->owner_filter = cgit_new_filter(value, OWNER);

+ }

+}

+

+static void config_cb(const char *name, const char *value)

+{

+ const char *arg;

+

+ if (!strcmp(name, "section"))

+ ctx.cfg.section = strdup_first_line(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 && skip_prefix(name, "repo.", &arg))

+ cgit_repo_config(ctx.repo, arg, value);

+ else if (!strcmp(name, "readme"))

+ string_list_append(&ctx.cfg.readme, strdup_first_line(value));

+ else if (!strcmp(name, "root-title"))

+ ctx.cfg.root_title = strdup_first_line(value);

+ else if (!strcmp(name, "root-desc"))

+ ctx.cfg.root_desc = strdup_first_line(value);

+ else if (!strcmp(name, "root-readme"))

+ ctx.cfg.root_readme = strdup_first_line(value);

+ else if (!strcmp(name, "css"))

+ string_list_append(&ctx.cfg.css, strdup_first_line(value));

+ else if (!strcmp(name, "js"))

+ string_list_append(&ctx.cfg.js, strdup_first_line(value));

+ else if (!strcmp(name, "favicon"))

+ ctx.cfg.favicon = strdup_first_line(value);

+ else if (!strcmp(name, "footer"))

+ ctx.cfg.footer = strdup_first_line(value);

+ else if (!strcmp(name, "head-include"))

+ ctx.cfg.head_include = strdup_first_line(value);

+ else if (!strcmp(name, "header"))

+ ctx.cfg.header = strdup_first_line(value);

+ else if (!strcmp(name, "logo"))

+ ctx.cfg.logo = strdup_first_line(value);

+ else if (!strcmp(name, "logo-link"))

+ ctx.cfg.logo_link = strdup_first_line(value);

+ else if (!strcmp(name, "module-link"))

+ ctx.cfg.module_link = strdup_first_line(value);

+ else if (!strcmp(name, "strict-export"))

+ ctx.cfg.strict_export = strdup_first_line(value);

+ else if (!strcmp(name, "virtual-root"))

+ ctx.cfg.virtual_root = ensure_end(value, '/');

+ else if (!strcmp(name, "noplainemail"))

+ ctx.cfg.noplainemail = atoi(value);

+ else if (!strcmp(name, "noheader"))

+ ctx.cfg.noheader = atoi(value);

+ else if (!strcmp(name, "snapshots"))

+ ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);

+ else if (!strcmp(name, "enable-filter-overrides"))

+ ctx.cfg.enable_filter_overrides = atoi(value);

+ else if (!strcmp(name, "enable-follow-links"))

+ ctx.cfg.enable_follow_links = atoi(value);

+ else if (!strcmp(name, "enable-http-clone"))

+ ctx.cfg.enable_http_clone = atoi(value);

+ else if (!strcmp(name, "enable-index-links"))

+ 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"))

+ ctx.cfg.enable_log_filecount = atoi(value);

+ else if (!strcmp(name, "enable-log-linecount"))

+ ctx.cfg.enable_log_linecount = atoi(value);

+ else if (!strcmp(name, "enable-remote-branches"))

+ ctx.cfg.enable_remote_branches = atoi(value);

+ else if (!strcmp(name, "enable-subject-links"))

+ ctx.cfg.enable_subject_links = atoi(value);

+ else if (!strcmp(name, "enable-html-serving"))

+ ctx.cfg.enable_html_serving = atoi(value);

+ else if (!strcmp(name, "enable-tree-linenumbers"))

+ ctx.cfg.enable_tree_linenumbers = atoi(value);

+ else if (!strcmp(name, "enable-git-config"))

+ ctx.cfg.enable_git_config = atoi(value);

+ else if (!strcmp(name, "max-stats"))

+ ctx.cfg.max_stats = cgit_find_stats_period(value, NULL);

+ else if (!strcmp(name, "cache-size"))

+ ctx.cfg.cache_size = atoi(value);

+ else if (!strcmp(name, "cache-root"))

+ ctx.cfg.cache_root = strdup_first_line(expand_macros(value));

+ else if (!strcmp(name, "cache-root-ttl"))

+ ctx.cfg.cache_root_ttl = atoi(value);

+ else if (!strcmp(name, "cache-repo-ttl"))

+ ctx.cfg.cache_repo_ttl = atoi(value);

+ else if (!strcmp(name, "cache-scanrc-ttl"))

+ ctx.cfg.cache_scanrc_ttl = atoi(value);

+ else if (!strcmp(name, "cache-static-ttl"))

+ ctx.cfg.cache_static_ttl = atoi(value);

+ else if (!strcmp(name, "cache-dynamic-ttl"))

+ ctx.cfg.cache_dynamic_ttl = atoi(value);

+ else if (!strcmp(name, "cache-about-ttl"))

+ ctx.cfg.cache_about_ttl = atoi(value);

+ else if (!strcmp(name, "cache-snapshot-ttl"))

+ ctx.cfg.cache_snapshot_ttl = atoi(value);

+ else if (!strcmp(name, "case-sensitive-sort"))

+ ctx.cfg.case_sensitive_sort = atoi(value);

+ else if (!strcmp(name, "about-filter"))

+ ctx.cfg.about_filter = cgit_new_filter(value, ABOUT);

+ else if (!strcmp(name, "commit-filter"))

+ ctx.cfg.commit_filter = cgit_new_filter(value, COMMIT);

+ else if (!strcmp(name, "email-filter"))

+ ctx.cfg.email_filter = cgit_new_filter(value, EMAIL);

+ else if (!strcmp(name, "owner-filter"))

+ ctx.cfg.owner_filter = cgit_new_filter(value, OWNER);

+ else if (!strcmp(name, "auth-filter"))

+ ctx.cfg.auth_filter = cgit_new_filter(value, AUTH);

+ else if (!strcmp(name, "embedded"))

+ ctx.cfg.embedded = atoi(value);

+ else if (!strcmp(name, "max-atom-items"))

+ ctx.cfg.max_atom_items = atoi(value);

+ else if (!strcmp(name, "max-message-length"))

+ ctx.cfg.max_msg_len = atoi(value);

+ else if (!strcmp(name, "max-repodesc-length"))

+ 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")) {

+ ctx.cfg.max_repo_count = atoi(value);

+ 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 = strdup_first_line(expand_macros(value));

+ else if (!strcmp(name, "scan-path"))

+ if (ctx.cfg.cache_size)

+ process_cached_repolist(expand_macros(value));

+ else if (ctx.cfg.project_list)

+ scan_projects(expand_macros(value),

+ ctx.cfg.project_list);

+ else

+ scan_tree(expand_macros(value));

+ else if (!strcmp(name, "scan-hidden-path"))

+ ctx.cfg.scan_hidden_path = atoi(value);

+ else if (!strcmp(name, "section-from-path"))

+ ctx.cfg.section_from_path = atoi(value);

+ else if (!strcmp(name, "repository-sort"))

+ ctx.cfg.repository_sort = strdup_first_line(value);

+ else if (!strcmp(name, "section-sort"))

+ ctx.cfg.section_sort = atoi(value);

+ else if (!strcmp(name, "source-filter"))

+ ctx.cfg.source_filter = cgit_new_filter(value, SOURCE);

+ else if (!strcmp(name, "summary-log"))

+ ctx.cfg.summary_log = atoi(value);

+ else if (!strcmp(name, "summary-branches"))

+ ctx.cfg.summary_branches = atoi(value);

+ else if (!strcmp(name, "summary-tags"))

+ ctx.cfg.summary_tags = atoi(value);

+ else if (!strcmp(name, "side-by-side-diffs"))

+ ctx.cfg.difftype = atoi(value) ? DIFF_SSDIFF : DIFF_UNIFIED;

+ else if (!strcmp(name, "agefile"))

+ ctx.cfg.agefile = strdup_first_line(value);

+ else if (!strcmp(name, "mimetype-file"))

+ ctx.cfg.mimetype_file = strdup_first_line(value);

+ else if (!strcmp(name, "renamelimit"))

+ ctx.cfg.renamelimit = atoi(value);

+ else if (!strcmp(name, "remove-suffix"))

+ ctx.cfg.remove_suffix = atoi(value);

+ else if (!strcmp(name, "robots"))

+ ctx.cfg.robots = strdup_first_line(value);

+ else if (!strcmp(name, "clone-prefix"))

+ ctx.cfg.clone_prefix = strdup_first_line(value);

+ else if (!strcmp(name, "clone-url"))

+ ctx.cfg.clone_url = strdup_first_line(value);

+ else if (!strcmp(name, "local-time"))

+ ctx.cfg.local_time = atoi(value);

+ else if (!strcmp(name, "commit-sort")) {

+ if (!strcmp(value, "date"))

+ ctx.cfg.commit_sort = 1;

+ if (!strcmp(value, "topo"))

+ ctx.cfg.commit_sort = 2;

+ } else if (!strcmp(name, "branch-sort")) {

+ if (!strcmp(value, "age"))

+ ctx.cfg.branch_sort = 1;

+ if (!strcmp(value, "name"))

+ ctx.cfg.branch_sort = 0;

+ } else if (skip_prefix(name, "mimetype.", &arg))

+ add_mimetype(arg, value);

+ else if (!strcmp(name, "include"))

+ parse_configfile(expand_macros(value), config_cb);

+}

+

+static void querystring_cb(const char *name, const char *value)

+{

+ if (!value)

+ value = "";

+

+ if (!strcmp(name,"r")) {

+ ctx.qry.repo = xstrdup(value);

+ ctx.repo = cgit_get_repoinfo(value);

+ } else if (!strcmp(name, "p")) {

+ ctx.qry.page = xstrdup(value);

+ } else if (!strcmp(name, "url")) {

+ if (*value == '/')

+ value++;

+ ctx.qry.url = xstrdup(value);

+ cgit_parse_url(value);

+ } else if (!strcmp(name, "qt")) {

+ ctx.qry.grep = xstrdup(value);

+ } else if (!strcmp(name, "q")) {

+ ctx.qry.search = xstrdup(value);

+ } else if (!strcmp(name, "h")) {

+ ctx.qry.head = xstrdup(value);

+ ctx.qry.has_symref = 1;

+ } else if (!strcmp(name, "id")) {

+ ctx.qry.oid = xstrdup(value);

+ ctx.qry.has_oid = 1;

+ } else if (!strcmp(name, "id2")) {

+ 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")) {

+ ctx.qry.path = trim_end(value, '/');

+ } else if (!strcmp(name, "name")) {

+ ctx.qry.name = xstrdup(value);

+ } else if (!strcmp(name, "s")) {

+ ctx.qry.sort = xstrdup(value);

+ } else if (!strcmp(name, "showmsg")) {

+ ctx.qry.showmsg = atoi(value);

+ } else if (!strcmp(name, "period")) {

+ ctx.qry.period = xstrdup(value);

+ } else if (!strcmp(name, "dt")) {

+ ctx.qry.difftype = atoi(value);

+ ctx.qry.has_difftype = 1;

+ } else if (!strcmp(name, "ss")) {

+ /* No longer generated, but there may be links out there. */

+ ctx.qry.difftype = atoi(value) ? DIFF_SSDIFF : DIFF_UNIFIED;

+ ctx.qry.has_difftype = 1;

+ } else if (!strcmp(name, "all")) {

+ ctx.qry.show_all = atoi(value);

+ } else if (!strcmp(name, "context")) {

+ ctx.qry.context = atoi(value);

+ } else if (!strcmp(name, "ignorews")) {

+ ctx.qry.ignorews = atoi(value);

+ } else if (!strcmp(name, "follow")) {

+ ctx.qry.follow = atoi(value);

+ }

+}

+

+static void prepare_context(void)

+{

+ memset(&ctx, 0, sizeof(ctx));

+ ctx.cfg.agefile = "info/web/last-modified";

+ ctx.cfg.cache_size = 0;

+ ctx.cfg.cache_max_create_time = 5;

+ ctx.cfg.cache_root = CGIT_CACHE_ROOT;

+ ctx.cfg.cache_about_ttl = 15;

+ ctx.cfg.cache_snapshot_ttl = 5;

+ ctx.cfg.cache_repo_ttl = 5;

+ ctx.cfg.cache_root_ttl = 5;

+ ctx.cfg.cache_scanrc_ttl = 15;

+ ctx.cfg.cache_dynamic_ttl = 5;

+ ctx.cfg.cache_static_ttl = -1;

+ ctx.cfg.case_sensitive_sort = 1;

+ ctx.cfg.branch_sort = 0;

+ ctx.cfg.commit_sort = 0;

+ ctx.cfg.logo = "/cgit.png";

+ ctx.cfg.favicon = "/favicon.ico";

+ ctx.cfg.local_time = 0;

+ ctx.cfg.enable_http_clone = 1;

+ ctx.cfg.enable_index_owner = 1;

+ ctx.cfg.enable_tree_linenumbers = 1;

+ ctx.cfg.enable_git_config = 0;

+ ctx.cfg.max_repo_count = 50;

+ ctx.cfg.max_commit_count = 50;

+ ctx.cfg.max_lock_attempts = 5;

+ ctx.cfg.max_msg_len = 80;

+ ctx.cfg.max_repodesc_len = 80;

+ ctx.cfg.max_blob_size = 0;

+ ctx.cfg.max_stats = 0;

+ ctx.cfg.project_list = NULL;

+ ctx.cfg.renamelimit = -1;

+ ctx.cfg.remove_suffix = 0;

+ ctx.cfg.robots = "index, nofollow";

+ ctx.cfg.root_title = "Git repository browser";

+ ctx.cfg.root_desc = "a fast webinterface for the git dscm";

+ ctx.cfg.scan_hidden_path = 0;

+ ctx.cfg.script_name = CGIT_SCRIPT_NAME;

+ ctx.cfg.section = "";

+ ctx.cfg.repository_sort = "name";

+ ctx.cfg.section_sort = 1;

+ ctx.cfg.summary_branches = 10;

+ ctx.cfg.summary_log = 10;

+ ctx.cfg.summary_tags = 10;

+ ctx.cfg.max_atom_items = 10;

+ ctx.cfg.difftype = DIFF_UNIFIED;

+ ctx.env.cgit_config = getenv("CGIT_CONFIG");

+ ctx.env.http_host = getenv("HTTP_HOST");

+ ctx.env.https = getenv("HTTPS");

+ ctx.env.no_http = getenv("NO_HTTP");

+ ctx.env.path_info = getenv("PATH_INFO");

+ ctx.env.query_string = getenv("QUERY_STRING");

+ ctx.env.request_method = getenv("REQUEST_METHOD");

+ ctx.env.script_name = getenv("SCRIPT_NAME");

+ ctx.env.server_name = getenv("SERVER_NAME");

+ ctx.env.server_port = getenv("SERVER_PORT");

+ ctx.env.http_cookie = getenv("HTTP_COOKIE");

+ ctx.env.http_referer = getenv("HTTP_REFERER");

+ ctx.env.content_length = getenv("CONTENT_LENGTH") ? strtoul(getenv("CONTENT_LENGTH"), NULL, 10) : 0;

+ ctx.env.authenticated = 0;

+ ctx.page.mimetype = "text/html";

+ ctx.page.charset = PAGE_ENCODING;

+ ctx.page.filename = NULL;

+ ctx.page.size = 0;

+ ctx.page.modified = time(NULL);

+ ctx.page.expires = ctx.page.modified;

+ ctx.page.etag = NULL;

+ 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)

+ ctx.qry.raw = xstrdup(ctx.env.query_string);

+ if (!ctx.env.cgit_config)

+ ctx.env.cgit_config = CGIT_CONFIG;

+}

+

+struct refmatch {

+ char *req_ref;

+ char *first_ref;

+ int match;

+};

+

+static int find_current_ref(const struct reference *ref, void *cb_data)

+{

+ struct refmatch *info;

+

+ info = (struct refmatch *)cb_data;

+ if (!strcmp(ref->name, info->req_ref))

+ info->match = 1;

+ if (!info->first_ref)

+ info->first_ref = xstrdup(ref->name);

+ return info->match;

+}

+

+static void free_refmatch_inner(struct refmatch *info)

+{

+ if (info->first_ref)

+ free(info->first_ref);

+}

+

+static char *find_default_branch(struct cgit_repo *repo)

+{

+ struct refmatch info;

+ char *ref;

+

+ info.req_ref = repo->defbranch;

+ info.first_ref = NULL;

+ info.match = 0;

+ refs_for_each_branch_ref(get_main_ref_store(the_repository),

+ find_current_ref, &info);

+ if (info.match)

+ ref = info.req_ref;

+ else

+ ref = info.first_ref;

+ if (ref)

+ ref = xstrdup(ref);

+ free_refmatch_inner(&info);

+

+ return ref;

+}

+

+static char *guess_defbranch(void)

+{

+ const char *ref, *refname;

+ struct object_id oid;

+

+ ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),

+ "HEAD", 0, &oid, NULL);

+ if (!ref || !skip_prefix(ref, "refs/heads/", &refname))

+ return "master";

+ 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)

+{

+ const char *colon;

+

+ *filename = NULL;

+ *ref = NULL;

+

+ if (!readme || !readme[0])

+ return;

+

+ /* 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 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);

+ readme = colon + 1;

+ }

+

+ /* Prepend repo path to relative readme path unless tracked. */

+ if (!(*ref) && readme[0] != '/')

+ *filename = fmtalloc("%s/%s", repo->path, readme);

+ else

+ *filename = xstrdup(readme);

+}

+static void choose_readme(struct cgit_repo *repo)

+{

+ int found;

+ char *filename, *ref;

+ struct string_list_item *entry;

+

+ if (!repo->readme.nr)

+ return;

+

+ found = 0;

+ for_each_string_list_item(entry, &repo->readme) {

+ parse_readme(entry->string, &filename, &ref, repo);

+ if (!filename) {

+ free(filename);

+ free(ref);

+ continue;

+ }

+ if (ref) {

+ if (cgit_ref_path_exists(filename, ref, 1)) {

+ found = 1;

+ break;

+ }

+ }

+ else if (!access(filename, R_OK)) {

+ found = 1;

+ break;

+ }

+ free(filename);

+ free(ref);

+ }

+ repo->readme.strdup_strings = 1;

+ string_list_clear(&repo->readme, 0);

+ repo->readme.strdup_strings = 0;

+ if (found)

+ string_list_append(&repo->readme, filename)->util = ref;

+}

+

+static void print_no_repo_clone_urls(const char *url)

+{

+ html("<tr><td><a rel='vcs-git' href='");

+ html_url_path(url);

+ html("' title='");

+ html_attr(ctx.repo->name);

+ html(" Git repository'>");

+ html_txt(url);

+ html("</a></td></tr>\n");

+}

+

+static void prepare_repo_env(int *nongit)

+{

+ /* The path to the git repository. */

+ setenv("GIT_DIR", ctx.repo->path, 1);

+

+ /* 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);

+ 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;

+ rc = errno;

+ ctx.page.title = fmtalloc("%s - %s", ctx.cfg.root_title,

+ "config error");

+ ctx.repo = NULL;

+ cgit_print_http_headers();

+ cgit_print_docstart();

+ cgit_print_pageheader();

+ cgit_print_error("Failed to open %s: %s", name,

+ rc ? strerror(rc) : "Not a valid git repository");

+ cgit_print_docend();

+ return 1;

+ }

+ ctx.page.title = fmtalloc("%s - %s", ctx.repo->name, ctx.repo->desc);

+

+ if (!ctx.repo->defbranch)

+ ctx.repo->defbranch = guess_defbranch();

+

+ if (!ctx.qry.head) {

+ ctx.qry.nohead = 1;

+ ctx.qry.head = find_default_branch(ctx.repo);

+ }

+

+ if (!ctx.qry.head) {

+ cgit_print_http_headers();

+ cgit_print_docstart();

+ cgit_print_pageheader();

+ cgit_print_error("Repository seems to be empty");

+ if (!strcmp(ctx.qry.page, "summary")) {

+ html("<table class='list'><tr class='nohover'><td>&nbsp;</td></tr><tr class='nohover'><th class='left'>Clone</th></tr>\n");

+ cgit_prepare_repo_env(ctx.repo);

+ cgit_add_clone_urls(print_no_repo_clone_urls);

+ html("</table>\n");

+ }

+ cgit_print_docend();

+ return 1;

+ }

+

+ if (repo_get_oid(the_repository, 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", old_head);

+ free(old_head);

+ return 1;

+ }

+ string_list_sort(&ctx.repo->submodules);

+ cgit_prepare_repo_env(ctx.repo);

+ choose_readme(ctx.repo);

+ return 0;

+}

+

+static inline void open_auth_filter(const char *function)

+{

+ cgit_open_filter(ctx.cfg.auth_filter, function,

+ ctx.env.http_cookie ? ctx.env.http_cookie : "",

+ ctx.env.request_method ? ctx.env.request_method : "",

+ ctx.env.query_string ? ctx.env.query_string : "",

+ ctx.env.http_referer ? ctx.env.http_referer : "",

+ ctx.env.path_info ? ctx.env.path_info : "",

+ ctx.env.http_host ? ctx.env.http_host : "",

+ ctx.env.https ? ctx.env.https : "",

+ ctx.qry.repo ? ctx.qry.repo : "",

+ ctx.qry.page ? ctx.qry.page : "",

+ cgit_currentfullurl(),

+ cgit_loginurl());

+}

+

+/* We intentionally keep this rather small, instead of looping and

+ * feeding it to the filter a couple bytes at a time. This way, the

+ * filter itself does not need to handle any denial of service or

+ * buffer bloat issues. If this winds up being too small, people

+ * will complain on the mailing list, and we'll increase it as needed. */

+#define MAX_AUTHENTICATION_POST_BYTES 4096

+/* The filter is expected to spit out "Status: " and all headers. */

+static inline void authenticate_post(void)

+{

+ char buffer[MAX_AUTHENTICATION_POST_BYTES];

+ 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 ((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");

+ cgit_close_filter(ctx.cfg.auth_filter);

+ exit(0);

+}

+

+static inline void authenticate_cookie(void)

+{

+ /* If we don't have an auth_filter, consider all cookies valid, and thus return early. */

+ if (!ctx.cfg.auth_filter) {

+ ctx.env.authenticated = 1;

+ return;

+ }

+

+ /* If we're having something POST'd to /login, we're authenticating POST,

+ * instead of the cookie, so call authenticate_post and bail out early.

+ * This pattern here should match /?p=login with POST. */

+ if (ctx.env.request_method && ctx.qry.page && !ctx.repo && \

+ !strcmp(ctx.env.request_method, "POST") && !strcmp(ctx.qry.page, "login")) {

+ authenticate_post();

+ return;

+ }

+

+ /* If we've made it this far, we're authenticating the cookie for real, so do that. */

+ open_auth_filter("authenticate-cookie");

+ ctx.env.authenticated = cgit_close_filter(ctx.cfg.auth_filter);

+}

+

+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

+ * never be cached. */

+ if (!ctx.env.authenticated) {

+ ctx.page.title = "Authentication Required";

+ cgit_print_http_headers();

+ cgit_print_docstart();

+ cgit_print_pageheader();

+ open_auth_filter("body");

+ cgit_close_filter(ctx.cfg.auth_filter);

+ cgit_print_docend();

+ return;

+ }

+

+ if (ctx.repo)

+ prepare_repo_env(&nongit);

+

+ cmd = cgit_get_cmd();

+ if (!cmd) {

+ ctx.page.title = "cgit error";

+ cgit_print_error_page(404, "Not found", "Invalid request");

+ return;

+ }

+

+ if (!ctx.cfg.enable_http_clone && cmd->is_clone) {

+ ctx.page.title = "cgit error";

+ cgit_print_error_page(404, "Not found", "Invalid request");

+ return;

+ }

+

+ if (cmd->want_repo && !ctx.repo) {

+ cgit_print_error_page(400, "Bad request",

+ "No repository selected");

+ 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 (ctx.repo && prepare_repo_cmd(nongit))

+ return;

+

+ cmd->fn();

+}

+

+static int cmp_repos(const void *a, const void *b)

+{

+ const struct cgit_repo *ra = a, *rb = b;

+ return strcmp(ra->url, rb->url);

+}

+

+static char *build_snapshot_setting(int bitmap)

+{

+ const struct cgit_snapshot_format *f;

+ struct strbuf result = STRBUF_INIT;

+

+ for (f = cgit_snapshot_formats; f->suffix; f++) {

+ if (cgit_snapshot_format_bit(f) & bitmap) {

+ if (result.len)

+ strbuf_addch(&result, ' ');

+ strbuf_addstr(&result, f->suffix);

+ }

+ }

+ return strbuf_detach(&result, NULL);

+}

+

+static void print_repo(FILE *f, struct cgit_repo *repo)

+{

+ struct string_list_item *item;

+ fprintf(f, "repo.url=%s\n", repo->url);

+ fprintf(f, "repo.name=%s\n", repo->name);

+ fprintf(f, "repo.path=%s\n", repo->path);

+ if (repo->owner)

+ fprintf(f, "repo.owner=%s\n", repo->owner);

+ if (repo->desc)

+ fprintf(f, "repo.desc=%s\n", repo->desc);

+ for_each_string_list_item(item, &repo->readme) {

+ if (item->util)

+ fprintf(f, "repo.readme=%s:%s\n", (char *)item->util, item->string);

+ else

+ fprintf(f, "repo.readme=%s\n", item->string);

+ }

+ 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-follow-links=%d\n",

+ repo->enable_follow_links);

+ fprintf(f, "repo.enable-log-filecount=%d\n",

+ repo->enable_log_filecount);

+ fprintf(f, "repo.enable-log-linecount=%d\n",

+ repo->enable_log_linecount);

+ if (repo->about_filter && repo->about_filter != ctx.cfg.about_filter)

+ cgit_fprintf_filter(repo->about_filter, f, "repo.about-filter=");

+ if (repo->commit_filter && repo->commit_filter != ctx.cfg.commit_filter)

+ cgit_fprintf_filter(repo->commit_filter, f, "repo.commit-filter=");

+ if (repo->source_filter && repo->source_filter != ctx.cfg.source_filter)

+ cgit_fprintf_filter(repo->source_filter, f, "repo.source-filter=");

+ if (repo->email_filter && repo->email_filter != ctx.cfg.email_filter)

+ cgit_fprintf_filter(repo->email_filter, f, "repo.email-filter=");

+ if (repo->owner_filter && repo->owner_filter != ctx.cfg.owner_filter)

+ cgit_fprintf_filter(repo->owner_filter, f, "repo.owner-filter=");

+ if (repo->snapshots != ctx.cfg.snapshots) {

+ char *tmp = build_snapshot_setting(repo->snapshots);

+ 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));

+ if (repo->logo)

+ fprintf(f, "repo.logo=%s\n", repo->logo);

+ if (repo->logo_link)

+ fprintf(f, "repo.logo-link=%s\n", repo->logo_link);

+ fprintf(f, "repo.enable-remote-branches=%d\n", repo->enable_remote_branches);

+ fprintf(f, "repo.enable-subject-links=%d\n", repo->enable_subject_links);

+ fprintf(f, "repo.enable-html-serving=%d\n", repo->enable_html_serving);

+ if (repo->branch_sort == 1)

+ fprintf(f, "repo.branch-sort=age\n");

+ if (repo->commit_sort) {

+ if (repo->commit_sort == 1)

+ fprintf(f, "repo.commit-sort=date\n");

+ else if (repo->commit_sort == 2)

+ fprintf(f, "repo.commit-sort=topo\n");

+ }

+ fprintf(f, "repo.hide=%d\n", repo->hide);

+ fprintf(f, "repo.ignore=%d\n", repo->ignore);

+ fprintf(f, "\n");

+}

+

+static void print_repolist(FILE *f, struct cgit_repolist *list, int start)

+{

+ int i;

+

+ for (i = start; i < list->count; i++)

+ print_repo(f, &list->repos[i]);

+}

+

+/* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'

+ * and return 0 on success.

+ */

+static int generate_cached_repolist(const char *path, const char *cached_rc)

+{

+ struct strbuf locked_rc = STRBUF_INIT;

+ int result = 0;

+ int idx;

+ FILE *f;

+

+ strbuf_addf(&locked_rc, "%s.lock", cached_rc);

+ f = fopen(locked_rc.buf, "wx");

+ if (!f) {

+ /* Inform about the error unless the lockfile already existed,

+ * since that only means we've got concurrent requests.

+ */

+ result = errno;

+ if (result != EEXIST)

+ fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",

+ locked_rc.buf, strerror(result), result);

+ goto out;

+ }

+ idx = cgit_repolist.count;

+ if (ctx.cfg.project_list)

+ scan_projects(path, ctx.cfg.project_list);

+ else

+ scan_tree(path);

+ print_repolist(f, &cgit_repolist, idx);

+ if (rename(locked_rc.buf, cached_rc))

+ fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",

+ locked_rc.buf, cached_rc, strerror(errno), errno);

+ fclose(f);

+out:

+ strbuf_release(&locked_rc);

+ return result;

+}

+

+static void process_cached_repolist(const char *path)

+{

+ struct stat st;

+ struct strbuf cached_rc = STRBUF_INIT;

+ time_t age;

+ unsigned long hash;

+

+ hash = hash_str(path);

+ if (ctx.cfg.project_list)

+ hash += hash_str(ctx.cfg.project_list);

+ strbuf_addf(&cached_rc, "%s/rc-%8lx", ctx.cfg.cache_root, hash);

+

+ if (stat(cached_rc.buf, &st)) {

+ /* Nothing is cached, we need to scan without forking. And

+ * if we fail to generate a cached repolist, we need to

+ * invoke scan_tree manually.

+ */

+ if (generate_cached_repolist(path, cached_rc.buf)) {

+ if (ctx.cfg.project_list)

+ scan_projects(path, ctx.cfg.project_list);

+ else

+ scan_tree(path);

+ }

+ goto out;

+ }

+

+ parse_configfile(cached_rc.buf, config_cb);

+

+ /* If the cached configfile hasn't expired, lets exit now */

+ age = time(NULL) - st.st_mtime;

+ if (age <= (ctx.cfg.cache_scanrc_ttl * 60))

+ goto out;

+

+ /* The cached repolist has been parsed, but it was old. So lets

+ * rescan the specified path and generate a new cached repolist

+ * in a child-process to avoid latency for the current request.

+ */

+ if (fork())

+ goto out;

+

+ exit(generate_cached_repolist(path, cached_rc.buf));

+out:

+ strbuf_release(&cached_rc);

+}

+

+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 | https://git.zx2c4.com/cgit/\n\nCompiled in features:\n", CGIT_VERSION);

+#ifdef NO_LUA

+ printf("[-] ");

+#else

+ printf("[+] ");

+#endif

+ printf("Lua scripting\n");

+#ifndef HAVE_LINUX_SENDFILE

+ printf("[-] ");

+#else

+ printf("[+] ");

+#endif

+ printf("Linux sendfile() usage\n");

+

+ exit(0);

+ }

+ 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 (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 (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

+ * hasn't been parsed yet so the mask is currently 0.

+ * By setting all bits high before scanning we make

+ * sure that any in-repo cgitrc snapshot setting is

+ * respected by scan_tree().

+ *

+ * NOTE: We assume that there aren't more than 8

+ * different snapshot formats supported by cgit...

+ */

+ ctx.cfg.snapshots = 0xFF;

+ scan++;

+ scan_tree(arg);

+ }

+ }

+ if (scan) {

+ qsort(cgit_repolist.repos, cgit_repolist.count,

+ sizeof(struct cgit_repo), cmp_repos);

+ print_repolist(stdout, &cgit_repolist, 0);

+ exit(0);

+ }

+}

+

+static int calc_ttl(void)

+{

+ if (!ctx.repo)

+ return ctx.cfg.cache_root_ttl;

+

+ if (!ctx.qry.page)

+ return ctx.cfg.cache_repo_ttl;

+

+ if (!strcmp(ctx.qry.page, "about"))

+ return ctx.cfg.cache_about_ttl;

+

+ if (!strcmp(ctx.qry.page, "snapshot"))

+ return ctx.cfg.cache_snapshot_ttl;

+

+ if (ctx.qry.has_oid)

+ return ctx.cfg.cache_static_ttl;

+

+ if (ctx.qry.has_symref)

+ return ctx.cfg.cache_dynamic_ttl;

+

+ return ctx.cfg.cache_repo_ttl;

+}

+

+static NORETURN void cgit_die_routine(const char *msg, va_list params)

+{

+ cgit_vprint_error_page(400, "Bad request", msg, params);

+ exit(0);

+}

+

+int cmd_main(int argc, const char **argv)

+{

+ const char *path;

+ int err, ttl;

+

+ cgit_init_filters();

+ atexit(cgit_cleanup_filters);

+ set_die_routine(cgit_die_routine);

+

+ prepare_context();

+ cgit_repolist.length = 0;

+ cgit_repolist.count = 0;

+ cgit_repolist.repos = NULL;

+

+ cgit_parse_args(argc, argv);

+ parse_configfile(expand_macros(ctx.env.cgit_config), config_cb);

+ ctx.repo = NULL;

+ http_parse_querystring(ctx.qry.raw, querystring_cb);

+

+ /* If virtual-root isn't specified in cgitrc, lets pretend

+ * that virtual-root equals SCRIPT_NAME, minus any possibly

+ * trailing slashes.

+ */

+ if (!ctx.cfg.virtual_root && ctx.cfg.script_name)

+ ctx.cfg.virtual_root = ensure_end(ctx.cfg.script_name, '/');

+

+ /* If no url parameter is specified on the querystring, lets

+ * use PATH_INFO as url. This allows cgit to work with virtual

+ * urls without the need for rewriterules in the webserver (as

+ * long as PATH_INFO is included in the cache lookup key).

+ */

+ path = ctx.env.path_info;

+ if (!ctx.qry.url && path) {

+ if (path[0] == '/')

+ path++;

+ ctx.qry.url = xstrdup(path);

+ if (ctx.qry.raw) {

+ char *newqry = fmtalloc("%s?%s", path, ctx.qry.raw);

+ free(ctx.qry.raw);

+ ctx.qry.raw = newqry;

+ } else

+ ctx.qry.raw = xstrdup(ctx.qry.url);

+ cgit_parse_url(ctx.qry.url);

+ }

+

+ /* Before we go any further, we set ctx.env.authenticated by checking to see

+ * if the supplied cookie is valid. All cookies are valid if there is no

+ * auth_filter. If there is an auth_filter, the filter decides. */

+ authenticate_cookie();

+

+ ttl = calc_ttl();

+ if (ttl < 0)

+ ctx.page.expires += 10 * 365 * 24 * 60 * 60; /* 10 years */

+ else

+ ctx.page.expires += ttl * 60;

+ if (!ctx.env.authenticated || (ctx.env.request_method && !strcmp(ctx.env.request_method, "HEAD")))

+ ctx.cfg.cache_size = 0;

+ err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,

+ ctx.qry.raw, ttl, process_request);

+ cgit_cleanup_filters();

+ if (err)

+ cgit_print_error("Error processing page: %s (%d)",

+ strerror(err), err);

+ return err;

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+div#cgit {

+ padding: 0em;

+ margin: 0em;

+ font-family: sans-serif;

+ font-size: 10pt;

+ color: #333;

+ background: white;

+ padding: 4px;

+}

+

+div#cgit a {

+ color: blue;

+ text-decoration: none;

+}

+

+div#cgit a:hover {

+ text-decoration: underline;

+}

+

+div#cgit table {

+ border-collapse: collapse;

+}

+

+div#cgit table#header {

+ width: 100%;

+ margin-bottom: 1em;

+}

+

+div#cgit table#header td.logo {

+ width: 96px;

+ vertical-align: top;

+}

+

+div#cgit table#header td.main {

+ font-size: 250%;

+ padding-left: 10px;

+ white-space: nowrap;

+}

+

+div#cgit table#header td.main a {

+ color: #000;

+}

+

+div#cgit table#header td.form {

+ text-align: right;

+ vertical-align: bottom;

+ padding-right: 1em;

+ padding-bottom: 2px;

+ white-space: nowrap;

+}

+

+div#cgit table#header td.form form,

+div#cgit table#header td.form input,

+div#cgit table#header td.form select {

+ font-size: 90%;

+}

+

+div#cgit table#header td.sub {

+ color: #777;

+ border-top: solid 1px #ccc;

+ padding-left: 10px;

+}

+

+div#cgit table.tabs {

+ border-bottom: solid 3px #ccc;

+ border-collapse: collapse;

+ margin-top: 2em;

+ margin-bottom: 0px;

+ width: 100%;

+}

+

+div#cgit table.tabs td {

+ padding: 0px 1em;

+ vertical-align: bottom;

+}

+

+div#cgit table.tabs td a {

+ padding: 2px 0.75em;

+ color: #777;

+ font-size: 110%;

+}

+

+div#cgit table.tabs td a.active {

+ color: #000;

+ 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;

+}

+

+div#cgit table.tabs td.form form {

+ padding-bottom: 2px;

+ font-size: 90%;

+ white-space: nowrap;

+}

+

+div#cgit table.tabs td.form input,

+div#cgit table.tabs td.form select {

+ font-size: 90%;

+}

+

+div#cgit div.path {

+ margin: 0px;

+ padding: 5px 2em 2px 2em;

+ color: #000;

+ background-color: #eee;

+}

+

+div#cgit div.content {

+ margin: 0px;

+ padding: 2em;

+ border-bottom: solid 3px #ccc;

+}

+

+

+div#cgit table.list {

+ width: 100%;

+ border: none;

+ border-collapse: collapse;

+}

+

+div#cgit table.list tr {

+ background: white;

+}

+

+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;

+ border-top: dashed 1px #888;

+ border-bottom: dashed 1px #888;

+ */

+ padding: 0.1em 0.5em 0.05em 0.5em;

+ vertical-align: baseline;

+}

+

+div#cgit table.list td {

+ border: none;

+ padding: 0.1em 0.5em 0.1em 0.5em;

+}

+

+div#cgit table.list td.commitgraph {

+ font-family: monospace;

+ white-space: pre;

+}

+

+div#cgit table.list td.commitgraph .column1 {

+ color: #a00;

+}

+

+div#cgit table.list td.commitgraph .column2 {

+ color: #0a0;

+}

+

+div#cgit table.list td.commitgraph .column3 {

+ color: #aa0;

+}

+

+div#cgit table.list td.commitgraph .column4 {

+ color: #00a;

+}

+

+div#cgit table.list td.commitgraph .column5 {

+ color: #a0a;

+}

+

+div#cgit table.list td.commitgraph .column6 {

+ color: #0aa;

+}

+

+div#cgit table.list td.logsubject {

+ font-family: monospace;

+ font-weight: bold;

+}

+

+div#cgit table.list td.logmsg {

+ font-family: monospace;

+ white-space: pre;

+ padding: 0 0.5em;

+}

+

+div#cgit table.list td a {

+ color: black;

+}

+

+div#cgit table.list td a.ls-dir {

+ font-weight: bold;

+ color: #00f;

+}

+

+div#cgit table.list td a:hover {

+ color: #00f;

+}

+

+div#cgit img {

+ border: none;

+}

+

+div#cgit input#switch-btn {

+ margin: 2px 0px 0px 0px;

+}

+

+div#cgit td#sidebar input.txt {

+ width: 100%;

+ margin: 2px 0px 0px 0px;

+}

+

+div#cgit table#grid {

+ margin: 0px;

+}

+

+div#cgit td#content {

+ vertical-align: top;

+ padding: 1em 2em 1em 1em;

+ border: none;

+}

+

+div#cgit div#summary {

+ vertical-align: top;

+ margin-bottom: 1em;

+}

+

+div#cgit table#downloads {

+ float: right;

+ border-collapse: collapse;

+ border: solid 1px #777;

+ margin-left: 0.5em;

+ margin-bottom: 0.5em;

+}

+

+div#cgit table#downloads th {

+ background-color: #ccc;

+}

+

+div#cgit div#blob {

+ border: solid 1px black;

+}

+

+div#cgit div.error {

+ color: red;

+ font-weight: bold;

+ margin: 1em 2em;

+}

+

+div#cgit a.ls-blob, div#cgit a.ls-dir, div#cgit .ls-mod {

+ font-family: monospace;

+}

+

+div#cgit td.ls-size {

+ text-align: right;

+ font-family: monospace;

+ width: 10em;

+}

+

+div#cgit td.ls-mode {

+ font-family: monospace;

+ width: 10em;

+}

+

+div#cgit table.blob {

+ margin-top: 0.5em;

+ 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;

+ color: black;

+}

+

+div#cgit table.blob td.linenumbers {

+ margin: 0; padding: 0 0.5em 0 0.5em;

+ vertical-align: top;

+ text-align: right;

+ border-right: 1px solid gray;

+}

+

+div#cgit table.blob pre {

+ padding: 0; margin: 0;

+}

+

+div#cgit table.blob td.linenumbers a,

+div#cgit table.ssdiff td.lineno a {

+ color: gray;

+ text-align: right;

+ text-decoration: none;

+}

+

+div#cgit table.blob td.linenumbers a:hover,

+div#cgit table.ssdiff td.lineno a:hover {

+ color: black;

+}

+

+div#cgit table.blob td.linenumbers a:target:before {

+ color: red;

+ content: "\2BA9";

+}

+

+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;

+}

+

+div#cgit table.bin-blob th {

+ font-family: monospace;

+ white-space: pre;

+ border: solid 1px #777;

+ padding: 0.5em 1em;

+}

+

+div#cgit table.bin-blob td {

+ font-family: monospace;

+ white-space: pre;

+ border-left: solid 1px #777;

+ padding: 0em 1em;

+}

+

+div#cgit table.nowrap td {

+ white-space: nowrap;

+}

+

+div#cgit table.commit-info {

+ border-collapse: collapse;

+ margin-top: 1.5em;

+}

+

+div#cgit div.cgit-panel {

+ float: right;

+ margin-top: 1.5em;

+}

+

+div#cgit div.cgit-panel table {

+ border-collapse: collapse;

+ border: solid 1px #aaa;

+ background-color: #eee;

+}

+

+div#cgit div.cgit-panel th {

+ text-align: center;

+}

+

+div#cgit div.cgit-panel td {

+ padding: 0.25em 0.5em;

+}

+

+div#cgit div.cgit-panel td.label {

+ padding-right: 0.5em;

+}

+

+div#cgit div.cgit-panel td.ctrl {

+ padding-left: 0.5em;

+}

+

+div#cgit table.commit-info th {

+ text-align: left;

+ font-weight: normal;

+ padding: 0.1em 1em 0.1em 0.1em;

+ vertical-align: top;

+}

+

+div#cgit table.commit-info td {

+ font-weight: normal;

+ padding: 0.1em 1em 0.1em 0.1em;

+}

+

+div#cgit div.commit-subject {

+ font-weight: bold;

+ font-size: 125%;

+ margin: 1.5em 0em 0.5em 0em;

+ padding: 0em;

+}

+

+div#cgit div.commit-msg {

+ white-space: pre;

+ font-family: monospace;

+}

+

+div#cgit div.notes-header {

+ font-weight: bold;

+ padding-top: 1.5em;

+}

+

+div#cgit div.notes {

+ white-space: pre;

+ font-family: monospace;

+ border: solid 1px #ee9;

+ background-color: #ffd;

+ padding: 0.3em 2em 0.3em 1em;

+ float: left;

+}

+

+div#cgit div.notes-footer {

+ clear: left;

+}

+

+div#cgit div.diffstat-header {

+ font-weight: bold;

+ padding-top: 1.5em;

+}

+

+div#cgit table.diffstat {

+ border-collapse: collapse;

+ border: solid 1px #aaa;

+ background-color: #eee;

+}

+

+div#cgit table.diffstat th {

+ font-weight: normal;

+ text-align: left;

+ text-decoration: underline;

+ padding: 0.1em 1em 0.1em 0.1em;

+ font-size: 100%;

+}

+

+div#cgit table.diffstat td {

+ padding: 0.2em 0.2em 0.1em 0.1em;

+ font-size: 100%;

+ border: none;

+}

+

+div#cgit table.diffstat td.mode {

+ white-space: nowrap;

+}

+

+div#cgit table.diffstat td span.modechange {

+ padding-left: 1em;

+ color: red;

+}

+

+div#cgit table.diffstat td.add a {

+ color: green;

+}

+

+div#cgit table.diffstat td.del a {

+ color: red;

+}

+

+div#cgit table.diffstat td.upd a {

+ color: blue;

+}

+

+div#cgit table.diffstat td.graph {

+ width: 500px;

+ vertical-align: middle;

+}

+

+div#cgit table.diffstat td.graph table {

+ border: none;

+}

+

+div#cgit table.diffstat td.graph td {

+ padding: 0px;

+ border: 0px;

+ height: 7pt;

+}

+

+div#cgit table.diffstat td.graph td.add {

+ background-color: #5c5;

+}

+

+div#cgit table.diffstat td.graph td.rem {

+ background-color: #c55;

+}

+

+div#cgit div.diffstat-summary {

+ color: #888;

+ padding-top: 0.5em;

+}

+

+div#cgit table.diff {

+ width: 100%;

+}

+

+div#cgit table.diff td {

+ font-family: monospace;

+ white-space: pre;

+}

+

+div#cgit table.diff td div.head {

+ font-weight: bold;

+ margin-top: 1em;

+ color: black;

+}

+

+div#cgit table.diff td div.hunk {

+ color: #009;

+}

+

+div#cgit table.diff td div.add {

+ color: green;

+}

+

+div#cgit table.diff td div.del {

+ color: red;

+}

+

+div#cgit .oid {

+ font-family: monospace;

+ font-size: 90%;

+}

+

+div#cgit .left {

+ text-align: left;

+}

+

+div#cgit .right {

+ text-align: right;

+}

+

+div#cgit table.list td.reposection {

+ font-style: italic;

+ color: #888;

+}

+

+div#cgit a.button {

+ font-size: 80%;

+ padding: 0em 0.5em;

+}

+

+div#cgit a.primary {

+ font-size: 100%;

+}

+

+div#cgit a.secondary {

+ font-size: 90%;

+}

+

+div#cgit td.toplevel-repo {

+

+}

+

+div#cgit table.list td.sublevel-repo {

+ padding-left: 1.5em;

+}

+

+div#cgit ul.pager {

+ list-style-type: none;

+ text-align: center;

+ margin: 1em 0em 0em 0em;

+ padding: 0;

+}

+

+div#cgit ul.pager li {

+ display: inline-block;

+ margin: 0.25em 0.5em;

+}

+

+div#cgit ul.pager a {

+ color: #777;

+}

+

+div#cgit ul.pager .current {

+ font-weight: bold;

+}

+

+div#cgit span.age-mins {

+ font-weight: bold;

+ color: #080;

+}

+

+div#cgit span.age-hours {

+ color: #080;

+}

+

+div#cgit span.age-days {

+ color: #040;

+}

+

+div#cgit span.age-weeks {

+ color: #444;

+}

+

+div#cgit span.age-months {

+ color: #888;

+}

+

+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;

+ padding: 0px 0.25em;

+ background-color: #88ff88;

+ border: solid 1px #007700;

+ border-radius: 2px;

+}

+

+div#cgit a.tag-deco {

+ color: #000;

+ margin: 0px 0.5em;

+ padding: 0px 0.25em;

+ background-color: #ffff88;

+ border: solid 1px #777700;

+ border-radius: 2px;

+}

+

+div#cgit a.tag-annotated-deco {

+ color: #000;

+ margin: 0px 0.5em;

+ padding: 0px 0.25em;

+ background-color: #ffcc88;

+ border: solid 1px #777700;

+ border-radius: 2px;

+}

+

+div#cgit a.remote-deco {

+ color: #000;

+ margin: 0px 0.5em;

+ padding: 0px 0.25em;

+ background-color: #ccccff;

+ border: solid 1px #000077;

+ border-radius: 2px;

+}

+

+div#cgit a.deco {

+ color: #000;

+ margin: 0px 0.5em;

+ padding: 0px 0.25em;

+ background-color: #ff8888;

+ border: solid 1px #770000;

+ border-radius: 2px;

+}

+

+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;

+ font-size: 75%;

+}

+

+div#cgit table.stats {

+ border: solid 1px black;

+ border-collapse: collapse;

+}

+

+div#cgit table.stats th {

+ text-align: left;

+ padding: 1px 0.5em;

+ background-color: #eee;

+ border: solid 1px black;

+}

+

+div#cgit table.stats td {

+ text-align: right;

+ padding: 1px 0.5em;

+ border: solid 1px black;

+}

+

+div#cgit table.stats td.total {

+ font-weight: bold;

+ text-align: left;

+}

+

+div#cgit table.stats td.sum {

+ color: #c00;

+ font-weight: bold;

+/* background-color: #eee; */

+}

+

+div#cgit table.stats td.left {

+ text-align: left;

+}

+

+div#cgit table.vgraph {

+ border-collapse: separate;

+ border: solid 1px black;

+ height: 200px;

+}

+

+div#cgit table.vgraph th {

+ background-color: #eee;

+ font-weight: bold;

+ border: solid 1px white;

+ padding: 1px 0.5em;

+}

+

+div#cgit table.vgraph td {

+ vertical-align: bottom;

+ padding: 0px 10px;

+}

+

+div#cgit table.vgraph div.bar {

+ background-color: #eee;

+}

+

+div#cgit table.hgraph {

+ border: solid 1px black;

+ width: 800px;

+}

+

+div#cgit table.hgraph th {

+ background-color: #eee;

+ font-weight: bold;

+ border: solid 1px black;

+ padding: 1px 0.5em;

+}

+

+div#cgit table.hgraph td {

+ vertical-align: middle;

+ padding: 2px 2px;

+}

+

+div#cgit table.hgraph div.bar {

+ background-color: #eee;

+ height: 1em;

+}

+

+div#cgit table.ssdiff {

+ width: 100%;

+}

+

+div#cgit table.ssdiff td {

+ font-size: 75%;

+ font-family: monospace;

+ white-space: pre;

+ padding: 1px 4px 1px 4px;

+ border-left: solid 1px #aaa;

+ border-right: solid 1px #aaa;

+}

+

+div#cgit table.ssdiff td.add {

+ color: black;

+ background: #cfc;

+ min-width: 50%;

+}

+

+div#cgit table.ssdiff td.add_dark {

+ color: black;

+ background: #aca;

+ min-width: 50%;

+}

+

+div#cgit table.ssdiff span.add {

+ background: #cfc;

+ font-weight: bold;

+}

+

+div#cgit table.ssdiff td.del {

+ color: black;

+ background: #fcc;

+ min-width: 50%;

+}

+

+div#cgit table.ssdiff td.del_dark {

+ color: black;

+ background: #caa;

+ min-width: 50%;

+}

+

+div#cgit table.ssdiff span.del {

+ background: #fcc;

+ font-weight: bold;

+}

+

+div#cgit table.ssdiff td.changed {

+ color: black;

+ background: #ffc;

+ min-width: 50%;

+}

+

+div#cgit table.ssdiff td.changed_dark {

+ color: black;

+ background: #cca;

+ min-width: 50%;

+}

+

+div#cgit table.ssdiff td.lineno {

+ color: black;

+ background: #eee;

+ text-align: right;

+ width: 3em;

+ min-width: 3em;

+}

+

+div#cgit table.ssdiff td.hunk {

+ color: black;

+ background: #ccf;

+ border-top: solid 1px #aaa;

+ border-bottom: solid 1px #aaa;

+}

+

+div#cgit table.ssdiff td.head {

+ border-top: solid 1px #aaa;

+ border-bottom: solid 1px #aaa;

+}

+

+div#cgit table.ssdiff td.head div.head {

+ font-weight: bold;

+ color: black;

+}

+

+div#cgit table.ssdiff td.foot {

+ border-top: solid 1px #aaa;

+ border-left: none;

+ border-right: none;

+ border-bottom: none;

+}

+

+div#cgit table.ssdiff td.space {

+ border: none;

+}

+

+div#cgit table.ssdiff td.space div {

+ min-height: 3em;

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef CGIT_H

+#define CGIT_H

+

+#include <stdbool.h>

+

+#include <git-compat-util.h>

+

+#include <archive.h>

+#include <commit.h>

+#include <diffcore.h>

+#include <diff.h>

+#include <environment.h>

+#include <graph.h>

+#include <grep.h>

+#include <hex.h>

+#include <log-tree.h>

+#include <notes.h>

+#include <object.h>

+#include <object-name.h>

+#include <odb.h>

+#include <path.h>

+#include <refs.h>

+#include <revision.h>

+#include <setup.h>

+#include <string-list.h>

+#include <strvec.h>

+#include <tag.h>

+#include <tree.h>

+#include <utf8.h>

+#include <wrapper.h>

+#include <xdiff-interface.h>

+#include <xdiff/xdiff.h>

+

+/* Add isgraph(x) to Git's sane ctype support (see git-compat-util.h) */

+#undef isgraph

+#define isgraph(x) (isprint((x)) && !isspace((x)))

+

+

+/*

+ * Limits used for relative dates

+ */

+#define TM_MIN 60

+#define TM_HOUR (TM_MIN * 60)

+#define TM_DAY (TM_HOUR * 24)

+#define TM_WEEK (TM_DAY * 7)

+#define TM_YEAR (TM_DAY * 365)

+#define TM_MONTH (TM_YEAR / 12.0)

+

+

+/*

+ * Default encoding

+ */

+#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);

+

+typedef enum {

+ DIFF_UNIFIED, DIFF_SSDIFF, DIFF_STATONLY

+} diff_type;

+

+typedef enum {

+ ABOUT, COMMIT, SOURCE, EMAIL, AUTH, OWNER

+} filter_type;

+

+struct cgit_filter {

+ int (*open)(struct cgit_filter *, va_list ap);

+ int (*close)(struct cgit_filter *);

+ void (*fprintfp)(struct cgit_filter *, FILE *, const char *prefix);

+ void (*cleanup)(struct cgit_filter *);

+ int argument_count;

+};

+

+struct cgit_exec_filter {

+ struct cgit_filter base;

+ char *cmd;

+ char **argv;

+ int old_stdout;

+ int pid;

+};

+

+struct cgit_repo {

+ char *url;

+ char *name;

+ char *path;

+ char *desc;

+ char *extra_head_content;

+ char *owner;

+ char *homepage;

+ char *defbranch;

+ char *module_link;

+ struct string_list readme;

+ char *section;

+ char *clone_url;

+ char *logo;

+ char *logo_link;

+ char *snapshot_prefix;

+ int snapshots;

+ int enable_blame;

+ int enable_commit_graph;

+ int enable_follow_links;

+ int enable_log_filecount;

+ int enable_log_linecount;

+ int enable_remote_branches;

+ int enable_subject_links;

+ int enable_html_serving;

+ int max_stats;

+ int branch_sort;

+ int commit_sort;

+ time_t mtime;

+ struct cgit_filter *about_filter;

+ struct cgit_filter *commit_filter;

+ struct cgit_filter *source_filter;

+ struct cgit_filter *email_filter;

+ struct cgit_filter *owner_filter;

+ struct string_list submodules;

+ int hide;

+ int ignore;

+};

+

+struct cgit_repolist {

+ int length;

+ int count;

+ struct cgit_repo *repos;

+};

+

+struct commitinfo {

+ struct commit *commit;

+ 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;

+};

+

+struct taginfo {

+ char *tagger;

+ char *tagger_email;

+ unsigned long tagger_date;

+ int tagger_tz;

+ char *msg;

+};

+

+struct refinfo {

+ const char *refname;

+ struct object *object;

+ union {

+ struct taginfo *tag;

+ struct commitinfo *commit;

+ };

+};

+

+struct reflist {

+ struct refinfo **refs;

+ int alloc;

+ int count;

+};

+

+struct cgit_query {

+ int has_symref;

+ int has_oid;

+ int has_difftype;

+ char *raw;

+ char *repo;

+ char *page;

+ char *search;

+ char *grep;

+ char *head;

+ char *oid;

+ char *oid2;

+ char *path;

+ char *name;

+ char *url;

+ char *period;

+ int ofs;

+ int nohead;

+ char *sort;

+ int showmsg;

+ diff_type difftype;

+ int show_all;

+ int context;

+ int ignorews;

+ int follow;

+ char *vpath;

+};

+

+struct cgit_config {

+ char *agefile;

+ char *cache_root;

+ char *clone_prefix;

+ char *clone_url;

+ char *favicon;

+ char *footer;

+ char *head_include;

+ char *header;

+ 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;

+ char *root_readme;

+ char *script_name;

+ char *section;

+ char *repository_sort;

+ char *virtual_root; /* Always ends with '/'. */

+ char *strict_export;

+ int cache_size;

+ int cache_dynamic_ttl;

+ int cache_max_create_time;

+ int cache_repo_ttl;

+ int cache_root_ttl;

+ int cache_scanrc_ttl;

+ int cache_static_ttl;

+ int cache_about_ttl;

+ int cache_snapshot_ttl;

+ int case_sensitive_sort;

+ int embedded;

+ int enable_filter_overrides;

+ int enable_follow_links;

+ 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;

+ int enable_remote_branches;

+ int enable_subject_links;

+ int enable_html_serving;

+ int enable_tree_linenumbers;

+ int enable_git_config;

+ int local_time;

+ int max_atom_items;

+ int max_repo_count;

+ int max_commit_count;

+ int max_lock_attempts;

+ int max_msg_len;

+ int max_repodesc_len;

+ int max_blob_size;

+ int max_stats;

+ int noplainemail;

+ int noheader;

+ int renamelimit;

+ int remove_suffix;

+ int scan_hidden_path;

+ int section_from_path;

+ int snapshots;

+ int section_sort;

+ int summary_branches;

+ int summary_log;

+ int summary_tags;

+ diff_type difftype;

+ 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;

+ struct cgit_filter *email_filter;

+ struct cgit_filter *owner_filter;

+ struct cgit_filter *auth_filter;

+};

+

+struct cgit_page {

+ time_t modified;

+ time_t expires;

+ size_t size;

+ const char *mimetype;

+ const char *charset;

+ const char *filename;

+ const char *etag;

+ const char *title;

+ int status;

+ const char *statusmsg;

+};

+

+struct cgit_environment {

+ const char *cgit_config;

+ const char *http_host;

+ const char *https;

+ const char *no_http;

+ const char *path_info;

+ const char *query_string;

+ const char *request_method;

+ const char *script_name;

+ const char *server_name;

+ const char *server_port;

+ const char *http_cookie;

+ const char *http_referer;

+ unsigned int content_length;

+ int authenticated;

+};

+

+struct cgit_context {

+ struct cgit_environment env;

+ struct cgit_query qry;

+ struct cgit_config cfg;

+ struct cgit_repo *repo;

+ struct cgit_page page;

+};

+

+typedef int (*write_archive_fn_t)(const char *, const char *);

+

+struct cgit_snapshot_format {

+ const char *suffix;

+ const char *mimetype;

+ write_archive_fn_t write_func;

+};

+

+extern const char *cgit_version;

+

+extern struct cgit_repolist cgit_repolist;

+extern struct cgit_context ctx;

+extern const struct cgit_snapshot_format cgit_snapshot_formats[];

+

+extern char *cgit_default_repo_desc;

+extern struct cgit_repo *cgit_add_repo(const char *url);

+extern struct cgit_repo *cgit_get_repoinfo(const char *url);

+extern void cgit_repo_config(struct cgit_repo *repo, const char *name,

+ const char *value);

+

+extern int chk_zero(int result, char *msg);

+extern int chk_positive(int result, char *msg);

+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 void strbuf_ensure_end(struct strbuf *sb, char c);

+

+extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);

+extern void cgit_free_reflist_inner(struct reflist *list);

+extern int cgit_refs_cb(const struct reference *ref, void *cb_data);

+

+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 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 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,

+ const char *prefix);

+

+__attribute__((format (printf,1,2)))

+extern char *fmt(const char *format,...);

+

+__attribute__((format (printf,1,2)))

+extern char *fmtalloc(const char *format,...);

+

+extern struct commitinfo *cgit_parse_commit(struct commit *commit);

+extern struct taginfo *cgit_parse_tag(struct tag *tag);

+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);

+extern void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix);

+extern void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv);

+extern struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype);

+extern void cgit_cleanup_filters(void);

+extern void cgit_init_filters(void);

+

+extern void cgit_prepare_repo_env(struct cgit_repo * repo);

+

+extern int read_first_line(const char *path, char **buf, size_t *size);

+

+extern char *strdup_first_line(const char *txt);

+

+extern char *expand_macros(const char *txt);

+

+extern char *get_mimetype_for_filename(const char *filename);

+

+#endif /* CGIT_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* 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);

+

+})();

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* cmd.c: the cgit command dispatcher

+ *

+ * 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 "cmd.h"

+#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"

+#include "ui-diff.h"

+#include "ui-log.h"

+#include "ui-patch.h"

+#include "ui-plain.h"

+#include "ui-refs.h"

+#include "ui-repolist.h"

+#include "ui-snapshot.h"

+#include "ui-stats.h"

+#include "ui-summary.h"

+#include "ui-tag.h"

+#include "ui-tree.h"

+

+static void HEAD_fn(void)

+{

+ cgit_clone_head();

+}

+

+static void atom_fn(void)

+{

+ cgit_print_atom(ctx.qry.head, ctx.qry.path, ctx.cfg.max_atom_items);

+}

+

+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] != '/' &&

+ (!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 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.oid, ctx.qry.path, ctx.qry.head, 0);

+}

+

+static void commit_fn(void)

+{

+ cgit_print_commit(ctx.qry.oid, ctx.qry.path);

+}

+

+static void diff_fn(void)

+{

+ cgit_print_diff(ctx.qry.oid, ctx.qry.oid2, ctx.qry.path, 1, 0);

+}

+

+static void rawdiff_fn(void)

+{

+ cgit_print_diff(ctx.qry.oid, ctx.qry.oid2, ctx.qry.path, 1, 1);

+}

+

+static void info_fn(void)

+{

+ cgit_clone_info();

+}

+

+static void log_fn(void)

+{

+ 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);

+}

+

+static void ls_cache_fn(void)

+{

+ ctx.page.mimetype = "text/plain";

+ ctx.page.filename = "ls-cache.txt";

+ cgit_print_http_headers();

+ cache_ls(ctx.cfg.cache_root);

+}

+

+static void objects_fn(void)

+{

+ cgit_clone_objects();

+}

+

+static void repolist_fn(void)

+{

+ cgit_print_repolist();

+}

+

+static void patch_fn(void)

+{

+ cgit_print_patch(ctx.qry.oid, ctx.qry.oid2, ctx.qry.path);

+}

+

+static void plain_fn(void)

+{

+ cgit_print_plain();

+}

+

+static void refs_fn(void)

+{

+ cgit_print_refs();

+}

+

+static void snapshot_fn(void)

+{

+ cgit_print_snapshot(ctx.qry.head, ctx.qry.oid, ctx.qry.path,

+ ctx.qry.nohead);

+}

+

+static void stats_fn(void)

+{

+ cgit_show_stats();

+}

+

+static void summary_fn(void)

+{

+ cgit_print_summary();

+}

+

+static void tag_fn(void)

+{

+ cgit_print_tag(ctx.qry.oid);

+}

+

+static void tree_fn(void)

+{

+ cgit_print_tree(ctx.qry.oid, ctx.qry.path);

+}

+

+#define def_cmd(name, want_repo, want_vpath, is_clone) \

+ {#name, name##_fn, want_repo, want_vpath, is_clone}

+

+struct cgit_cmd *cgit_get_cmd(void)

+{

+ static struct cgit_cmd cmds[] = {

+ 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),

+ def_cmd(info, 1, 0, 1),

+ def_cmd(log, 1, 1, 0),

+ def_cmd(ls_cache, 0, 0, 0),

+ def_cmd(objects, 1, 0, 1),

+ def_cmd(patch, 1, 1, 0),

+ def_cmd(plain, 1, 0, 0),

+ def_cmd(rawdiff, 1, 1, 0),

+ def_cmd(refs, 1, 0, 0),

+ def_cmd(repolist, 0, 0, 0),

+ def_cmd(snapshot, 1, 0, 0),

+ def_cmd(stats, 1, 1, 0),

+ def_cmd(summary, 1, 0, 0),

+ def_cmd(tag, 1, 0, 0),

+ def_cmd(tree, 1, 1, 0),

+ };

+ int i;

+

+ if (ctx.qry.page == NULL) {

+ if (ctx.repo)

+ ctx.qry.page = "summary";

+ else

+ ctx.qry.page = "repolist";

+ }

+

+ for (i = 0; i < sizeof(cmds)/sizeof(*cmds); i++)

+ if (!strcmp(ctx.qry.page, cmds[i].name))

+ return &cmds[i];

+ return NULL;

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef CMD_H

+#define CMD_H

+

+typedef void (*cgit_cmd_fn)(void);

+

+struct cgit_cmd {

+ const char *name;

+ cgit_cmd_fn fn;

+ unsigned int want_repo:1,

+ want_vpath:1,

+ is_clone:1;

+};

+

+extern struct cgit_cmd *cgit_get_cmd(void);

+

+#endif /* CMD_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* configfile.c: parsing of config files

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#include <git-compat-util.h>

+#include "configfile.h"

+

+static int next_char(FILE *f)

+{

+ int c = fgetc(f);

+ if (c == '\r') {

+ c = fgetc(f);

+ if (c != '\n') {

+ ungetc(c, f);

+ c = '\r';

+ }

+ }

+ return c;

+}

+

+static void skip_line(FILE *f)

+{

+ int c;

+

+ while ((c = next_char(f)) && c != '\n' && c != EOF)

+ ;

+}

+

+static int read_config_line(FILE *f, struct strbuf *name, struct strbuf *value)

+{

+ int c = next_char(f);

+

+ strbuf_reset(name);

+ strbuf_reset(value);

+

+ /* Skip comments and preceding spaces. */

+ for(;;) {

+ if (c == EOF)

+ return 0;

+ else if (c == '#' || c == ';')

+ skip_line(f);

+ else if (!isspace(c))

+ break;

+ c = next_char(f);

+ }

+

+ /* Read variable name. */

+ while (c != '=') {

+ if (c == '\n' || c == EOF)

+ return 0;

+ strbuf_addch(name, c);

+ c = next_char(f);

+ }

+

+ /* Read variable value. */

+ c = next_char(f);

+ while (c != '\n' && c != EOF) {

+ strbuf_addch(value, c);

+ c = next_char(f);

+ }

+

+ return 1;

+}

+

+int parse_configfile(const char *filename, configfile_value_fn fn)

+{

+ static int nesting;

+ struct strbuf name = STRBUF_INIT;

+ struct strbuf value = STRBUF_INIT;

+ FILE *f;

+

+ /* cancel deeply nested include-commands */

+ if (nesting > 8)

+ return -1;

+ if (!(f = fopen(filename, "r")))

+ return -1;

+ nesting++;

+ while (read_config_line(f, &name, &value))

+ fn(name.buf, value.buf);

+ nesting--;

+ fclose(f);

+ strbuf_release(&name);

+ strbuf_release(&value);

+ return 0;

+}

+

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef CONFIGFILE_H

+#define CONFIGFILE_H

+

+#include "cgit.h"

+

+typedef void (*configfile_value_fn)(const char *name, const char *value);

+

+extern int parse_configfile(const char *filename, configfile_value_fn fn);

+

+#endif /* CONFIGFILE_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* filter.c: filter framework functions

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#include "cgit.h"

+#include "html.h"

+#ifndef NO_LUA

+#include <dlfcn.h>

+#include <lua.h>

+#include <lualib.h>

+#include <lauxlib.h>

+#endif

+

+static inline void reap_filter(struct cgit_filter *filter)

+{

+ if (filter && filter->cleanup)

+ filter->cleanup(filter);

+}

+

+void cgit_cleanup_filters(void)

+{

+ int i;

+ reap_filter(ctx.cfg.about_filter);

+ reap_filter(ctx.cfg.commit_filter);

+ reap_filter(ctx.cfg.source_filter);

+ reap_filter(ctx.cfg.email_filter);

+ reap_filter(ctx.cfg.owner_filter);

+ reap_filter(ctx.cfg.auth_filter);

+ for (i = 0; i < cgit_repolist.count; ++i) {

+ reap_filter(cgit_repolist.repos[i].about_filter);

+ reap_filter(cgit_repolist.repos[i].commit_filter);

+ reap_filter(cgit_repolist.repos[i].source_filter);

+ reap_filter(cgit_repolist.repos[i].email_filter);

+ reap_filter(cgit_repolist.repos[i].owner_filter);

+ }

+}

+

+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++)

+ filter->argv[i + 1] = va_arg(ap, char *);

+

+ filter->old_stdout = chk_positive(dup(STDOUT_FILENO),

+ "Unable to duplicate STDOUT");

+ 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(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(pipe_fh[0]);

+ chk_non_negative(dup2(pipe_fh[1], STDOUT_FILENO),

+ "Unable to use pipe as STDOUT");

+ close(pipe_fh[1]);

+ return 0;

+}

+

+static int close_exec_filter(struct cgit_filter *base)

+{

+ struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;

+ int i, exit_status = 0;

+

+ chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),

+ "Unable to restore STDOUT");

+ close(filter->old_stdout);

+ if (filter->pid < 0)

+ goto done;

+ waitpid(filter->pid, &exit_status, 0);

+ if (WIFEXITED(exit_status))

+ goto done;

+ die("Subprocess %s exited abnormally", filter->cmd);

+

+done:

+ for (i = 0; i < filter->base.argument_count; i++)

+ filter->argv[i + 1] = NULL;

+ return WEXITSTATUS(exit_status);

+

+}

+

+static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *prefix)

+{

+ struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;

+ fprintf(f, "%sexec:%s\n", prefix, filter->cmd);

+}

+

+static void cleanup_exec_filter(struct cgit_filter *base)

+{

+ struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;

+ if (filter->argv) {

+ free(filter->argv);

+ filter->argv = NULL;

+ }

+ if (filter->cmd) {

+ free(filter->cmd);

+ filter->cmd = NULL;

+ }

+}

+

+static struct cgit_filter *new_exec_filter(const char *cmd, int argument_count)

+{

+ struct cgit_exec_filter *f;

+ int args_size = 0;

+

+ f = xmalloc(sizeof(*f));

+ /* We leave argv for now and assign it below. */

+ cgit_exec_filter_init(f, strdup_first_line(cmd), NULL);

+ f->base.argument_count = argument_count;

+ args_size = (2 + argument_count) * sizeof(char *);

+ f->argv = xmalloc(args_size);

+ memset(f->argv, 0, args_size);

+ f->argv[0] = f->cmd;

+ return &f->base;

+}

+

+void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)

+{

+ memset(filter, 0, sizeof(*filter));

+ filter->base.open = open_exec_filter;

+ filter->base.close = close_exec_filter;

+ filter->base.fprintfp = fprintf_exec_filter;

+ filter->base.cleanup = cleanup_exec_filter;

+ filter->cmd = cmd;

+ filter->argv = argv;

+ /* The argument count for open_filter is zero by default, unless called from new_filter, above. */

+ filter->base.argument_count = 0;

+}

+

+#ifdef NO_LUA

+void cgit_init_filters(void)

+{

+}

+#endif

+

+#ifndef NO_LUA

+static ssize_t (*libc_write)(int fd, const void *buf, size_t count);

+static ssize_t (*filter_write)(struct cgit_filter *base, const void *buf, size_t count) = NULL;

+static struct cgit_filter *current_write_filter = NULL;

+

+void cgit_init_filters(void)

+{

+ libc_write = dlsym(RTLD_NEXT, "write");

+ if (!libc_write)

+ die("Could not locate libc's write function");

+}

+

+ssize_t write(int fd, const void *buf, size_t count)

+{

+ if (fd != STDOUT_FILENO || !filter_write)

+ return libc_write(fd, buf, count);

+ return filter_write(current_write_filter, buf, count);

+}

+

+static inline void hook_write(struct cgit_filter *filter, ssize_t (*new_write)(struct cgit_filter *base, const void *buf, size_t count))

+{

+ /* We want to avoid buggy nested patterns. */

+ assert(filter_write == NULL);

+ assert(current_write_filter == NULL);

+ current_write_filter = filter;

+ filter_write = new_write;

+}

+

+static inline void unhook_write(void)

+{

+ assert(filter_write != NULL);

+ assert(current_write_filter != NULL);

+ filter_write = NULL;

+ current_write_filter = NULL;

+}

+

+struct lua_filter {

+ struct cgit_filter base;

+ char *script_file;

+ lua_State *lua_state;

+};

+

+static void error_lua_filter(struct lua_filter *filter)

+{

+ die("Lua error in %s: %s", filter->script_file, lua_tostring(filter->lua_state, -1));

+ lua_pop(filter->lua_state, 1);

+}

+

+static ssize_t write_lua_filter(struct cgit_filter *base, const void *buf, size_t count)

+{

+ struct lua_filter *filter = (struct lua_filter *)base;

+

+ lua_getglobal(filter->lua_state, "filter_write");

+ lua_pushlstring(filter->lua_state, buf, count);

+ if (lua_pcall(filter->lua_state, 1, 0, 0)) {

+ error_lua_filter(filter);

+ errno = EIO;

+ return -1;

+ }

+ return count;

+}

+

+static inline int hook_lua_filter(lua_State *lua_state, void (*fn)(const char *txt))

+{

+ const char *str;

+ ssize_t (*save_filter_write)(struct cgit_filter *base, const void *buf, size_t count);

+ struct cgit_filter *save_filter;

+

+ str = lua_tostring(lua_state, 1);

+ if (!str)

+ return 0;

+

+ save_filter_write = filter_write;

+ save_filter = current_write_filter;

+ unhook_write();

+ fn(str);

+ hook_write(save_filter, save_filter_write);

+

+ return 0;

+}

+

+static int html_lua_filter(lua_State *lua_state)

+{

+ return hook_lua_filter(lua_state, html);

+}

+

+static int html_txt_lua_filter(lua_State *lua_state)

+{

+ return hook_lua_filter(lua_state, html_txt);

+}

+

+static int html_attr_lua_filter(lua_State *lua_state)

+{

+ return hook_lua_filter(lua_state, html_attr);

+}

+

+static int html_url_path_lua_filter(lua_State *lua_state)

+{

+ return hook_lua_filter(lua_state, html_url_path);

+}

+

+static int html_url_arg_lua_filter(lua_State *lua_state)

+{

+ return hook_lua_filter(lua_state, html_url_arg);

+}

+

+static int html_include_lua_filter(lua_State *lua_state)

+{

+ return hook_lua_filter(lua_state, (void (*)(const char *))html_include);

+}

+

+static void cleanup_lua_filter(struct cgit_filter *base)

+{

+ struct lua_filter *filter = (struct lua_filter *)base;

+

+ if (!filter->lua_state)

+ return;

+

+ lua_close(filter->lua_state);

+ filter->lua_state = NULL;

+ if (filter->script_file) {

+ free(filter->script_file);

+ filter->script_file = NULL;

+ }

+}

+

+static int init_lua_filter(struct lua_filter *filter)

+{

+ if (filter->lua_state)

+ return 0;

+

+ if (!(filter->lua_state = luaL_newstate()))

+ return 1;

+

+ luaL_openlibs(filter->lua_state);

+

+ lua_pushcfunction(filter->lua_state, html_lua_filter);

+ lua_setglobal(filter->lua_state, "html");

+ lua_pushcfunction(filter->lua_state, html_txt_lua_filter);

+ lua_setglobal(filter->lua_state, "html_txt");

+ lua_pushcfunction(filter->lua_state, html_attr_lua_filter);

+ lua_setglobal(filter->lua_state, "html_attr");

+ lua_pushcfunction(filter->lua_state, html_url_path_lua_filter);

+ lua_setglobal(filter->lua_state, "html_url_path");

+ lua_pushcfunction(filter->lua_state, html_url_arg_lua_filter);

+ lua_setglobal(filter->lua_state, "html_url_arg");

+ lua_pushcfunction(filter->lua_state, html_include_lua_filter);

+ lua_setglobal(filter->lua_state, "html_include");

+

+ if (luaL_dofile(filter->lua_state, filter->script_file)) {

+ error_lua_filter(filter);

+ lua_close(filter->lua_state);

+ filter->lua_state = NULL;

+ return 1;

+ }

+ return 0;

+}

+

+static int open_lua_filter(struct cgit_filter *base, va_list ap)

+{

+ struct lua_filter *filter = (struct lua_filter *)base;

+ int i;

+

+ if (init_lua_filter(filter))

+ return 1;

+

+ hook_write(base, write_lua_filter);

+

+ lua_getglobal(filter->lua_state, "filter_open");

+ for (i = 0; i < filter->base.argument_count; ++i)

+ lua_pushstring(filter->lua_state, va_arg(ap, char *));

+ if (lua_pcall(filter->lua_state, filter->base.argument_count, 0, 0)) {

+ error_lua_filter(filter);

+ return 1;

+ }

+ return 0;

+}

+

+static int close_lua_filter(struct cgit_filter *base)

+{

+ struct lua_filter *filter = (struct lua_filter *)base;

+ int ret = 0;

+

+ lua_getglobal(filter->lua_state, "filter_close");

+ if (lua_pcall(filter->lua_state, 0, 1, 0)) {

+ error_lua_filter(filter);

+ ret = -1;

+ } else {

+ ret = lua_tonumber(filter->lua_state, -1);

+ lua_pop(filter->lua_state, 1);

+ }

+

+ unhook_write();

+ return ret;

+}

+

+static void fprintf_lua_filter(struct cgit_filter *base, FILE *f, const char *prefix)

+{

+ struct lua_filter *filter = (struct lua_filter *)base;

+ fprintf(f, "%slua:%s\n", prefix, filter->script_file);

+}

+

+

+static struct cgit_filter *new_lua_filter(const char *cmd, int argument_count)

+{

+ struct lua_filter *filter;

+

+ filter = xmalloc(sizeof(*filter));

+ memset(filter, 0, sizeof(*filter));

+ filter->base.open = open_lua_filter;

+ filter->base.close = close_lua_filter;

+ filter->base.fprintfp = fprintf_lua_filter;

+ filter->base.cleanup = cleanup_lua_filter;

+ filter->base.argument_count = argument_count;

+ filter->script_file = strdup_first_line(cmd);

+

+ return &filter->base;

+}

+

+#endif

+

+

+int cgit_open_filter(struct cgit_filter *filter, ...)

+{

+ int result;

+ va_list ap;

+ if (!filter)

+ return 0;

+ va_start(ap, filter);

+ result = filter->open(filter, ap);

+ va_end(ap);

+ return result;

+}

+

+int cgit_close_filter(struct cgit_filter *filter)

+{

+ if (!filter)

+ return 0;

+ return filter->close(filter);

+}

+

+void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)

+{

+ filter->fprintfp(filter, f, prefix);

+}

+

+

+

+static const struct {

+ const char *prefix;

+ struct cgit_filter *(*ctor)(const char *cmd, int argument_count);

+} filter_specs[] = {

+ { "exec", new_exec_filter },

+#ifndef NO_LUA

+ { "lua", new_lua_filter },

+#endif

+};

+

+struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype)

+{

+ const char *colon;

+ int i;

+ size_t len;

+ int argument_count;

+

+ if (!cmd || !cmd[0])

+ return NULL;

+

+ colon = strchr(cmd, ':');

+ len = colon - cmd;

+ /*

+ * In case we're running on Windows, don't allow a single letter before

+ * the colon.

+ */

+ if (len == 1)

+ colon = NULL;

+

+ switch (filtertype) {

+ case AUTH:

+ argument_count = 12;

+ break;

+

+ case EMAIL:

+ argument_count = 2;

+ break;

+

+ case OWNER:

+ argument_count = 0;

+ break;

+

+ case SOURCE:

+ case ABOUT:

+ argument_count = 1;

+ break;

+

+ case COMMIT:

+ default:

+ argument_count = 0;

+ break;

+ }

+

+ /* If no prefix is given, exec filter is the default. */

+ if (!colon)

+ return new_exec_filter(cmd, argument_count);

+

+ for (i = 0; i < ARRAY_SIZE(filter_specs); i++) {

+ if (len == strlen(filter_specs[i].prefix) &&

+ !strncmp(filter_specs[i].prefix, cmd, len))

+ return filter_specs[i].ctor(colon + 1, argument_count);

+ }

+

+ die("Invalid filter type: %.*s", (int) len, cmd);

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* html.c: helper functions for html output

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#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] = {

+ "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",

+ "%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",

+ "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",

+ "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",

+ "%20", NULL, "%22", "%23", NULL, "%25", "%26", "%27",

+ NULL, NULL, NULL, "%2b", NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, "%3c", "%3d", "%3e", "%3f",

+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, "%5c", NULL, "%5e", NULL,

+ "%60", NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

+ NULL, NULL, NULL, "%7b", "%7c", "%7d", NULL, "%7f",

+ "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",

+ "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",

+ "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",

+ "%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",

+ "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",

+ "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",

+ "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",

+ "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",

+ "%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",

+ "%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",

+ "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",

+ "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",

+ "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",

+ "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",

+ "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",

+ "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"

+};

+

+char *fmt(const char *format, ...)

+{

+ static char buf[8][1024];

+ static int bufidx;

+ int len;

+ va_list args;

+

+ bufidx++;

+ bufidx &= 7;

+

+ va_start(args, format);

+ len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args);

+ va_end(args);

+ if (len >= sizeof(buf[bufidx])) {

+ fprintf(stderr, "[html.c] string truncated: %s\n", format);

+ exit(1);

+ }

+ return buf[bufidx];

+}

+

+char *fmtalloc(const char *format, ...)

+{

+ struct strbuf sb = STRBUF_INIT;

+ va_list args;

+

+ va_start(args, format);

+ strbuf_vaddf(&sb, format, args);

+ va_end(args);

+

+ return strbuf_detach(&sb, NULL);

+}

+

+void html_raw(const char *data, size_t size)

+{

+ if (write(STDOUT_FILENO, data, size) != size)

+ die_errno("write error on html output");

+}

+

+void html(const char *txt)

+{

+ html_raw(txt, strlen(txt));

+}

+

+void htmlf(const char *format, ...)

+{

+ va_list args;

+ struct strbuf buf = STRBUF_INIT;

+

+ va_start(args, format);

+ strbuf_vaddf(&buf, format, args);

+ va_end(args);

+ html(buf.buf);

+ strbuf_release(&buf);

+}

+

+void html_txtf(const char *format, ...)

+{

+ va_list args;

+

+ va_start(args, format);

+ html_vtxtf(format, args);

+ va_end(args);

+}

+

+void html_vtxtf(const char *format, va_list ap)

+{

+ va_list cp;

+ struct strbuf buf = STRBUF_INIT;

+

+ va_copy(cp, ap);

+ strbuf_vaddf(&buf, format, cp);

+ va_end(cp);

+ html_txt(buf.buf);

+ strbuf_release(&buf);

+}

+

+void html_txt(const char *txt)

+{

+ if (txt)

+ html_ntxt(txt, strlen(txt));

+}

+

+ssize_t html_ntxt(const char *txt, size_t len)

+{

+ const char *t = txt;

+ 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);

+ if (c == '>')

+ html("&gt;");

+ else if (c == '<')

+ html("&lt;");

+ else if (c == '&')

+ html("&amp;");

+ txt = t + 1;

+ }

+ t++;

+ }

+ if (t != txt)

+ html_raw(txt, t - txt);

+ return slen;

+}

+

+void html_attrf(const char *fmt, ...)

+{

+ va_list ap;

+ struct strbuf sb = STRBUF_INIT;

+

+ va_start(ap, fmt);

+ strbuf_vaddf(&sb, fmt, ap);

+ va_end(ap);

+

+ html_attr(sb.buf);

+ strbuf_release(&sb);

+}

+

+void html_attr(const char *txt)

+{

+ const char *t = txt;

+ while (t && *t) {

+ int c = *t;

+ if (c == '<' || c == '>' || c == '\'' || c == '\"' || c == '&') {

+ html_raw(txt, t - txt);

+ if (c == '>')

+ html("&gt;");

+ else if (c == '<')

+ html("&lt;");

+ else if (c == '\'')

+ html("&#x27;");

+ else if (c == '"')

+ html("&quot;");

+ else if (c == '&')

+ html("&amp;");

+ txt = t + 1;

+ }

+ t++;

+ }

+ if (t != txt)

+ html(txt);

+}

+

+void html_url_path(const char *txt)

+{

+ const char *t = txt;

+ while (t && *t) {

+ unsigned char c = *t;

+ const char *e = url_escape_table[c];

+ if (e && c != '+' && c != '&') {

+ html_raw(txt, t - txt);

+ html(e);

+ txt = t + 1;

+ }

+ t++;

+ }

+ if (t != txt)

+ html(txt);

+}

+

+void html_url_arg(const char *txt)

+{

+ const char *t = txt;

+ while (t && *t) {

+ unsigned char c = *t;

+ const char *e = url_escape_table[c];

+ if (c == ' ')

+ e = "+";

+ if (e) {

+ html_raw(txt, t - txt);

+ html(e);

+ txt = t + 1;

+ }

+ t++;

+ }

+ if (t != txt)

+ html(txt);

+}

+

+void html_header_arg_in_quotes(const char *txt)

+{

+ const char *t = txt;

+ while (t && *t) {

+ unsigned char c = *t;

+ const char *e = NULL;

+ if (c == '\\')

+ e = "\\\\";

+ else if (c == '\r')

+ e = "\\r";

+ else if (c == '\n')

+ e = "\\n";

+ else if (c == '"')

+ e = "\\\"";

+ if (e) {

+ html_raw(txt, t - txt);

+ html(e);

+ txt = t + 1;

+ }

+ t++;

+ }

+ if (t != txt)

+ html(txt);

+

+}

+

+void html_hidden(const char *name, const char *value)

+{

+ html("<input type='hidden' name='");

+ html_attr(name);

+ html("' value='");

+ html_attr(value);

+ html("'/>");

+}

+

+void html_option(const char *value, const char *text, const char *selected_value)

+{

+ html("<option value='");

+ html_attr(value);

+ html("'");

+ if (selected_value && !strcmp(selected_value, value))

+ html(" selected='selected'");

+ html(">");

+ html_txt(text);

+ html("</option>\n");

+}

+

+void html_intoption(int value, const char *text, int selected_value)

+{

+ htmlf("<option value='%d'%s>", value,

+ value == selected_value ? " selected='selected'" : "");

+ html_txt(text);

+ html("</option>");

+}

+

+void html_link_open(const char *url, const char *title, const char *class)

+{

+ html("<a href='");

+ html_attr(url);

+ if (title) {

+ html("' title='");

+ html_attr(title);

+ }

+ if (class) {

+ html("' class='");

+ html_attr(class);

+ }

+ html("'>");

+}

+

+void html_link_close(void)

+{

+ html("</a>");

+}

+

+void html_fileperm(unsigned short mode)

+{

+ htmlf("%c%c%c", (mode & 4 ? 'r' : '-'),

+ (mode & 2 ? 'w' : '-'), (mode & 1 ? 'x' : '-'));

+}

+

+int html_include(const char *filename)

+{

+ FILE *f;

+ char buf[4096];

+ size_t len;

+

+ if (!(f = fopen(filename, "r"))) {

+ fprintf(stderr, "[cgit] Failed to include file %s: %s (%d).\n",

+ filename, strerror(errno), errno);

+ return -1;

+ }

+ while ((len = fread(buf, 1, 4096, f)) > 0)

+ html_raw(buf, len);

+ fclose(f);

+ return 0;

+}

+

+void http_parse_querystring(const char *txt, void (*fn)(const char *name, const char *value))

+{

+ const char *t = txt;

+

+ while (t && *t) {

+ char *name = url_decode_parameter_name(&t);

+ if (*name) {

+ char *value = url_decode_parameter_value(&t);

+ fn(name, value);

+ free(value);

+ }

+ free(name);

+ }

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef HTML_H

+#define HTML_H

+

+#include "cgit.h"

+

+extern void html_raw(const char *txt, size_t size);

+extern void html(const char *txt);

+

+__attribute__((format (printf,1,2)))

+extern void htmlf(const char *format,...);

+

+__attribute__((format (printf,1,2)))

+extern void html_txtf(const char *format,...);

+

+__attribute__((format (printf,1,0)))

+extern void html_vtxtf(const char *format, va_list ap);

+

+__attribute__((format (printf,1,2)))

+extern void html_attrf(const char *format,...);

+

+extern void html_txt(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);

+extern void html_header_arg_in_quotes(const char *txt);

+extern void html_hidden(const char *name, const char *value);

+extern void html_option(const char *value, const char *text, const char *selected_value);

+extern void html_intoption(int value, const char *text, int selected_value);

+extern void html_link_open(const char *url, const char *title, const char *class);

+extern void html_link_close(void);

+extern void html_fileperm(unsigned short mode);

+extern int html_include(const char *filename);

+

+extern void http_parse_querystring(const char *txt, void (*fn)(const char *name, const char *value));

+

+#endif /* HTML_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* parsing.c: parsing of config files

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+

+/*

+ * url syntax: [repo ['/' cmd [ '/' path]]]

+ * repo: any valid repo url, may contain '/'

+ * cmd: log | commit | diff | tree | view | blob | snapshot

+ * path: any valid path, may contain '/'

+ *

+ */

+void cgit_parse_url(const char *url)

+{

+ char *c, *cmd, *p, *buf;

+ struct cgit_repo *repo;

+

+ 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;

+ return;

+ }

+

+ buf = xstrdup(url);

+ cmd = NULL;

+ c = strchr(buf, '/');

+ while (c) {

+ c[0] = '\0';

+ repo = cgit_get_repoinfo(buf);

+ if (repo) {

+ ctx.repo = repo;

+ cmd = c;

+ }

+ c[0] = '/';

+ c = strchr(c + 1, '/');

+ }

+

+ if (ctx.repo) {

+ ctx.qry.repo = ctx.repo->url;

+ p = strchr(cmd + 1, '/');

+ if (p) {

+ p[0] = '\0';

+ if (p[1])

+ ctx.qry.path = trim_end(p + 1, '/');

+ }

+ if (cmd[1])

+ ctx.qry.page = xstrdup(cmd + 1);

+ }

+ free(buf);

+}

+

+static char *substr(const char *head, const char *tail)

+{

+ char *buf;

+

+ if (tail < head)

+ return xstrdup("");

+ buf = xmalloc(tail - head + 1);

+ strlcpy(buf, head, tail - head + 1);

+ return buf;

+}

+

+static void parse_user(const char *t, char **name, char **email, unsigned long *date, int *tz)

+{

+ struct ident_split ident;

+ unsigned email_len;

+

+ if (!split_ident_line(&ident, t, strchrnul(t, '\n') - t)) {

+ *name = substr(ident.name_begin, ident.name_end);

+

+ email_len = ident.mail_end - ident.mail_begin;

+ *email = xmalloc(strlen("<") + email_len + strlen(">") + 1);

+ 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);

+ }

+}

+

+#ifdef NO_ICONV

+#define reencode(a, b, c)

+#else

+static const char *reencode(char **txt, const char *src_enc, const char *dst_enc)

+{

+ char *tmp;

+

+ if (!txt)

+ return NULL;

+

+ if (!*txt || !src_enc || !dst_enc)

+ return *txt;

+

+ /* no encoding needed if src_enc equals dst_enc */

+ if (!strcasecmp(src_enc, dst_enc))

+ return *txt;

+

+ tmp = reencode_string(*txt, dst_enc, src_enc);

+ if (tmp) {

+ free(*txt);

+ *txt = tmp;

+ }

+ return *txt;

+}

+#endif

+

+static const char *next_header_line(const char *p)

+{

+ p = strchr(p, '\n');

+ if (!p)

+ return NULL;

+ return p + 1;

+}

+

+static int end_of_header(const char *p)

+{

+ return !p || (*p == '\n');

+}

+

+struct commitinfo *cgit_parse_commit(struct commit *commit)

+{

+ struct commitinfo *ret;

+ const char *p = repo_get_commit_buffer(the_repository, commit, NULL);

+ const char *t;

+

+ ret = xcalloc(1, sizeof(struct commitinfo));

+ ret->commit = commit;

+

+ if (!p)

+ return ret;

+

+ if (!skip_prefix(p, "tree ", &p))

+ die("Bad commit: %s", oid_to_hex(&commit->object.oid));

+ p += the_hash_algo->hexsz + 1;

+

+ while (skip_prefix(p, "parent ", &p))

+ 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_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_tz);

+ p = next_header_line(p);

+ }

+

+ if (p && skip_prefix(p, "encoding ", &p)) {

+ t = strchr(p, '\n');

+ if (t) {

+ ret->msg_encoding = substr(p, t + 1);

+ p = t + 1;

+ }

+ }

+

+ if (!ret->msg_encoding)

+ ret->msg_encoding = xstrdup("UTF-8");

+

+ while (!end_of_header(p))

+ p = next_header_line(p);

+ while (p && *p == '\n')

+ p++;

+ if (!p)

+ return ret;

+

+ t = strchrnul(p, '\n');

+ ret->subject = substr(p, t);

+ while (*t == '\n')

+ t++;

+ ret->msg = xstrdup(t);

+

+ reencode(&ret->author, ret->msg_encoding, PAGE_ENCODING);

+ reencode(&ret->author_email, ret->msg_encoding, PAGE_ENCODING);

+ reencode(&ret->committer, ret->msg_encoding, PAGE_ENCODING);

+ reencode(&ret->committer_email, ret->msg_encoding, PAGE_ENCODING);

+ reencode(&ret->subject, ret->msg_encoding, PAGE_ENCODING);

+ reencode(&ret->msg, ret->msg_encoding, PAGE_ENCODING);

+

+ return ret;

+}

+

+struct taginfo *cgit_parse_tag(struct tag *tag)

+{

+ void *data;

+ enum object_type type;

+ unsigned long size;

+ const char *p;

+ struct taginfo *ret = NULL;

+

+ data = odb_read_object(the_repository->objects, &tag->object.oid, &type, &size);

+ if (!data || type != OBJ_TAG)

+ goto cleanup;

+

+ ret = xcalloc(1, sizeof(struct taginfo));

+

+ 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_tz);

+ }

+ }

+

+ while (p && *p == '\n')

+ p++;

+

+ if (p && *p)

+ ret->msg = xstrdup(p);

+

+cleanup:

+ free(data);

+ return ret;

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* scan-tree.c

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#include "cgit.h"

+#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)

+{

+ struct stat st;

+ struct strbuf pathbuf = STRBUF_INIT;

+ int result = 0;

+

+ strbuf_addf(&pathbuf, "%s/objects", path);

+ if (stat(pathbuf.buf, &st)) {

+ if (errno != ENOENT)

+ fprintf(stderr, "Error checking path %s: %s (%d)\n",

+ path, strerror(errno), errno);

+ goto out;

+ }

+ if (!S_ISDIR(st.st_mode))

+ goto out;

+

+ strbuf_reset(&pathbuf);

+ strbuf_addf(&pathbuf, "%s/HEAD", path);

+ if (stat(pathbuf.buf, &st)) {

+ if (errno != ENOENT)

+ fprintf(stderr, "Error checking path %s: %s (%d)\n",

+ path, strerror(errno), errno);

+ goto out;

+ }

+ if (!S_ISREG(st.st_mode))

+ goto out;

+

+ result = 1;

+out:

+ strbuf_release(&pathbuf);

+ return result;

+}

+

+static struct cgit_repo *repo;

+

+static void scan_tree_repo_config(const char *name, const char *value)

+{

+ cgit_repo_config(repo, name, value);

+}

+

+static int gitconfig_config(const char *key, const char *value,

+ const __attribute__((unused)) struct config_context *ctx, void *cb)

+{

+ const char *name;

+

+ if (!strcmp(key, "gitweb.owner"))

+ cgit_repo_config(repo, "owner", value);

+ else if (!strcmp(key, "gitweb.description"))

+ cgit_repo_config(repo, "desc", value);

+ else if (!strcmp(key, "gitweb.category"))

+ cgit_repo_config(repo, "section", value);

+ else if (!strcmp(key, "gitweb.homepage"))

+ cgit_repo_config(repo, "homepage", value);

+ else if (skip_prefix(key, "cgit.", &name))

+ cgit_repo_config(repo, name, value);

+

+ return 0;

+}

+

+static char *xstrrchr(char *s, char *from, int c)

+{

+ while (from >= s && *from != c)

+ from--;

+ return from < s ? NULL : from;

+}

+

+static void add_repo(const char *base, struct strbuf *path)

+{

+ struct stat st;

+ struct passwd *pwd;

+ size_t pathlen;

+ struct strbuf rel = STRBUF_INIT;

+ char *p, *slash;

+ int n;

+ size_t size;

+

+ if (stat(path->buf, &st)) {

+ fprintf(stderr, "Error accessing %s: %s (%d)\n",

+ path->buf, strerror(errno), errno);

+ return;

+ }

+

+ strbuf_addch(path, '/');

+ pathlen = path->len;

+

+ if (ctx.cfg.strict_export) {

+ strbuf_addstr(path, ctx.cfg.strict_export);

+ if(stat(path->buf, &st))

+ return;

+ strbuf_setlen(path, pathlen);

+ }

+

+ strbuf_addstr(path, "noweb");

+ if (!stat(path->buf, &st))

+ return;

+ strbuf_setlen(path, pathlen);

+

+ if (!starts_with(path->buf, base))

+ strbuf_addbuf(&rel, path);

+ else

+ strbuf_addstr(&rel, path->buf + strlen(base) + 1);

+

+ if (!strcmp(rel.buf + rel.len - 5, "/.git"))

+ strbuf_setlen(&rel, rel.len - 5);

+ else if (rel.len && rel.buf[rel.len - 1] == '/')

+ strbuf_setlen(&rel, rel.len - 1);

+

+ repo = cgit_add_repo(rel.buf);

+ if (ctx.cfg.enable_git_config) {

+ strbuf_addstr(path, "config");

+ git_config_from_file(gitconfig_config, path->buf, NULL);

+ strbuf_setlen(path, pathlen);

+ }

+

+ if (ctx.cfg.remove_suffix) {

+ size_t urllen;

+ strip_suffix(repo->url, ".git", &urllen);

+ strip_suffix_mem(repo->url, &urllen, "/");

+ repo->url[urllen] = '\0';

+ }

+ repo->path = strdup_first_line(path->buf);

+ while (!repo->owner) {

+ if ((pwd = getpwuid(st.st_uid)) == NULL) {

+ fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",

+ path->buf, strerror(errno), errno);

+ break;

+ }

+ if (pwd->pw_gecos)

+ if ((p = strchr(pwd->pw_gecos, ',')))

+ *p = '\0';

+ repo->owner = strdup_first_line(pwd->pw_gecos ? pwd->pw_gecos : pwd->pw_name);

+ }

+

+ if (repo->desc == cgit_default_repo_desc || !repo->desc) {

+ strbuf_addstr(path, "description");

+ if (!stat(path->buf, &st))

+ read_first_line(path->buf, &repo->desc, &size);

+ strbuf_setlen(path, pathlen);

+ }

+

+ if (ctx.cfg.section_from_path) {

+ n = ctx.cfg.section_from_path;

+ if (n > 0) {

+ slash = rel.buf - 1;

+ while (slash && n && (slash = strchr(slash + 1, '/')))

+ n--;

+ } else {

+ slash = rel.buf + rel.len;

+ while (slash && n && (slash = xstrrchr(rel.buf, slash - 1, '/')))

+ n++;

+ }

+ if (slash && !n) {

+ *slash = '\0';

+ repo->section = strdup_first_line(rel.buf);

+ *slash = '/';

+ if (starts_with(repo->name, repo->section)) {

+ repo->name += strlen(repo->section);

+ if (*repo->name == '/')

+ repo->name++;

+ }

+ }

+ }

+

+ strbuf_addstr(path, "cgitrc");

+ if (!stat(path->buf, &st))

+ parse_configfile(path->buf, &scan_tree_repo_config);

+

+ strbuf_release(&rel);

+}

+

+static void scan_path(const char *base, const char *path)

+{

+ DIR *dir = opendir(path);

+ struct dirent *ent;

+ struct strbuf pathbuf = STRBUF_INIT;

+ size_t pathlen = strlen(path);

+ struct stat st;

+

+ if (!dir) {

+ fprintf(stderr, "Error opening directory %s: %s (%d)\n",

+ path, strerror(errno), errno);

+ return;

+ }

+

+ strbuf_add(&pathbuf, path, strlen(path));

+ if (is_git_dir(pathbuf.buf)) {

+ add_repo(base, &pathbuf);

+ goto end;

+ }

+ strbuf_addstr(&pathbuf, "/.git");

+ if (is_git_dir(pathbuf.buf)) {

+ add_repo(base, &pathbuf);

+ goto end;

+ }

+ /*

+ * Add one because we don't want to lose the trailing '/' when we

+ * reset the length of pathbuf in the loop below.

+ */

+ pathlen++;

+ while ((ent = readdir(dir)) != NULL) {

+ if (ent->d_name[0] == '.') {

+ if (ent->d_name[1] == '\0')

+ continue;

+ if (ent->d_name[1] == '.' && ent->d_name[2] == '\0')

+ continue;

+ if (!ctx.cfg.scan_hidden_path)

+ continue;

+ }

+ strbuf_setlen(&pathbuf, pathlen);

+ strbuf_addstr(&pathbuf, ent->d_name);

+ if (stat(pathbuf.buf, &st)) {

+ fprintf(stderr, "Error checking path %s: %s (%d)\n",

+ pathbuf.buf, strerror(errno), errno);

+ continue;

+ }

+ if (S_ISDIR(st.st_mode))

+ scan_path(base, pathbuf.buf);

+ }

+end:

+ strbuf_release(&pathbuf);

+ closedir(dir);

+}

+

+void scan_projects(const char *path, const char *projectsfile)

+{

+ struct strbuf line = STRBUF_INIT;

+ FILE *projects;

+ int err;

+

+ projects = fopen(projectsfile, "r");

+ if (!projects) {

+ fprintf(stderr, "Error opening projectsfile %s: %s (%d)\n",

+ projectsfile, strerror(errno), errno);

+ return;

+ }

+ while (strbuf_getline(&line, projects) != EOF) {

+ if (!line.len)

+ continue;

+ strbuf_insert(&line, 0, "/", 1);

+ strbuf_insert(&line, 0, path, strlen(path));

+ scan_path(path, line.buf);

+ }

+ if ((err = ferror(projects))) {

+ fprintf(stderr, "Error reading from projectsfile %s: %s (%d)\n",

+ projectsfile, strerror(err), err);

+ }

+ fclose(projects);

+ strbuf_release(&line);

+}

+

+void scan_tree(const char *path)

+{

+ scan_path(path, path);

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+extern void scan_projects(const char *path, const char *projectsfile);

+extern void scan_tree(const char *path);

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* shared.c: global vars + some callback functions

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+

+struct cgit_repolist cgit_repolist;

+struct cgit_context ctx;

+

+int chk_zero(int result, char *msg)

+{

+ if (result != 0)

+ die_errno("%s", msg);

+ return result;

+}

+

+int chk_positive(int result, char *msg)

+{

+ if (result <= 0)

+ die_errno("%s", msg);

+ return result;

+}

+

+int chk_non_negative(int result, char *msg)

+{

+ if (result < 0)

+ die_errno("%s", msg);

+ return result;

+}

+

+char *cgit_default_repo_desc = "[no description]";

+struct cgit_repo *cgit_add_repo(const char *url)

+{

+ struct cgit_repo *ret;

+

+ if (++cgit_repolist.count > cgit_repolist.length) {

+ if (cgit_repolist.length == 0)

+ cgit_repolist.length = 8;

+ else

+ cgit_repolist.length *= 2;

+ cgit_repolist.repos = xrealloc(cgit_repolist.repos,

+ cgit_repolist.length *

+ sizeof(struct cgit_repo));

+ }

+

+ ret = &cgit_repolist.repos[cgit_repolist.count-1];

+ memset(ret, 0, sizeof(struct cgit_repo));

+ ret->url = trim_end(url, '/');

+ *strchrnul(ret->url, '\n') = '\0';

+ 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_follow_links = ctx.cfg.enable_follow_links;

+ ret->enable_log_filecount = ctx.cfg.enable_log_filecount;

+ ret->enable_log_linecount = ctx.cfg.enable_log_linecount;

+ ret->enable_remote_branches = ctx.cfg.enable_remote_branches;

+ ret->enable_subject_links = ctx.cfg.enable_subject_links;

+ ret->enable_html_serving = ctx.cfg.enable_html_serving;

+ ret->max_stats = ctx.cfg.max_stats;

+ ret->branch_sort = ctx.cfg.branch_sort;

+ ret->commit_sort = ctx.cfg.commit_sort;

+ ret->module_link = ctx.cfg.module_link;

+ ret->readme = ctx.cfg.readme;

+ ret->mtime = -1;

+ ret->about_filter = ctx.cfg.about_filter;

+ ret->commit_filter = ctx.cfg.commit_filter;

+ ret->source_filter = ctx.cfg.source_filter;

+ ret->email_filter = ctx.cfg.email_filter;

+ ret->owner_filter = ctx.cfg.owner_filter;

+ ret->clone_url = ctx.cfg.clone_url;

+ ret->submodules.strdup_strings = 1;

+ ret->hide = ret->ignore = 0;

+ return ret;

+}

+

+struct cgit_repo *cgit_get_repoinfo(const char *url)

+{

+ int i;

+ struct cgit_repo *repo;

+

+ for (i = 0; i < cgit_repolist.count; i++) {

+ repo = &cgit_repolist.repos[i];

+ if (repo->ignore)

+ continue;

+ if (!strcmp(repo->url, url))

+ return repo;

+ }

+ return NULL;

+}

+

+void cgit_free_commitinfo(struct commitinfo *info)

+{

+ free(info->author);

+ free(info->author_email);

+ free(info->committer);

+ free(info->committer_email);

+ free(info->subject);

+ free(info->msg);

+ free(info->msg_encoding);

+ free(info);

+}

+

+char *trim_end(const char *str, char c)

+{

+ int len;

+

+ if (str == NULL)

+ return NULL;

+ len = strlen(str);

+ while (len > 0 && str[len - 1] == c)

+ len--;

+ if (len == 0)

+ return NULL;

+ return xstrndup(str, len);

+}

+

+char *ensure_end(const char *str, char c)

+{

+ size_t len = strlen(str);

+ char *result;

+

+ if (len && str[len - 1] == c)

+ return xstrndup(str, len);

+

+ result = xmalloc(len + 2);

+ memcpy(result, str, len);

+ result[len] = '/';

+ result[len + 1] = '\0';

+ return result;

+}

+

+void strbuf_ensure_end(struct strbuf *sb, char c)

+{

+ if (!sb->len || sb->buf[sb->len - 1] != c)

+ strbuf_addch(sb, c);

+}

+

+void cgit_add_ref(struct reflist *list, struct refinfo *ref)

+{

+ size_t size;

+

+ if (list->count >= list->alloc) {

+ list->alloc += (list->alloc ? list->alloc : 4);

+ size = list->alloc * sizeof(struct refinfo *);

+ list->refs = xrealloc(list->refs, size);

+ }

+ list->refs[list->count++] = ref;

+}

+

+static struct refinfo *cgit_mk_refinfo(const char *refname, const struct object_id *oid)

+{

+ struct refinfo *ref;

+

+ ref = xmalloc(sizeof (struct refinfo));

+ ref->refname = xstrdup(refname);

+ ref->object = parse_object(the_repository, oid);

+ switch (ref->object->type) {

+ case OBJ_TAG:

+ ref->tag = cgit_parse_tag((struct tag *)ref->object);

+ break;

+ case OBJ_COMMIT:

+ ref->commit = cgit_parse_commit((struct commit *)ref->object);

+ break;

+ }

+ return ref;

+}

+

+void cgit_free_taginfo(struct taginfo *tag)

+{

+ if (tag->tagger)

+ free(tag->tagger);

+ if (tag->tagger_email)

+ free(tag->tagger_email);

+ if (tag->msg)

+ free(tag->msg);

+ free(tag);

+}

+

+static void cgit_free_refinfo(struct refinfo *ref)

+{

+ if (ref->refname)

+ free((char *)ref->refname);

+ switch (ref->object->type) {

+ case OBJ_TAG:

+ cgit_free_taginfo(ref->tag);

+ break;

+ case OBJ_COMMIT:

+ cgit_free_commitinfo(ref->commit);

+ break;

+ }

+ free(ref);

+}

+

+void cgit_free_reflist_inner(struct reflist *list)

+{

+ int i;

+

+ for (i = 0; i < list->count; i++) {

+ cgit_free_refinfo(list->refs[i]);

+ }

+ free(list->refs);

+}

+

+int cgit_refs_cb(const struct reference *ref, void *cb_data)

+{

+ struct reflist *list = (struct reflist *)cb_data;

+ struct refinfo *info = cgit_mk_refinfo(ref->name, ref->oid);

+

+ if (info)

+ cgit_add_ref(list, info);

+ return 0;

+}

+

+void cgit_diff_tree_cb(struct diff_queue_struct *q,

+ struct diff_options *options, void *data)

+{

+ int i;

+

+ for (i = 0; i < q->nr; i++) {

+ if (q->queue[i]->status == 'U')

+ continue;

+ ((filepair_fn)data)(q->queue[i]);

+ }

+}

+

+static int load_mmfile(mmfile_t *file, const struct object_id *oid)

+{

+ enum object_type type;

+

+ if (is_null_oid(oid)) {

+ file->ptr = (char *)"";

+ file->size = 0;

+ } else {

+ file->ptr = odb_read_object(the_repository->objects, oid, &type,

+ (unsigned long *)&file->size);

+ }

+ return 1;

+}

+

+/*

+ * Receive diff-buffers from xdiff and concatenate them as

+ * needed across multiple callbacks.

+ *

+ * This is basically a copy of xdiff-interface.c/xdiff_outf(),

+ * ripped from git and modified to use globals instead of

+ * a special callback-struct.

+ */

+static char *diffbuf = NULL;

+static int buflen = 0;

+

+static int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)

+{

+ int i;

+

+ for (i = 0; i < nbuf; i++) {

+ if (mb[i].ptr[mb[i].size-1] != '\n') {

+ /* Incomplete line */

+ diffbuf = xrealloc(diffbuf, buflen + mb[i].size);

+ memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);

+ buflen += mb[i].size;

+ continue;

+ }

+

+ /* we have a complete line */

+ if (!diffbuf) {

+ ((linediff_fn)priv)(mb[i].ptr, mb[i].size);

+ continue;

+ }

+ diffbuf = xrealloc(diffbuf, buflen + mb[i].size);

+ memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);

+ ((linediff_fn)priv)(diffbuf, buflen + mb[i].size);

+ free(diffbuf);

+ diffbuf = NULL;

+ buflen = 0;

+ }

+ if (diffbuf) {

+ ((linediff_fn)priv)(diffbuf, buflen);

+ free(diffbuf);

+ diffbuf = NULL;

+ buflen = 0;

+ }

+ return 0;

+}

+

+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)

+{

+ mmfile_t file1, file2;

+ xpparam_t diff_params;

+ xdemitconf_t emit_params;

+ xdemitcb_t emit_cb;

+

+ if (!load_mmfile(&file1, old_oid) || !load_mmfile(&file2, new_oid))

+ return 1;

+

+ *old_size = file1.size;

+ *new_size = file2.size;

+

+ if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) ||

+ (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) {

+ *binary = 1;

+ if (file1.size)

+ free(file1.ptr);

+ if (file2.size)

+ free(file2.ptr);

+ return 0;

+ }

+

+ memset(&diff_params, 0, sizeof(diff_params));

+ memset(&emit_params, 0, sizeof(emit_params));

+ memset(&emit_cb, 0, sizeof(emit_cb));

+ diff_params.flags = XDF_NEED_MINIMAL;

+ if (ignorews)

+ diff_params.flags |= XDF_IGNORE_WHITESPACE;

+ emit_params.ctxlen = context > 0 ? context : 3;

+ emit_params.flags = XDL_EMIT_FUNCNAMES;

+ emit_cb.out_line = filediff_cb;

+ emit_cb.priv = fn;

+ xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);

+ if (file1.size)

+ free(file1.ptr);

+ if (file2.size)

+ free(file2.ptr);

+ return 0;

+}

+

+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;

+

+ repo_diff_setup(the_repository, &opt);

+ opt.output_format = DIFF_FORMAT_CALLBACK;

+ opt.detect_rename = 1;

+ opt.rename_limit = ctx.cfg.renamelimit;

+ 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 = xcalloc(1, sizeof(*item));

+ item->match = xstrdup(prefix);

+ item->len = strlen(prefix);

+ opt.pathspec.nr = 1;

+ opt.pathspec.items = item;

+ }

+ diff_setup_done(&opt);

+

+ if (old_oid && !is_null_oid(old_oid))

+ diff_tree_oid(old_oid, new_oid, "", &opt);

+ else

+ 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)

+{

+ const struct object_id *old_oid = NULL;

+

+ if (commit->parents)

+ old_oid = &commit->parents->item->object.oid;

+ cgit_diff_tree(old_oid, &commit->object.oid, fn, prefix,

+ ctx.qry.ignorews);

+}

+

+int cgit_parse_snapshots_mask(const char *str)

+{

+ struct string_list tokens = STRING_LIST_INIT_DUP;

+ struct string_list_item *item;

+ const struct cgit_snapshot_format *f;

+ int rv = 0;

+

+ /* favor legacy setting */

+ 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);

+

+ for_each_string_list_item(item, &tokens) {

+ for (f = cgit_snapshot_formats; f->suffix; f++) {

+ if (!strcmp(item->string, f->suffix) ||

+ !strcmp(item->string, f->suffix + 1)) {

+ rv |= cgit_snapshot_format_bit(f);

+ break;

+ }

+ }

+ }

+

+ string_list_clear(&tokens, 0);

+ return rv;

+}

+

+typedef struct {

+ char * name;

+ char * value;

+} cgit_env_var;

+

+void cgit_prepare_repo_env(struct cgit_repo * repo)

+{

+ cgit_env_var env_vars[] = {

+ { .name = "CGIT_REPO_URL", .value = repo->url },

+ { .name = "CGIT_REPO_NAME", .value = repo->name },

+ { .name = "CGIT_REPO_PATH", .value = repo->path },

+ { .name = "CGIT_REPO_OWNER", .value = repo->owner },

+ { .name = "CGIT_REPO_DEFBRANCH", .value = repo->defbranch },

+ { .name = "CGIT_REPO_SECTION", .value = repo->section },

+ { .name = "CGIT_REPO_CLONE_URL", .value = repo->clone_url }

+ };

+ int env_var_count = ARRAY_SIZE(env_vars);

+ cgit_env_var *p, *q;

+ static char *warn = "cgit warning: failed to set env: %s=%s\n";

+

+ p = env_vars;

+ q = p + env_var_count;

+ for (; p < q; p++)

+ if (p->value && setenv(p->name, p->value, 1))

+ fprintf(stderr, warn, p->name, p->value);

+}

+

+/* Read the content of the specified file into a newly allocated buffer,

+ * zeroterminate the buffer, truncate at a new line, and return 0 on success,

+ * errno otherwise.

+ */

+int read_first_line(const char *path, char **buf, size_t *size)

+{

+ int fd, e;

+ struct stat st;

+

+ fd = open(path, O_RDONLY);

+ if (fd == -1)

+ return errno;

+ if (fstat(fd, &st)) {

+ e = errno;

+ close(fd);

+ return e;

+ }

+ if (!S_ISREG(st.st_mode)) {

+ close(fd);

+ return EISDIR;

+ }

+ *buf = xmalloc(st.st_size + 1);

+ *size = read_in_full(fd, *buf, st.st_size);

+ e = errno;

+ (*buf)[*size] = '\0';

+ *strchrnul(*buf, '\n') = '\0';

+ close(fd);

+ return (*size == st.st_size ? 0 : e);

+}

+

+char *strdup_first_line(const char *txt)

+{

+ char *t = xstrdup(txt);

+ *strchrnul(t, '\n') = '\0';

+ return t;

+}

+

+static int is_token_char(char c)

+{

+ return isalnum(c) || c == '_';

+}

+

+/* Replace name with getenv(name), return pointer to zero-terminating char

+ */

+static char *expand_macro(char *name, int maxlength)

+{

+ char *value;

+ size_t len;

+

+ len = 0;

+ value = getenv(name);

+ if (value) {

+ len = strlen(value) + 1;

+ if (len > maxlength)

+ len = maxlength;

+ strlcpy(name, value, len);

+ --len;

+ }

+ return name + len;

+}

+

+#define EXPBUFSIZE (1024 * 8)

+

+/* Replace all tokens prefixed by '$' in the specified text with the

+ * value of the named environment variable.

+ * NB: the return value is a static buffer, i.e. it must be strdup'd

+ * by the caller.

+ */

+char *expand_macros(const char *txt)

+{

+ static char result[EXPBUFSIZE];

+ char *p, *start;

+ int len;

+

+ p = result;

+ start = NULL;

+ while (p < result + EXPBUFSIZE - 1 && txt && *txt) {

+ *p = *txt;

+ if (start) {

+ if (!is_token_char(*txt)) {

+ if (p - start > 0) {

+ *p = '\0';

+ len = result + EXPBUFSIZE - start - 1;

+ p = expand_macro(start, len) - 1;

+ }

+ start = NULL;

+ txt--;

+ }

+ p++;

+ txt++;

+ continue;

+ }

+ if (*txt == '$') {

+ start = p;

+ txt++;

+ continue;

+ }

+ p++;

+ txt++;

+ }

+ *p = '\0';

+ if (start && p - start > 0) {

+ len = result + EXPBUFSIZE - start - 1;

+ p = expand_macro(start, len);

+ *p = '\0';

+ }

+ return result;

+}

+

+char *get_mimetype_for_filename(const char *filename)

+{

+ const char *ext;

+ char *mimetype, line[1024];

+ struct string_list list = STRING_LIST_INIT_NODUP;

+ int i;

+ FILE *file;

+ struct string_list_item *mime;

+

+ if (!filename)

+ return NULL;

+

+ ext = strrchr(filename, '.');

+ if (!ext)

+ return NULL;

+ ++ext;

+ if (!ext[0])

+ return NULL;

+ mime = string_list_lookup(&ctx.cfg.mimetypes, ext);

+ if (mime)

+ return xstrdup(mime->util);

+

+ if (!ctx.cfg.mimetype_file)

+ return NULL;

+ file = fopen(ctx.cfg.mimetype_file, "r");

+ if (!file)

+ return NULL;

+ while (fgets(line, sizeof(line), file)) {

+ if (!line[0] || line[0] == '#')

+ continue;

+ string_list_split_in_place(&list, line, " \t\r\n", -1);

+ string_list_remove_empty_items(&list, 0);

+ mimetype = list.items[0].string;

+ for (i = 1; i < list.nr; i++) {

+ if (!strcasecmp(ext, list.items[i].string)) {

+ fclose(file);

+ return xstrdup(mimetype);

+ }

+ }

+ string_list_clear(&list, 0);

+ }

+ fclose(file);

+ return NULL;

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* ui-atom.c: functions for atom feeds

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+#include "ui-atom.h"

+#include "html.h"

+#include "ui-shared.h"

+

+static void add_entry(struct commit *commit, const char *host)

+{

+ char delim = '&';

+ char *hex;

+ char *mail, *t, *t2;

+ struct commitinfo *info;

+

+ info = cgit_parse_commit(commit);

+ hex = oid_to_hex(&commit->object.oid);

+ html("<entry>\n");

+ html("<title>");

+ html_txt(info->subject);

+ html("</title>\n");

+ html("<updated>");

+ html_txt(show_date(info->committer_date, 0,

+ date_mode_from_type(DATE_ISO8601_STRICT)));

+ html("</updated>\n");

+ html("<author>\n");

+ if (info->author) {

+ html("<name>");

+ html_txt(info->author);

+ html("</name>\n");

+ }

+ if (info->author_email && !ctx.cfg.noplainemail) {

+ mail = xstrdup(info->author_email);

+ t = strchr(mail, '<');

+ if (t)

+ t++;

+ else

+ t = mail;

+ t2 = strchr(t, '>');

+ if (t2)

+ *t2 = '\0';

+ html("<email>");

+ html_txt(t);

+ html("</email>\n");

+ free(mail);

+ }

+ html("</author>\n");

+ html("<published>");

+ html_txt(show_date(info->author_date, 0,

+ date_mode_from_type(DATE_ISO8601_STRICT)));

+ html("</published>\n");

+ if (host) {

+ char *pageurl;

+ html("<link rel='alternate' type='text/html' href='");

+ html(cgit_httpscheme());

+ html_attr(host);

+ pageurl = cgit_pageurl(ctx.repo->url, "commit", NULL);

+ html_attr(pageurl);

+ if (ctx.cfg.virtual_root)

+ delim = '?';

+ html_attrf("%cid=%s", delim, hex);

+ html("'/>\n");

+ free(pageurl);

+ }

+ 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("</entry>\n");

+ cgit_free_commitinfo(info);

+}

+

+

+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";

+ else if (!tip)

+ argv[1] = ctx.qry.head;

+

+ if (path) {

+ argv[argc++] = "--";

+ argv[argc++] = path;

+ }

+

+ repo_init_revisions(the_repository, &rev, NULL);

+ rev.abbrev = DEFAULT_ABBREV;

+ rev.commit_format = CMIT_FMT_DEFAULT;

+ rev.verbose_header = 1;

+ rev.show_root_diff = 0;

+ rev.max_count = max_count;

+ setup_revisions(argc, argv, &rev, NULL);

+ prepare_revision_walk(&rev);

+

+ host = cgit_hosturl();

+ ctx.page.mimetype = "text/xml";

+ ctx.page.charset = "utf-8";

+ cgit_print_http_headers();

+ html("<feed xmlns='http://www.w3.org/2005/Atom'>\n");

+ html("<title>");

+ html_txt(ctx.repo->name);

+ if (path) {

+ html("/");

+ html_txt(path);

+ }

+ if (tip && !ctx.qry.show_all) {

+ html(", branch ");

+ html_txt(tip);

+ }

+ html("</title>\n");

+ html("<subtitle>");

+ 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_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);

+ release_commit_memory(the_repository->parsed_objects, commit);

+ commit->parents = NULL;

+ }

+ html("</feed>\n");

+ free(host);

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef UI_ATOM_H

+#define UI_ATOM_H

+

+extern void cgit_print_atom(char *tip, const char *path, int max_count);

+

+#endif

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* 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)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#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(repo_find_unique_abbrev(the_repository, oid, DEFAULT_ABBREV), detail,

+ NULL, ctx.qry.head, oid_to_hex(oid), suspect->path);

+ html("</span>");

+ free(detail);

+

+ if (!repo_parse_commit(the_repository, 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 = odb_read_object_info(the_repository->objects, oid, &size);

+ if (type == OBJ_BAD) {

+ cgit_print_error_page(404, "Not found", "Bad object name: %s",

+ oid_to_hex(oid));

+ return;

+ }

+

+ buf = odb_read_object(the_repository->objects, 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);

+ repo_init_revisions(the_repository, &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)

+{

+ const 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 (repo_get_oid(the_repository, rev, &oid)) {

+ cgit_print_error_page(404, "Not found",

+ "Invalid revision name: %s", rev);

+ return;

+ }

+ commit = lookup_commit_reference(the_repository, &oid);

+ if (!commit || repo_parse_commit(the_repository, 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);

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef UI_BLAME_H

+#define UI_BLAME_H

+

+extern void cgit_print_blame(void);

+

+#endif /* UI_BLAME_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* ui-blob.c: show blob content

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+#include "ui-blob.h"

+#include "html.h"

+#include "ui-shared.h"

+

+struct walk_tree_context {

+ const char *match_path;

+ struct object_id *matched_oid;

+ unsigned int found_path:1;

+ unsigned int file_only:1;

+};

+

+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 (walk_tree_ctx->file_only && !S_ISREG(mode))

+ return READ_TREE_RECURSIVE;

+ if (strncmp(base->buf, walk_tree_ctx->match_path, base->len)

+ || strcmp(walk_tree_ctx->match_path + base->len, pathname))

+ return READ_TREE_RECURSIVE;

+ 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)

+{

+ struct object_id oid;

+ unsigned long size;

+ struct pathspec_item path_items = {

+ .match = xstrdup(path),

+ .len = strlen(path)

+ };

+ struct pathspec paths = {

+ .nr = 1,

+ .items = &path_items

+ };

+ struct walk_tree_context walk_tree_ctx = {

+ .match_path = path,

+ .matched_oid = &oid,

+ .found_path = 0,

+ .file_only = file_only

+ };

+

+ if (repo_get_oid(the_repository, ref, &oid))

+ goto done;

+ if (odb_read_object_info(the_repository->objects, &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)

+{

+ struct object_id oid;

+ enum object_type type;

+ char *buf;

+ unsigned long size;

+ struct commit *commit;

+ struct pathspec_item path_items = {

+ .match = path,

+ .len = strlen(path)

+ };

+ struct pathspec paths = {

+ .nr = 1,

+ .items = &path_items

+ };

+ struct walk_tree_context walk_tree_ctx = {

+ .match_path = path,

+ .matched_oid = &oid,

+ .found_path = 0,

+ .file_only = file_only

+ };

+

+ if (repo_get_oid(the_repository, head, &oid))

+ return -1;

+ type = odb_read_object_info(the_repository->objects, &oid, &size);

+ if (type == OBJ_COMMIT) {

+ 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 = odb_read_object_info(the_repository->objects, &oid, &size);

+ }

+ if (type == OBJ_BAD)

+ return -1;

+ buf = odb_read_object(the_repository->objects, &oid, &type, &size);

+ if (!buf)

+ return -1;

+ buf[size] = '\0';

+ html_raw(buf, size);

+ free(buf);

+ return 0;

+}

+

+void cgit_print_blob(const char *hex, char *path, const char *head, int file_only)

+{

+ struct object_id oid;

+ enum object_type type;

+ char *buf;

+ unsigned long size;

+ struct commit *commit;

+ struct pathspec_item path_items = {

+ .match = path,

+ .len = path ? strlen(path) : 0

+ };

+ struct pathspec paths = {

+ .nr = 1,

+ .items = &path_items

+ };

+ struct walk_tree_context walk_tree_ctx = {

+ .match_path = path,

+ .matched_oid = &oid,

+ .found_path = 0,

+ .file_only = file_only

+ };

+

+ if (hex) {

+ if (get_oid_hex(hex, &oid)) {

+ cgit_print_error_page(400, "Bad request",

+ "Bad hex value: %s", hex);

+ return;

+ }

+ } else {

+ if (repo_get_oid(the_repository, head, &oid)) {

+ cgit_print_error_page(404, "Not found",

+ "Bad ref: %s", head);

+ return;

+ }

+ }

+

+ type = odb_read_object_info(the_repository->objects, &oid, &size);

+

+ if ((!hex) && type == OBJ_COMMIT && path) {

+ 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 = odb_read_object_info(the_repository->objects, &oid, &size);

+ }

+

+ if (type == OBJ_BAD) {

+ cgit_print_error_page(404, "Not found",

+ "Bad object name: %s", hex);

+ return;

+ }

+

+ buf = odb_read_object(the_repository->objects, &oid, &type, &size);

+ if (!buf) {

+ cgit_print_error_page(500, "Internal server error",

+ "Error reading object %s", hex);

+ return;

+ }

+

+ buf[size] = '\0';

+ if (buffer_is_binary(buf, size))

+ ctx.page.mimetype = "application/octet-stream";

+ else

+ ctx.page.mimetype = "text/plain";

+ ctx.page.filename = path;

+

+ html("X-Content-Type-Options: nosniff\n");

+ html("Content-Security-Policy: default-src 'none'\n");

+ cgit_print_http_headers();

+ html_raw(buf, size);

+ free(buf);

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef UI_BLOB_H

+#define UI_BLOB_H

+

+extern int cgit_ref_path_exists(const char *path, const char *ref, int file_only);

+extern int cgit_print_file(char *path, const char *head, int file_only);

+extern void cgit_print_blob(const char *hex, char *path, const char *head, int file_only);

+

+#endif /* UI_BLOB_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* ui-clone.c: functions for http cloning, based on

+ * git's http-backend.c by Shawn O. Pearce

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+#include "ui-clone.h"

+#include "html.h"

+#include "ui-shared.h"

+#include "packfile.h"

+

+static int print_ref_info(const struct reference *ref, void *cb_data)

+{

+ struct object *obj;

+

+ if (!(obj = parse_object(the_repository, ref->oid)))

+ return 0;

+

+ htmlf("%s\t%s\n", oid_to_hex(ref->oid), ref->name);

+ if (obj->type == OBJ_TAG) {

+ if (!(obj = deref_tag(the_repository, obj, ref->name, 0)))

+ return 0;

+ htmlf("%s\t%s^{}\n", oid_to_hex(&obj->oid), ref->name);

+ }

+ return 0;

+}

+

+static void print_pack_info(void)

+{

+ struct odb_source *source;

+ char *offset;

+

+ ctx.page.mimetype = "text/plain";

+ ctx.page.filename = "objects/info/packs";

+ cgit_print_http_headers();

+ odb_reprepare(the_repository->objects);

+ for (source = the_repository->objects->sources; source; source = source->next) {

+ struct odb_source_files *files = odb_source_files_downcast(source);

+ struct packfile_list_entry *e;

+ for (e = files->packed->packs.head; e; e = e->next) {

+ struct packed_git *p = e->pack;

+ if (p->pack_local) {

+ offset = strrchr(p->pack_name, '/');

+ if (offset && offset[1] != '\0')

+ ++offset;

+ else

+ offset = p->pack_name;

+ htmlf("P %s\n", offset);

+ }

+ }

+ }

+}

+

+static void send_file(const char *path)

+{

+ struct stat st;

+

+ if (stat(path, &st)) {

+ switch (errno) {

+ case ENOENT:

+ cgit_print_error_page(404, "Not found", "Not found");

+ break;

+ case EACCES:

+ cgit_print_error_page(403, "Forbidden", "Forbidden");

+ break;

+ default:

+ cgit_print_error_page(400, "Bad request", "Bad request");

+ }

+ return;

+ }

+ ctx.page.mimetype = "application/octet-stream";

+ ctx.page.filename = path;

+ skip_prefix(path, ctx.repo->path, &ctx.page.filename);

+ skip_prefix(ctx.page.filename, "/", &ctx.page.filename);

+ cgit_print_http_headers();

+ html_include(path);

+}

+

+void cgit_clone_info(void)

+{

+ if (!ctx.qry.path || strcmp(ctx.qry.path, "refs")) {

+ cgit_print_error_page(400, "Bad request", "Bad request");

+ return;

+ }

+

+ ctx.page.mimetype = "text/plain";

+ ctx.page.filename = "info/refs";

+ cgit_print_http_headers();

+ refs_for_each_ref(get_main_ref_store(the_repository),

+ print_ref_info, NULL);

+}

+

+void cgit_clone_objects(void)

+{

+ char *p, *path;

+

+ 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;

+ }

+

+ path = repo_git_path(the_repository, "objects/%s", ctx.qry.path);

+ send_file(path);

+ free(path);

+ return;

+

+err:

+ cgit_print_error_page(400, "Bad request", "Bad request");

+}

+

+void cgit_clone_head(void)

+{

+ char *path;

+

+ path = repo_git_path(the_repository, "HEAD");

+ send_file(path);

+ free(path);

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef UI_CLONE_H

+#define UI_CLONE_H

+

+void cgit_clone_info(void);

+void cgit_clone_objects(void);

+void cgit_clone_head(void);

+

+#endif /* UI_CLONE_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* ui-commit.c: generate commit view

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+#include "ui-commit.h"

+#include "html.h"

+#include "ui-shared.h"

+#include "ui-diff.h"

+#include "ui-log.h"

+

+void cgit_print_commit(char *hex, const char *prefix)

+{

+ struct commit *commit, *parent;

+ struct commitinfo *info, *parent_info;

+ struct commit_list *p;

+ struct strbuf notes = STRBUF_INIT;

+ struct object_id oid;

+ char *tmp, *tmp2;

+ int parents = 0;

+

+ if (!hex)

+ hex = ctx.qry.head;

+

+ if (repo_get_oid(the_repository, hex, &oid)) {

+ cgit_print_error_page(400, "Bad request",

+ "Bad object id: %s", hex);

+ return;

+ }

+ commit = lookup_commit_reference(the_repository, &oid);

+ if (!commit) {

+ cgit_print_error_page(404, "Not found",

+ "Bad commit reference: %s", hex);

+ return;

+ }

+ info = cgit_parse_commit(commit);

+

+ format_display_notes(&oid, &notes, PAGE_ENCODING, 1);

+

+ 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");

+ html("<tr><th>author</th><td>");

+ cgit_open_filter(ctx.repo->email_filter, info->author_email, "commit");

+ html_txt(info->author);

+ if (!ctx.cfg.noplainemail) {

+ html(" ");

+ html_txt(info->author_email);

+ }

+ cgit_close_filter(ctx.repo->email_filter);

+ html("</td><td class='right'>");

+ 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");

+ html_txt(info->committer);

+ if (!ctx.cfg.noplainemail) {

+ html(" ");

+ html_txt(info->committer_email);

+ }

+ cgit_close_filter(ctx.repo->email_filter);

+ html("</td><td class='right'>");

+ 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='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='oid'>");

+ tmp = xstrdup(hex);

+ cgit_tree_link(oid_to_hex(get_commit_tree_oid(commit)), NULL, NULL,

+ ctx.qry.head, tmp, NULL);

+ if (prefix) {

+ html(" /");

+ cgit_tree_link(prefix, NULL, NULL, ctx.qry.head, tmp, prefix);

+ }

+ free(tmp);

+ html("</td></tr>\n");

+ for (p = commit->parents; p; p = p->next) {

+ parent = lookup_commit_reference(the_repository, &p->item->object.oid);

+ if (!parent) {

+ html("<tr><td colspan='3'>");

+ cgit_print_error("Error reading parent commit");

+ html("</td></tr>");

+ continue;

+ }

+ html("<tr><th>parent</th>"

+ "<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);

+ tmp2 = parent_info->subject;

+ }

+ cgit_commit_link(tmp2, NULL, NULL, ctx.qry.head, tmp, prefix);

+ html(" (");

+ cgit_diff_link("diff", NULL, NULL, ctx.qry.head, hex,

+ oid_to_hex(&p->item->object.oid), prefix);

+ html(")</td></tr>");

+ parents++;

+ }

+ if (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");

+ html("<div class='commit-subject'>");

+ cgit_open_filter(ctx.repo->commit_filter);

+ html_txt(info->subject);

+ cgit_close_filter(ctx.repo->commit_filter);

+ show_commit_decorations(commit);

+ html("</div>");

+ html("<div class='commit-msg'>");

+ cgit_open_filter(ctx.repo->commit_filter);

+ html_txt(info->msg);

+ cgit_close_filter(ctx.repo->commit_filter);

+ html("</div>");

+ if (notes.len != 0) {

+ html("<div class='notes-header'>Notes</div>");

+ html("<div class='notes'>");

+ cgit_open_filter(ctx.repo->commit_filter);

+ html_txt(notes.buf);

+ cgit_close_filter(ctx.repo->commit_filter);

+ html("</div>");

+ html("<div class='notes-footer'></div>");

+ }

+ if (parents < 3) {

+ if (parents)

+ tmp = oid_to_hex(&commit->parents->item->object.oid);

+ else

+ tmp = NULL;

+ cgit_print_diff(ctx.qry.oid, tmp, prefix, 0, 0);

+ }

+ strbuf_release(&notes);

+ cgit_free_commitinfo(info);

+ cgit_print_layout_end();

+}

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+#ifndef UI_COMMIT_H

+#define UI_COMMIT_H

+

+extern void cgit_print_commit(char *hex, const char *prefix);

+

+#endif /* UI_COMMIT_H */

+/* SPDX-FileCopyrightText: cgit Development Team <cgit@lists.zx2c4.com>

+ * SPDX-License-Identifier: GPL-2.0-only

+ */

+

+/* ui-diff.c: show diff between two blobs

+ *

+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>

+ *

+ * Licensed under GNU General Public License v2

+ * (see COPYING for full license text)

+ */

+

+#define USE_THE_REPOSITORY_VARIABLE

+

+#include "cgit.h"

+#include "ui-diff.h"

+#include "html.h"

+#include "ui-shared.h"

+#include "ui-ssdiff.h"

+

+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;

+static int lines_added, lines_removed;

+

+static struct fileinfo {

+ char status;

+ struct object_id old_oid[1];

+ struct object_id new_oid[1];

+ unsigned short old_mode;

+ unsigned short new_mode;

+ char *old_path;

+ char *new_path;

+ unsigned int added;

+ unsigned int removed;

+ unsigned long old_size;

+ unsigned long new_size;

+ unsigned int binary:1;

+} *items;

+

+static int use_ssdiff = 0;

+static struct diff_filepair *current_filepair;

+static const char *current_prefix;

+

+struct diff_filespec *cgit_get_current_old_file(void)

+{

+ return current_filepair->one;

+}

+

+struct diff_filespec *cgit_get_current_new_file(void)

+{

+ return current_filepair->two;

+}

+

+static void print_fileinfo(struct fileinfo *info)

+{

+ char *class;

+

+ switch (info->status) {

+ case DIFF_STATUS_ADDED:

+ class = "add";

+ break;

+ case DIFF_STATUS_COPIED:

+ class = "cpy";

+ break;

+ case DIFF_STATUS_DELETED:

+ class = "del";

+ break;

+ case DIFF_STATUS_MODIFIED:

+ class = "upd";

+ break;

+ case DIFF_STATUS_RENAMED:

+ class = "mov";

+ break;

+ case DIFF_STATUS_TYPE_CHANGED:

+ class = "typ";

+ break;

+ case DIFF_STATUS_UNKNOWN:

+ class = "unk";

+ break;

+ case DIFF_STATUS_UNMERGED:

+ class = "stg";

+ break;

+ default:

+ die("bug: unhandled diff status %c", info->status);

+ }

+

+ html("<tr>");

+ 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_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.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");

+ html_txt(info->old_path);

+ html(")");

+ }

+ html("</td><td class='right'>");

+ if (info->binary) {

+ htmlf("bin</td><td class='graph'>%ld -> %ld bytes",

+ info->old_size, info->new_size);

+ return;

+ }

+ htmlf("%d", info->added + info->removed);

+ html("</td><td class='graph'>");

+ htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes));

+ htmlf("<td class='add' style='width: %.1f%%;'/>",

+ info->added * 100.0 / max_changes);

+ htmlf("<td class='rem' style='width: %.1f%%;'/>",

+ info->removed * 100.0 / max_changes);

+ htmlf("<td class='none' style='width: %.1f%%;'/>",

+ (max_changes - info->removed - info->added) * 100.0 / max_changes);

+ html("</tr></table></td></tr>\n");

+}

+

+static void count_diff_lines(char *line, int len)

+{

+ if (line && (len > 0)) {

+ if (line[0] == '+')

+ lines_added++;

+ else if (line[0] == '-')

+ lines_removed++;

+ }

+}

+

+static int show_filepair(struct diff_filepair *pair)

+{

+ /* Always show if we have no limiting prefix. */

+ if (!current_prefix)

+ return 1;

+

+ /* Show if either path in the pair begins with the prefix. */

+ if (starts_with(pair->one->path, current_prefix) ||

+ starts_with(pair->two->path, current_prefix))

+ return 1;

+

+ /* Otherwise we don't want to show this filepair. */

+ return 0;

+}

+

+static void inspect_filepair(struct diff_filepair *pair)

+{

+ int binary = 0;

+ unsigned long old_size = 0;

+ unsigned long new_size = 0;

+

+ if (!show_filepair(pair))

+ return;

+

+ files++;

+ lines_added = 0;

+ lines_removed = 0;

+ 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)

+ slots = 4;

+ else

+ slots = slots * 2;

+ items = xrealloc(items, slots * sizeof(struct fileinfo));

+ }

+ items[files-1].status = pair->status;

+ 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);

+ items[files-1].new_path = xstrdup(pair->two->path);

+ items[files-1].added = lines_added;

+ items[files-1].removed = lines_removed;

+ items[files-1].old_size = old_size;

+ items[files-1].new_size = new_size;

+ items[files-1].binary = binary;

+ if (lines_added + lines_removed > max_changes)

+ max_changes = lines_added + lines_removed;

+ total_adds += lines_added;

+ total_rems += lines_removed;

+}

+

+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.oid,

+ ctx.qry.oid2, NULL);

+ if (prefix) {

+ html(" (limited to '");

+ html_txt(prefix);

+ html("')");

+ }

+ html("</div>");

+ html("<table summary='diffstat' class='diffstat'>");

+ max_changes = 0;

+ cgit_diff_tree(old_oid, new_oid, inspect_filepair, prefix,

+ ctx.qry.ignorews);

+ for (i = 0; i<files; i++)

+ print_fileinfo(&items[i]);

+ html("</table>");

+ html("<div class='diffstat-summary'>");

+ htmlf("%d files changed, %d insertions, %d deletions",

+ files, total_adds, total_rems);

+ html("</div>");

+}

+

+

+/*

+ * print a single line returned from xdiff

+ */

+static void print_line(char *line, int len)

+{

+ char *class = "ctx";

+ char c = line[len-1];

+

+ if (line[0] == '+')

+ class = "add";

+ else if (line[0] == '-')

+ class = "del";

+ else if (line[0] == '@')

+ class = "hunk";

+

+ htmlf("<div class='%s'>", class);

+ line[len-1] = '\0';

+ html_txt(line);

+ html("</div>");

+ line[len-1] = c;

+}

+

+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;

+