forgejo/modules/git/utils.go
Andrew Thornton 42d2b83950
Prepend refs/heads/ to issue template refs
Fix #20456

At some point during the 1.17 cycle abbreviated refs to issue branches
started breaking. This is likely due serious inconsistencies in our
management of refs throughout Gitea - which is a bug needing to be
addressed in a different PR. (Likely more than one)

We should try to use non-abbreviated refs as much as possible. That is
where a user has inputted a abbreviated ref we should add refs/heads/ if
it is branch etc. I know people keep writing and merging PRs that remove
prefixes from stored content but it is just wrong and it keeps causing
problems like this. We should only remove the prefix at the time of
presentation as the prefix is the only way of knowing umambiguously and
permanently if the ref is referring to a branch, tag or commit. We need
to make it so that every ref has the appropriate prefix, and probably
also need to come up with some definitely unambiguous way of storing
SHAs if they're used in a ref field. We must not store potentially
ambiguous refs. (Especially tagnames - there is no reason why users cannot
create a branch with the same short name as a tag and vice versa and any
attempt to prevent this will fail. You can even create a branch and a
tag that matches a SHA1 pattern.)

To that end in order to fix this bug, when parsing issue templates check
the provided Ref, if it does not start with refs/ add the BranchPrefix
to it. This allows people to make their templates refer to a tag.

Next we need to handle the issue links that are already written. The
links here are created with `git.RefURL`

Here we see there is a bug introduced in #17551 whereby the provided Ref
can be double-escaped so we remove the incorrect external escape.
(The escape added in #17551 is in the right place - unfortunately it
missed that the calling function was doing the wrong thing.)

Then within RefURL we check if the unprefixed ref could actually be a
SHA before defaulting that an unprefixed ref is actually a commit - if not
it is assumed to be a branch. This will handle most of the problem cases
excepting the very unusual cases where someone has deliberately written
a branch to look like a SHA1.

But please if something is called a `ref` or interpreted as a `ref` make
it a full-ref before storing or using it. By all means if something is a
`branch` assume the prefix is removed but always add it back in if you
are using it as a `ref`. Stop storing abbreviated branch names and tag
names as refs. It will keep on causing problems like this.

Fix #20456

Signed-off-by: Andrew Thornton <art27@cantab.net>
2022-07-23 11:39:36 +01:00

175 lines
4.1 KiB
Go

// Copyright 2015 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package git
import (
"fmt"
"io"
"os"
"strconv"
"strings"
"sync"
"code.gitea.io/gitea/modules/util"
)
// ObjectCache provides thread-safe cache operations.
type ObjectCache struct {
lock sync.RWMutex
cache map[string]interface{}
}
func newObjectCache() *ObjectCache {
return &ObjectCache{
cache: make(map[string]interface{}, 10),
}
}
// Set add obj to cache
func (oc *ObjectCache) Set(id string, obj interface{}) {
oc.lock.Lock()
defer oc.lock.Unlock()
oc.cache[id] = obj
}
// Get get cached obj by id
func (oc *ObjectCache) Get(id string) (interface{}, bool) {
oc.lock.RLock()
defer oc.lock.RUnlock()
obj, has := oc.cache[id]
return obj, has
}
// isDir returns true if given path is a directory,
// or returns false when it's a file or does not exist.
func isDir(dir string) bool {
f, e := os.Stat(dir)
if e != nil {
return false
}
return f.IsDir()
}
// isFile returns true if given path is a file,
// or returns false when it's a directory or does not exist.
func isFile(filePath string) bool {
f, e := os.Stat(filePath)
if e != nil {
return false
}
return !f.IsDir()
}
// isExist checks whether a file or directory exists.
// It returns false when the file or directory does not exist.
func isExist(path string) bool {
_, err := os.Stat(path)
return err == nil || os.IsExist(err)
}
// ConcatenateError concatenats an error with stderr string
func ConcatenateError(err error, stderr string) error {
if len(stderr) == 0 {
return err
}
return fmt.Errorf("%w - %s", err, stderr)
}
// RefEndName return the end name of a ref name
func RefEndName(refStr string) string {
if strings.HasPrefix(refStr, BranchPrefix) {
return refStr[len(BranchPrefix):]
}
if strings.HasPrefix(refStr, TagPrefix) {
return refStr[len(TagPrefix):]
}
return refStr
}
// RefURL returns the absolute URL for a ref in a repository
func RefURL(repoURL, ref string) string {
refName := util.PathEscapeSegments(RefEndName(ref))
switch {
case strings.HasPrefix(ref, BranchPrefix):
return repoURL + "/src/branch/" + refName
case strings.HasPrefix(ref, TagPrefix):
return repoURL + "/src/tag/" + refName
case !SHAPattern.MatchString(ref):
// assume they mean a branch
return repoURL + "/src/branch/" + refName
default:
return repoURL + "/src/commit/" + refName
}
}
// SplitRefName splits a full refname to reftype and simple refname
func SplitRefName(refStr string) (string, string) {
if strings.HasPrefix(refStr, BranchPrefix) {
return BranchPrefix, refStr[len(BranchPrefix):]
}
if strings.HasPrefix(refStr, TagPrefix) {
return TagPrefix, refStr[len(TagPrefix):]
}
return "", refStr
}
// ParseBool returns the boolean value represented by the string as per git's git_config_bool
// true will be returned for the result if the string is empty, but valid will be false.
// "true", "yes", "on" are all true, true
// "false", "no", "off" are all false, true
// 0 is false, true
// Any other integer is true, true
// Anything else will return false, false
func ParseBool(value string) (result, valid bool) {
// Empty strings are true but invalid
if len(value) == 0 {
return true, false
}
// These are the git expected true and false values
if strings.EqualFold(value, "true") || strings.EqualFold(value, "yes") || strings.EqualFold(value, "on") {
return true, true
}
if strings.EqualFold(value, "false") || strings.EqualFold(value, "no") || strings.EqualFold(value, "off") {
return false, true
}
// Try a number
intValue, err := strconv.ParseInt(value, 10, 32)
if err != nil {
return false, false
}
return intValue != 0, true
}
// LimitedReaderCloser is a limited reader closer
type LimitedReaderCloser struct {
R io.Reader
C io.Closer
N int64
}
// Read implements io.Reader
func (l *LimitedReaderCloser) Read(p []byte) (n int, err error) {
if l.N <= 0 {
_ = l.C.Close()
return 0, io.EOF
}
if int64(len(p)) > l.N {
p = p[0:l.N]
}
n, err = l.R.Read(p)
l.N -= int64(n)
return n, err
}
// Close implements io.Closer
func (l *LimitedReaderCloser) Close() error {
return l.C.Close()
}