mirror of
https://github.com/go-gitea/gitea.git
synced 2024-09-08 04:19:36 +02:00
* update github.com/alecthomas/chroma v0.8.0 -> v0.8.1 * github.com/blevesearch/bleve v1.0.10 -> v1.0.12 * editorconfig-core-go v2.1.1 -> v2.3.7 * github.com/gliderlabs/ssh v0.2.2 -> v0.3.1 * migrate editorconfig.ParseBytes to Parse * github.com/shurcooL/vfsgen to 0d455de96546 * github.com/go-git/go-git/v5 v5.1.0 -> v5.2.0 * github.com/google/uuid v1.1.1 -> v1.1.2 * github.com/huandu/xstrings v1.3.0 -> v1.3.2 * github.com/klauspost/compress v1.10.11 -> v1.11.1 * github.com/markbates/goth v1.61.2 -> v1.65.0 * github.com/mattn/go-sqlite3 v1.14.0 -> v1.14.4 * github.com/mholt/archiver v3.3.0 -> v3.3.2 * github.com/microcosm-cc/bluemonday 4f7140c49acb -> v1.0.4 * github.com/minio/minio-go v7.0.4 -> v7.0.5 * github.com/olivere/elastic v7.0.9 -> v7.0.20 * github.com/urfave/cli v1.20.0 -> v1.22.4 * github.com/prometheus/client_golang v1.1.0 -> v1.8.0 * github.com/xanzy/go-gitlab v0.37.0 -> v0.38.1 * mvdan.cc/xurls v2.1.0 -> v2.2.0 Co-authored-by: Lauris BH <lauris@nix.lv>
138 lines
3.3 KiB
Go
Vendored
138 lines
3.3 KiB
Go
Vendored
// Copyright 2019+ Klaus Post. All rights reserved.
|
|
// License information can be found in the LICENSE file.
|
|
// Based on work by Yann Collet, released under BSD License.
|
|
|
|
package zstd
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"math/bits"
|
|
)
|
|
|
|
type frameHeader struct {
|
|
ContentSize uint64
|
|
WindowSize uint32
|
|
SingleSegment bool
|
|
Checksum bool
|
|
DictID uint32
|
|
}
|
|
|
|
const maxHeaderSize = 14
|
|
|
|
func (f frameHeader) appendTo(dst []byte) ([]byte, error) {
|
|
dst = append(dst, frameMagic...)
|
|
var fhd uint8
|
|
if f.Checksum {
|
|
fhd |= 1 << 2
|
|
}
|
|
if f.SingleSegment {
|
|
fhd |= 1 << 5
|
|
}
|
|
|
|
var dictIDContent []byte
|
|
if f.DictID > 0 {
|
|
var tmp [4]byte
|
|
if f.DictID < 256 {
|
|
fhd |= 1
|
|
tmp[0] = uint8(f.DictID)
|
|
dictIDContent = tmp[:1]
|
|
} else if f.DictID < 1<<16 {
|
|
fhd |= 2
|
|
binary.LittleEndian.PutUint16(tmp[:2], uint16(f.DictID))
|
|
dictIDContent = tmp[:2]
|
|
} else {
|
|
fhd |= 3
|
|
binary.LittleEndian.PutUint32(tmp[:4], f.DictID)
|
|
dictIDContent = tmp[:4]
|
|
}
|
|
}
|
|
var fcs uint8
|
|
if f.ContentSize >= 256 {
|
|
fcs++
|
|
}
|
|
if f.ContentSize >= 65536+256 {
|
|
fcs++
|
|
}
|
|
if f.ContentSize >= 0xffffffff {
|
|
fcs++
|
|
}
|
|
|
|
fhd |= fcs << 6
|
|
|
|
dst = append(dst, fhd)
|
|
if !f.SingleSegment {
|
|
const winLogMin = 10
|
|
windowLog := (bits.Len32(f.WindowSize-1) - winLogMin) << 3
|
|
dst = append(dst, uint8(windowLog))
|
|
}
|
|
if f.DictID > 0 {
|
|
dst = append(dst, dictIDContent...)
|
|
}
|
|
switch fcs {
|
|
case 0:
|
|
if f.SingleSegment {
|
|
dst = append(dst, uint8(f.ContentSize))
|
|
}
|
|
// Unless SingleSegment is set, framessizes < 256 are nto stored.
|
|
case 1:
|
|
f.ContentSize -= 256
|
|
dst = append(dst, uint8(f.ContentSize), uint8(f.ContentSize>>8))
|
|
case 2:
|
|
dst = append(dst, uint8(f.ContentSize), uint8(f.ContentSize>>8), uint8(f.ContentSize>>16), uint8(f.ContentSize>>24))
|
|
case 3:
|
|
dst = append(dst, uint8(f.ContentSize), uint8(f.ContentSize>>8), uint8(f.ContentSize>>16), uint8(f.ContentSize>>24),
|
|
uint8(f.ContentSize>>32), uint8(f.ContentSize>>40), uint8(f.ContentSize>>48), uint8(f.ContentSize>>56))
|
|
default:
|
|
panic("invalid fcs")
|
|
}
|
|
return dst, nil
|
|
}
|
|
|
|
const skippableFrameHeader = 4 + 4
|
|
|
|
// calcSkippableFrame will return a total size to be added for written
|
|
// to be divisible by multiple.
|
|
// The value will always be > skippableFrameHeader.
|
|
// The function will panic if written < 0 or wantMultiple <= 0.
|
|
func calcSkippableFrame(written, wantMultiple int64) int {
|
|
if wantMultiple <= 0 {
|
|
panic("wantMultiple <= 0")
|
|
}
|
|
if written < 0 {
|
|
panic("written < 0")
|
|
}
|
|
leftOver := written % wantMultiple
|
|
if leftOver == 0 {
|
|
return 0
|
|
}
|
|
toAdd := wantMultiple - leftOver
|
|
for toAdd < skippableFrameHeader {
|
|
toAdd += wantMultiple
|
|
}
|
|
return int(toAdd)
|
|
}
|
|
|
|
// skippableFrame will add a skippable frame with a total size of bytes.
|
|
// total should be >= skippableFrameHeader and < math.MaxUint32.
|
|
func skippableFrame(dst []byte, total int, r io.Reader) ([]byte, error) {
|
|
if total == 0 {
|
|
return dst, nil
|
|
}
|
|
if total < skippableFrameHeader {
|
|
return dst, fmt.Errorf("requested skippable frame (%d) < 8", total)
|
|
}
|
|
if int64(total) > math.MaxUint32 {
|
|
return dst, fmt.Errorf("requested skippable frame (%d) > max uint32", total)
|
|
}
|
|
dst = append(dst, 0x50, 0x2a, 0x4d, 0x18)
|
|
f := uint32(total - skippableFrameHeader)
|
|
dst = append(dst, uint8(f), uint8(f>>8), uint8(f>>16), uint8(f>>24))
|
|
start := len(dst)
|
|
dst = append(dst, make([]byte, f)...)
|
|
_, err := io.ReadFull(r, dst[start:])
|
|
return dst, err
|
|
}
|