diff options
Diffstat (limited to 'vendor/go.mau.fi/util')
29 files changed, 1858 insertions, 0 deletions
diff --git a/vendor/go.mau.fi/util/LICENSE b/vendor/go.mau.fi/util/LICENSE new file mode 100644 index 0000000..a612ad9 --- /dev/null +++ b/vendor/go.mau.fi/util/LICENSE @@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/vendor/go.mau.fi/util/base58/README.md b/vendor/go.mau.fi/util/base58/README.md new file mode 100644 index 0000000..5095450 --- /dev/null +++ b/vendor/go.mau.fi/util/base58/README.md @@ -0,0 +1,9 @@ +base58 +========== + +This is a copy of <https://github.com/btcsuite/btcd/tree/master/btcutil/base58>. + +## License + +Package base58 is licensed under the [copyfree](http://copyfree.org) ISC +License. diff --git a/vendor/go.mau.fi/util/base58/alphabet.go b/vendor/go.mau.fi/util/base58/alphabet.go new file mode 100644 index 0000000..6bb39fe --- /dev/null +++ b/vendor/go.mau.fi/util/base58/alphabet.go @@ -0,0 +1,49 @@ +// Copyright (c) 2015 The btcsuite developers +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +// AUTOGENERATED by genalphabet.go; do not edit. + +package base58 + +const ( + // alphabet is the modified base58 alphabet used by Bitcoin. + alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" + + alphabetIdx0 = '1' +) + +var b58 = [256]byte{ + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 255, 255, 255, 255, 255, 255, + 255, 9, 10, 11, 12, 13, 14, 15, + 16, 255, 17, 18, 19, 20, 21, 255, + 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 255, 255, 255, 255, 255, + 255, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 255, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, +} diff --git a/vendor/go.mau.fi/util/base58/base58.go b/vendor/go.mau.fi/util/base58/base58.go new file mode 100644 index 0000000..8ee5956 --- /dev/null +++ b/vendor/go.mau.fi/util/base58/base58.go @@ -0,0 +1,138 @@ +// Copyright (c) 2013-2015 The btcsuite developers +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package base58 + +import ( + "math/big" +) + +//go:generate go run genalphabet.go + +var bigRadix = [...]*big.Int{ + big.NewInt(0), + big.NewInt(58), + big.NewInt(58 * 58), + big.NewInt(58 * 58 * 58), + big.NewInt(58 * 58 * 58 * 58), + big.NewInt(58 * 58 * 58 * 58 * 58), + big.NewInt(58 * 58 * 58 * 58 * 58 * 58), + big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58), + big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58), + big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58), + bigRadix10, +} + +var bigRadix10 = big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58) // 58^10 + +// Decode decodes a modified base58 string to a byte slice. +func Decode(b string) []byte { + answer := big.NewInt(0) + scratch := new(big.Int) + + // Calculating with big.Int is slow for each iteration. + // x += b58[b[i]] * j + // j *= 58 + // + // Instead we can try to do as much calculations on int64. + // We can represent a 10 digit base58 number using an int64. + // + // Hence we'll try to convert 10, base58 digits at a time. + // The rough idea is to calculate `t`, such that: + // + // t := b58[b[i+9]] * 58^9 ... + b58[b[i+1]] * 58^1 + b58[b[i]] * 58^0 + // x *= 58^10 + // x += t + // + // Of course, in addition, we'll need to handle boundary condition when `b` is not multiple of 58^10. + // In that case we'll use the bigRadix[n] lookup for the appropriate power. + for t := b; len(t) > 0; { + n := len(t) + if n > 10 { + n = 10 + } + + total := uint64(0) + for _, v := range t[:n] { + tmp := b58[v] + if tmp == 255 { + return []byte("") + } + total = total*58 + uint64(tmp) + } + + answer.Mul(answer, bigRadix[n]) + scratch.SetUint64(total) + answer.Add(answer, scratch) + + t = t[n:] + } + + tmpval := answer.Bytes() + + var numZeros int + for numZeros = 0; numZeros < len(b); numZeros++ { + if b[numZeros] != alphabetIdx0 { + break + } + } + flen := numZeros + len(tmpval) + val := make([]byte, flen) + copy(val[numZeros:], tmpval) + + return val +} + +// Encode encodes a byte slice to a modified base58 string. +func Encode(b []byte) string { + x := new(big.Int) + x.SetBytes(b) + + // maximum length of output is log58(2^(8*len(b))) == len(b) * 8 / log(58) + maxlen := int(float64(len(b))*1.365658237309761) + 1 + answer := make([]byte, 0, maxlen) + mod := new(big.Int) + for x.Sign() > 0 { + // Calculating with big.Int is slow for each iteration. + // x, mod = x / 58, x % 58 + // + // Instead we can try to do as much calculations on int64. + // x, mod = x / 58^10, x % 58^10 + // + // Which will give us mod, which is 10 digit base58 number. + // We'll loop that 10 times to convert to the answer. + + x.DivMod(x, bigRadix10, mod) + if x.Sign() == 0 { + // When x = 0, we need to ensure we don't add any extra zeros. + m := mod.Int64() + for m > 0 { + answer = append(answer, alphabet[m%58]) + m /= 58 + } + } else { + m := mod.Int64() + for i := 0; i < 10; i++ { + answer = append(answer, alphabet[m%58]) + m /= 58 + } + } + } + + // leading zero bytes + for _, i := range b { + if i != 0 { + break + } + answer = append(answer, alphabetIdx0) + } + + // reverse + alen := len(answer) + for i := 0; i < alen/2; i++ { + answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i] + } + + return string(answer) +} diff --git a/vendor/go.mau.fi/util/base58/base58check.go b/vendor/go.mau.fi/util/base58/base58check.go new file mode 100644 index 0000000..402c323 --- /dev/null +++ b/vendor/go.mau.fi/util/base58/base58check.go @@ -0,0 +1,52 @@ +// Copyright (c) 2013-2014 The btcsuite developers +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package base58 + +import ( + "crypto/sha256" + "errors" +) + +// ErrChecksum indicates that the checksum of a check-encoded string does not verify against +// the checksum. +var ErrChecksum = errors.New("checksum error") + +// ErrInvalidFormat indicates that the check-encoded string has an invalid format. +var ErrInvalidFormat = errors.New("invalid format: version and/or checksum bytes missing") + +// checksum: first four bytes of sha256^2 +func checksum(input []byte) (cksum [4]byte) { + h := sha256.Sum256(input) + h2 := sha256.Sum256(h[:]) + copy(cksum[:], h2[:4]) + return +} + +// CheckEncode prepends a version byte and appends a four byte checksum. +func CheckEncode(input []byte, version byte) string { + b := make([]byte, 0, 1+len(input)+4) + b = append(b, version) + b = append(b, input...) + cksum := checksum(b) + b = append(b, cksum[:]...) + return Encode(b) +} + +// CheckDecode decodes a string that was encoded with CheckEncode and verifies the checksum. +func CheckDecode(input string) (result []byte, version byte, err error) { + decoded := Decode(input) + if len(decoded) < 5 { + return nil, 0, ErrInvalidFormat + } + version = decoded[0] + var cksum [4]byte + copy(cksum[:], decoded[len(decoded)-4:]) + if checksum(decoded[:len(decoded)-4]) != cksum { + return nil, 0, ErrChecksum + } + payload := decoded[1 : len(decoded)-4] + result = append(result, payload...) + return +} diff --git a/vendor/go.mau.fi/util/base58/doc.go b/vendor/go.mau.fi/util/base58/doc.go new file mode 100644 index 0000000..d657f05 --- /dev/null +++ b/vendor/go.mau.fi/util/base58/doc.go @@ -0,0 +1,29 @@ +// Copyright (c) 2014 The btcsuite developers +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +/* +Package base58 provides an API for working with modified base58 and Base58Check +encodings. + +# Modified Base58 Encoding + +Standard base58 encoding is similar to standard base64 encoding except, as the +name implies, it uses a 58 character alphabet which results in an alphanumeric +string and allows some characters which are problematic for humans to be +excluded. Due to this, there can be various base58 alphabets. + +The modified base58 alphabet used by Bitcoin, and hence this package, omits the +0, O, I, and l characters that look the same in many fonts and are therefore +hard to humans to distinguish. + +# Base58Check Encoding Scheme + +The Base58Check encoding scheme is primarily used for Bitcoin addresses at the +time of this writing, however it can be used to generically encode arbitrary +byte arrays into human-readable strings along with a version byte that can be +used to differentiate the same payload. For Bitcoin addresses, the extra +version is used to differentiate the network of otherwise identical public keys +which helps prevent using an address intended for one network on another. +*/ +package base58 diff --git a/vendor/go.mau.fi/util/exerrors/dualerror.go b/vendor/go.mau.fi/util/exerrors/dualerror.go new file mode 100644 index 0000000..79acd06 --- /dev/null +++ b/vendor/go.mau.fi/util/exerrors/dualerror.go @@ -0,0 +1,33 @@ +// Copyright (c) 2022 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exerrors + +import ( + "errors" + "fmt" +) + +type DualError struct { + High error + Low error +} + +func NewDualError(high, low error) DualError { + return DualError{high, low} +} + +func (err DualError) Is(other error) bool { + return errors.Is(other, err.High) || errors.Is(other, err.Low) +} + +func (err DualError) Unwrap() error { + return err.Low +} + +func (err DualError) Error() string { + return fmt.Sprintf("%v: %v", err.High, err.Low) +} diff --git a/vendor/go.mau.fi/util/exerrors/must.go b/vendor/go.mau.fi/util/exerrors/must.go new file mode 100644 index 0000000..2ffda30 --- /dev/null +++ b/vendor/go.mau.fi/util/exerrors/must.go @@ -0,0 +1,23 @@ +// Copyright (c) 2024 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exerrors + +func Must[T any](val T, err error) T { + PanicIfNotNil(err) + return val +} + +func Must2[T any, T2 any](val T, val2 T2, err error) (T, T2) { + PanicIfNotNil(err) + return val, val2 +} + +func PanicIfNotNil(err error) { + if err != nil { + panic(err) + } +} diff --git a/vendor/go.mau.fi/util/exgjson/gjson.go b/vendor/go.mau.fi/util/exgjson/gjson.go new file mode 100644 index 0000000..ee8fcdd --- /dev/null +++ b/vendor/go.mau.fi/util/exgjson/gjson.go @@ -0,0 +1,33 @@ +// Copyright (c) 2022 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exgjson + +import ( + "strings" +) + +// Escaper escapes a string for use in a GJSON path. +var Escaper = strings.NewReplacer( + `\`, `\\`, + ".", `\.`, + "|", `\|`, + "#", `\#`, + "@", `\@`, + "*", `\*`, + "?", `\?`) + +// Path returns a GJSON path pointing at a nested object, with each provided string being a key. +func Path(path ...string) string { + var result strings.Builder + for i, part := range path { + _, _ = Escaper.WriteString(&result, part) + if i < len(path)-1 { + result.WriteRune('.') + } + } + return result.String() +} diff --git a/vendor/go.mau.fi/util/exhttp/cors.go b/vendor/go.mau.fi/util/exhttp/cors.go new file mode 100644 index 0000000..037be8d --- /dev/null +++ b/vendor/go.mau.fi/util/exhttp/cors.go @@ -0,0 +1,26 @@ +package exhttp + +import "net/http" + +func AddCORSHeaders(w http.ResponseWriter) { + // Recommended CORS headers can be found in https://spec.matrix.org/v1.3/client-server-api/#web-browser-clients + w.Header().Set("Access-Control-Allow-Origin", "*") + w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS") + w.Header().Set("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Authorization") + w.Header().Set("Content-Security-Policy", "sandbox; default-src 'none'; script-src 'none'; plugin-types application/pdf; style-src 'unsafe-inline'; object-src 'self';") + // Allow browsers to cache above for 1 day + w.Header().Set("Access-Control-Max-Age", "86400") +} + +// CORSMiddleware adds CORS headers to the response and handles OPTIONS +// requests by returning 200 OK immediately. +func CORSMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + AddCORSHeaders(w) + if r.Method == http.MethodOptions { + w.WriteHeader(http.StatusOK) + return + } + next.ServeHTTP(w, r) + }) +} diff --git a/vendor/go.mau.fi/util/exhttp/handleerrors.go b/vendor/go.mau.fi/util/exhttp/handleerrors.go new file mode 100644 index 0000000..d2d37b1 --- /dev/null +++ b/vendor/go.mau.fi/util/exhttp/handleerrors.go @@ -0,0 +1,58 @@ +package exhttp + +import "net/http" + +type ErrorBodyGenerators struct { + NotFound func() []byte + MethodNotAllowed func() []byte +} + +func HandleErrors(next http.Handler, gen ErrorBodyGenerators) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + next.ServeHTTP(&bodyOverrider{ + ResponseWriter: w, + statusNotFoundBodyGenerator: gen.NotFound, + statusMethodNotAllowedBodyGenerator: gen.MethodNotAllowed, + }, r) + }) +} + +type bodyOverrider struct { + http.ResponseWriter + + code int + override bool + + statusNotFoundBodyGenerator func() []byte + statusMethodNotAllowedBodyGenerator func() []byte +} + +var _ http.ResponseWriter = (*bodyOverrider)(nil) + +func (b *bodyOverrider) WriteHeader(code int) { + if b.Header().Get("Content-Type") == "text/plain; charset=utf-8" { + b.Header().Set("Content-Type", "application/json") + + b.override = true + } + + b.code = code + b.ResponseWriter.WriteHeader(code) +} + +func (b *bodyOverrider) Write(body []byte) (int, error) { + if b.override { + switch b.code { + case http.StatusNotFound: + if b.statusNotFoundBodyGenerator != nil { + body = b.statusNotFoundBodyGenerator() + } + case http.StatusMethodNotAllowed: + if b.statusMethodNotAllowedBodyGenerator != nil { + body = b.statusMethodNotAllowedBodyGenerator() + } + } + } + + return b.ResponseWriter.Write(body) +} diff --git a/vendor/go.mau.fi/util/exhttp/json.go b/vendor/go.mau.fi/util/exhttp/json.go new file mode 100644 index 0000000..48c8349 --- /dev/null +++ b/vendor/go.mau.fi/util/exhttp/json.go @@ -0,0 +1,27 @@ +package exhttp + +import ( + "encoding/json" + "net/http" +) + +func WriteJSONResponse(w http.ResponseWriter, httpStatusCode int, jsonData any) { + AddCORSHeaders(w) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(httpStatusCode) + _ = json.NewEncoder(w).Encode(jsonData) +} + +func WriteJSONData(w http.ResponseWriter, httpStatusCode int, data []byte) { + AddCORSHeaders(w) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(httpStatusCode) + _, _ = w.Write(data) +} + +func WriteEmptyJSONResponse(w http.ResponseWriter, httpStatusCode int) { + AddCORSHeaders(w) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(httpStatusCode) + _, _ = w.Write([]byte("{}")) +} diff --git a/vendor/go.mau.fi/util/exhttp/middleware.go b/vendor/go.mau.fi/util/exhttp/middleware.go new file mode 100644 index 0000000..733d348 --- /dev/null +++ b/vendor/go.mau.fi/util/exhttp/middleware.go @@ -0,0 +1,24 @@ +package exhttp + +import "net/http" + +// Middleware represents a middleware that can be applied to an [http.Handler]. +type Middleware func(http.Handler) http.Handler + +// ApplyMiddleware applies the provided [Middleware] functions to the given +// router. The middlewares will be applied in the order they are provided. +func ApplyMiddleware(router http.Handler, middlewares ...Middleware) http.Handler { + // Apply middlewares in reverse order because the first middleware provided + // needs to be the outermost one. + for i := len(middlewares) - 1; i >= 0; i-- { + router = middlewares[i](router) + } + return router +} + +// StripPrefix is a wrapper for [http.StripPrefix] is compatible with the middleware pattern. +func StripPrefix(prefix string) Middleware { + return func(next http.Handler) http.Handler { + return http.StripPrefix(prefix, next) + } +} diff --git a/vendor/go.mau.fi/util/exzerolog/callermarshal.go b/vendor/go.mau.fi/util/exzerolog/callermarshal.go new file mode 100644 index 0000000..938a5e0 --- /dev/null +++ b/vendor/go.mau.fi/util/exzerolog/callermarshal.go @@ -0,0 +1,28 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exzerolog + +import ( + "fmt" + "runtime" + "strings" +) + +// CallerWithFunctionName is an implementation for zerolog.CallerMarshalFunc that includes the caller function name +// in addition to the file and line number. +// +// Use as +// +// zerolog.CallerMarshalFunc = exzerolog.CallerWithFunctionName +func CallerWithFunctionName(pc uintptr, file string, line int) string { + files := strings.Split(file, "/") + file = files[len(files)-1] + name := runtime.FuncForPC(pc).Name() + fns := strings.Split(name, ".") + name = fns[len(fns)-1] + return fmt.Sprintf("%s:%d:%s()", file, line, name) +} diff --git a/vendor/go.mau.fi/util/exzerolog/defaults.go b/vendor/go.mau.fi/util/exzerolog/defaults.go new file mode 100644 index 0000000..c8c3c81 --- /dev/null +++ b/vendor/go.mau.fi/util/exzerolog/defaults.go @@ -0,0 +1,32 @@ +// Copyright (c) 2024 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exzerolog + +import ( + "time" + + "github.com/rs/zerolog" + deflog "github.com/rs/zerolog/log" +) + +// SetupDefaults updates zerolog globals with sensible defaults. +// +// * [zerolog.TimeFieldFormat] is set to time.RFC3339Nano instead of time.RFC3339 +// * [zerolog.CallerMarshalFunc] is set to [CallerWithFunctionName] +// * [zerolog.DefaultContextLogger] is set to the given logger with default_context_log=true and caller info enabled +// * The global default [log.Logger] is set to the given logger with global_log=true and caller info enabled +// * [zerolog.LevelColors] are updated to swap trace and debug level colors +func SetupDefaults(log *zerolog.Logger) { + zerolog.TimeFieldFormat = time.RFC3339Nano + zerolog.CallerMarshalFunc = CallerWithFunctionName + defaultCtxLog := log.With().Bool("default_context_log", true).Caller().Logger() + zerolog.DefaultContextLogger = &defaultCtxLog + deflog.Logger = log.With().Bool("global_log", true).Caller().Logger() + // Swap trace and debug level colors so trace pops out the least + zerolog.LevelColors[zerolog.TraceLevel] = 0 + zerolog.LevelColors[zerolog.DebugLevel] = 34 // blue +} diff --git a/vendor/go.mau.fi/util/exzerolog/generics.go b/vendor/go.mau.fi/util/exzerolog/generics.go new file mode 100644 index 0000000..ca1910b --- /dev/null +++ b/vendor/go.mau.fi/util/exzerolog/generics.go @@ -0,0 +1,45 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exzerolog + +import ( + "fmt" + + "github.com/rs/zerolog" +) + +func ArrayOf[T any](slice []T, fn func(arr *zerolog.Array, item T)) *zerolog.Array { + arr := zerolog.Arr() + for _, item := range slice { + fn(arr, item) + } + return arr +} + +func AddObject[T zerolog.LogObjectMarshaler](arr *zerolog.Array, obj T) { + arr.Object(obj) +} + +func AddStringer[T fmt.Stringer](arr *zerolog.Array, str T) { + arr.Str(str.String()) +} + +func AddStr[T ~string](arr *zerolog.Array, str T) { + arr.Str(string(str)) +} + +func ArrayOfObjs[T zerolog.LogObjectMarshaler](slice []T) *zerolog.Array { + return ArrayOf(slice, AddObject[T]) +} + +func ArrayOfStringers[T fmt.Stringer](slice []T) *zerolog.Array { + return ArrayOf(slice, AddStringer[T]) +} + +func ArrayOfStrs[T ~string](slice []T) *zerolog.Array { + return ArrayOf(slice, AddStr[T]) +} diff --git a/vendor/go.mau.fi/util/exzerolog/writer.go b/vendor/go.mau.fi/util/exzerolog/writer.go new file mode 100644 index 0000000..c570985 --- /dev/null +++ b/vendor/go.mau.fi/util/exzerolog/writer.go @@ -0,0 +1,81 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exzerolog + +import ( + "bytes" + "sync" + + "github.com/rs/zerolog" +) + +// LogWriter wraps a zerolog.Logger and provides an io.Writer with buffering so each written line is logged separately. +type LogWriter struct { + log zerolog.Logger + level zerolog.Level + field string + mu sync.Mutex + buf bytes.Buffer +} + +func NewLogWriter(log zerolog.Logger) *LogWriter { + zerolog.Nop() + return &LogWriter{ + log: log, + level: zerolog.DebugLevel, + field: zerolog.MessageFieldName, + } +} + +func (lw *LogWriter) WithLevel(level zerolog.Level) *LogWriter { + return &LogWriter{ + log: lw.log, + level: level, + field: lw.field, + } +} + +func (lw *LogWriter) WithField(field string) *LogWriter { + return &LogWriter{ + log: lw.log, + level: lw.level, + field: field, + } +} + +func (lw *LogWriter) writeLine(data []byte) { + if len(data) == 0 { + return + } + if data[len(data)-1] == '\n' { + data = data[:len(data)-1] + } + if lw.buf.Len() > 0 { + lw.buf.Write(data) + data = lw.buf.Bytes() + lw.buf.Reset() + } + lw.log.WithLevel(lw.level).Bytes(lw.field, data).Send() +} + +func (lw *LogWriter) Write(data []byte) (n int, err error) { + lw.mu.Lock() + defer lw.mu.Unlock() + newline := bytes.IndexByte(data, '\n') + if newline == len(data)-1 { + lw.writeLine(data) + } else if newline < 0 { + lw.buf.Write(data) + } else { + lines := bytes.Split(data, []byte{'\n'}) + for _, line := range lines[:len(lines)-1] { + lw.writeLine(line) + } + lw.buf.Write(lines[len(lines)-1]) + } + return len(data), nil +} diff --git a/vendor/go.mau.fi/util/glob/glob.go b/vendor/go.mau.fi/util/glob/glob.go new file mode 100644 index 0000000..67fce3e --- /dev/null +++ b/vendor/go.mau.fi/util/glob/glob.go @@ -0,0 +1,100 @@ +// Package glob implements very simple glob pattern matching used in various parts of the Matrix spec, +// such as push rules and moderation policy lists. +// +// See https://spec.matrix.org/v1.11/appendices/#glob-style-matching for more info. +package glob + +import ( + "strings" +) + +type Glob interface { + Match(string) bool +} + +var ( + _ Glob = ExactGlob("") + _ Glob = PrefixGlob("") + _ Glob = SuffixGlob("") + _ Glob = ContainsGlob("") + _ Glob = (*PrefixAndSuffixGlob)(nil) + _ Glob = (*PrefixSuffixAndContainsGlob)(nil) + _ Glob = (*RegexGlob)(nil) +) + +// Compile compiles a glob pattern into an object that can be used to efficiently match strings against the pattern. +// +// Simple globs will be converted into prefix/suffix/contains checks, while complicated ones will be compiled as regex. +func Compile(pattern string) Glob { + pattern = Simplify(pattern) + g := compileSimple(pattern) + if g != nil { + return g + } + g, _ = CompileRegex(pattern) + return g +} + +// CompileWithImplicitContains is a wrapper for Compile which will replace exact matches with contains matches. +// i.e. if the pattern has no wildcards, it will be treated as if it was surrounded in asterisks (`foo` -> `*foo*`). +func CompileWithImplicitContains(pattern string) Glob { + g := Compile(pattern) + if _, isExact := g.(ExactGlob); isExact { + return ContainsGlob(pattern) + } + return g +} + +// CompileSimple compiles a glob pattern into one of the non-regex forms. +// +// If the pattern can't be compiled into a simple form, it returns nil. +func CompileSimple(pattern string) Glob { + return compileSimple(Simplify(pattern)) +} + +func compileSimple(pattern string) Glob { + if strings.ContainsRune(pattern, '?') { + return nil + } + switch strings.Count(pattern, "*") { + case 0: + return ExactGlob(pattern) + case 1: + if strings.HasPrefix(pattern, "*") { + return SuffixGlob(pattern[1:]) + } else if strings.HasSuffix(pattern, "*") { + return PrefixGlob(pattern[:len(pattern)-1]) + } else { + parts := strings.Split(pattern, "*") + return PrefixAndSuffixGlob{ + Prefix: parts[0], + Suffix: parts[1], + } + } + case 2: + if strings.HasPrefix(pattern, "*") && strings.HasSuffix(pattern, "*") { + return ContainsGlob(pattern[1 : len(pattern)-1]) + } + parts := strings.Split(pattern, "*") + return PrefixSuffixAndContainsGlob{ + Prefix: parts[0], + Contains: parts[1], + Suffix: parts[2], + } + default: + return nil + } +} + +var sqlCompiler = strings.NewReplacer( + `\`, `\\`, + `%`, `\%`, + `_`, `\_`, + `*`, `%`, + `?`, `_`, +) + +// ToSQL converts a Matrix glob pattern to a SQL LIKE pattern. +func ToSQL(pattern string) string { + return sqlCompiler.Replace(Simplify(pattern)) +} diff --git a/vendor/go.mau.fi/util/glob/regex.go b/vendor/go.mau.fi/util/glob/regex.go new file mode 100644 index 0000000..f224533 --- /dev/null +++ b/vendor/go.mau.fi/util/glob/regex.go @@ -0,0 +1,43 @@ +package glob + +import ( + "fmt" + "regexp" + "strings" +) + +type RegexGlob struct { + regex *regexp.Regexp +} + +func (rg *RegexGlob) Match(s string) bool { + return rg.regex.MatchString(s) +} + +func CompileRegex(pattern string) (*RegexGlob, error) { + var buf strings.Builder + buf.WriteRune('^') + for _, part := range SplitPattern(pattern) { + if strings.ContainsRune(part, '*') || strings.ContainsRune(part, '?') { + questions := strings.Count(part, "?") + star := strings.ContainsRune(part, '*') + if star { + if questions > 0 { + _, _ = fmt.Fprintf(&buf, ".{%d,}", questions) + } else { + buf.WriteString(".*") + } + } else if questions > 0 { + _, _ = fmt.Fprintf(&buf, ".{%d}", questions) + } + } else { + buf.WriteString(regexp.QuoteMeta(part)) + } + } + buf.WriteRune('$') + regex, err := regexp.Compile(buf.String()) + if err != nil { + return nil, err + } + return &RegexGlob{regex}, nil +} diff --git a/vendor/go.mau.fi/util/glob/simple.go b/vendor/go.mau.fi/util/glob/simple.go new file mode 100644 index 0000000..bb9bf6d --- /dev/null +++ b/vendor/go.mau.fi/util/glob/simple.go @@ -0,0 +1,62 @@ +package glob + +import ( + "strings" +) + +// ExactGlob is the result of [Compile] when the pattern contains no glob characters. +// It uses a simple string comparison to match. +type ExactGlob string + +func (eg ExactGlob) Match(s string) bool { + return string(eg) == s +} + +// SuffixGlob is the result of [Compile] when the pattern only has one `*` at the beginning. +// It uses [strings.HasSuffix] to match. +type SuffixGlob string + +func (sg SuffixGlob) Match(s string) bool { + return strings.HasSuffix(s, string(sg)) +} + +// PrefixGlob is the result of [Compile] when the pattern only has one `*` at the end. +// It uses [strings.HasPrefix] to match. +type PrefixGlob string + +func (pg PrefixGlob) Match(s string) bool { + return strings.HasPrefix(s, string(pg)) +} + +// ContainsGlob is the result of [Compile] when the pattern has two `*`s, one at the beginning and one at the end. +// It uses [strings.Contains] to match. +// +// When there are exactly two `*`s, but they're not surrounding the string, the pattern is compiled as a [PrefixSuffixAndContainsGlob] instead. +type ContainsGlob string + +func (cg ContainsGlob) Match(s string) bool { + return strings.Contains(s, string(cg)) +} + +// PrefixAndSuffixGlob is the result of [Compile] when the pattern only has one `*` in the middle. +type PrefixAndSuffixGlob struct { + Prefix string + Suffix string +} + +func (psg PrefixAndSuffixGlob) Match(s string) bool { + return strings.HasPrefix(s, psg.Prefix) && strings.HasSuffix(s[len(psg.Prefix):], psg.Suffix) +} + +// PrefixSuffixAndContainsGlob is the result of [Compile] when the pattern has two `*`s which are not surrounding the rest of the pattern. +type PrefixSuffixAndContainsGlob struct { + Prefix string + Suffix string + Contains string +} + +func (psacg PrefixSuffixAndContainsGlob) Match(s string) bool { + return strings.HasPrefix(s, psacg.Prefix) && + strings.HasSuffix(s[len(psacg.Prefix):], psacg.Suffix) && + strings.Contains(s[len(psacg.Prefix):len(s)-len(psacg.Suffix)], psacg.Contains) +} diff --git a/vendor/go.mau.fi/util/glob/util.go b/vendor/go.mau.fi/util/glob/util.go new file mode 100644 index 0000000..37d9b2d --- /dev/null +++ b/vendor/go.mau.fi/util/glob/util.go @@ -0,0 +1,42 @@ +package glob + +import ( + "regexp" + "strings" +) + +var redundantStarRegex = regexp.MustCompile(`\*{2,}`) +var maybeRedundantQuestionRegex = regexp.MustCompile(`[*?]{2,}`) +var wildcardRegex = regexp.MustCompile(`[*?]+`) + +func SplitPattern(pattern string) []string { + indexes := wildcardRegex.FindAllStringIndex(pattern, -1) + if len(indexes) == 0 { + return []string{pattern} + } + parts := make([]string, 0, len(indexes)+1) + start := 0 + for _, part := range indexes { + end := part[0] + if end > start { + parts = append(parts, pattern[start:end]) + } + parts = append(parts, pattern[part[0]:part[1]]) + start = part[1] + } + if start < len(pattern) { + parts = append(parts, pattern[start:]) + } + return parts +} + +func Simplify(pattern string) string { + pattern = redundantStarRegex.ReplaceAllString(pattern, "*") + pattern = maybeRedundantQuestionRegex.ReplaceAllStringFunc(pattern, func(s string) string { + if !strings.ContainsRune(s, '*') { + return s + } + return strings.Repeat("?", strings.Count(s, "?")) + "*" + }) + return pattern +} diff --git a/vendor/go.mau.fi/util/jsonbytes/unpadded.go b/vendor/go.mau.fi/util/jsonbytes/unpadded.go new file mode 100644 index 0000000..37ffb64 --- /dev/null +++ b/vendor/go.mau.fi/util/jsonbytes/unpadded.go @@ -0,0 +1,30 @@ +// Copyright (c) 2024 Sumner Evans +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package jsonbytes + +import ( + "encoding/base64" + "encoding/json" +) + +// UnpaddedBytes is a byte slice that is encoded and decoded using +// [base64.RawStdEncoding] instead of the default padded base64. +type UnpaddedBytes []byte + +func (b UnpaddedBytes) MarshalJSON() ([]byte, error) { + return json.Marshal(base64.RawStdEncoding.EncodeToString(b)) +} + +func (b *UnpaddedBytes) UnmarshalJSON(data []byte) error { + var b64str string + err := json.Unmarshal(data, &b64str) + if err != nil { + return err + } + *b, err = base64.RawStdEncoding.DecodeString(b64str) + return err +} diff --git a/vendor/go.mau.fi/util/jsontime/helpers.go b/vendor/go.mau.fi/util/jsontime/helpers.go new file mode 100644 index 0000000..35f4cc2 --- /dev/null +++ b/vendor/go.mau.fi/util/jsontime/helpers.go @@ -0,0 +1,59 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package jsontime + +import ( + "time" +) + +func UM(time time.Time) UnixMilli { + return UnixMilli{Time: time} +} + +func UMInt(ts int64) UnixMilli { + return UM(time.UnixMilli(ts)) +} + +func UnixMilliNow() UnixMilli { + return UM(time.Now()) +} + +func UMicro(time time.Time) UnixMicro { + return UnixMicro{Time: time} +} + +func UMicroInto(ts int64) UnixMicro { + return UMicro(time.UnixMicro(ts)) +} + +func UnixMicroNow() UnixMicro { + return UMicro(time.Now()) +} + +func UN(time time.Time) UnixNano { + return UnixNano{Time: time} +} + +func UNInt(ts int64) UnixNano { + return UN(time.Unix(0, ts)) +} + +func UnixNanoNow() UnixNano { + return UN(time.Now()) +} + +func U(time time.Time) Unix { + return Unix{Time: time} +} + +func UInt(ts int64) Unix { + return U(time.Unix(ts, 0)) +} + +func UnixNow() Unix { + return U(time.Now()) +} diff --git a/vendor/go.mau.fi/util/jsontime/integer.go b/vendor/go.mau.fi/util/jsontime/integer.go new file mode 100644 index 0000000..7d15d5d --- /dev/null +++ b/vendor/go.mau.fi/util/jsontime/integer.go @@ -0,0 +1,163 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package jsontime + +import ( + "database/sql" + "database/sql/driver" + "encoding/json" + "errors" + "fmt" + "time" +) + +var ErrNotInteger = errors.New("value is not an integer") + +func parseTime(data []byte, unixConv func(int64) time.Time, into *time.Time) error { + var val int64 + err := json.Unmarshal(data, &val) + if err != nil { + return err + } + if val == 0 { + *into = time.Time{} + } else { + *into = unixConv(val) + } + return nil +} + +func anyIntegerToTime(src any, unixConv func(int64) time.Time, into *time.Time) error { + switch v := src.(type) { + case int: + *into = unixConv(int64(v)) + case int8: + *into = unixConv(int64(v)) + case int16: + *into = unixConv(int64(v)) + case int32: + *into = unixConv(int64(v)) + case int64: + *into = unixConv(int64(v)) + default: + return fmt.Errorf("%w: %T", ErrNotInteger, src) + } + + return nil +} + +var _ sql.Scanner = &UnixMilli{} +var _ driver.Valuer = UnixMilli{} + +type UnixMilli struct { + time.Time +} + +func (um UnixMilli) MarshalJSON() ([]byte, error) { + if um.IsZero() { + return []byte{'0'}, nil + } + return json.Marshal(um.UnixMilli()) +} + +func (um *UnixMilli) UnmarshalJSON(data []byte) error { + return parseTime(data, time.UnixMilli, &um.Time) +} + +func (um UnixMilli) Value() (driver.Value, error) { + return um.UnixMilli(), nil +} + +func (um *UnixMilli) Scan(src any) error { + return anyIntegerToTime(src, time.UnixMilli, &um.Time) +} + +var _ sql.Scanner = &UnixMicro{} +var _ driver.Valuer = UnixMicro{} + +type UnixMicro struct { + time.Time +} + +func (um UnixMicro) MarshalJSON() ([]byte, error) { + if um.IsZero() { + return []byte{'0'}, nil + } + return json.Marshal(um.UnixMicro()) +} + +func (um *UnixMicro) UnmarshalJSON(data []byte) error { + return parseTime(data, time.UnixMicro, &um.Time) +} + +func (um UnixMicro) Value() (driver.Value, error) { + return um.UnixMicro(), nil +} + +func (um *UnixMicro) Scan(src any) error { + return anyIntegerToTime(src, time.UnixMicro, &um.Time) +} + +var _ sql.Scanner = &UnixNano{} +var _ driver.Valuer = UnixNano{} + +type UnixNano struct { + time.Time +} + +func (un UnixNano) MarshalJSON() ([]byte, error) { + if un.IsZero() { + return []byte{'0'}, nil + } + return json.Marshal(un.UnixNano()) +} + +func (un *UnixNano) UnmarshalJSON(data []byte) error { + return parseTime(data, func(i int64) time.Time { + return time.Unix(0, i) + }, &un.Time) +} + +func (un UnixNano) Value() (driver.Value, error) { + return un.UnixNano(), nil +} + +func (un *UnixNano) Scan(src any) error { + return anyIntegerToTime(src, func(i int64) time.Time { + return time.Unix(0, i) + }, &un.Time) +} + +type Unix struct { + time.Time +} + +func (u Unix) MarshalJSON() ([]byte, error) { + if u.IsZero() { + return []byte{'0'}, nil + } + return json.Marshal(u.Unix()) +} + +var _ sql.Scanner = &Unix{} +var _ driver.Valuer = Unix{} + +func (u *Unix) UnmarshalJSON(data []byte) error { + return parseTime(data, func(i int64) time.Time { + return time.Unix(i, 0) + }, &u.Time) +} + +func (u Unix) Value() (driver.Value, error) { + return u.Unix(), nil +} + +func (u *Unix) Scan(src any) error { + return anyIntegerToTime(src, func(i int64) time.Time { + return time.Unix(i, 0) + }, &u.Time) +} diff --git a/vendor/go.mau.fi/util/jsontime/string.go b/vendor/go.mau.fi/util/jsontime/string.go new file mode 100644 index 0000000..c3729d5 --- /dev/null +++ b/vendor/go.mau.fi/util/jsontime/string.go @@ -0,0 +1,95 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package jsontime + +import ( + "encoding/json" + "strconv" + "time" +) + +func parseTimeString(data []byte, unixConv func(int64) time.Time, into *time.Time) error { + var strVal string + err := json.Unmarshal(data, &strVal) + if err != nil { + return err + } + val, err := strconv.ParseInt(strVal, 10, 64) + if err != nil { + return err + } + if val == 0 { + *into = time.Time{} + } else { + *into = unixConv(val) + } + return nil +} + +type UnixMilliString struct { + time.Time +} + +func (um UnixMilliString) MarshalJSON() ([]byte, error) { + if um.IsZero() { + return []byte{'"', '0', '"'}, nil + } + return json.Marshal(strconv.FormatInt(um.UnixMilli(), 10)) +} + +func (um *UnixMilliString) UnmarshalJSON(data []byte) error { + return parseTimeString(data, time.UnixMilli, &um.Time) +} + +type UnixMicroString struct { + time.Time +} + +func (um UnixMicroString) MarshalJSON() ([]byte, error) { + if um.IsZero() { + return []byte{'"', '0', '"'}, nil + } + return json.Marshal(strconv.FormatInt(um.UnixMicro(), 10)) +} + +func (um *UnixMicroString) UnmarshalJSON(data []byte) error { + return parseTimeString(data, time.UnixMicro, &um.Time) +} + +type UnixNanoString struct { + time.Time +} + +func (um UnixNanoString) MarshalJSON() ([]byte, error) { + if um.IsZero() { + return []byte{'"', '0', '"'}, nil + } + return json.Marshal(strconv.FormatInt(um.UnixNano(), 10)) +} + +func (um *UnixNanoString) UnmarshalJSON(data []byte) error { + return parseTimeString(data, func(i int64) time.Time { + return time.Unix(0, i) + }, &um.Time) +} + +type UnixString struct { + time.Time +} + +func (u UnixString) MarshalJSON() ([]byte, error) { + if u.IsZero() { + return []byte{'"', '0', '"'}, nil + } + return json.Marshal(strconv.FormatInt(u.Unix(), 10)) +} + +func (u *UnixString) UnmarshalJSON(data []byte) error { + return parseTimeString(data, func(i int64) time.Time { + return time.Unix(i, 0) + }, &u.Time) +} diff --git a/vendor/go.mau.fi/util/ptr/ptr.go b/vendor/go.mau.fi/util/ptr/ptr.go new file mode 100644 index 0000000..b04fa19 --- /dev/null +++ b/vendor/go.mau.fi/util/ptr/ptr.go @@ -0,0 +1,43 @@ +// Copyright (c) 2024 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package ptr + +// Clone creates a shallow copy of the given pointer. +func Clone[T any](val *T) *T { + if val == nil { + return nil + } + valCopy := *val + return &valCopy +} + +// Ptr returns a pointer to the given value. +func Ptr[T any](val T) *T { + return &val +} + +// NonZero returns a pointer to the given comparable value, unless the value is the type's zero value. +func NonZero[T comparable](val T) *T { + var zero T + return NonDefault(val, zero) +} + +// NonDefault returns a pointer to the first parameter, unless it is equal to the second parameter. +func NonDefault[T comparable](val, def T) *T { + if val == def { + return nil + } + return &val +} + +// Val returns the value of the given pointer, or the zero value of the type if the pointer is nil. +func Val[T any](ptr *T) (val T) { + if ptr != nil { + val = *ptr + } + return +} diff --git a/vendor/go.mau.fi/util/random/bytes.go b/vendor/go.mau.fi/util/random/bytes.go new file mode 100644 index 0000000..c3a706b --- /dev/null +++ b/vendor/go.mau.fi/util/random/bytes.go @@ -0,0 +1,21 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package random + +import ( + "crypto/rand" +) + +// Bytes generates the given amount of random bytes using crypto/rand, and panics if it fails. +func Bytes(n int) []byte { + data := make([]byte, n) + _, err := rand.Read(data) + if err != nil { + panic(err) + } + return data +} diff --git a/vendor/go.mau.fi/util/random/string.go b/vendor/go.mau.fi/util/random/string.go new file mode 100644 index 0000000..b9cb0ae --- /dev/null +++ b/vendor/go.mau.fi/util/random/string.go @@ -0,0 +1,87 @@ +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package random + +import ( + "encoding/binary" + "hash/crc32" + "strings" + "unsafe" +) + +const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + +// StringBytes generates a random string of the given length and returns it as a byte array. +func StringBytes(n int) []byte { + if n <= 0 { + return []byte{} + } + input := Bytes(n * 2) + for i := 0; i < n; i++ { + // Risk of modulo bias is only 2 in 65535, values between 0 and 65533 are uniformly distributed + input[i] = letters[binary.BigEndian.Uint16(input[i*2:])%uint16(len(letters))] + } + input = input[:n] + return input +} + +// String generates a random string of the given length. +func String(n int) string { + if n <= 0 { + return "" + } + str := StringBytes(n) + return *(*string)(unsafe.Pointer(&str)) +} + +func base62Encode(val uint32, minWidth int) []byte { + out := make([]byte, 0, minWidth) + for val > 0 { + out = append(out, letters[val%uint32(len(letters))]) + val /= 62 + } + if len(out) < minWidth { + paddedOut := make([]byte, minWidth) + copy(paddedOut[minWidth-len(out):], out) + for i := 0; i < minWidth-len(out); i++ { + paddedOut[i] = '0' + } + out = paddedOut + } + return out +} + +// Token generates a GitHub-style token with the given prefix, a random part, and a checksum at the end. +// The format is `prefix_random_checksum`. The checksum is always 6 characters. +func Token(namespace string, randomLength int) string { + token := make([]byte, len(namespace)+1+randomLength+1+6) + copy(token, namespace) + token[len(namespace)] = '_' + copy(token[len(namespace)+1:], StringBytes(randomLength)) + token[len(namespace)+randomLength+1] = '_' + checksum := base62Encode(crc32.ChecksumIEEE(token[:len(token)-7]), 6) + copy(token[len(token)-6:], checksum) + return *(*string)(unsafe.Pointer(&token)) +} + +// GetTokenPrefix parses the given token generated with Token, validates the checksum and returns the prefix namespace. +func GetTokenPrefix(token string) string { + parts := strings.Split(token, "_") + if len(parts) != 3 { + return "" + } + checksum := base62Encode(crc32.ChecksumIEEE([]byte(parts[0]+"_"+parts[1])), 6) + if string(checksum) != parts[2] { + return "" + } + return parts[0] +} + +// IsToken checks if the given token is a valid token generated with Token with the given namespace.. +func IsToken(namespace, token string) bool { + return GetTokenPrefix(token) == namespace +} diff --git a/vendor/go.mau.fi/util/retryafter/retryafter.go b/vendor/go.mau.fi/util/retryafter/retryafter.go new file mode 100644 index 0000000..57ec814 --- /dev/null +++ b/vendor/go.mau.fi/util/retryafter/retryafter.go @@ -0,0 +1,53 @@ +// Copyright (c) 2021 Dillon Dixon +// Copyright (c) 2023 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +// Package retryafter contains a utility function for parsing the Retry-After HTTP header. +package retryafter + +import ( + "net/http" + "strconv" + "time" +) + +var now = time.Now + +// Parse parses the backoff time specified in the Retry-After header if present. +// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After. +// +// The second parameter is the fallback duration to use if the header is not present or invalid. +// +// Example: +// +// time.Sleep(retryafter.Parse(resp.Header.Get("Retry-After"), 5*time.Second)) +func Parse(retryAfter string, fallback time.Duration) time.Duration { + if retryAfter == "" { + return fallback + } else if t, err := time.Parse(http.TimeFormat, retryAfter); err == nil { + return t.Sub(now()) + } else if seconds, err := strconv.Atoi(retryAfter); err == nil { + return time.Duration(seconds) * time.Second + } + + return fallback +} + +// Should returns true if the given status code indicates that the request should be retried. +// +// if retryafter.Should(resp.StatusCode, true) { +// time.Sleep(retryafter.Parse(resp.Header.Get("Retry-After"), 5*time.Second)) +// } +func Should(statusCode int, retryOnRateLimit bool) bool { + switch statusCode { + case http.StatusBadGateway, http.StatusServiceUnavailable, http.StatusGatewayTimeout: + return true + case http.StatusTooManyRequests: + return retryOnRateLimit + default: + return false + } +} |
