Bump dependencies

Reviewed-on: #2

.gitignore

@@ -0,0 +1,5 @@
+# Artificats
+/rio
+
+# Testing stuff
+*.json

.woodpecker.yml

@@ -0,0 +1,15 @@
+steps:
+  build:
+    image: "golang:1.21.5-alpine"
+    commands:
+      - go build ./cmd/rio
+      - go test $(go list ./... | grep -v /vendor/)
+    when:
+      - path: "**/*.go"
+  lint:
+    image: "golang:1.21.5-alpine"
+    commands:
+      - go fmt $(go list ./... | grep -v /vendor/)
+      - go vet $(go list ./... | grep -v /vendor/)
+    when:
+      - path: "**/*.go"

Containerfile

@@ -0,0 +1,10 @@
+FROM golang:1.25-alpine3.22 AS builder
+
+COPY . /app
+WORKDIR /app
+RUN go build ./cmd/rio
+
+FROM alpine:3.22
+
+COPY --from=builder /app/rio /usr/local/bin/rio
+ENTRYPOINT ["/usr/local/bin/rio"]

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  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
+them 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 prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  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.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey 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;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If 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 convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  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.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+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.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     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
+state 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 3 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, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program 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, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU 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.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -0,0 +1,103 @@
+# rio
+
+A webserver similat to Github Pages using the Gitea API. Supports running in HTTP-only
+mode and running in HTTPS mode with automatic certificates using ACME HTTP01 challenges.
+
+## Setup
+### DNS
+
+Assuming your pages domain is `pages.example.org`, you should add a  wildcard
+DNS record (if your provider supports it) to allow clients to resolve any
+`*.pages.example.org` record:
+
+```
+; Example for an authoritative Bind nameserver
+*.pages		3600	IN	A       <IPv4>
+*.pages		3600	IN	AAAA	<IPv6>
+```
+
+If you have setup a CAA record to lock ACME certificates to a certain
+CA, make sure you allow certificates using the HTTP01 challenge type from the
+ACME CA configured in rio.
+
+### rio
+
+To run rio, you can use environment variables or commandline flags. To see them,
+run `rio --help` or look at the [main file](./cmd/rio/main.go).
+
+If you run with `--acme-disable` (or `ACME_DISABLE=1`), then rio will not set up
+an HTTPS server and run with HTTP only on the configured host and port. In this
+configuration, only `--gitea-url` (`GITEA_URL`) and `--pages-domain` (`PAEGS_DOMAIN`)
+are required.
+
+If you run without `--acme-disable` (default), then rio will set up a HTTPS server
+to listen on the configured host and port. Additionally, a DNS01 challenge solver
+will be created using the provider specified by `--acme-dns-provider` (`ACME_DNS_PROVIDER`). For a provider list and each provider's options, see
+the [lego documentation](https://go-acme.github.io/lego/dns/). In this mode, `--acme-email` (`ACME_EMAIL`; The email to use to register
+an ACME account), `--acme-file` (`ACME_FILE`; Path to the file where ACME account data is stored), `--certs-file` (`CERTS_FILE`; Path to the file where certificates
+are stored in) are additionally required. `--acme-server` (`ACME_SERVER`) should also
+be set to your ACME CA's directory URL as this option defaults to the
+[Let's Encrypt Staging Environment](https://letsencrypt.org/docs/staging-environment/). Note that using this optional implies that you accept your
+configured ACME CA's Terms of Service. rio will also spawn an unencrypted HTTP server that is bound to the host specified with `--http-host` (`HTTP_HOST`) and
+the port specified with `--http-port` (`HTTP_PORT`). The functionality of this second HTTP server is to upgrade plain HTTP requests to HTTPS requests.
+
+You can also run with `--debug` (`DEBUG_ENABLE=1`) to enable debug logging.
+
+## Usage
+### Plain Domains
+
+When a user tries to access `<user>.pages.example.org/some-repo/files.html`, rio will
+first see if the repository `some-repo` exists for the user `<user>` on the configured
+Gitea server. If it does, then rio will try to proxy the file `files.html` from
+the repository `<user>/some-repo`. If that repository does not exist, then
+rio will try the repository `<user>/<user>.pages.example.org` next and look for the
+file `some-repo/files.html`.
+
+Note that the files MUST reside in the repository's `pages` branch. Otherwise, rio
+will not find the files.
+
+### CNAME Domains
+
+If you don't want to use `<user>.pages.example.org` and instead prefer to use your own
+domain (`cooldomain.rio`), you can add a CNAME record on your domain, redirecting to
+the pages domain:
+
+```
+; Example for Bind
+cooldomain.rio.                 3600    IN  CNAME   <user>.pages.example.org
+; For Let's Encrypt
+_acme-challenge.cooldomain.rio. 3600    IN  CNAME   cooldomain.rio.pages.example.org
+```
+
+This additionally requires your repository to have a file named `CNAME` that contains
+the domain to use (`cooldomain.rio` in this case).
+
+### Alternate CNAME Domains
+
+If there is a situation where you want to use a CNAME redirect on a (sub-) domain,
+where having a CNAME is not feasible, you can configure an "alternate CNAME".
+This is a special TXT record that contains the "CNAME" you want to specify.
+
+```
+; Example for Bind
+cooldomain.rio.                 3600    IN  A       <IPv4 of rio>
+_rio-cname.cooldomain.rio.      3600    IN  TXT     "cname=user.pages.example.org"
+```
+
+### Repository Redirects
+
+If you have multiple repositories with pages (and you use a CNAME), you can additionally
+add a TXT record to tell rio what repository to look for. For example, the following
+TXT record will tell rio to use the repository `example-repository` whenever
+`example-repository.rio` is accessed:
+
+```
+; Example for Bind
+_rio-pages.example-repository.rio.  3600    IN  TXT "repo=example-repository"
+```
+
+For this to work, it is important that the record's value starts with `repo=`.
+
+## License
+
+See `LICENSE`.

acme.go

@@ -1,343 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/base64"
-	"encoding/json"
-	"encoding/pem"
-	"io/ioutil"
-	"math/big"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/go-acme/lego/v4/certcrypto"
-	"github.com/go-acme/lego/v4/certificate"
-	"github.com/go-acme/lego/v4/lego"
-
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	AcmeChallengePathPrefix = "/.well-known/acme-challenge/"
-)
-
-var (
-	// Well-known -> Challenge solution
-	runningChallenges = make(map[string]string)
-	Certificates = CertificatesCache{
-		Certificates: make(map[string]CertificateWrapper),
-	}
-
-	// To access requestingDomains, first acquire the lock.
-	requestingLock = sync.Mutex{}
-
-	// Domain -> _. Check if domain is a key here to see if we're already requeting
-	// a certificate for it.
-	requestingDomains = make(map[string]bool)
-)
-
-func lockIfUnlockedDomain(domain string) bool {
-	requestingLock.Lock()
-	defer requestingLock.Unlock()
-
-	_, found := requestingDomains[domain]
-	if !found {
-		requestingDomains[domain] = true
-	}
-
-	return found
-}
-
-func unlockDomain(domain string) {
-	requestingLock.Lock()
-	defer requestingLock.Unlock()
-
-	delete(requestingDomains, domain)
-}
-
-type CertificateWrapper struct {
-	TlsCertificate *tls.Certificate `json:"-"`
-	Domain string `json:"domain"`
-	NotAfter time.Time `json:"not_after"`
-	PrivateKeyEncoded string `json:"private_key"`
-	Certificate []byte `json:"certificate"`
-	IssuerCertificate []byte `json:"issuer_certificate"`
-	CertificateUrl string `json:"certificate_url"`
-}
-
-func (c *CertificateWrapper) GetPrivateKey() *rsa.PrivateKey {
-	data, _ := base64.StdEncoding.DecodeString(c.PrivateKeyEncoded)
-	pk, _ := certcrypto.ParsePEMPrivateKey(data);
-
-	return pk.(*rsa.PrivateKey)
-}
-
-type CertificatesCache struct {
-	FallbackCertificate *CertificateWrapper
-	Certificates map[string]CertificateWrapper
-}
-
-type CertificatesStore struct {
-	FallbackCertificate CertificateWrapper `json:"fallback"`
-	Certificates []CertificateWrapper `json:"certificates"`
-}
-
-func (c *CertificatesCache) toStoreData() string {
-	certs := make([]CertificateWrapper, 0)
-	for _, cert := range c.Certificates {
-		certs = append(certs, cert)
-	}
-
-	result, err := json.Marshal(CertificatesStore{
-		FallbackCertificate: *c.FallbackCertificate,
-		Certificates: certs,
-	})
-	if err != nil {
-		log.Errorf("Failed to Marshal cache: %v", err)
-	}
-	return string(result)
-}
-
-func (c *CertificateWrapper) initTlsCertificate() {
-	pk, _ := base64.StdEncoding.DecodeString(c.PrivateKeyEncoded)
-	tlsCert, _ := tls.X509KeyPair(
-		c.Certificate,
-		pk,
-	)
-	c.TlsCertificate = &tlsCert
-}
-
-func CertificateFromStoreData(rawJson string) CertificatesCache {
-	var store CertificatesStore
-	_ = json.Unmarshal([]byte(rawJson), &store)
-
-	store.FallbackCertificate.initTlsCertificate()
-	cache := CertificatesCache{
-		FallbackCertificate: &store.FallbackCertificate,
-	}
-
-	certs := make(map[string]CertificateWrapper)
-	for _, cert := range store.Certificates {
-		cert.initTlsCertificate()
-		certs[cert.Domain] = cert
-	}
-	cache.Certificates = certs
-	
-	return cache
-}
-
-func LoadCertificateStoreFromFile(path string) error {
-	content, err := ioutil.ReadFile(path)
-	if err != nil {
-		return err
-	}
-
-	Certificates = CertificateFromStoreData(string(content))
-	return nil
-}
-
-func FlushCertificateStoreToFile(path string) {
-	data := Certificates.toStoreData()
-	ioutil.WriteFile(path, []byte(data), 0600)
-}
-
-func InitialiseFallbackCert(pagesDomain string) error {
-	cert, err := fallbackCert(pagesDomain)
-	Certificates.FallbackCertificate = cert
-	return err
-}
-
-func fallbackCert(pagesDomain string) (*CertificateWrapper, error) {
-	key, err := certcrypto.GeneratePrivateKey(certcrypto.RSA2048)
-	if err != nil {
-		return nil, err
-	}
-
-	notAfter := time.Now().Add(time.Hour*24*7);
-	cert := x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject: pkix.Name{
-			CommonName: pagesDomain,
-			Organization: []string{"Pages Server"},
-		},
-		NotAfter: notAfter,
-		NotBefore: time.Now(),
-		KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-	}
-	certBytes, err := x509.CreateCertificate(
-		rand.Reader,
-		&cert,
-		&cert,
-		&key.(*rsa.PrivateKey).PublicKey,
-		key,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	out := &bytes.Buffer{}
-	err = pem.Encode(out, &pem.Block{
-		Bytes: certBytes,
-		Type: "CERTIFICATE",
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	outBytes := out.Bytes()
-	res := &certificate.Resource{
-		PrivateKey: certcrypto.PEMEncode(key),
-		Certificate: outBytes,
-		IssuerCertificate: outBytes,
-		Domain: pagesDomain,
-	}
-	tlsCertificate, err := tls.X509KeyPair(res.Certificate, res.PrivateKey)
-	if err != nil {
-		return nil, err
-	}
-	return &CertificateWrapper{
-		TlsCertificate: &tlsCertificate,
-		Domain: pagesDomain,
-		NotAfter: notAfter,
-		PrivateKeyEncoded: base64.StdEncoding.EncodeToString(certcrypto.PEMEncode(key)),
-		Certificate: outBytes,
-		IssuerCertificate: outBytes,
-		CertificateUrl: "localhost",
-	}, nil
-}
-
-func isCertStillValid(cert CertificateWrapper) bool {
-	return time.Now().Compare(cert.NotAfter) <= -1
-}
-
-func makeTlsConfig(pagesDomain, path string, acmeClient *lego.Client) *tls.Config {
-	return &tls.Config{
-		InsecureSkipVerify: true,
-		GetCertificate: func (info *tls.ClientHelloInfo) (*tls.Certificate, error) {
-			// Validate that we should even care about this domain
-			if !strings.HasSuffix(info.ServerName, pagesDomain) {
-				// Note: We do not check err here because err != nil
-				// always implies that cname == "", which does not have
-				// pagesDomain as a suffix.
-				cname, _ := lookupCNAME(info.ServerName)
-				if !strings.HasSuffix(cname, pagesDomain) {
-					log.Warnf("Got ServerName for Domain %s that we're not responsible for", info.ServerName)
-					return Certificates.FallbackCertificate.TlsCertificate, nil
-				}
-			}
-
-			// If we want to access <user>.<pages domain>, then we can just
-			// use a wildcard certificate.
-			domain := info.ServerName
-			/*if strings.HasSuffix(info.ServerName, pagesDomain) {
-				domain = "*." + pagesDomain
-			}*/
-
-			cert, found := Certificates.Certificates[info.ServerName]
-			if found {
-				if isCertStillValid(cert) {
-					return cert.TlsCertificate, nil
-				} else {
-					// If we're already working on the domain,
-					// return the old certificate
-					if lockIfUnlockedDomain(domain) {
-						return cert.TlsCertificate, nil
-					}
-					defer unlockDomain(domain)
-
-					// TODO: Renew
-					log.Debugf("Certificate for %s expired, renewing", domain)
-				}
-			} else {
-				// Don't request if we're already requesting.
-				if lockIfUnlockedDomain(domain) {
-					return Certificates.FallbackCertificate.TlsCertificate, nil
-				}
-				defer unlockDomain(domain)
-
-				// Request new certificate
-				log.Debugf("Obtaining new certificate for %s...", domain)
-				err := ObtainNewCertificate(
-					[]string{domain},
-					path,
-					acmeClient,
-				)
-				if err != nil {
-					log.Errorf(
-						"Failed to get certificate for %s: %v",
-						domain,
-						err,
-					)
-					return Certificates.FallbackCertificate.TlsCertificate, nil
-				}
-
-				cert, _ = Certificates.Certificates[domain]
-				return cert.TlsCertificate, nil
-			}
-
-			log.Debugf("TLS ServerName: %s", info.ServerName)
-			return Certificates.FallbackCertificate.TlsCertificate, nil
-		},
-		NextProtos: []string{
-			"http/0.9",
-			"http/1.0",
-			"http/1.1",
-			"h2",
-			"h2c",
-		},
-		MinVersion: tls.VersionTLS12,
-		CipherSuites: []uint16{
-			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-		},
-	}
-}
-
-func addChallenge(id, token string) {
-	runningChallenges[id] = token
-}
-
-func removeChallenge(id string) {
-	delete(runningChallenges, id)
-}
-
-func getChallenge(id string) string {
-	if value, found := runningChallenges[id]; found {
-		return value
-	}
-
-	return ""
-}
-
-func handleLetsEncryptChallenge(w http.ResponseWriter, req *http.Request) bool {
-	if !strings.HasPrefix(req.URL.Path, AcmeChallengePathPrefix) {
-		return false
-	}
-
-	log.Debug("Handling ACME challenge path")
-	id := strings.TrimPrefix(req.URL.Path, AcmeChallengePathPrefix)
-	challenge := getChallenge(id)
-	if id == "" {
-		w.WriteHeader(404)
-		return true
-	}
-
-	w.WriteHeader(200)
-	w.Write([]byte(challenge))
-
-	removeChallenge(id)
-	return true
-}

certificate.go

@@ -1,41 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"encoding/base64"
-	"time"
-
-	// "github.com/go-acme/lego/v4/certcrypto"
-	"github.com/go-acme/lego/v4/certificate"
-	"github.com/go-acme/lego/v4/lego"
-)
-
-func ObtainNewCertificate(domains []string, path string, acmeClient *lego.Client) error {
-	req := certificate.ObtainRequest{
-		Domains: domains,
-		Bundle: true,
-	}
-	cert, err := acmeClient.Certificate.Obtain(req)
-	if err != nil {
-		return err
-	}
-
-	tlsCert, err := tls.X509KeyPair(cert.Certificate, cert.PrivateKey)
-	if err != nil {
-		return err
-	}
-
-	wrapper := CertificateWrapper{
-		TlsCertificate: &tlsCert,
-		Domain: cert.Domain,
-		//NotAfter: tlsCert.Leaf.NotAfter,
-		NotAfter: time.Now().Add(time.Hour * 24 * 60),
-		PrivateKeyEncoded: base64.StdEncoding.EncodeToString(cert.PrivateKey),
-		Certificate: cert.Certificate,
-		IssuerCertificate: cert.IssuerCertificate,
-		CertificateUrl: cert.CertURL,
-	}
-	Certificates.Certificates[cert.Domain] = wrapper
-	FlushCertificateStoreToFile(path)
-	return nil
-}

cmd/rio/main.go

@@ -0,0 +1,442 @@
+package main
+
+import (
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"git.polynom.me/rio/internal/acme"
+	"git.polynom.me/rio/internal/certificates"
+	"git.polynom.me/rio/internal/context"
+	"git.polynom.me/rio/internal/dns"
+	riogitea "git.polynom.me/rio/internal/gitea"
+	"git.polynom.me/rio/internal/metrics"
+	"git.polynom.me/rio/internal/pages"
+	"git.polynom.me/rio/internal/repo"
+	"git.polynom.me/rio/internal/server"
+
+	"code.gitea.io/sdk/gitea"
+	legodns "github.com/go-acme/lego/v4/providers/dns"
+	log "github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+func handleSubdomain(ctx *context.GlobalContext, domain, cname, path string, req *http.Request, w http.ResponseWriter) {
+	username := ""
+	if cname != "" {
+		// If we are accessed via a CNAME, then CNAME contains our <user>.<pages domain> value.
+		username = dns.ExtractUsername(ctx.PagesDomain, cname)
+	} else {
+		// If we are directly accessed, then domain contains our <user>.<pages domain> value.
+		username = dns.ExtractUsername(ctx.PagesDomain, domain)
+	}
+
+	// Strip the leading /
+	if path[:1] == "/" {
+		path = path[1:]
+	}
+
+	// Provide a default file.
+	switch {
+	case path == "":
+		path = "/index.html"
+	case path[len(path)-1] == '/':
+		path = path + "index.html"
+	}
+
+	repo, path, err := repo.RepoFromPath(
+		username,
+		domain,
+		cname,
+		path,
+		ctx,
+	)
+	if err != nil {
+		log.Errorf("Failed to get repo: %s", err)
+		w.WriteHeader(404)
+		return
+	}
+
+	c := &context.Context{
+		Username:  username,
+		Reponame:  repo.Name,
+		Domain:    domain,
+		Path:      path,
+		Referrer:  req.Header.Get("Referer"),
+		UserAgent: req.Header.Get("User-Agent"),
+		DNT:       req.Header.Get("DNT"),
+		GPC:       req.Header.Get("Sec-GPC"),
+		Writer:    w,
+		Global:    ctx,
+	}
+	pages.ServeFile(c)
+}
+
+func Handler(ctx *context.GlobalContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Set("Server", "rio")
+
+		// Is the direct domain requested?
+		if req.Host == ctx.PagesDomain {
+			log.Debug("Direct pages domain is requested.")
+
+			// TODO: Handle
+			w.WriteHeader(404)
+			return
+		}
+
+		// Is a direct subdomain requested?
+		if strings.HasSuffix(req.Host, ctx.PagesDomain) {
+			log.Debug("Domain can be directly handled")
+			handleSubdomain(ctx, req.Host, "", req.URL.Path, req, w)
+			return
+		}
+
+		cname, err := dns.LookupCNAME(req.Host)
+		if err != nil {
+			log.Warningf("CNAME request failed, we don't handle %s", req.Host)
+			w.WriteHeader(400)
+			return
+		}
+		log.Debugf("Got CNAME %s", cname)
+
+		// Is a direct subdomain requested after CNAME lookup?
+		// NOTE: We now require the leading dot because a CNAME to the direct
+		//       pages domain makes no sense.
+		if strings.HasSuffix(cname, "."+ctx.PagesDomain) {
+			log.Debugf("%s is alias of %s and can be handled after a CNAME query", req.Host, cname)
+			handleSubdomain(ctx, req.Host, cname, req.URL.Path, req, w)
+			return
+		}
+
+		log.Errorf("Not handling %s", req.Host)
+		w.WriteHeader(404)
+	}
+}
+
+// Handle HTTP redirects to HTTPS.
+func httpHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Set("Server", "rio")
+		w.Header().Set("Strict-Transport-Security", "max-age=31536000")
+
+		// Upgrade the URL
+		req.URL.Scheme = "https"
+		req.URL.Host = req.Host
+		w.Header().Set("Location", req.URL.String())
+
+		// Send the 301
+		w.WriteHeader(301)
+	}
+}
+
+func runServer(ctx *cli.Context) error {
+	giteaUrl := ctx.String("gitea-url")
+	domain := ctx.String("pages-domain")
+	certsFile := ctx.String("certs-file")
+	acmeEmail := ctx.String("acme-email")
+	acmeServer := ctx.String("acme-server")
+	acmeFile := ctx.String("acme-file")
+	acmeDnsProvider := ctx.String("acme-dns-provider")
+	acmeDisable := ctx.Bool("acme-disable")
+	defaultCsp := ctx.String("default-csp")
+	metricsUrl := ctx.String("metrics-url")
+	metricsBotList := ctx.String("metrics-bot-list")
+	tokenFile := ctx.String("token-file")
+
+	// Init Logging
+	if ctx.Bool("debug") {
+		log.SetLevel(log.DebugLevel)
+	} else {
+		log.SetLevel(log.InfoLevel)
+	}
+
+	// Set up the Loki metrics
+	var lokiConfig metrics.MetricConfig
+	if metricsUrl == "" {
+		lokiConfig = metrics.MetricConfig{
+			Enabled: false,
+		}
+	} else {
+		var patterns []regexp.Regexp
+		if metricsBotList != "" {
+			patterns, _ = metrics.ReadBotPatterns(metricsBotList)
+		} else {
+			patterns = make([]regexp.Regexp, 0)
+		}
+		log.Infof("Read %d bot patterns from disk", len(patterns))
+
+		lokiConfig = metrics.MetricConfig{
+			Enabled:       true,
+			BotUserAgents: &patterns,
+			Url:           metricsUrl,
+		}
+	}
+
+	// If specified, read in an access token
+	token := ""
+	if tokenFile != "" {
+		t, err := readSecret(tokenFile)
+		if err != nil {
+			log.Warnf("Failed to read secret: %v", err)
+		}
+		token = t
+	}
+
+	// Setup the Gitea stuff
+	httpClient := http.Client{Timeout: 10 * time.Second}
+	giteaApiClient, err := gitea.NewClient(
+		giteaUrl,
+		gitea.SetHTTPClient(&httpClient),
+		gitea.SetToken(token),
+		gitea.SetUserAgent("rio"),
+	)
+	if err != nil {
+		return err
+	}
+	giteaClient := riogitea.NewGiteaClient(giteaUrl, token, giteaApiClient)
+
+	// Listen on the port
+	addr := ctx.String("listen-host") + ":" + ctx.String("listen-port")
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		errMsg := fmt.Errorf("Failed to create listener: %v", err)
+		fmt.Println(errMsg.Error())
+		return err
+	}
+
+	// Prepare the context
+	cacheCtx := context.CacheContext{
+		RepositoryInformationCache: context.MakeRepoInfoCache(),
+		RepositoryPathCache:        context.MakeRepoPathCache(),
+		UsernameCache:              context.MakeUsernameCache(),
+	}
+	globalCtx := &context.GlobalContext{
+		DefaultCSP:   defaultCsp,
+		PagesDomain:  domain,
+		Gitea:        &giteaClient,
+		MetricConfig: &lokiConfig,
+		Cache:        &cacheCtx,
+	}
+
+	if !acmeDisable {
+		if acmeEmail == "" || acmeFile == "" || certsFile == "" || acmeDnsProvider == "" {
+			return errors.New("The options acme-dns-provider, acme-file, acme-email, and certs-file are required")
+		}
+
+		cache, err := certificates.CertificateCacheFromFile(certsFile)
+		if err != nil {
+			log.Debugf("Generating cert")
+			fallback, err := certificates.MakeFallbackCertificate(domain)
+			if err != nil {
+				log.Fatalf("Failed to generate fallback certificate: %v", err)
+				return err
+			}
+
+			cache.FallbackCertificate = fallback
+			cache.Certificates = make(map[string]certificates.CertificateWrapper)
+			cache.FlushToDisk(certsFile)
+			log.Debug("Certificate wrote to disk")
+		} else {
+			log.Debug("Certificate store read from disk")
+		}
+
+		// Create an ACME client, if we failed to load one
+		acmeClient, err := acme.ClientFromFile(acmeFile, acmeServer)
+		if err != nil {
+			log.Warn("Failed to load ACME client data from disk. Generating new account")
+			acmeClient, err = acme.GenerateNewAccount(acmeEmail, acmeFile, acmeServer)
+			if err != nil {
+				log.Fatalf("Failed to generate new ACME client: %v", err)
+				return err
+			}
+			log.Info("ACME account registered")
+		} else {
+			log.Info("ACME client data read from disk")
+		}
+
+		// Set up the DNS01 challenge solver
+		provider, err := legodns.NewDNSChallengeProviderByName(acmeDnsProvider)
+		if err != nil {
+			log.Fatalf("Failed to create DNS01 challenge provider: %v", err)
+			return err
+		}
+		err = acmeClient.Challenge.SetDNS01Provider(provider)
+		if err != nil {
+			log.Fatalf("Failed to setup DNS01 challenge solver: %v", err)
+			return err
+		}
+
+		tlsConfig := server.MakeTlsConfig(
+			domain,
+			certsFile,
+			&cache,
+			acmeClient,
+			globalCtx,
+		)
+		listener = tls.NewListener(listener, tlsConfig)
+	}
+
+	var waitGroup sync.WaitGroup
+	servers := 2
+	if acmeDisable {
+		servers = 1
+	}
+	waitGroup.Add(servers)
+
+	go func() {
+		defer waitGroup.Done()
+
+		log.Infof("Listening on main HTTP server %s", addr)
+		if err := http.Serve(listener, Handler(globalCtx)); err != nil {
+			log.Fatal(fmt.Errorf("Listening failed: %v", err))
+		}
+		log.Debug("Listening on main HTTP server done!")
+	}()
+
+	if !acmeDisable {
+		// Listen on the HTTP port
+		httpAddr := ctx.String("http-host") + ":" + ctx.String("http-port")
+		httpListener, err := net.Listen("tcp", httpAddr)
+		if err != nil {
+			fmt.Println(
+				fmt.Errorf("Failed to create HTTP listener: %v", err),
+			)
+			return err
+		}
+
+		go func() {
+			defer waitGroup.Done()
+
+			log.Debug("Listening on redirect HTTP server")
+			if err := http.Serve(httpListener, httpHandler()); err != nil {
+				log.Fatal(fmt.Errorf("Listening failed: %v", err))
+			}
+			log.Debug("Listening on redirect HTTP server done!")
+		}()
+	}
+
+	log.Debug("Waiting...")
+	waitGroup.Wait()
+	log.Debug("Done...")
+	return nil
+}
+
+func main() {
+	app := &cli.App{
+		Action: runServer,
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:     "gitea-url",
+				Usage:    "The (HTTPS) URL to the serving Gitea instance",
+				EnvVars:  []string{"GITEA_URL"},
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:    "listen-host",
+				Usage:   "The host to listen on",
+				EnvVars: []string{"HOST"},
+				Value:   "127.0.0.1",
+			},
+			&cli.StringFlag{
+				Name:    "listen-port",
+				Usage:   "The port to listen on",
+				EnvVars: []string{"PORT"},
+				Value:   "8888",
+			},
+			&cli.StringFlag{
+				Name:    "http-host",
+				Usage:   "The host to have unencrypted HTTP listen on",
+				EnvVars: []string{"HTTP_HOST"},
+				Value:   "127.0.0.1",
+			},
+			&cli.StringFlag{
+				Name:    "http-port",
+				Usage:   "The port to have unencrypted HTTP listen on",
+				EnvVars: []string{"HTTP_PORT"},
+				Value:   "9999",
+			},
+			&cli.StringFlag{
+				Name:    "acme-dns-provider",
+				Usage:   "The provider to use for DNS01 challenge solving",
+				EnvVars: []string{"ACME_DNS_PROVIDER"},
+				Value:   "",
+			},
+			&cli.StringFlag{
+				Name:     "pages-domain",
+				Usage:    "The domain on which the server is reachable",
+				EnvVars:  []string{"PAGES_DOMAIN"},
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:    "certs-file",
+				Usage:   "File to store certificates in",
+				EnvVars: []string{"CERTS_FILE"},
+				Value:   "",
+			},
+			&cli.StringFlag{
+				Name:    "acme-file",
+				Usage:   "File to store ACME configuration in",
+				EnvVars: []string{"ACME_FILE"},
+				Value:   "",
+			},
+			&cli.StringFlag{
+				Name:    "acme-email",
+				Usage:   "Email to use for an ACME account",
+				EnvVars: []string{"ACME_EMAIL"},
+				Value:   "",
+			},
+			&cli.StringFlag{
+				Name:    "acme-server",
+				Usage:   "CA Directory to use",
+				EnvVars: []string{"ACME_SERVER"},
+				Value:   "https://acme-staging-v02.api.letsencrypt.org/directory",
+			},
+			&cli.BoolFlag{
+				Name:    "acme-disable",
+				Usage:   "Whether to disable automatic ACME certificates",
+				EnvVars: []string{"ACME_DISABLE"},
+			},
+			&cli.BoolFlag{
+				Name:    "debug",
+				Usage:   "Whether to enable debug logging",
+				EnvVars: []string{"DEBUG_ENABLE"},
+			},
+			&cli.StringFlag{
+				Name:    "default-csp",
+				Usage:   "The default CSP to include when sending HTTP responses",
+				Value:   "",
+				EnvVars: []string{"DEFAULT_CSP"},
+			},
+			&cli.StringFlag{
+				Name:    "metrics-url",
+				Usage:   "The URL for metric pings",
+				Value:   "",
+				EnvVars: []string{"METRICS_URL"},
+			},
+			&cli.StringFlag{
+				Name:    "metrics-bot-list",
+				Usage:   "File to read a list of regular expressions modelling bot user agents from",
+				Value:   "",
+				EnvVars: []string{"METRICS_BOT_LIST"},
+			},
+			&cli.StringFlag{
+				Name:    "token-file",
+				Usage:   "File containing a access token. Required for serving private repositories",
+				Value:   "",
+				EnvVars: []string{"TOKEN_FILE"},
+			},
+		},
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Fatalf("Failed to run app: %s", err)
+	}
+}

cmd/rio/utils.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"os"
+	"strings"
+)
+
+// Read a secret file and return its (cleaned) content.
+func readSecret(path string) (string, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+
+	return strings.Trim(string(content), "\n\r "), nil
+}

dns.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"errors"
-	"net"
-	"strings"
-	"time"
-
-	"github.com/patrickmn/go-cache"
-)
-
-const (
-	TxtRepoKey = "repo="
-)
-
-var (
-	cnameCache = cache.New(1 * time.Hour, 1 * time.Hour)
-	txtRepoCache = cache.New(1 * time.Hour, 1 * time.Hour)
-)
-
-func lookupRepoTXT(domain string) (string, error) {
-	repoLookup, found := txtRepoCache.Get(domain)
-	if found {
-		return repoLookup.(string), nil
-	}
-
-	txts, err := net.LookupTXT("_rio-pages." + domain)
-	if err != nil {
-		return "", err
-	}
-
-	repo := ""
-	for _, txt := range txts {
-		if !strings.HasPrefix(txt, TxtRepoKey) {
-			continue
-		}
-
-		repo = strings.TrimPrefix(txt, TxtRepoKey)
-		break
-	}
-
-	txtRepoCache.Set(domain, repo, cache.DefaultExpiration)
-	return repo, nil
-}
-
-func lookupCNAME(domain string) (string, error) {
-	cname, found := cnameCache.Get(domain)
-	if found {
-		if cname == "" {
-			return "", errors.New("Previous request failure")
-		}
-
-		return cname.(string), nil
-	}
-
-	cname, err := net.LookupCNAME(domain)
-	if err == nil {
-		cnameCache.Set(domain, cname, cache.DefaultExpiration)
-		return cname.(string), nil
-	}
-
-	cnameCache.Set(domain, "", cache.DefaultExpiration)
-	return "", err
-}

go.mod

@@ -1,29 +1,246 @@
-module paptutuwawa/rio
+module git.polynom.me/rio
 
-go 1.20
+go 1.24.7
 
 require (
-	code.gitea.io/sdk/gitea v0.17.0
+	code.gitea.io/sdk/gitea v0.22.1
-	github.com/go-acme/lego/v4 v4.14.2
+	github.com/go-acme/lego/v4 v4.28.0
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/sirupsen/logrus v1.9.3
-	github.com/urfave/cli/v2 v2.27.1
+	github.com/urfave/cli/v2 v2.27.7
 )
 
 require (
-	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
+	cloud.google.com/go/auth v0.17.0 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
+	cloud.google.com/go/compute v1.49.1 // indirect
+	cloud.google.com/go/compute/metadata v0.9.0 // indirect
+	github.com/42wim/httpsig v1.2.3 // indirect
+	github.com/AdamSLevy/jsonrpc2/v14 v14.1.0 // indirect
+	github.com/Azure/azure-sdk-for-go v68.0.0+incompatible // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.19.1 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dns/armdns v1.2.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns v1.3.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourcegraph/armresourcegraph v0.9.0 // indirect
+	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
+	github.com/Azure/go-autorest/autorest v0.11.30 // indirect
+	github.com/Azure/go-autorest/autorest/adal v0.9.24 // indirect
+	github.com/Azure/go-autorest/autorest/azure/auth v0.5.13 // indirect
+	github.com/Azure/go-autorest/autorest/azure/cli v0.4.7 // indirect
+	github.com/Azure/go-autorest/autorest/date v0.3.1 // indirect
+	github.com/Azure/go-autorest/autorest/to v0.4.1 // indirect
+	github.com/Azure/go-autorest/logger v0.2.2 // indirect
+	github.com/Azure/go-autorest/tracing v0.6.1 // indirect
+	github.com/AzureAD/microsoft-authentication-library-for-go v1.5.0 // indirect
+	github.com/OpenDNS/vegadns2client v0.0.0-20180418235048-a3fa4a771d87 // indirect
+	github.com/akamai/AkamaiOPEN-edgegrid-golang v1.2.2 // indirect
+	github.com/akamai/AkamaiOPEN-edgegrid-golang/v11 v11.1.0 // indirect
+	github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5 // indirect
+	github.com/alibabacloud-go/darabonba-openapi/v2 v2.1.13 // indirect
+	github.com/alibabacloud-go/debug v1.0.1 // indirect
+	github.com/alibabacloud-go/tea v1.3.13 // indirect
+	github.com/alibabacloud-go/tea-utils/v2 v2.0.7 // indirect
+	github.com/aliyun/alibaba-cloud-sdk-go v1.63.107 // indirect
+	github.com/aliyun/credentials-go v1.4.8 // indirect
+	github.com/andres-erbsen/clock v0.0.0-20160526145045-9e14626cd129 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.39.5 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.31.16 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.18.20 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.12 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.12 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.12 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.12 // indirect
+	github.com/aws/aws-sdk-go-v2/service/lightsail v1.50.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/route53 v1.59.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.30.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.39.0 // indirect
+	github.com/aws/smithy-go v1.23.2 // indirect
+	github.com/aziontech/azionapi-go-sdk v0.143.0 // indirect
+	github.com/baidubce/bce-sdk-go v0.9.250 // indirect
+	github.com/benbjohnson/clock v1.3.5 // indirect
+	github.com/boombuler/barcode v1.1.0 // indirect
+	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
+	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
+	github.com/civo/civogo v0.6.4 // indirect
+	github.com/clbanning/mxj/v2 v2.7.0 // indirect
+	github.com/cloudflare/cloudflare-go v0.116.0 // indirect
+	github.com/cpu/goacmedns v0.1.1 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/davidmz/go-pageant v1.0.2 // indirect
+	github.com/deepmap/oapi-codegen v1.16.3 // indirect
+	github.com/dimchansky/utfbom v1.1.1 // indirect
+	github.com/dnsimple/dnsimple-go v1.7.0 // indirect
+	github.com/dnsimple/dnsimple-go/v4 v4.0.0 // indirect
+	github.com/exoscale/egoscale v0.102.4 // indirect
+	github.com/exoscale/egoscale/v3 v3.1.27 // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/fatih/structs v1.1.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.11 // indirect
+	github.com/ghodss/yaml v1.0.0 // indirect
+	github.com/go-acme/alidns-20150109/v4 v4.6.1 // indirect
+	github.com/go-acme/tencentclouddnspod v1.1.25 // indirect
+	github.com/go-acme/tencentedgdeone v1.1.48 // indirect
+	github.com/go-errors/errors v1.5.1 // indirect
 	github.com/go-fed/httpsig v1.1.0 // indirect
-	github.com/go-jose/go-jose/v3 v3.0.0 // indirect
+	github.com/go-jose/go-jose/v3 v3.0.4 // indirect
-	github.com/hashicorp/go-version v1.5.0 // indirect
+	github.com/go-jose/go-jose/v4 v4.1.3 // indirect
-	github.com/miekg/dns v1.1.55 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.28.0 // indirect
+	github.com/go-resty/resty/v2 v2.16.5 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/goccy/go-yaml v1.18.0 // indirect
+	github.com/gofrs/flock v0.13.0 // indirect
+	github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/google/s2a-go v0.1.9 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.6 // indirect
+	github.com/googleapis/gax-go/v2 v2.15.0 // indirect
+	github.com/gophercloud/gophercloud v1.14.1 // indirect
+	github.com/gophercloud/utils v0.0.0-20231010081019-80377eca5d56 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.8 // indirect
+	github.com/hashicorp/go-uuid v1.0.3 // indirect
+	github.com/hashicorp/go-version v1.7.0 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/huaweicloud/huaweicloud-sdk-go-v3 v0.1.174 // indirect
+	github.com/iij/doapi v0.0.0-20190504054126-0bbf12d6d7df // indirect
+	github.com/infobloxopen/infoblox-go-client v1.1.1 // indirect
+	github.com/infobloxopen/infoblox-go-client/v2 v2.11.0 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
+	github.com/json-iterator/go v1.1.13-0.20220915233716-71ac16282d12 // indirect
+	github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213 // indirect
+	github.com/kolo/xmlrpc v0.0.0-20220921171641-a4b6fa1dd06b // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
+	github.com/labbsr0x/bindman-dns-webhook v1.0.2 // indirect
+	github.com/labbsr0x/goh v1.0.1 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/linode/linodego v1.60.0 // indirect
+	github.com/liquidweb/go-lwApi v0.0.5 // indirect
+	github.com/liquidweb/liquidweb-cli v0.7.0 // indirect
+	github.com/liquidweb/liquidweb-go v1.6.4 // indirect
+	github.com/magiconair/properties v1.8.10 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/miekg/dns v1.1.68 // indirect
+	github.com/mimuret/golang-iij-dpf v0.9.1 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/namedotcom/go v0.0.0-20180403034216-08470befbe04 // indirect
+	github.com/namedotcom/go/v4 v4.0.2 // indirect
+	github.com/nrdcg/auroradns v1.1.0 // indirect
+	github.com/nrdcg/bunny-go v0.1.0 // indirect
+	github.com/nrdcg/desec v0.11.1 // indirect
+	github.com/nrdcg/dnspod-go v0.4.0 // indirect
+	github.com/nrdcg/freemyip v0.3.0 // indirect
+	github.com/nrdcg/goacmedns v0.2.0 // indirect
+	github.com/nrdcg/goinwx v0.11.0 // indirect
+	github.com/nrdcg/mailinabox v0.3.0 // indirect
+	github.com/nrdcg/namesilo v0.5.0 // indirect
+	github.com/nrdcg/nodion v0.1.0 // indirect
+	github.com/nrdcg/oci-go-sdk/common/v1065 v1065.103.0 // indirect
+	github.com/nrdcg/oci-go-sdk/dns/v1065 v1065.103.0 // indirect
+	github.com/nrdcg/porkbun v0.4.0 // indirect
+	github.com/nrdcg/vegadns v0.3.0 // indirect
+	github.com/nzdjb/go-metaname v1.0.0 // indirect
+	github.com/onsi/gomega v1.37.0 // indirect
+	github.com/oracle/oci-go-sdk v24.3.0+incompatible // indirect
+	github.com/ovh/go-ovh v1.9.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/peterhellberg/link v1.2.0 // indirect
+	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/pquerna/otp v1.5.0 // indirect
+	github.com/regfish/regfish-dnsapi-go v0.1.1 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
+	github.com/sacloud/api-client-go v0.3.3 // indirect
-	golang.org/x/crypto v0.10.0 // indirect
+	github.com/sacloud/go-http v0.1.9 // indirect
-	golang.org/x/mod v0.11.0 // indirect
+	github.com/sacloud/iaas-api-go v1.20.0 // indirect
-	golang.org/x/net v0.11.0 // indirect
+	github.com/sacloud/packages-go v0.0.11 // indirect
-	golang.org/x/sys v0.9.0 // indirect
+	github.com/sagikazarmark/locafero v0.12.0 // indirect
-	golang.org/x/text v0.10.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
-	golang.org/x/tools v0.10.0 // indirect
+	github.com/scaleway/scaleway-sdk-go v1.0.0-beta.35 // indirect
+	github.com/selectel/domains-go v1.1.0 // indirect
+	github.com/selectel/go-selvpcclient/v4 v4.1.0 // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
+	github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9 // indirect
+	github.com/softlayer/softlayer-go v1.2.1 // indirect
+	github.com/softlayer/xmlrpc v0.0.0-20200409220501-5f089df7cb7e // indirect
+	github.com/sony/gobreaker v1.0.0 // indirect
+	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
+	github.com/spf13/afero v1.15.0 // indirect
+	github.com/spf13/cast v1.10.0 // indirect
+	github.com/spf13/pflag v1.0.10 // indirect
+	github.com/spf13/viper v1.21.0 // indirect
+	github.com/stretchr/objx v0.5.3 // indirect
+	github.com/stretchr/testify v1.11.1 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.1.48 // indirect
+	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/dnspod v1.1.25 // indirect
+	github.com/tjfoc/gmsm v1.4.1 // indirect
+	github.com/transip/gotransip/v6 v6.26.1 // indirect
+	github.com/ultradns/ultradns-go-sdk v1.8.1-20250722213956-faef419 // indirect
+	github.com/vinyldns/go-vinyldns v0.9.16 // indirect
+	github.com/volcengine/volc-sdk-golang v1.0.225 // indirect
+	github.com/vultr/govultr/v2 v2.17.2 // indirect
+	github.com/vultr/govultr/v3 v3.24.0 // indirect
+	github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342 // indirect
+	github.com/yandex-cloud/go-genproto v0.34.0 // indirect
+	github.com/yandex-cloud/go-sdk v0.27.0 // indirect
+	github.com/yandex-cloud/go-sdk/services/dns v0.0.16 // indirect
+	github.com/yandex-cloud/go-sdk/v2 v2.24.0 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
+	go.mongodb.org/mongo-driver v1.17.6 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	go.uber.org/ratelimit v0.3.1 // indirect
+	go.uber.org/zap v1.27.0 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/crypto v0.43.0 // indirect
+	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect
+	golang.org/x/mod v0.29.0 // indirect
+	golang.org/x/net v0.46.0 // indirect
+	golang.org/x/oauth2 v0.32.0 // indirect
+	golang.org/x/sync v0.17.0 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/text v0.30.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	golang.org/x/tools v0.38.0 // indirect
+	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
+	google.golang.org/api v0.254.0 // indirect
+	google.golang.org/appengine v1.6.8 // indirect
+	google.golang.org/genproto v0.0.0-20251103181224-f26f9409b101 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101 // indirect
+	google.golang.org/grpc v1.76.0 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/ns1/ns1-go.v2 v2.15.1 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

internal/acme/account.go

@@ -1,12 +1,12 @@
-package main
+package acme
 
 import (
 	"crypto"
 	"crypto/ecdsa"
 	"crypto/elliptic"
 	"crypto/rand"
-	"encoding/json"
 	"encoding/base64"
+	"encoding/json"
 	"io/ioutil"
 
 	"github.com/go-acme/lego/v4/acme"
@@ -61,7 +61,6 @@ func ClientFromFile(storage, acmeServer string) (*lego.Client, error) {
 		contacts = append(contacts, v.(string))
 	}
 
-
 	registration := registration.Resource{
 		URI: reg["uri"].(string),
 		Body: acme.Account{

internal/certificates/certificate.go

@@ -0,0 +1,136 @@
+package certificates
+
+import (
+	"crypto/rsa"
+	"crypto/tls"
+	"encoding/base64"
+	"encoding/pem"
+	"time"
+
+	"bytes"
+	"crypto/rand"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"math/big"
+
+	"github.com/go-acme/lego/v4/certcrypto"
+	"github.com/go-acme/lego/v4/certificate"
+	"github.com/go-acme/lego/v4/lego"
+)
+
+func RenewCertificate(old *CertificateWrapper, acmeClient *lego.Client) (CertificateWrapper, error) {
+	pk, _ := base64.StdEncoding.DecodeString(old.PrivateKeyEncoded)
+	res := certificate.Resource{
+		PrivateKey:  pk,
+		Certificate: old.Certificate,
+		CSR:         old.CSR,
+	}
+
+	new, err := acmeClient.Certificate.Renew(res, true, false, "")
+	if err != nil {
+		return CertificateWrapper{}, err
+	}
+
+	// Convert the new certificate into a wrapper struct
+	tlsCert, err := tls.X509KeyPair(new.Certificate, new.PrivateKey)
+	if err != nil {
+		return CertificateWrapper{}, err
+	}
+	wrapper := CertificateWrapper{
+		TlsCertificate:    &tlsCert,
+		DomainKey:         old.DomainKey,
+		NotAfter:          time.Now().Add(time.Hour * 24 * 60),
+		PrivateKeyEncoded: base64.StdEncoding.EncodeToString(new.PrivateKey),
+		Certificate:       new.Certificate,
+		CSR:               new.CSR,
+	}
+	return wrapper, nil
+}
+
+func ObtainNewCertificate(domains []string, domainKey string, acmeClient *lego.Client) (CertificateWrapper, error) {
+	req := certificate.ObtainRequest{
+		Domains: domains,
+		Bundle:  true,
+	}
+	cert, err := acmeClient.Certificate.Obtain(req)
+	if err != nil {
+		return CertificateWrapper{}, err
+	}
+
+	tlsCert, err := tls.X509KeyPair(cert.Certificate, cert.PrivateKey)
+	if err != nil {
+		return CertificateWrapper{}, err
+	}
+
+	wrapper := CertificateWrapper{
+		TlsCertificate: &tlsCert,
+		DomainKey:      domainKey,
+		//NotAfter:        tlsCert.Leaf.NotAfter,
+		NotAfter:          time.Now().Add(time.Hour * 24 * 60),
+		PrivateKeyEncoded: base64.StdEncoding.EncodeToString(cert.PrivateKey),
+		Certificate:       cert.Certificate,
+		CSR:               cert.CSR,
+	}
+	return wrapper, nil
+}
+
+// Generate a fallback certificate for the domain.
+func MakeFallbackCertificate(pagesDomain string) (*CertificateWrapper, error) {
+	key, err := certcrypto.GeneratePrivateKey(certcrypto.RSA2048)
+	if err != nil {
+		return nil, err
+	}
+
+	notAfter := time.Now().Add(time.Hour * 24 * 7)
+	cert := x509.Certificate{
+		SerialNumber: big.NewInt(1),
+		Subject: pkix.Name{
+			CommonName:   pagesDomain,
+			Organization: []string{"Pages Server"},
+		},
+		NotAfter:              notAfter,
+		NotBefore:             time.Now(),
+		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+	}
+	certBytes, err := x509.CreateCertificate(
+		rand.Reader,
+		&cert,
+		&cert,
+		&key.(*rsa.PrivateKey).PublicKey,
+		key,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	out := &bytes.Buffer{}
+	err = pem.Encode(out, &pem.Block{
+		Bytes: certBytes,
+		Type:  "CERTIFICATE",
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	outBytes := out.Bytes()
+	res := &certificate.Resource{
+		PrivateKey:        certcrypto.PEMEncode(key),
+		Certificate:       outBytes,
+		IssuerCertificate: outBytes,
+		Domain:            pagesDomain,
+	}
+	tlsCertificate, err := tls.X509KeyPair(res.Certificate, res.PrivateKey)
+	if err != nil {
+		return nil, err
+	}
+	return &CertificateWrapper{
+		TlsCertificate:    &tlsCertificate,
+		DomainKey:         "*." + pagesDomain,
+		NotAfter:          notAfter,
+		PrivateKeyEncoded: base64.StdEncoding.EncodeToString(certcrypto.PEMEncode(key)),
+		Certificate:       outBytes,
+		CSR:               []byte{},
+	}, nil
+}

internal/certificates/store.go

@@ -0,0 +1,124 @@
+package certificates
+
+import (
+	"crypto/rsa"
+	"crypto/tls"
+	"encoding/base64"
+	"encoding/json"
+	"io/ioutil"
+	"time"
+
+	"github.com/go-acme/lego/v4/certcrypto"
+	log "github.com/sirupsen/logrus"
+)
+
+// A convenience wrapper around a TLS certificate
+type CertificateWrapper struct {
+	// The parsed TLS certificate we can pass to the tls listener
+	TlsCertificate *tls.Certificate `json:"-"`
+
+	// Key identifying for which domain(s) this certificate is valid.
+	DomainKey string `json:"domain"`
+
+	// Indicates at which point in time this certificate is no longer valid.
+	NotAfter time.Time `json:"not_after"`
+
+	// The encoded private key.
+	PrivateKeyEncoded string `json:"private_key"`
+
+	// The PEM-encoded certificate.
+	Certificate []byte `json:"certificate"`
+
+	// The CSR provided when we requested the certificate.
+	CSR []byte `json:"csr"`
+}
+
+// A structure to store all the certificates we know of in.
+type CertificatesCache struct {
+	// The certificate to use as a fallback if all else fails.
+	FallbackCertificate *CertificateWrapper
+
+	// Mapping of a domain's domain key to the certificate.
+	Certificates map[string]CertificateWrapper
+}
+
+// Internal type to let encoding JSON handle the bulk of the work.
+type certificatesStore struct {
+	FallbackCertificate CertificateWrapper   `json:"fallback"`
+	Certificates        []CertificateWrapper `json:"certificates"`
+}
+
+// Decodes the private key of the certificate wrapper.
+func (c *CertificateWrapper) GetPrivateKey() *rsa.PrivateKey {
+	data, _ := base64.StdEncoding.DecodeString(c.PrivateKeyEncoded)
+	pk, _ := certcrypto.ParsePEMPrivateKey(data)
+
+	return pk.(*rsa.PrivateKey)
+}
+
+// Populate the certificate's TlsCertificate field.
+func (c *CertificateWrapper) initTlsCertificate() {
+	pk, _ := base64.StdEncoding.DecodeString(c.PrivateKeyEncoded)
+	tlsCert, _ := tls.X509KeyPair(
+		c.Certificate,
+		pk,
+	)
+	c.TlsCertificate = &tlsCert
+}
+
+// Checks if the certificate is still valid now.
+func (c *CertificateWrapper) IsValid() bool {
+	return time.Now().Compare(c.NotAfter) <= -1
+}
+
+// Serializes the certificate cache to a JSON string for writing to a file.
+func (c *CertificatesCache) toStoreData() []byte {
+	certs := make([]CertificateWrapper, 0)
+	for _, cert := range c.Certificates {
+		certs = append(certs, cert)
+	}
+
+	result, err := json.Marshal(certificatesStore{
+		FallbackCertificate: *c.FallbackCertificate,
+		Certificates:        certs,
+	})
+	if err != nil {
+		log.Errorf("Failed to Marshal cache: %v", err)
+	}
+	return result
+}
+
+// Saves the cache to disk.
+func (c *CertificatesCache) FlushToDisk(path string) {
+	ioutil.WriteFile(path, c.toStoreData(), 0600)
+}
+
+func (c *CertificatesCache) AddCert(cert CertificateWrapper, path string) {
+	c.Certificates[cert.DomainKey] = cert
+	c.FlushToDisk(path)
+}
+
+// Load the certificate cache from the file.
+func CertificateCacheFromFile(path string) (CertificatesCache, error) {
+	content, err := ioutil.ReadFile(path)
+	if err != nil {
+		return CertificatesCache{}, err
+	}
+
+	var store certificatesStore
+	_ = json.Unmarshal(content, &store)
+
+	store.FallbackCertificate.initTlsCertificate()
+	cache := CertificatesCache{
+		FallbackCertificate: &store.FallbackCertificate,
+	}
+
+	certs := make(map[string]CertificateWrapper)
+	for _, cert := range store.Certificates {
+		cert.initTlsCertificate()
+		certs[cert.DomainKey] = cert
+	}
+	cache.Certificates = certs
+
+	return cache, nil
+}

internal/constants/const.go

@@ -0,0 +1,6 @@
+package constants
+
+const (
+	// The branch to serve.
+	PagesBranch = "pages"
+)

internal/context/context.go

@@ -0,0 +1,45 @@
+package context
+
+import (
+	"net/http"
+
+	"git.polynom.me/rio/internal/gitea"
+	"git.polynom.me/rio/internal/metrics"
+	"github.com/patrickmn/go-cache"
+)
+
+type CacheContext struct {
+	// Cache for general repository information
+	RepositoryInformationCache cache.Cache
+
+	// Cache for path resolutions
+	RepositoryPathCache cache.Cache
+
+	// Cache for username lookups
+	UsernameCache cache.Cache
+}
+
+type GlobalContext struct {
+	DefaultCSP   string
+	PagesDomain  string
+	Gitea        *gitea.GiteaClient
+	MetricConfig *metrics.MetricConfig
+	Cache        *CacheContext
+}
+
+type Context struct {
+	Username string
+	Reponame string
+	Domain   string
+	Path     string
+
+	// HTTP Stuff
+	Referrer  string
+	UserAgent string
+	DNT       string
+	GPC       string
+	Writer    http.ResponseWriter
+
+	// Pointer to the global context
+	Global *GlobalContext
+}

internal/context/info.go

@@ -0,0 +1,40 @@
+package context
+
+import (
+	"time"
+
+	"github.com/patrickmn/go-cache"
+)
+
+type RepositoryInformation struct {
+	// Headers to include in every response
+	Headers map[string]string
+
+	CNAME string
+}
+
+func repoInfoKey(owner, name string) string {
+	return owner + ":" + name
+}
+
+func (c *CacheContext) GetRepositoryInformation(owner, repoName string) *RepositoryInformation {
+	data, found := c.RepositoryInformationCache.Get(repoInfoKey(owner, repoName))
+	if !found {
+		return nil
+	}
+
+	typedData := data.(RepositoryInformation)
+	return &typedData
+}
+
+func (c *CacheContext) SetRepositoryInformation(owner, repoName string, info RepositoryInformation) {
+	c.RepositoryInformationCache.Set(
+		repoInfoKey(owner, repoName),
+		info,
+		cache.DefaultExpiration,
+	)
+}
+
+func MakeRepoInfoCache() cache.Cache {
+	return *cache.New(24*time.Hour, 12*time.Hour)
+}

internal/context/path.go

@@ -0,0 +1,39 @@
+package context
+
+import (
+	"time"
+
+	"git.polynom.me/rio/internal/gitea"
+	"github.com/patrickmn/go-cache"
+)
+
+type RepositoryPathInformation struct {
+	Repository gitea.Repository
+	Path       string
+}
+
+func pathInfoKey(domain, path string) string {
+	return domain + "/" + path
+}
+
+func (c *CacheContext) GetRepositoryPath(domain, path string) *RepositoryPathInformation {
+	data, found := c.RepositoryPathCache.Get(pathInfoKey(domain, path))
+	if !found {
+		return nil
+	}
+
+	typedData := data.(RepositoryPathInformation)
+	return &typedData
+}
+
+func (c *CacheContext) SetRepositoryPath(domain, path string, info RepositoryPathInformation) {
+	c.RepositoryPathCache.Set(
+		pathInfoKey(domain, path),
+		info,
+		cache.DefaultExpiration,
+	)
+}
+
+func MakeRepoPathCache() cache.Cache {
+	return *cache.New(24*time.Hour, 12*time.Hour)
+}

internal/context/user.go

@@ -0,0 +1,24 @@
+package context
+
+import (
+	"time"
+
+	"github.com/patrickmn/go-cache"
+)
+
+func (c *CacheContext) GetUser(username string) bool {
+	_, found := c.UsernameCache.Get(username)
+	return found
+}
+
+func (c *CacheContext) SetUser(username string) {
+	c.UsernameCache.Set(
+		username,
+		true,
+		cache.DefaultExpiration,
+	)
+}
+
+func MakeUsernameCache() cache.Cache {
+	return *cache.New(24*time.Hour, 12*time.Hour)
+}

internal/dns/dns.go

@@ -0,0 +1,118 @@
+package dns
+
+import (
+	"net"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+)
+
+const (
+	// TXT record name that lookupRepoTXT will try to lookup.
+	TxtRepoRecord = "_rio-pages."
+
+	// The key that the TXT record will have to start with, e.g.
+	// "repo=some-random-repo".
+	TxtRepoKey = "repo="
+
+	TxtCNAMERecord = "_rio-cname."
+
+	TxtCNAMEKey = "cname="
+)
+
+var (
+	// Cache for CNAME resolution results.
+	cnameCache = cache.New(1*time.Hour, 1*time.Hour)
+
+	// Cache for TXT resolution results.
+	txtRepoCache = cache.New(1*time.Hour, 1*time.Hour)
+)
+
+// Query the domain for the a repository redirect.
+// Returns the new repository name or "", if we could not
+// resolve a repository redirect.
+func LookupRepoTXT(domain string) (string, error) {
+	repoLookup, found := txtRepoCache.Get(domain)
+	if found {
+		return repoLookup.(string), nil
+	}
+
+	txts, err := net.LookupTXT("_rio-pages." + domain)
+	if err != nil {
+		return "", err
+	}
+
+	repo := ""
+	for _, txt := range txts {
+		if !strings.HasPrefix(txt, TxtRepoKey) {
+			continue
+		}
+
+		repo = strings.TrimPrefix(txt, TxtRepoKey)
+		break
+	}
+
+	txtRepoCache.Set(domain, repo, cache.DefaultExpiration)
+	return repo, nil
+}
+
+// Query the domain for a CNAME record. Returns the resolved
+// CNAME or "", if no CNAME could be queried.
+func LookupCNAME(domain string) (string, error) {
+	cname, found := cnameCache.Get(domain)
+	if found {
+		return cname.(string), nil
+	}
+
+	cname, err := lookupCNAME(domain)
+	if err == nil {
+		cnameCache.Set(domain, cname, cache.DefaultExpiration)
+		return cname.(string), nil
+	}
+
+	altCname, err := lookupCNAMETxt(domain)
+	if err == nil {
+		cnameCache.Set(domain, altCname, cache.DefaultExpiration)
+		return altCname, nil
+	}
+
+	return "", err
+}
+
+// Lookup the CNAME by trying to find a CNAME RR. Contrary to net.LookupCNAME,
+// this method fails if we find no CNAME RR.
+func lookupCNAME(domain string) (string, error) {
+	query, err := net.LookupCNAME(domain)
+	if err == nil {
+		if query[len(query)-1] == '.' {
+			query = query[:len(query)-1]
+		}
+
+		// Fail if we have no CNAME RR.
+		if query == domain {
+			return "", errors.New("CNAME is equal to domain")
+		}
+
+		return query, nil
+	}
+
+	return "", err
+}
+
+// Performs an alternative CNAME lookup by looking for a special TXT record.
+func lookupCNAMETxt(domain string) (string, error) {
+	txts, err := net.LookupTXT(TxtCNAMERecord+domain)
+	if err == nil {
+		for _, txt := range txts {
+			if !strings.HasPrefix(txt, TxtCNAMEKey) {
+				continue
+			}
+
+			return strings.TrimPrefix(txt, TxtCNAMEKey), nil
+		}
+	}
+	
+	return "", err
+}

internal/dns/dns_test.go

@@ -0,0 +1,32 @@
+package dns
+
+import "testing"
+
+func cleanCache() {
+	cnameCache.Flush()
+	txtRepoCache.Flush()
+}
+
+func TestAltCNAME(t *testing.T) {
+	defer cleanCache()
+
+	res, err := lookupCNAMETxt("moxxy.org")
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	if res != "moxxy.pages.polynom.me" {
+		t.Fatalf("Unexpected alt CNAME: %s", res)
+	}
+}
+
+func TestLookupCNAMEWithAlt(t *testing.T) {
+	defer cleanCache()
+
+	res, err := LookupCNAME("moxxy.org")
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	if res != "moxxy.pages.polynom.me" {
+		t.Fatalf("Unexpected alt CNAME: %s", res)
+	}
+}

internal/dns/username.go

@@ -0,0 +1,15 @@
+package dns
+
+import "strings"
+
+// Extract the username from the domain name @domain that we're processing
+// at the moment.
+func ExtractUsername(pagesDomain, domain string) string {
+	suffixlessDomain := strings.TrimSuffix(domain, "."+pagesDomain)
+	usernameParts := strings.Split(suffixlessDomain, ".")
+	if len(usernameParts) == 1 {
+		return usernameParts[0]
+	}
+
+	return strings.Join(usernameParts, ".")
+}

internal/dns/username_test.go

@@ -0,0 +1,23 @@
+package dns
+
+import "testing"
+
+func TestExtractUsernameSimple(t *testing.T) {
+	username := ExtractUsername(
+		"pages.local",
+		"papatutuwawa.pages.local",
+	)
+	if username != "papatutuwawa" {
+		t.Fatalf("Unexpected username: '%s'", username)
+	}
+}
+
+func TestExtractUsernameDot(t *testing.T) {
+	username := ExtractUsername(
+		"pages.local",
+		"polynom.me.pages.local",
+	)
+	if username != "polynom.me" {
+		t.Fatalf("Unexpected username: '%s'", username)
+	}
+}

internal/gitea/client.go

@@ -0,0 +1,130 @@
+package gitea
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"code.gitea.io/sdk/gitea"
+	log "github.com/sirupsen/logrus"
+
+	"git.polynom.me/rio/internal/dns"
+)
+
+// Returns true if the repository at <username>/<repository> exists, false if it
+// does not.
+type GetRepositoryMethod func(username, repositoryName string) (Repository, error)
+
+// Returns <file content>, nil if the file exists at path <path> (relative to the repository) in
+// <username>/<repository>@<branch> exists. If not, returns "", error.
+type GetFileMethod func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error)
+
+// Returns the result of a CNAME lookup for @domain.
+type LookupCNAMEMethod func(domain string) (string, error)
+
+// Return the repository the domain should point to by looking up the TXT record
+// "_rio-pages.<domain>".
+type LookupRepoTXTMethod func(domain string) (string, error)
+
+// Check of the repository <username>/<repositoryName> contains the specified
+// branch.
+type HasBranchMethod func(username, repositoryName, branchName string) bool
+
+// Check if the specified username exists.
+type HasUserMethod func(username string) bool
+
+type Repository struct {
+	Name string
+}
+
+type GiteaClient struct {
+	Token string
+
+	GetRepository GetRepositoryMethod
+	HasBranch     HasBranchMethod
+	HasUser       HasUserMethod
+	GetFile       GetFileMethod
+	LookupCNAME   LookupCNAMEMethod
+	LookupRepoTXT LookupRepoTXTMethod
+}
+
+func NewGiteaClient(giteaUrl string, token string, giteaClient *gitea.Client) GiteaClient {
+	return GiteaClient{
+		Token: token,
+		GetRepository: func(username, repositoryName string) (Repository, error) {
+			repo, _, err := giteaClient.GetRepo(username, repositoryName)
+			if err != nil {
+				return Repository{}, err
+			}
+
+			return Repository{
+				Name: repo.Name,
+			}, nil
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			res, _, err := giteaClient.ListRepoBranches(username, repositoryName, gitea.ListRepoBranchesOptions{})
+			if err != nil {
+				return false
+			}
+
+			for _, branch := range res {
+				if branch.Name == branchName {
+					return true
+				}
+			}
+			return false
+		},
+		HasUser: func(username string) bool {
+			_, _, err := giteaClient.GetUserInfo(username)
+			return err == nil
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			// We have to do the raw request manually because the Gitea SDK does not allow
+			// passing the If-Modfied-Since header.
+			apiUrl := fmt.Sprintf(
+				"%s/api/v1/repos/%s/%s/raw/%s?ref=%s",
+				giteaUrl,
+				username,
+				repositoryName,
+				path,
+				branch,
+			)
+			log.Debugf("GetFile: Requesting '%s'", apiUrl)
+			client := &http.Client{}
+			req, err := http.NewRequest("GET", apiUrl, nil)
+			if since != nil {
+				sinceFormat := since.Format(time.RFC1123)
+				req.Header.Add("If-Modified-Since", sinceFormat)
+			}
+
+			// Add authentication, if we have a token
+			if token != "" {
+				req.Header.Add("Authorization", "token "+token)
+			}
+
+			resp, err := client.Do(req)
+			if err != nil {
+				return []byte{}, true, err
+			}
+			defer resp.Body.Close()
+			content, err := io.ReadAll(resp.Body)
+
+			if err != nil {
+				return []byte{}, true, err
+			} else if resp.StatusCode == 302 {
+				return []byte{}, false, nil
+			} else if resp.StatusCode == 404 {
+				return []byte{}, false, fmt.Errorf("File does not exist")
+			} else {
+				return content, true, err
+			}
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return dns.LookupCNAME(domain)
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			return dns.LookupRepoTXT(domain)
+		},
+	}
+}

internal/metrics/metrics.go

@@ -0,0 +1,99 @@
+package metrics
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type MetricConfig struct {
+	Url           string
+	BotUserAgents *[]regexp.Regexp
+	Enabled       bool
+}
+
+// Checks if we should send a metric ping to page-metrics based on the served path.
+func (c *MetricConfig) ShouldSendMetrics(path, userAgent, dnt, gpc string) bool {
+	if !strings.HasSuffix(path, ".html") || !c.Enabled {
+		return false
+	}
+
+	// Ignore requests where the user have set "Do-Not-Track" or "Do-Not-Sell-My-Data", even though
+	// there is no user data and we're not selling it.
+	if dnt == "1" || gpc == "1" {
+		return false
+	}
+
+	// Filter out bots
+	for _, pattern := range *c.BotUserAgents {
+		if pattern.MatchString(userAgent) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (c *MetricConfig) SendMetricPing(domain, path, referrer string) {
+	data := map[string]string{
+		"domain":  domain,
+		"path":    path,
+		"referer": referrer,
+	}
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		log.Errorf("Failed to send metric ping: %v", err)
+		return
+	}
+
+	log.Debugf("Sending payload %s", string(jsonData))
+
+	// Send the ping to the server
+	go func() {
+		res, err := http.Post(
+			c.Url,
+			"application/json",
+			strings.NewReader(string(jsonData)),
+		)
+		if err != nil {
+			log.Errorf("Failed to send payload to: %v", err)
+			return
+		}
+
+		defer res.Body.Close()
+		if res.StatusCode != 200 {
+			log.Errorf("Server returned non-200 status code %d", res.StatusCode)
+		}
+	}()
+}
+
+// Reads a JSON array of bot user agents from disk and parses them
+// into regular expressions.
+func ReadBotPatterns(file string) ([]regexp.Regexp, error) {
+	content, err := os.ReadFile(file)
+	if err != nil {
+		log.Warnf("Failed to read bot metrics file: %v", err)
+		return []regexp.Regexp{}, err
+	}
+
+	var payload []string
+	err = json.Unmarshal(content, &payload)
+	if err != nil {
+		log.Warnf("Failed to unmarshal file: %v", err)
+		return []regexp.Regexp{}, err
+	}
+
+	patterns := make([]regexp.Regexp, 0)
+	for _, v := range payload {
+		patterns = append(
+			patterns,
+			*regexp.MustCompile(v),
+		)
+	}
+
+	return patterns, nil
+}

internal/metrics/metrics_test.go

@@ -0,0 +1,32 @@
+package metrics
+
+import (
+	"regexp"
+	"testing"
+)
+
+func TestShouldPing(t *testing.T) {
+	cfg := MetricConfig{
+		Enabled: true,
+		Url:     "",
+		BotUserAgents: &[]regexp.Regexp{
+			*regexp.MustCompile("random-bot/.*"),
+		},
+	}
+
+	if cfg.ShouldSendMetrics("/index.html", "random-bot/v23.5", "", "") {
+		t.Fatalf("Accepted bot user-agent")
+	}
+
+	if !cfg.ShouldSendMetrics("/index.html", "Firefox/...", "", "") {
+		t.Fatalf("Rejected real user-agent")
+	}
+
+	if cfg.ShouldSendMetrics("/index.html", "Firefox/...", "1", "") {
+		t.Fatalf("Ignored DNT")
+	}
+
+	if cfg.ShouldSendMetrics("/index.html", "Firefox/...", "", "1") {
+		t.Fatalf("Ignored GPC")
+	}
+}

internal/pages/pages.go

@@ -0,0 +1,130 @@
+package pages
+
+import (
+	"mime"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"git.polynom.me/rio/internal/constants"
+	"git.polynom.me/rio/internal/context"
+
+	"github.com/patrickmn/go-cache"
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	pageCache = cache.New(6*time.Hour, 1*time.Hour)
+)
+
+type PageContentCache struct {
+	Content     []byte
+	mimeType    string
+	RequestedAt time.Time
+}
+
+func makePageContentCacheEntry(username, path string) string {
+	return username + ":" + path
+}
+
+func addHeaders(repoInfo *context.RepositoryInformation, contentType string, contentLength int, w http.ResponseWriter) {
+	// Always set a content type
+	if strings.Trim(contentType, " ") == "" {
+		w.Header().Set("Content-Type", "application/octet-stream")
+	} else {
+		w.Header().Set("Content-Type", contentType)
+	}
+
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.Header().Set("Strict-Transport-Security", "max-age=31536000")
+	w.Header().Set("Content-Length", strconv.Itoa(contentLength))
+
+	if repoInfo != nil {
+		for key, value := range repoInfo.Headers {
+			w.Header().Set(key, value)
+		}
+	}
+}
+
+func ServeFile(context *context.Context) {
+	// Strip away a starting / as it messes with Gitea
+	path := context.Path
+	if path[:1] == "/" {
+		path = path[1:]
+	}
+
+	key := makePageContentCacheEntry(context.Username, path)
+	entry, found := pageCache.Get(key)
+	var content []byte
+	var mimeType string
+	var err error
+	var since *time.Time = nil
+	if found {
+		log.Debugf("Returning %s from cache", path)
+		content = entry.(PageContentCache).Content
+		mimeType = entry.(PageContentCache).mimeType
+		sinceRaw := entry.(PageContentCache).RequestedAt
+		since = &sinceRaw
+	}
+
+	content, changed, err := context.Global.Gitea.GetFile(
+		context.Username,
+		context.Reponame,
+		constants.PagesBranch,
+		path,
+		since,
+	)
+	repoInfo := context.Global.Cache.GetRepositoryInformation(
+		context.Username,
+		context.Reponame,
+	)
+
+	if err != nil {
+		if !found {
+			log.Errorf("Failed to get file %s/%s/%s (%s)", context.Username, context.Reponame, path, err)
+			addHeaders(repoInfo, "text/html", 0, context.Writer)
+			context.Writer.WriteHeader(404)
+		} else {
+			log.Debugf("Request failed but page %s is cached in memory", path)
+			addHeaders(repoInfo, mimeType, len(content), context.Writer)
+			context.Writer.WriteHeader(200)
+			context.Writer.Write(content)
+		}
+
+		return
+	}
+
+	if found && !changed {
+		log.Debugf("Page %s is unchanged and cached in memory", path)
+		addHeaders(repoInfo, mimeType, len(content), context.Writer)
+		context.Writer.WriteHeader(200)
+		context.Writer.Write(content)
+		return
+	}
+
+	pathParts := strings.Split(path, ".")
+	ext := pathParts[len(pathParts)-1]
+	mimeType = mime.TypeByExtension("." + ext)
+
+	now := time.Now()
+	pageCache.Set(
+		key,
+		PageContentCache{
+			content,
+			mimeType,
+			now,
+		},
+		cache.DefaultExpiration,
+	)
+
+	log.Debugf("Page %s requested from Gitea and cached in memory at %v", path, now)
+	addHeaders(repoInfo, mimeType, len(content), context.Writer)
+	context.Writer.WriteHeader(200)
+	context.Writer.Write(content)
+
+	// Tell Loki about if, if desired
+	if context.Global.MetricConfig.ShouldSendMetrics(path, context.UserAgent, context.DNT, context.GPC) {
+		context.Global.MetricConfig.SendMetricPing(context.Domain, path, context.Referrer)
+	}
+}

internal/repo/repo.go

@@ -0,0 +1,223 @@
+package repo
+
+//go:generate mockgen -destination mock_repo_test.go -package repo code.gitea.io/sdk/gitea Client
+
+import (
+	"encoding/json"
+	"errors"
+	"slices"
+	"strings"
+
+	"git.polynom.me/rio/internal/constants"
+	"git.polynom.me/rio/internal/context"
+	"git.polynom.me/rio/internal/gitea"
+
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	ForbiddenHeaders = []string{
+		"content-length",
+		"content-type",
+		"date",
+		"location",
+		"strict-transport-security",
+		"set-cookie",
+	}
+)
+
+func lookupRepositoryAndCache(username, reponame, branchName, host, domain, path, cname string, ctx *context.GlobalContext) (*gitea.Repository, error) {
+	log.Debugf("CNAME: %s", cname)
+	log.Debugf("Looking up repository %s/%s", username, reponame)
+	repo, err := ctx.Gitea.GetRepository(username, reponame)
+	if err != nil {
+		return nil, err
+	}
+
+	if !ctx.Gitea.HasBranch(username, reponame, branchName) {
+		return nil, errors.New("Specified branch does not exist")
+	}
+
+	// Check if the CNAME file matches
+
+	if cname != "" {
+		log.Debug("Checking CNAME")
+		repoInfo := GetRepositoryInformation(username, reponame, ctx)
+		if repoInfo == nil {
+			log.Warn("Repository does not contain a rio.json file")
+			return nil, errors.New("No CNAME available in repository")
+		}
+
+		log.Debugf("CNAME Content: \"%s\"", repoInfo.CNAME)
+		if repoInfo.CNAME != host {
+			log.Warnf("CNAME mismatch: Repo '%s', Host '%s'", repoInfo.CNAME, host)
+			return nil, errors.New("CNAME mismatch")
+		}
+	}
+
+	// Cache data
+	ctx.Cache.SetRepositoryPath(
+		domain,
+		path,
+		context.RepositoryPathInformation{
+			Repository: repo,
+			Path:       path,
+		},
+	)
+	return &repo, nil
+}
+
+// host is the domain name we're accessed from. cname is the domain that host is pointing
+// if, if we're accessed via a CNAME. If not, then cname is "".
+func RepoFromPath(username, host, cname, path string, ctx *context.GlobalContext) (*gitea.Repository, string, error) {
+	domain := host
+
+	// Guess the repository
+	entry := ctx.Cache.GetRepositoryPath(domain, path)
+	if entry != nil {
+		return &entry.Repository, entry.Path, nil
+	}
+
+	// Allow specifying the repository name in the TXT record
+	reponame := ""
+	if cname != "" {
+		repoLookup, err := ctx.Gitea.LookupRepoTXT(host)
+		if err == nil && repoLookup != "" {
+			log.Infof(
+				"TXT lookup for %s resulted in choosing repository %s",
+				host,
+				repoLookup,
+			)
+			reponame = repoLookup
+		}
+	}
+
+	pathParts := strings.Split(path, "/")
+	log.Debugf("reponame='%s' len(pathParts)='%d'", reponame, len(pathParts))
+	if reponame == "" && len(pathParts) > 1 {
+		log.Debugf("Trying repository %s", pathParts[0])
+		modifiedPath := strings.Join(pathParts[1:], "/")
+		repo, err := lookupRepositoryAndCache(
+			username,
+			pathParts[0],
+			constants.PagesBranch,
+			host,
+			domain,
+			modifiedPath,
+			cname,
+			ctx,
+		)
+		if err == nil {
+			return repo, modifiedPath, nil
+		}
+	}
+
+	if reponame == "" {
+		reponame = domain
+	}
+	log.Debugf("Trying repository %s/%s", username, reponame)
+	repo, err := lookupRepositoryAndCache(
+		username,
+		reponame,
+		constants.PagesBranch,
+		host,
+		domain,
+		path,
+		cname,
+		ctx,
+	)
+	return repo, path, err
+}
+
+// Checks if the username exists as an organisation or an user on the Gitea
+// instance, so that an attacker can't just request certificates for random
+// usernames.
+func CanRequestCertificate(username string, ctx *context.GlobalContext) bool {
+	found := ctx.Cache.GetUser(username)
+	if found {
+		return true
+	}
+
+	hasUser := ctx.Gitea.HasUser(username)
+	if hasUser {
+		ctx.Cache.SetUser(username)
+	}
+	return hasUser
+}
+
+func filterHeaders(headers map[string]interface{}) map[string]string {
+	newHeaders := make(map[string]string)
+
+	for key, value := range headers {
+		if slices.Contains[[]string, string](ForbiddenHeaders, strings.ToLower(key)) {
+			continue
+		}
+
+		switch value.(type) {
+		case string:
+			newHeaders[key] = value.(string)
+		}
+	}
+
+	return newHeaders
+}
+
+func GetRepositoryInformation(owner, repoName string, ctx *context.GlobalContext) *context.RepositoryInformation {
+	res := ctx.Cache.GetRepositoryInformation(owner, repoName)
+	if res != nil {
+		return res
+	}
+
+	fetchedConfig, _, err := ctx.Gitea.GetFile(
+		owner,
+		repoName,
+		constants.PagesBranch,
+		"rio.json",
+		nil,
+	)
+	if err != nil {
+		log.Errorf("Failed to request rio.json for %s/%s:%v", owner, repoName, err)
+		return nil
+	}
+
+	var payload map[string]interface{}
+	err = json.Unmarshal(fetchedConfig, &payload)
+	if err != nil {
+		log.Errorf("Failed to unmarshal rio.json for %s/%s:%v", owner, repoName, err)
+		return nil
+	}
+
+	headers, found := payload["headers"]
+	if !found {
+		log.Warnf("Did not find headers key in rio.json for %s/%s", owner, repoName)
+		headers = make(map[string]interface{})
+	} else {
+		switch headers.(type) {
+		case map[string]interface{}:
+			// NOOP
+		default:
+			log.Warn("headers attribute has invalid data type")
+			headers = make(map[string]string)
+		}
+	}
+
+	cname, found := payload["CNAME"]
+	if found {
+		switch cname.(type) {
+		case string:
+			// NOOP
+		default:
+			log.Warnf("CNAME attribute is not a string for %s/%s", owner, repoName)
+			cname = ""
+		}
+	} else {
+		cname = ""
+	}
+
+	info := context.RepositoryInformation{
+		Headers: filterHeaders(headers.(map[string]interface{})),
+		CNAME:   cname.(string),
+	}
+	ctx.Cache.SetRepositoryInformation(owner, repoName, info)
+	return &info
+}

internal/repo/repo_test.go

@@ -0,0 +1,550 @@
+package repo
+
+import (
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"git.polynom.me/rio/internal/context"
+	"git.polynom.me/rio/internal/gitea"
+
+	log "github.com/sirupsen/logrus"
+)
+
+func TestHeaderFilter(t *testing.T) {
+	map1 := filterHeaders(
+		map[string]interface{}{
+			"Content-Type":            "hallo",
+			"content-Type":            "welt",
+			"content-type":            "uwu",
+			"CONTENT-TYPE":            "lol",
+			"Content-Security-Policy": "none",
+		},
+	)
+
+	if len(map1) != 1 {
+		t.Fatalf("filterHeaders allowed %d != 1 headers", len(map1))
+	}
+
+	for key := range map1 {
+		if strings.ToLower(key) == "content-type" {
+			t.Fatalf("filterHeaders allowed Content-Type")
+		}
+	}
+}
+
+func TestPickingCorrectRepositoryDefault(t *testing.T) {
+	// Test that we default to the <username>.<pages domain> repository, if we have only
+	// one path component.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username != "example-user" {
+				t.Fatalf("Called with unknown user %s", username)
+			}
+			if repositoryName != "example-user.pages.example.org" {
+				t.Fatalf("Called with unknown repository %s", repositoryName)
+			}
+
+			return gitea.Repository{}, nil
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "example-user.pages.example.org" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			t.Fatal("getFile called")
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			t.Fatal("LookupCNAME called")
+			return "", nil
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			t.Fatal("LookupRepoTXT called")
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	res, path, err := RepoFromPath("example-user", "example-user.pages.example.org", "", "index.html", ctx)
+	if err != nil {
+		t.Fatalf("An error occured: %v", err)
+	}
+	if res == nil {
+		t.Fatal("Result is nil")
+	}
+	if path != "index.html" {
+		t.Fatalf("Returned path is invalid: %s", path)
+	}
+}
+
+func TestPickingCorrectRepositoryDefaultSubdirectory(t *testing.T) {
+	// Test that we return the default repository when the first path component does
+	// not correspong to an existing repository.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username != "example-user" {
+				t.Fatalf("Called with unknown user %s", username)
+			}
+			if repositoryName == "assets" {
+				return gitea.Repository{}, errors.New("gitea.Repository does not exist")
+			} else if repositoryName == "example-user.pages.example.org" {
+				return gitea.Repository{}, nil
+			} else {
+				t.Fatalf("Called with unknown repository %s", repositoryName)
+				return gitea.Repository{}, nil
+			}
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "example-user.pages.example.org" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			t.Fatal("getFile called")
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			t.Fatal("LookupCNAME called")
+			return "", nil
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			t.Fatal("LookupRepoTXT called")
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	res, path, err := RepoFromPath("example-user", "example-user.pages.example.org", "", "assets/index.css", ctx)
+	if err != nil {
+		t.Fatalf("An error occured: %v", err)
+	}
+	if res == nil {
+		t.Fatal("Result is nil")
+	}
+	if path != "assets/index.css" {
+		t.Fatalf("Returned path is invalid: %s", path)
+	}
+}
+
+func TestPickingCorrectRepositorySubdirectoryNoPagesBranch(t *testing.T) {
+	// Test that we're picking the correct repository when the first path component
+	// returns a repository without a pages branch.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username != "example-user" {
+				t.Fatalf("Called with unknown user %s", username)
+			}
+			if repositoryName == "blog" {
+				return gitea.Repository{
+					Name: "blog",
+				}, nil
+			} else if repositoryName == "example-user.pages.example.org" {
+				return gitea.Repository{
+					Name: "example-user.pages.example.org",
+				}, nil
+			} else {
+				t.Fatalf("Called with unknown repository %s", repositoryName)
+				return gitea.Repository{}, nil
+			}
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "example-user.pages.example.org" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			t.Fatal("getFile called")
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			t.Fatal("LookupCNAME called")
+			return "", nil
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			t.Fatal("LookupRepoTXT called")
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	res, path, err := RepoFromPath("example-user", "example-user.pages.example.org", "", "blog/post1.html", ctx)
+	if err != nil {
+		t.Fatalf("An error occured: %v", err)
+	}
+	if res == nil {
+		t.Fatal("Result is nil")
+	}
+	if res.Name != "example-user.pages.example.org" {
+		t.Fatalf("Invalid repository selected: %s", res.Name)
+	}
+	if path != "blog/post1.html" {
+		t.Fatalf("Returned path is invalid: %s", path)
+	}
+}
+
+func TestPickingNoRepositoryInvalidCNAME(t *testing.T) {
+	// Test that we're not picking a repository if the CNAME validation fails.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username == "example-user" && repositoryName == "example-user.pages.example.org" {
+				return gitea.Repository{
+					Name: "example-user.pages.example.org",
+				}, nil
+			} else {
+				t.Fatalf("Called with unknown repository %s", repositoryName)
+				return gitea.Repository{}, nil
+			}
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "example-user.pages.example.org" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			if username == "example-user" && repositoryName == "example-user.pages.example.org" && branch == "pages" && path == "rio.json" {
+				return []byte("{\"CNAME\": \"some-other-domain.local\"}"), true, nil
+			}
+
+			t.Fatalf("Invalid file requested: %s/%s@%s:%s", username, repositoryName, branch, path)
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return "", errors.New("No CNAME")
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	_, _, err := RepoFromPath("example-user", "example-user.pages.example.org", "example-user.local", "index.html", ctx)
+	if err == nil {
+		t.Fatal("gitea.Repository returned even though CNAME validation should fail")
+	}
+}
+
+func TestPickingRepositoryValidCNAME(t *testing.T) {
+	// Test that we're picking a repository, given a CNAME, if the CNAME validation succeeds.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username == "example-user" && repositoryName == "example-user.local" {
+				return gitea.Repository{
+					Name: "example-user.local",
+				}, nil
+			} else {
+				t.Fatalf("Called with unknown repository %s", repositoryName)
+				return gitea.Repository{}, nil
+			}
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "example-user.local" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			if username == "example-user" && repositoryName == "example-user.local" && branch == "pages" && path == "rio.json" {
+				return []byte("{\"CNAME\": \"example-user.local\"}"), true, nil
+			}
+
+			t.Fatalf("Invalid file requested: %s/%s@%s:%s", username, repositoryName, branch, path)
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return "", errors.New("No CNAME")
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	repo, _, err := RepoFromPath("example-user", "example-user.local", "example-user.pages.example.org", "index.html", ctx)
+	if err != nil {
+		t.Fatalf("Error returned: %v", err)
+	}
+	if repo.Name != "example-user.local" {
+		t.Fatalf("Invalid repository name returned: %s", repo.Name)
+	}
+}
+
+func TestPickingRepositoryValidCNAMEWithTXTLookup(t *testing.T) {
+	// Test that we're picking a repository, given a CNAME, if the CNAME validation succeeds
+	// and the TXT lookup returns something different.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" {
+				return gitea.Repository{
+					Name: "some-different-repository",
+				}, nil
+			} else {
+				t.Fatalf("Called with unknown repository %s", repositoryName)
+				return gitea.Repository{}, nil
+			}
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "some-different-repository" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" && branch == "pages" && path == "rio.json" {
+				return []byte("{\"CNAME\": \"example-user.local\"}"), true, nil
+			}
+
+			t.Fatalf("Invalid file requested: %s/%s@%s:%s", username, repositoryName, branch, path)
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return "", errors.New("No CNAME")
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			if domain == "example-user.local" {
+				return "some-different-repository", nil
+			}
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	repo, _, err := RepoFromPath("example-user", "example-user.local", "example-user.pages.example.org", "index.html", ctx)
+	if err != nil {
+		t.Fatalf("Error returned: %v", err)
+	}
+	if repo.Name != "some-different-repository" {
+		t.Fatalf("Invalid repository name returned: %s", repo.Name)
+	}
+}
+
+func TestPickingRepositoryValidCNAMEWithTXTLookupAndSubdirectory(t *testing.T) {
+	// Test that we're picking a repository, given a CNAME, if the CNAME validation succeeds
+	// and the TXT lookup returns something different. Additionally, we now have a subdirectory
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" {
+				return gitea.Repository{
+					Name: "some-different-repository",
+				}, nil
+			}
+
+			return gitea.Repository{}, errors.New("Unknown repository")
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "some-different-repository" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" && branch == "pages" && path == "rio.json" {
+				return []byte("{\"CNAME\": \"example-user.local\"}"), true, nil
+			}
+
+			t.Fatalf("Invalid file requested: %s/%s@%s:%s", username, repositoryName, branch, path)
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return "", errors.New("No CNAME")
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			if domain == "example-user.local" {
+				return "some-different-repository", nil
+			}
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	repo, _, err := RepoFromPath("example-user", "example-user.local", "example-user.pages.example.org", "blog/index.html", ctx)
+	if err != nil {
+		t.Fatalf("Error returned: %v", err)
+	}
+	if repo.Name != "some-different-repository" {
+		t.Fatalf("Invalid repository name returned: %s", repo.Name)
+	}
+}
+
+func TestHeaderParsingEmpty(t *testing.T) {
+	// Test that we are correctly handling a repository with no headers.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" {
+				return gitea.Repository{
+					Name: "some-different-repository",
+				}, nil
+			}
+
+			return gitea.Repository{}, errors.New("Unknown repository")
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "some-different-repository" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" && branch == "pages" && path == "rio.json" {
+				return []byte("{\"CNAME\": \"example-user.local\"}"), true, nil
+			}
+
+			t.Fatalf("Invalid file requested: %s/%s@%s:%s", username, repositoryName, branch, path)
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return "", errors.New("No CNAME")
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			if domain == "example-user.local" {
+				return "some-different-repository", nil
+			}
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	info := GetRepositoryInformation("example-user", "some-different-repository", ctx)
+	if info == nil {
+		t.Fatalf("No repository information returned")
+	}
+
+	if len(info.Headers) > 0 {
+		t.Fatalf("Headers returned: %v", info.Headers)
+	}
+}
+
+func TestHeaderParsing(t *testing.T) {
+	// Test that we are correctly handling a repository with no headers.
+	log.SetLevel(log.DebugLevel)
+	client := gitea.GiteaClient{
+		GetRepository: func(username, repositoryName string) (gitea.Repository, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" {
+				return gitea.Repository{
+					Name: "some-different-repository",
+				}, nil
+			}
+
+			return gitea.Repository{}, errors.New("Unknown repository")
+		},
+		HasBranch: func(username, repositoryName, branchName string) bool {
+			if username == "example-user" && repositoryName == "some-different-repository" && branchName == "pages" {
+				return true
+			}
+
+			return false
+		},
+		GetFile: func(username, repositoryName, branch, path string, since *time.Time) ([]byte, bool, error) {
+			if username == "example-user" && repositoryName == "some-different-repository" && branch == "pages" && path == "rio.json" {
+				return []byte("{\"CNAME\": \"example-user.local\", \"headers\": {\"X-Cool-Header\": \"Very nice!\"}}"), true, nil
+			}
+
+			t.Fatalf("Invalid file requested: %s/%s@%s:%s", username, repositoryName, branch, path)
+			return []byte{}, true, nil
+		},
+		LookupCNAME: func(domain string) (string, error) {
+			return "", errors.New("No CNAME")
+		},
+		LookupRepoTXT: func(domain string) (string, error) {
+			if domain == "example-user.local" {
+				return "some-different-repository", nil
+			}
+			return "", nil
+		},
+	}
+	ctx := &context.GlobalContext{
+		Gitea: &client,
+		Cache: &context.CacheContext{
+			RepositoryInformationCache: context.MakeRepoInfoCache(),
+			RepositoryPathCache:        context.MakeRepoPathCache(),
+		},
+	}
+
+	info := GetRepositoryInformation("example-user", "some-different-repository", ctx)
+	if info == nil {
+		t.Fatalf("No repository information returned")
+	}
+
+	if len(info.Headers) != 1 {
+		t.Fatalf("len(info.Headers) != 1: %v", info.Headers)
+	}
+
+	header, found := info.Headers["X-Cool-Header"]
+	if !found {
+		t.Fatal("Header X-Cool-Header not found")
+	}
+
+	if header != "Very nice!" {
+		t.Fatalf("Invalid header value for X-Cool-Header: \"%s\"", header)
+	}
+}

internal/server/tls.go

@@ -0,0 +1,187 @@
+package server
+
+import (
+	"crypto/tls"
+	"errors"
+	"strings"
+	"sync"
+
+	"git.polynom.me/rio/internal/certificates"
+	"git.polynom.me/rio/internal/context"
+	"git.polynom.me/rio/internal/dns"
+	"git.polynom.me/rio/internal/repo"
+
+	"github.com/go-acme/lego/v4/lego"
+
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	// To access requestingDomains, first acquire the lock.
+	domainsLock = sync.Mutex{}
+
+	// Domain -> _. Check if domain is a key here to see if we're already requesting
+	// or renewing a certificate for that domain.
+	workingDomains = make(map[string]bool)
+)
+
+func lockIfUnlockedDomain(domain string) bool {
+	domainsLock.Lock()
+	defer domainsLock.Unlock()
+
+	_, found := workingDomains[domain]
+	if !found {
+		workingDomains[domain] = true
+	}
+
+	return found
+}
+
+func unlockDomain(domain string) {
+	domainsLock.Lock()
+	defer domainsLock.Unlock()
+
+	delete(workingDomains, domain)
+}
+
+func buildDomainList(domain, pagesDomain string) []string {
+	if domain == pagesDomain || strings.HasSuffix(domain, pagesDomain) {
+		return []string{
+			pagesDomain,
+			"*." + pagesDomain,
+		}
+	}
+
+	return []string{domain}
+}
+
+func getDomainKey(domain, pagesDomain string) string {
+	if domain == pagesDomain || strings.HasSuffix(domain, pagesDomain) {
+		return "*." + pagesDomain
+	}
+
+	return domain
+}
+
+func getUsername(sni, pagesDomain string) (string, error) {
+	if !strings.HasSuffix(sni, pagesDomain) {
+		log.Debugf("'%s' is not a subdomain of '%s'", sni, pagesDomain)
+
+		// Note: We do not check err here because err != nil
+		// always implies that cname == "", which does not have
+		// pagesDomain as a suffix.
+		query, err := dns.LookupCNAME(sni)
+		if !strings.HasSuffix(query, pagesDomain) {
+			log.Warnf("Got ServerName for Domain %s that we're not responsible for. CNAME '%s', err: %v", sni, query, err)
+			return "", errors.New("CNAME does not resolve to subdomain of pages domain")
+		}
+
+		return dns.ExtractUsername(pagesDomain, query), nil
+	}
+
+	return dns.ExtractUsername(pagesDomain, sni), nil
+}
+
+func MakeTlsConfig(pagesDomain, cachePath string, cache *certificates.CertificatesCache, acmeClient *lego.Client, ctx *context.GlobalContext) *tls.Config {
+	return &tls.Config{
+		GetCertificate: func(info *tls.ClientHelloInfo) (*tls.Certificate, error) {
+			// Validate that we should even care about this domain
+			isPagesDomain := info.ServerName == pagesDomain
+			username, err := getUsername(info.ServerName, pagesDomain)
+			if err != nil {
+				log.Warnf("Failed to get username for %s: %v", info.ServerName, err)
+				return cache.FallbackCertificate.TlsCertificate, nil
+			}
+
+			// Find the correct certificate
+			domainKey := getDomainKey(info.ServerName, pagesDomain)
+			cert, found := cache.Certificates[domainKey]
+			if found {
+				if cert.IsValid() {
+					return cert.TlsCertificate, nil
+				} else {
+					if !isPagesDomain && !repo.CanRequestCertificate(username, ctx) {
+						log.Warnf(
+							"Cannot renew certificate for %s because CanRequestCertificate(%s) returned false",
+							info.ServerName,
+							username,
+						)
+						return cert.TlsCertificate, nil
+					}
+
+					// If we're already working on the domain,
+					// return the old certificate
+					if lockIfUnlockedDomain(domainKey) {
+						return cert.TlsCertificate, nil
+					}
+					defer unlockDomain(domainKey)
+
+					// Renew the certificate
+					log.Infof("Certificate for %s expired, renewing", info.ServerName)
+					newCert, err := certificates.RenewCertificate(&cert, acmeClient)
+					if err != nil {
+						log.Errorf("Failed to renew certificate for %s: %v", info.ServerName, err)
+						return cert.TlsCertificate, nil
+					}
+
+					log.Info("Successfully renewed certificate!")
+					cache.AddCert(newCert, cachePath)
+					return newCert.TlsCertificate, nil
+				}
+			} else {
+				if !isPagesDomain && !repo.CanRequestCertificate(username, ctx) {
+					log.Warnf(
+						"Cannot request certificate for %s because CanRequestCertificate(%s) returned false",
+						info.ServerName,
+						username,
+					)
+					return cache.FallbackCertificate.TlsCertificate, nil
+				}
+
+				// Don't request if we're already requesting.
+				key := getDomainKey(info.ServerName, pagesDomain)
+				if lockIfUnlockedDomain(domainKey) {
+					return cache.FallbackCertificate.TlsCertificate, nil
+				}
+				defer unlockDomain(key)
+
+				// Request new certificate
+				log.Infof("Obtaining new certificate for %s...", info.ServerName)
+				cert, err := certificates.ObtainNewCertificate(
+					buildDomainList(info.ServerName, pagesDomain),
+					domainKey,
+					acmeClient,
+				)
+				if err != nil {
+					log.Errorf(
+						"Failed to get certificate for %s: %v",
+						info.ServerName,
+						err,
+					)
+					return cache.FallbackCertificate.TlsCertificate, nil
+				}
+
+				// Add to cache and flush
+				log.Info("Successfully obtained new certificate!")
+				cache.AddCert(cert, cachePath)
+				return cert.TlsCertificate, nil
+			}
+		},
+		NextProtos: []string{
+			"http/0.9",
+			"http/1.0",
+			"http/1.1",
+			"h2",
+			"h2c",
+		},
+		MinVersion: tls.VersionTLS12,
+		CipherSuites: []uint16{
+			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+		},
+	}
+}

internal/server/tls_test.go

@@ -0,0 +1,67 @@
+package server
+
+import "testing"
+
+const (
+	pagesDomain         = "pages.local"
+	pagesDomainWildcard = "*.pages.local"
+)
+
+func equals(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+func TestDomainListBare(t *testing.T) {
+	expect := []string{pagesDomain, pagesDomainWildcard}
+	res := buildDomainList(pagesDomain, pagesDomain)
+	if !equals(res, expect) {
+		t.Fatalf("%v != %v", res, expect)
+	}
+}
+
+func TestDomainListSubdomain(t *testing.T) {
+	expect := []string{pagesDomain, pagesDomainWildcard}
+	res := buildDomainList("user."+pagesDomain, pagesDomain)
+	if !equals(res, expect) {
+		t.Fatalf("%v != %v", res, expect)
+	}
+}
+
+func TestDomainListCNAME(t *testing.T) {
+	expect := []string{"testdomain.example"}
+	res := buildDomainList("testdomain.example", pagesDomain)
+	if !equals(res, expect) {
+		t.Fatalf("%v != %v", res, expect)
+	}
+}
+
+func TestDomainKeyBare(t *testing.T) {
+	res := getDomainKey(pagesDomain, pagesDomain)
+	if res != pagesDomainWildcard {
+		t.Fatalf("%s != %s", res, pagesDomainWildcard)
+	}
+}
+
+func TestDomainKeySubdomain(t *testing.T) {
+	res := getDomainKey("user."+pagesDomain, pagesDomain)
+	if res != pagesDomainWildcard {
+		t.Fatalf("%s != %s", res, pagesDomainWildcard)
+	}
+}
+
+func TestDomainKeyCNAME(t *testing.T) {
+	res := getDomainKey("testdomain.example", pagesDomain)
+	if res != "testdomain.example" {
+		t.Fatalf("%s != %s", res, "testdomain.example")
+	}
+}

main.go

@@ -1,236 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"os"
-	"fmt"
-	"net"
-	"net/http"
-	"strings"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
-	"github.com/go-acme/lego/v4/challenge/http01"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	PagesBranch = "pages"
-)
-
-func handleSubdomain(domain string, cname string, path string, giteaClient *gitea.Client, w http.ResponseWriter) {
-	hostParts := strings.Split(domain, ".")
-	username := hostParts[0]
-
-	// Strip the leading /
-	if path[:1] == "/" {
-		path = path[1:]
-	}
-
-	repo, path, err := RepoFromPath(
-		username,
-		domain,
-		cname,
-		path,
-		giteaClient,
-		
-	)
-	if err != nil {
-		log.Errorf("Failed to get repo: %s", err)
-		w.WriteHeader(404)
-		return
-	}
-
-	serveFile(username, repo.Name, path, giteaClient, w)
-}
-
-func Handler(pagesDomain string, giteaClient *gitea.Client) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		w.Header().Set("Server", "rio")
-
-		if strings.HasSuffix(req.Host, pagesDomain){
-			if handleLetsEncryptChallenge(w, req) {
-				return
-			}
-
-			log.Debug("Domain can be directly handled")
-			handleSubdomain(req.Host, "", req.URL.Path, giteaClient, w)
-			return
-		}
-		
-		cname, err := lookupCNAME(req.Host)
-		if err != nil {
-			log.Warningf("CNAME request failed, we don't handle %s", req.Host)
-			w.WriteHeader(400)
-			return
-		}
-		log.Debugf("Got CNAME %s", cname)
-
-		if strings.HasSuffix(cname, pagesDomain) {
-			log.Debugf("%s is alias of %s", req.Host, cname)
-			if handleLetsEncryptChallenge(w, req) {
-				return
-			}
-
-			log.Debugf("Domain can be handled after a CNAME query")
-			handleSubdomain(cname, cname, req.URL.Path, giteaClient, w)
-			return
-		}
-
-		log.Errorf("Not handling %s", req.Host)
-		w.WriteHeader(404)
-	}
-}
-
-func runServer(ctx *cli.Context) error {
-	log.SetLevel(log.DebugLevel)
-	giteaUrl := ctx.String("gitea-url")
-	addr := ctx.String("listen-host") + ":" + ctx.String("listen-port")
-	domain := ctx.String("pages-domain")
-	certsFile := ctx.String("certs-file")
-	acmeEmail := ctx.String("acme-email")
-	acmeServer := ctx.String("acme-server")
-	acmeFile := ctx.String("acme-file")
-	acmeHost := ctx.String("acme-host")
-	acmePort := ctx.String("acme-port")
-
-	err := LoadCertificateStoreFromFile(certsFile)
-	if err != nil {
-		log.Debugf("Generating cert")
-		err := InitialiseFallbackCert(domain)
-		if err != nil {
-			log.Fatalf("Failed to generate fallback certificate: %v", err)
-			return err
-		}
-
-		FlushCertificateStoreToFile(certsFile)
-		log.Debug("Certificate wrote to disk")
-	} else {
-		log.Debug("Certificate store read from disk")
-	}
-
-	// Create an ACME client, if we failed to load one
-	acmeClient, err := ClientFromFile(acmeFile, acmeServer)
-	if err != nil {
-		log.Warn("Failed to load ACME client data from disk. Generating new account")
-		acmeClient, err = GenerateNewAccount(acmeEmail, acmeFile, acmeServer)
-		if err != nil {
-			log.Fatalf("Failed to generate new ACME client: %v", err)
-			return err
-		}
-		log.Info("ACME account registered")
-	} else {
-		log.Info("ACME client data read from disk")
-	}
-
-	// Set up the HTTP01 listener
-	err = acmeClient.Challenge.SetHTTP01Provider(
-		http01.NewProviderServer(acmeHost, acmePort),
-	)
-	if err != nil {
-		log.Fatalf("Failed to setup HTTP01 challenge listener: %v", err)
-		return err
-	}
-
-	// Setup the HTTPS stuff
-	httpClient := http.Client{Timeout: 10 * time.Second}
-	client, err := gitea.NewClient(
-		giteaUrl,
-		gitea.SetHTTPClient(&httpClient),
-		gitea.SetToken(""),
-		gitea.SetUserAgent("rio"),
-	)
-
-	listener, err := net.Listen("tcp", addr)
-	if err != nil {
-		fmt.Errorf("Failed to create listener: %v", err)
-		return err
-	}
-
-	tlsConfig := makeTlsConfig(
-		domain,
-		certsFile,
-		acmeClient,
-	)
-	listener = tls.NewListener(listener, tlsConfig)
-
-	if err := http.Serve(listener, Handler(domain, client)); err != nil {
-		fmt.Printf("Listening failed")
-		return err
-	}
-
-	return nil
-}
-
-func main() {
-	app := &cli.App{
-		Action: runServer,
-		Flags: []cli.Flag{
-			&cli.StringFlag{
-				Name: "gitea-url",
-				Usage: "The (HTTPS) URL to the serving Gitea instance",
-				EnvVars: []string{"GITEA_URL"},
-				Required: true,
-			},
-			&cli.StringFlag{
-				Name: "listen-host",
-				Usage: "The host to listen on",
-				EnvVars: []string{"HOST"},
-				Value: "127.0.0.1",
-			},
-			&cli.StringFlag{
-				Name: "listen-port",
-				Usage: "The port to listen on",
-				EnvVars: []string{"PORT"},
-				Value: "8888",
-			},
-			&cli.StringFlag{
-				Name: "acme-host",
-				Usage: "The host to bind to for ACME challenges",
-				EnvVars: []string{"ACME_HOST"},
-				Value: "",
-			},
-			&cli.StringFlag{
-				Name: "acme-port",
-				Usage: "The port to listen on for ACME challenges",
-				EnvVars: []string{"ACME_PORT"},
-				Value: "8889",
-			},
-			&cli.StringFlag{
-				Name: "pages-domain",
-				Usage: "The domain on which the server is reachable",
-				EnvVars: []string{"PAGES_DOMAIN"},
-				Required: true,
-			},
-			&cli.StringFlag{
-				Name: "certs-file",
-				Usage: "File to store certificates in",
-				EnvVars: []string{"CERTS_FILE"},
-				Required: true,
-			},
-			&cli.StringFlag{
-				Name: "acme-file",
-				Usage: "File to store ACME configuration in",
-				EnvVars: []string{"ACME_FILE"},
-				Required: true,
-			},
-			&cli.StringFlag{
-				Name: "acme-email",
-				Usage: "Email to use for an ACME account",
-				EnvVars: []string{"ACME_EMAIL"},
-				Required: true,
-			},
-			&cli.StringFlag{
-				Name: "acme-server",
-				Usage: "CA Directory to use",
-				EnvVars: []string{"ACME_SERVER"},
-				Value: "https://acme-staging-v02.api.letsencrypt.org/directory",
-			},
-		},
-	}
-
-	if err := app.Run(os.Args); err != nil {
-		log.Fatalf("Failed to run app: %s", err)
-	}
-}

pages.go

@@ -1,74 +0,0 @@
-package main
-
-import (
-	"mime"
-	"net/http"
-	"strings"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-	"github.com/patrickmn/go-cache"
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	pageCache = cache.New(6 * time.Hour, 1 * time.Hour)
-)
-
-type PageContentCache struct {
-	Content []byte
-	mimeType string
-}
-
-func makePageContentCacheEntry(username, path string) string {
-	return username + ":" + path
-}
-
-func serveFile(username, reponame, path string, giteaClient *gitea.Client, w http.ResponseWriter) {
-	// Provide a default
-	if path == "" {
-		path = "/index.html"
-	}
-
-	// Strip away a starting / as it messes with Gitea
-	if path[:1] == "/" {
-		path = path[1:]
-	}
-
-	key := makePageContentCacheEntry(username, path)
-	entry, found := pageCache.Get(key)
-	var content []byte
-	var mimeType string
-	var err error
-	if found {
-		log.Debugf("Returning %s from cache", path)
-		content = entry.(PageContentCache).Content
-		mimeType = entry.(PageContentCache).mimeType
-	} else {
-		content, _, err = giteaClient.GetFile(username, reponame, PagesBranch, path, false)
-		if err != nil {
-			log.Errorf("Failed to get file %s/%s/%s (%s)", username, reponame, path, err)
-			w.WriteHeader(404)
-			return
-		}
-
-		pathParts := strings.Split(path, ".")
-		ext := pathParts[len(pathParts) - 1]
-		mimeType = mime.TypeByExtension("." + ext)
-
-		pageCache.Set(
-			key,
-			PageContentCache{
-				content,
-				mimeType,
-			},
-			cache.DefaultExpiration,
-		)
-
-		log.Debugf("Page %s requested from Gitea and cached in memory", path)
-	}
-
-	w.WriteHeader(200)
-	w.Header().Set("Content-Type", mimeType)
-	w.Write(content)
-}

repo.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"errors"
-	"strings"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-	"github.com/patrickmn/go-cache"
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	pathCache = cache.New(1 * time.Hour, 1 * time.Hour)
-)
-
-
-type PageCacheEntry struct {
-	Repository *gitea.Repository
-	Path string
-}
-
-func makePageCacheKey(domain, path string) string {
-	return domain + "/" + path
-}
-
-/// Try to find the repository with name @reponame of the user @username. If @cname
-/// is not "", then it also verifies that the repository contains a "CNAME" with
-/// the value of @cname as its content. @host, @domain, and @path are passed for
-/// caching on success.
-func lookupRepositoryAndCache(username, reponame, host, domain, path, cname string, giteaClient *gitea.Client) (*gitea.Repository, error) {
-	log.Debugf("Looking up repository %s/%s", username, reponame)
-	repo, _, err := giteaClient.GetRepo(username, reponame)
-	if err != nil {
-		return nil, err
-	}
-
-	// Check if the CNAME file matches
-	if cname != "" {
-		file, _, err := giteaClient.GetFile(
-			username,
-			repo.Name,
-			PagesBranch,
-			"CNAME",
-			false,
-		)
-		if err != nil {
-			log.Errorf("Could not verify CNAME of %s/%s: %v\n", username, repo.Name, err)
-			return nil, err
-		}
-
-		cnameContent := strings.Trim(
-			string(file[:]),
-			"\n",
-		)
-		if cnameContent != cname {
-			return nil, errors.New("CNAME mismatch")
-		}
-	}
-
-	// Cache data
-	pathCache.Set(
-		makePageCacheKey(domain, path),
-		PageCacheEntry{
-			repo,
-			path,
-		},
-		cache.DefaultExpiration,
-	)
-	return repo, nil
-}
-
-func RepoFromPath(username, host, cname, path string, giteaClient *gitea.Client) (*gitea.Repository, string, error) {
-	domain := host
-
-	// Guess the repository
-	key := makePageCacheKey(domain, path)
-	entry, found := pathCache.Get(key)
-	if found {
-		pageEntry := entry.(PageCacheEntry)
-		return pageEntry.Repository, pageEntry.Path, nil
-	}
-
-	pathParts := strings.Split(path, "/")
-	if len(pathParts) > 1 {
-		log.Debugf("Trying repository %s", pathParts[0])
-		modifiedPath := strings.Join(pathParts[1:], "/")
-		repo, err := lookupRepositoryAndCache(
-			username,
-			pathParts[0],
-			host,
-			domain,
-			modifiedPath,
-			cname,
-			giteaClient,
-		)
-		if err == nil {
-			return repo, modifiedPath, nil
-		}
-	}
-
-	// Allow specifying the repository name in the TXT record
-	reponame := domain
-	lookupDomain := domain
-	if cname != "" {
-		lookupDomain = cname
-	}
-	repoLookup, err := lookupRepoTXT(lookupDomain)
-	if err != nil && repoLookup != "" {
-		log.Infof(
-			"TXT lookup for %s resulted in choosing repository %s",
-			lookupDomain,
-			repoLookup,
-		)
-		reponame = repoLookup
-	} else if (cname != "") {
-		// Allow naming the repository "example.org" (But give the TXT record preference)
-		reponame = cname;
-	}
-
-	log.Debugf("Trying repository %s/%s", username, reponame)
-	repo, err := lookupRepositoryAndCache(
-		username,
-		reponame,
-		host,
-		domain,
-		path,
-		cname,
-		giteaClient,
-	)
-	return repo, path, err
-}