Hello community, here is the log from the commit of package v2ray-core for openSUSE:Factory checked in at 2020-06-22 17:45:53 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/v2ray-core (Old) and /work/SRC/openSUSE:Factory/.v2ray-core.new.2956 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "v2ray-core" Mon Jun 22 17:45:53 2020 rev:2 rq:816222 version:4.25.0 Changes: -------- --- /work/SRC/openSUSE:Factory/v2ray-core/v2ray-core.changes 2020-06-15 20:27:46.349805201 +0200 +++ /work/SRC/openSUSE:Factory/.v2ray-core.new.2956/v2ray-core.changes 2020-06-22 17:45:55.413850337 +0200 @@ -1,0 +2,22 @@ +Sun Jun 21 09:05:14 UTC 2020 - opensuse-packaging <opensuse-packag...@opensuse.org> + +- Update version to 4.25.0 + * VMess's new header format experiment begins. You can now enable VMessAEAD to + be better protected. Documents EN CH are updated. See extra-VMessAEADdoc.zip + for a more detailed explanation available in both Chinese and English. + * mKCP can now be encrypted to resist recognition, address issue mentioned in + #2530 #2253 #2131. Documents EN CH are updated. + * Updated Golang tool-chain. Thanks @rprx + * LocalAddr() in UDP workers will now return correct local addr. Thanks + @zhuobixin + * Further remove the identity leakage with TLS ClientHello from #2521 thank + @darhwa + * Fix UDP stability issue in Socks5 inbound, Shadowsocks inbound, and + Dokodemo( TProxy ) inbound. This should alleviate unnecessary CPU, memory + usage, and premature disconnection issue typically triggered by playing + games, video conference, and Torrenting. See #2565 thank @JimHan75d8c5 + @xiaokangwang and Other testers @1265578519 @zhj9709 @Kylejustknows etc + * Added ARM v5 binary in the release. This should allow legacy ARM devices to + run V2Ray correctly. See #2536 + +------------------------------------------------------------------- Old: ---- v2ray-core-4.23.4.tar.gz New: ---- v2ray-core-4.25.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ v2ray-core.spec ++++++ --- /var/tmp/diff_new_pack.5sbzht/_old 2020-06-22 17:45:56.365853323 +0200 +++ /var/tmp/diff_new_pack.5sbzht/_new 2020-06-22 17:45:56.369853336 +0200 @@ -1,7 +1,7 @@ # # spec file for package v2ray-core # -# Copyright (c) 2020 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2020 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -12,9 +12,10 @@ # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. -# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# Please submit bugfixes or comments via https://bugs.opensuse.org/ # + %define provider github %define provider_tld com %define project v2ray @@ -24,11 +25,11 @@ %define import_path v2ray.com/core Name: v2ray-core -Version: 4.23.4 +Version: 4.25.0 Release: 0 Summary: Project V -Group: Productivity/Networking/Web/Proxy License: MIT +Group: Productivity/Networking/Web/Proxy URL: https://github.com/v2ray/v2ray-core Source0: https://github.com/v2ray/v2ray-core/archive/v%{version}/%{name}-%{version}.tar.gz Source1: vendor.tar.xz @@ -40,8 +41,8 @@ BuildRequires: fdupes BuildRequires: golang-packaging # This package can be built with go version < 1.13 -BuildRequires: golang(API) = 1.14 BuildRequires: systemd-rpm-macros +BuildRequires: golang(API) = 1.14 BuildRequires: pkgconfig(systemd) AutoReqProv: Off Provides: %{project} = %{version}-%{release} @@ -59,7 +60,6 @@ Summary: Additional mobile libraries Group: Development/Languages/Golang BuildArch: noarch -AutoReqProv: On %description -n golang-%{provider}-%{project}-%{repo} Project V is a set of network tools that help you to build your own computer ++++++ v2ray-core-4.23.4.tar.gz -> v2ray-core-4.25.0.tar.gz ++++++ /work/SRC/openSUSE:Factory/v2ray-core/v2ray-core-4.23.4.tar.gz /work/SRC/openSUSE:Factory/.v2ray-core.new.2956/v2ray-core-4.25.0.tar.gz differ: char 14, line 1 ++++++ vendor.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/LICENSE new/vendor/github.com/dgryski/go-metro/LICENSE --- old/vendor/github.com/dgryski/go-metro/LICENSE 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/LICENSE 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,24 @@ +This package is a mechanical translation of the reference C++ code for +MetroHash, available at https://github.com/jandrewrogers/MetroHash + +The MIT License (MIT) + +Copyright (c) 2016 Damian Gryski + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/README new/vendor/github.com/dgryski/go-metro/README --- old/vendor/github.com/dgryski/go-metro/README 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/README 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,6 @@ +MetroHash + +This package is a mechanical translation of the reference C++ code for +MetroHash, available at https://github.com/jandrewrogers/MetroHash + +I claim no additional copyright over the original implementation. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/metro.py new/vendor/github.com/dgryski/go-metro/metro.py --- old/vendor/github.com/dgryski/go-metro/metro.py 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/metro.py 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,199 @@ +import peachpy.x86_64 + +k0 = 0xD6D018F5 +k1 = 0xA2AA033B +k2 = 0x62992FC1 +k3 = 0x30BC5B29 + +def advance(p,l,c): + ADD(p,c) + SUB(l,c) + +def imul(r,k): + t = GeneralPurposeRegister64() + MOV(t, k) + IMUL(r, t) + +def update32(v, p,idx, k, vadd): + r = GeneralPurposeRegister64() + MOV(r, [p + idx]) + imul(r, k) + ADD(v, r) + ROR(v, 29) + ADD(v, vadd) + +def final32(v, regs, keys): + r = GeneralPurposeRegister64() + MOV(r, v[regs[1]]) + ADD(r, v[regs[2]]) + imul(r, keys[0]) + ADD(r, v[regs[3]]) + ROR(r, 37) + imul(r, keys[1]) + XOR(v[regs[0]], r) + +seed = Argument(uint64_t) +buffer_base = Argument(ptr()) +buffer_len = Argument(int64_t) +buffer_cap = Argument(int64_t) + +def makeHash(name, args): + with Function(name, args, uint64_t) as function: + + reg_ptr = GeneralPurposeRegister64() + reg_ptr_len = GeneralPurposeRegister64() + reg_hash = GeneralPurposeRegister64() + + LOAD.ARGUMENT(reg_hash, seed) + LOAD.ARGUMENT(reg_ptr, buffer_base) + LOAD.ARGUMENT(reg_ptr_len, buffer_len) + + imul(reg_hash, k0) + r = GeneralPurposeRegister64() + MOV(r, k2*k0) + ADD(reg_hash, r) + + after32 = Label("after32") + + CMP(reg_ptr_len, 32) + JL(after32) + v = [GeneralPurposeRegister64() for _ in range(4)] + for i in range(4): + MOV(v[i], reg_hash) + + with Loop() as loop: + update32(v[0], reg_ptr, 0, k0, v[2]) + update32(v[1], reg_ptr, 8, k1, v[3]) + update32(v[2], reg_ptr, 16, k2, v[0]) + update32(v[3], reg_ptr, 24, k3, v[1]) + + ADD(reg_ptr, 32) + SUB(reg_ptr_len, 32) + CMP(reg_ptr_len, 32) + JGE(loop.begin) + + final32(v, [2,0,3,1], [k0, k1]) + final32(v, [3,1,2,0], [k1, k0]) + final32(v, [0,0,2,3], [k0, k1]) + final32(v, [1,1,3,2], [k1, k0]) + + XOR(v[0], v[1]) + ADD(reg_hash, v[0]) + + LABEL(after32) + + after16 = Label("after16") + CMP(reg_ptr_len, 16) + JL(after16) + + for i in range(2): + MOV(v[i], [reg_ptr]) + imul(v[i], k2) + ADD(v[i], reg_hash) + + advance(reg_ptr, reg_ptr_len, 8) + + ROR(v[i], 29) + imul(v[i], k3) + + r = GeneralPurposeRegister64() + MOV(r, v[0]) + imul(r, k0) + ROR(r, 21) + ADD(r, v[1]) + XOR(v[0], r) + + MOV(r, v[1]) + imul(r, k3) + ROR(r, 21) + ADD(r, v[0]) + XOR(v[1], r) + + ADD(reg_hash, v[1]) + + LABEL(after16) + + after8 = Label("after8") + CMP(reg_ptr_len, 8) + JL(after8) + + r = GeneralPurposeRegister64() + MOV(r, [reg_ptr]) + imul(r, k3) + ADD(reg_hash, r) + advance(reg_ptr, reg_ptr_len, 8) + + MOV(r, reg_hash) + ROR(r, 55) + imul(r, k1) + XOR(reg_hash, r) + + LABEL(after8) + + after4 = Label("after4") + CMP(reg_ptr_len, 4) + JL(after4) + + r = GeneralPurposeRegister64() + XOR(r, r) + MOV(r.as_dword, dword[reg_ptr]) + imul(r, k3) + ADD(reg_hash, r) + advance(reg_ptr, reg_ptr_len, 4) + + MOV(r, reg_hash) + ROR(r, 26) + imul(r, k1) + XOR(reg_hash, r) + + LABEL(after4) + + after2 = Label("after2") + CMP(reg_ptr_len, 2) + JL(after2) + + r = GeneralPurposeRegister64() + XOR(r,r) + MOV(r.as_word, word[reg_ptr]) + imul(r, k3) + ADD(reg_hash, r) + advance(reg_ptr, reg_ptr_len, 2) + + MOV(r, reg_hash) + ROR(r, 48) + imul(r, k1) + XOR(reg_hash, r) + + LABEL(after2) + + after1 = Label("after1") + CMP(reg_ptr_len, 1) + JL(after1) + + r = GeneralPurposeRegister64() + MOVZX(r, byte[reg_ptr]) + imul(r, k3) + ADD(reg_hash, r) + + MOV(r, reg_hash) + ROR(r, 37) + imul(r, k1) + XOR(reg_hash, r) + + LABEL(after1) + + r = GeneralPurposeRegister64() + MOV(r, reg_hash) + ROR(r, 28) + XOR(reg_hash, r) + + imul(reg_hash, k0) + + MOV(r, reg_hash) + ROR(r, 29) + XOR(reg_hash, r) + + RETURN(reg_hash) + +makeHash("Hash64", (buffer_base, buffer_len, buffer_cap, seed)) +makeHash("Hash64Str", (buffer_base, buffer_len, seed)) \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/metro128.go new/vendor/github.com/dgryski/go-metro/metro128.go --- old/vendor/github.com/dgryski/go-metro/metro128.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/metro128.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,94 @@ +package metro + +import "encoding/binary" + +func rotate_right(v uint64, k uint) uint64 { + return (v >> k) | (v << (64 - k)) +} + +func Hash128(buffer []byte, seed uint64) (uint64, uint64) { + + const ( + k0 = 0xC83A91E1 + k1 = 0x8648DBDB + k2 = 0x7BDEC03B + k3 = 0x2F5870A5 + ) + + ptr := buffer + + var v [4]uint64 + + v[0] = (seed - k0) * k3 + v[1] = (seed + k1) * k2 + + if len(ptr) >= 32 { + v[2] = (seed + k0) * k2 + v[3] = (seed - k1) * k3 + + for len(ptr) >= 32 { + v[0] += binary.LittleEndian.Uint64(ptr) * k0 + ptr = ptr[8:] + v[0] = rotate_right(v[0], 29) + v[2] + v[1] += binary.LittleEndian.Uint64(ptr) * k1 + ptr = ptr[8:] + v[1] = rotate_right(v[1], 29) + v[3] + v[2] += binary.LittleEndian.Uint64(ptr) * k2 + ptr = ptr[8:] + v[2] = rotate_right(v[2], 29) + v[0] + v[3] += binary.LittleEndian.Uint64(ptr) * k3 + ptr = ptr[8:] + v[3] = rotate_right(v[3], 29) + v[1] + } + + v[2] ^= rotate_right(((v[0]+v[3])*k0)+v[1], 21) * k1 + v[3] ^= rotate_right(((v[1]+v[2])*k1)+v[0], 21) * k0 + v[0] ^= rotate_right(((v[0]+v[2])*k0)+v[3], 21) * k1 + v[1] ^= rotate_right(((v[1]+v[3])*k1)+v[2], 21) * k0 + } + + if len(ptr) >= 16 { + v[0] += binary.LittleEndian.Uint64(ptr) * k2 + ptr = ptr[8:] + v[0] = rotate_right(v[0], 33) * k3 + v[1] += binary.LittleEndian.Uint64(ptr) * k2 + ptr = ptr[8:] + v[1] = rotate_right(v[1], 33) * k3 + v[0] ^= rotate_right((v[0]*k2)+v[1], 45) * k1 + v[1] ^= rotate_right((v[1]*k3)+v[0], 45) * k0 + } + + if len(ptr) >= 8 { + v[0] += binary.LittleEndian.Uint64(ptr) * k2 + ptr = ptr[8:] + v[0] = rotate_right(v[0], 33) * k3 + v[0] ^= rotate_right((v[0]*k2)+v[1], 27) * k1 + } + + if len(ptr) >= 4 { + v[1] += uint64(binary.LittleEndian.Uint32(ptr)) * k2 + ptr = ptr[4:] + v[1] = rotate_right(v[1], 33) * k3 + v[1] ^= rotate_right((v[1]*k3)+v[0], 46) * k0 + } + + if len(ptr) >= 2 { + v[0] += uint64(binary.LittleEndian.Uint16(ptr)) * k2 + ptr = ptr[2:] + v[0] = rotate_right(v[0], 33) * k3 + v[0] ^= rotate_right((v[0]*k2)+v[1], 22) * k1 + } + + if len(ptr) >= 1 { + v[1] += uint64(ptr[0]) * k2 + v[1] = rotate_right(v[1], 33) * k3 + v[1] ^= rotate_right((v[1]*k3)+v[0], 58) * k0 + } + + v[0] += rotate_right((v[0]*k0)+v[1], 13) + v[1] += rotate_right((v[1]*k1)+v[0], 37) + v[0] += rotate_right((v[0]*k2)+v[1], 13) + v[1] += rotate_right((v[1]*k3)+v[0], 37) + + return v[0], v[1] +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/metro64.go new/vendor/github.com/dgryski/go-metro/metro64.go --- old/vendor/github.com/dgryski/go-metro/metro64.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/metro64.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,85 @@ +// +build noasm !amd64 gccgo + +package metro + +import "encoding/binary" + +func Hash64(buffer []byte, seed uint64) uint64 { + + const ( + k0 = 0xD6D018F5 + k1 = 0xA2AA033B + k2 = 0x62992FC1 + k3 = 0x30BC5B29 + ) + + ptr := buffer + + hash := (seed + k2) * k0 + + if len(ptr) >= 32 { + v := [4]uint64{hash, hash, hash, hash} + + for len(ptr) >= 32 { + v[0] += binary.LittleEndian.Uint64(ptr[:8]) * k0 + v[0] = rotate_right(v[0], 29) + v[2] + v[1] += binary.LittleEndian.Uint64(ptr[8:16]) * k1 + v[1] = rotate_right(v[1], 29) + v[3] + v[2] += binary.LittleEndian.Uint64(ptr[16:24]) * k2 + v[2] = rotate_right(v[2], 29) + v[0] + v[3] += binary.LittleEndian.Uint64(ptr[24:32]) * k3 + v[3] = rotate_right(v[3], 29) + v[1] + ptr = ptr[32:] + } + + v[2] ^= rotate_right(((v[0]+v[3])*k0)+v[1], 37) * k1 + v[3] ^= rotate_right(((v[1]+v[2])*k1)+v[0], 37) * k0 + v[0] ^= rotate_right(((v[0]+v[2])*k0)+v[3], 37) * k1 + v[1] ^= rotate_right(((v[1]+v[3])*k1)+v[2], 37) * k0 + hash += v[0] ^ v[1] + } + + if len(ptr) >= 16 { + v0 := hash + (binary.LittleEndian.Uint64(ptr[:8]) * k2) + v0 = rotate_right(v0, 29) * k3 + v1 := hash + (binary.LittleEndian.Uint64(ptr[8:16]) * k2) + v1 = rotate_right(v1, 29) * k3 + v0 ^= rotate_right(v0*k0, 21) + v1 + v1 ^= rotate_right(v1*k3, 21) + v0 + hash += v1 + ptr = ptr[16:] + } + + if len(ptr) >= 8 { + hash += binary.LittleEndian.Uint64(ptr[:8]) * k3 + ptr = ptr[8:] + hash ^= rotate_right(hash, 55) * k1 + } + + if len(ptr) >= 4 { + hash += uint64(binary.LittleEndian.Uint32(ptr[:4])) * k3 + hash ^= rotate_right(hash, 26) * k1 + ptr = ptr[4:] + } + + if len(ptr) >= 2 { + hash += uint64(binary.LittleEndian.Uint16(ptr[:2])) * k3 + ptr = ptr[2:] + hash ^= rotate_right(hash, 48) * k1 + } + + if len(ptr) >= 1 { + hash += uint64(ptr[0]) * k3 + hash ^= rotate_right(hash, 37) * k1 + } + + hash ^= rotate_right(hash, 28) + hash *= k0 + hash ^= rotate_right(hash, 29) + + return hash +} + +func Hash64Str(buffer string, seed uint64) uint64 { + return Hash64([]byte(buffer), seed) +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/metro_amd64.s new/vendor/github.com/dgryski/go-metro/metro_amd64.s --- old/vendor/github.com/dgryski/go-metro/metro_amd64.s 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/metro_amd64.s 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,372 @@ +// +build !noasm +// +build !gccgo + +// Generated by PeachPy 0.2.0 from metro.py + +// func Hash64(buffer_base uintptr, buffer_len int64, buffer_cap int64, seed uint64) uint64 +TEXT ·Hash64(SB),4,$0-40 + MOVQ seed+24(FP), AX + MOVQ buffer_base+0(FP), BX + MOVQ buffer_len+8(FP), CX + MOVQ $3603962101, DX + IMULQ DX, AX + MOVQ $5961697176435608501, DX + ADDQ DX, AX + CMPQ CX, $32 + JLT after32 + MOVQ AX, DX + MOVQ AX, DI + MOVQ AX, SI + MOVQ AX, BP +loop_begin: + MOVQ 0(BX), R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + ADDQ R8, DX + RORQ $29, DX + ADDQ SI, DX + MOVQ 8(BX), R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + ADDQ R8, DI + RORQ $29, DI + ADDQ BP, DI + MOVQ 16(BX), R8 + MOVQ $1654206401, R9 + IMULQ R9, R8 + ADDQ R8, SI + RORQ $29, SI + ADDQ DX, SI + MOVQ 24(BX), R8 + MOVQ $817650473, R9 + IMULQ R9, R8 + ADDQ R8, BP + RORQ $29, BP + ADDQ DI, BP + ADDQ $32, BX + SUBQ $32, CX + CMPQ CX, $32 + JGE loop_begin + MOVQ DX, R8 + ADDQ BP, R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + ADDQ DI, R8 + RORQ $37, R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + XORQ R8, SI + MOVQ DI, R8 + ADDQ SI, R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + ADDQ DX, R8 + RORQ $37, R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + XORQ R8, BP + MOVQ DX, R8 + ADDQ SI, R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + ADDQ BP, R8 + RORQ $37, R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + XORQ R8, DX + MOVQ DI, R8 + ADDQ BP, R8 + MOVQ $2729050939, BP + IMULQ BP, R8 + ADDQ SI, R8 + RORQ $37, R8 + MOVQ $3603962101, SI + IMULQ SI, R8 + XORQ R8, DI + XORQ DI, DX + ADDQ DX, AX +after32: + CMPQ CX, $16 + JLT after16 + MOVQ 0(BX), DX + MOVQ $1654206401, DI + IMULQ DI, DX + ADDQ AX, DX + ADDQ $8, BX + SUBQ $8, CX + RORQ $29, DX + MOVQ $817650473, DI + IMULQ DI, DX + MOVQ 0(BX), DI + MOVQ $1654206401, SI + IMULQ SI, DI + ADDQ AX, DI + ADDQ $8, BX + SUBQ $8, CX + RORQ $29, DI + MOVQ $817650473, SI + IMULQ SI, DI + MOVQ DX, SI + MOVQ $3603962101, BP + IMULQ BP, SI + RORQ $21, SI + ADDQ DI, SI + XORQ SI, DX + MOVQ DI, SI + MOVQ $817650473, BP + IMULQ BP, SI + RORQ $21, SI + ADDQ DX, SI + XORQ SI, DI + ADDQ DI, AX +after16: + CMPQ CX, $8 + JLT after8 + MOVQ 0(BX), DX + MOVQ $817650473, DI + IMULQ DI, DX + ADDQ DX, AX + ADDQ $8, BX + SUBQ $8, CX + MOVQ AX, DX + RORQ $55, DX + MOVQ $2729050939, DI + IMULQ DI, DX + XORQ DX, AX +after8: + CMPQ CX, $4 + JLT after4 + XORQ DX, DX + MOVL 0(BX), DX + MOVQ $817650473, DI + IMULQ DI, DX + ADDQ DX, AX + ADDQ $4, BX + SUBQ $4, CX + MOVQ AX, DX + RORQ $26, DX + MOVQ $2729050939, DI + IMULQ DI, DX + XORQ DX, AX +after4: + CMPQ CX, $2 + JLT after2 + XORQ DX, DX + MOVW 0(BX), DX + MOVQ $817650473, DI + IMULQ DI, DX + ADDQ DX, AX + ADDQ $2, BX + SUBQ $2, CX + MOVQ AX, DX + RORQ $48, DX + MOVQ $2729050939, DI + IMULQ DI, DX + XORQ DX, AX +after2: + CMPQ CX, $1 + JLT after1 + MOVBQZX 0(BX), BX + MOVQ $817650473, CX + IMULQ CX, BX + ADDQ BX, AX + MOVQ AX, BX + RORQ $37, BX + MOVQ $2729050939, CX + IMULQ CX, BX + XORQ BX, AX +after1: + MOVQ AX, BX + RORQ $28, BX + XORQ BX, AX + MOVQ $3603962101, BX + IMULQ BX, AX + MOVQ AX, BX + RORQ $29, BX + XORQ BX, AX + MOVQ AX, ret+32(FP) + RET + +// func Hash64Str(buffer_base uintptr, buffer_len int64, seed uint64) uint64 +TEXT ·Hash64Str(SB),4,$0-32 + MOVQ seed+16(FP), AX + MOVQ buffer_base+0(FP), BX + MOVQ buffer_len+8(FP), CX + MOVQ $3603962101, DX + IMULQ DX, AX + MOVQ $5961697176435608501, DX + ADDQ DX, AX + CMPQ CX, $32 + JLT after32 + MOVQ AX, DX + MOVQ AX, DI + MOVQ AX, SI + MOVQ AX, BP +loop_begin: + MOVQ 0(BX), R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + ADDQ R8, DX + RORQ $29, DX + ADDQ SI, DX + MOVQ 8(BX), R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + ADDQ R8, DI + RORQ $29, DI + ADDQ BP, DI + MOVQ 16(BX), R8 + MOVQ $1654206401, R9 + IMULQ R9, R8 + ADDQ R8, SI + RORQ $29, SI + ADDQ DX, SI + MOVQ 24(BX), R8 + MOVQ $817650473, R9 + IMULQ R9, R8 + ADDQ R8, BP + RORQ $29, BP + ADDQ DI, BP + ADDQ $32, BX + SUBQ $32, CX + CMPQ CX, $32 + JGE loop_begin + MOVQ DX, R8 + ADDQ BP, R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + ADDQ DI, R8 + RORQ $37, R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + XORQ R8, SI + MOVQ DI, R8 + ADDQ SI, R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + ADDQ DX, R8 + RORQ $37, R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + XORQ R8, BP + MOVQ DX, R8 + ADDQ SI, R8 + MOVQ $3603962101, R9 + IMULQ R9, R8 + ADDQ BP, R8 + RORQ $37, R8 + MOVQ $2729050939, R9 + IMULQ R9, R8 + XORQ R8, DX + MOVQ DI, R8 + ADDQ BP, R8 + MOVQ $2729050939, BP + IMULQ BP, R8 + ADDQ SI, R8 + RORQ $37, R8 + MOVQ $3603962101, SI + IMULQ SI, R8 + XORQ R8, DI + XORQ DI, DX + ADDQ DX, AX +after32: + CMPQ CX, $16 + JLT after16 + MOVQ 0(BX), DX + MOVQ $1654206401, DI + IMULQ DI, DX + ADDQ AX, DX + ADDQ $8, BX + SUBQ $8, CX + RORQ $29, DX + MOVQ $817650473, DI + IMULQ DI, DX + MOVQ 0(BX), DI + MOVQ $1654206401, SI + IMULQ SI, DI + ADDQ AX, DI + ADDQ $8, BX + SUBQ $8, CX + RORQ $29, DI + MOVQ $817650473, SI + IMULQ SI, DI + MOVQ DX, SI + MOVQ $3603962101, BP + IMULQ BP, SI + RORQ $21, SI + ADDQ DI, SI + XORQ SI, DX + MOVQ DI, SI + MOVQ $817650473, BP + IMULQ BP, SI + RORQ $21, SI + ADDQ DX, SI + XORQ SI, DI + ADDQ DI, AX +after16: + CMPQ CX, $8 + JLT after8 + MOVQ 0(BX), DX + MOVQ $817650473, DI + IMULQ DI, DX + ADDQ DX, AX + ADDQ $8, BX + SUBQ $8, CX + MOVQ AX, DX + RORQ $55, DX + MOVQ $2729050939, DI + IMULQ DI, DX + XORQ DX, AX +after8: + CMPQ CX, $4 + JLT after4 + XORQ DX, DX + MOVL 0(BX), DX + MOVQ $817650473, DI + IMULQ DI, DX + ADDQ DX, AX + ADDQ $4, BX + SUBQ $4, CX + MOVQ AX, DX + RORQ $26, DX + MOVQ $2729050939, DI + IMULQ DI, DX + XORQ DX, AX +after4: + CMPQ CX, $2 + JLT after2 + XORQ DX, DX + MOVW 0(BX), DX + MOVQ $817650473, DI + IMULQ DI, DX + ADDQ DX, AX + ADDQ $2, BX + SUBQ $2, CX + MOVQ AX, DX + RORQ $48, DX + MOVQ $2729050939, DI + IMULQ DI, DX + XORQ DX, AX +after2: + CMPQ CX, $1 + JLT after1 + MOVBQZX 0(BX), BX + MOVQ $817650473, CX + IMULQ CX, BX + ADDQ BX, AX + MOVQ AX, BX + RORQ $37, BX + MOVQ $2729050939, CX + IMULQ CX, BX + XORQ BX, AX +after1: + MOVQ AX, BX + RORQ $28, BX + XORQ BX, AX + MOVQ $3603962101, BX + IMULQ BX, AX + MOVQ AX, BX + RORQ $29, BX + XORQ BX, AX + MOVQ AX, ret+24(FP) + RET diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/dgryski/go-metro/metro_stub.go new/vendor/github.com/dgryski/go-metro/metro_stub.go --- old/vendor/github.com/dgryski/go-metro/metro_stub.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/dgryski/go-metro/metro_stub.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,10 @@ +// +build !noasm,amd64 +// +build !gccgo + +package metro + +//go:generate python -m peachpy.x86_64 metro.py -S -o metro_amd64.s -mabi=goasm +//go:noescape + +func Hash64(buffer []byte, seed uint64) uint64 +func Hash64Str(buffer string, seed uint64) uint64 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/.gitignore new/vendor/github.com/seiflotfy/cuckoofilter/.gitignore --- old/vendor/github.com/seiflotfy/cuckoofilter/.gitignore 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/.gitignore 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,26 @@ +# Compiled Object files, Static and Dynamic libs (Shared Objects) +*.o +*.a +*.so + +# Folders +_obj +_test + +# Architecture specific extensions/prefixes +*.[568vq] +[568vq].out + +*.cgo1.go +*.cgo2.c +_cgo_defun.c +_cgo_gotypes.go +_cgo_export.* + +_testmain.go + +*.exe +*.test +*.prof + +.idea diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/LICENSE new/vendor/github.com/seiflotfy/cuckoofilter/LICENSE --- old/vendor/github.com/seiflotfy/cuckoofilter/LICENSE 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/LICENSE 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Seif Lotfy <seif.lo...@gmail.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/README.md new/vendor/github.com/seiflotfy/cuckoofilter/README.md --- old/vendor/github.com/seiflotfy/cuckoofilter/README.md 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/README.md 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,50 @@ +# Cuckoo Filter + +[](https://godoc.org/github.com/seiflotfy/cuckoofilter) [](http://codehunt.io/sub/cuckoo-filter/?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) + +Cuckoo filter is a Bloom filter replacement for approximated set-membership queries. While Bloom filters are well-known space-efficient data structures to serve queries like "if item x is in a set?", they do not support deletion. Their variances to enable deletion (like counting Bloom filters) usually require much more space. + +Cuckoo filters provide the flexibility to add and remove items dynamically. A cuckoo filter is based on cuckoo hashing (and therefore named as cuckoo filter). It is essentially a cuckoo hash table storing each key's fingerprint. Cuckoo hash tables can be highly compact, thus a cuckoo filter could use less space than conventional Bloom filters, for applications that require low false positive rates (< 3%). + +For details about the algorithm and citations please use this article for now + +["Cuckoo Filter: Better Than Bloom" by Bin Fan, Dave Andersen and Michael Kaminsky](https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf) + +## Note +This implementation uses a a static bucket size of 4 fingerprints and a fingerprint size of 1 byte based on my understanding of an optimal bucket/fingerprint/size ratio from the aforementioned paper. + +## Example usage: +```go +package main + +import "fmt" +import "github.com/seiflotfy/cuckoofilter" + +func main() { + cf := cuckoo.NewFilter(1000) + cf.InsertUnique([]byte("geeky ogre")) + + // Lookup a string (and it a miss) if it exists in the cuckoofilter + cf.Lookup([]byte("hello")) + + count := cf.Count() + fmt.Println(count) // count == 1 + + // Delete a string (and it a miss) + cf.Delete([]byte("hello")) + + count = cf.Count() + fmt.Println(count) // count == 1 + + // Delete a string (a hit) + cf.Delete([]byte("geeky ogre")) + + count = cf.Count() + fmt.Println(count) // count == 0 + + cf.Reset() // reset +} +``` + +## Documentation: +["Cuckoo Filter on GoDoc"](http://godoc.org/github.com/seiflotfy/cuckoofilter) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/bucket.go new/vendor/github.com/seiflotfy/cuckoofilter/bucket.go --- old/vendor/github.com/seiflotfy/cuckoofilter/bucket.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/bucket.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,43 @@ +package cuckoo + +type bucket [bucketSize]byte + +const ( + nullFp = 0 + bucketSize = 4 +) + +func (b *bucket) insert(fp byte) bool { + for i, tfp := range b { + if tfp == nullFp { + b[i] = fp + return true + } + } + return false +} + +func (b *bucket) delete(fp byte) bool { + for i, tfp := range b { + if tfp == fp { + b[i] = nullFp + return true + } + } + return false +} + +func (b *bucket) getFingerprintIndex(fp byte) int { + for i, tfp := range b { + if tfp == fp { + return i + } + } + return -1 +} + +func (b *bucket) reset() { + for i := range b { + b[i] = nullFp + } +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/cuckoofilter.go new/vendor/github.com/seiflotfy/cuckoofilter/cuckoofilter.go --- old/vendor/github.com/seiflotfy/cuckoofilter/cuckoofilter.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/cuckoofilter.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,148 @@ +package cuckoo + +import ( + "fmt" + "math/bits" + "math/rand" +) + +const maxCuckooCount = 500 + +// Filter is a probabilistic counter +type Filter struct { + buckets []bucket + count uint + bucketPow uint +} + +// NewFilter returns a new cuckoofilter with a given capacity. +// A capacity of 1000000 is a normal default, which allocates +// about ~1MB on 64-bit machines. +func NewFilter(capacity uint) *Filter { + capacity = getNextPow2(uint64(capacity)) / bucketSize + if capacity == 0 { + capacity = 1 + } + buckets := make([]bucket, capacity) + return &Filter{ + buckets: buckets, + count: 0, + bucketPow: uint(bits.TrailingZeros(capacity)), + } +} + +// Lookup returns true if data is in the counter +func (cf *Filter) Lookup(data []byte) bool { + i1, i2, fp := getIndicesAndFingerprint(data, cf.bucketPow) + b1, b2 := cf.buckets[i1], cf.buckets[i2] + return b1.getFingerprintIndex(fp) > -1 || b2.getFingerprintIndex(fp) > -1 +} + +func (cf *Filter) Reset() { + for i := range cf.buckets { + cf.buckets[i].reset() + } + cf.count = 0 +} + +func randi(i1, i2 uint) uint { + if rand.Intn(2) == 0 { + return i1 + } + return i2 +} + +// Insert inserts data into the counter and returns true upon success +func (cf *Filter) Insert(data []byte) bool { + i1, i2, fp := getIndicesAndFingerprint(data, cf.bucketPow) + if cf.insert(fp, i1) || cf.insert(fp, i2) { + return true + } + return cf.reinsert(fp, randi(i1, i2)) +} + +// InsertUnique inserts data into the counter if not exists and returns true upon success +func (cf *Filter) InsertUnique(data []byte) bool { + if cf.Lookup(data) { + return false + } + return cf.Insert(data) +} + +func (cf *Filter) insert(fp byte, i uint) bool { + if cf.buckets[i].insert(fp) { + cf.count++ + return true + } + return false +} + +func (cf *Filter) reinsert(fp byte, i uint) bool { + for k := 0; k < maxCuckooCount; k++ { + j := rand.Intn(bucketSize) + oldfp := fp + fp = cf.buckets[i][j] + cf.buckets[i][j] = oldfp + + // look in the alternate location for that random element + i = getAltIndex(fp, i, cf.bucketPow) + if cf.insert(fp, i) { + return true + } + } + return false +} + +// Delete data from counter if exists and return if deleted or not +func (cf *Filter) Delete(data []byte) bool { + i1, i2, fp := getIndicesAndFingerprint(data, cf.bucketPow) + return cf.delete(fp, i1) || cf.delete(fp, i2) +} + +func (cf *Filter) delete(fp byte, i uint) bool { + if cf.buckets[i].delete(fp) { + cf.count-- + return true + } + return false +} + +// Count returns the number of items in the counter +func (cf *Filter) Count() uint { + return cf.count +} + +// Encode returns a byte slice representing a Cuckoofilter +func (cf *Filter) Encode() []byte { + bytes := make([]byte, len(cf.buckets)*bucketSize) + for i, b := range cf.buckets { + for j, f := range b { + index := (i * len(b)) + j + bytes[index] = f + } + } + return bytes +} + +// Decode returns a Cuckoofilter from a byte slice +func Decode(bytes []byte) (*Filter, error) { + var count uint + if len(bytes)%bucketSize != 0 { + return nil, fmt.Errorf("expected bytes to be multiple of %d, got %d", bucketSize, len(bytes)) + } + buckets := make([]bucket, len(bytes)/4) + for i, b := range buckets { + for j := range b { + index := (i * len(b)) + j + if bytes[index] != 0 { + buckets[i][j] = bytes[index] + count++ + } + } + } + return &Filter{ + buckets: buckets, + count: count, + bucketPow: uint(bits.TrailingZeros(uint(len(buckets)))), + }, nil +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/doc.go new/vendor/github.com/seiflotfy/cuckoofilter/doc.go --- old/vendor/github.com/seiflotfy/cuckoofilter/doc.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/doc.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,35 @@ +/* +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/* +Package cuckoo provides a Cuckoo Filter, a Bloom filter replacement for approximated set-membership queries. + +While Bloom filters are well-known space-efficient data structures to serve queries like "if item x is in a set?", they do not support deletion. Their variances to enable deletion (like counting Bloom filters) usually require much more space. + +Cuckoo filters provide the flexibility to add and remove items dynamically. A cuckoo filter is based on cuckoo hashing (and therefore named as cuckoo filter). It is essentially a cuckoo hash table storing each key's fingerprint. Cuckoo hash tables can be highly compact, thus a cuckoo filter could use less space than conventional Bloom filters, for applications that require low false positive rates (< 3%). + +For details about the algorithm and citations please use this article: + +"Cuckoo Filter: Better Than Bloom" by Bin Fan, Dave Andersen and Michael Kaminsky +(https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf) + +Note: +This implementation uses a a static bucket size of 4 fingerprints and a fingerprint size of 1 byte based on my understanding of an optimal bucket/fingerprint/size ratio from the aforementioned paper.*/ +package cuckoo diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/seiflotfy/cuckoofilter/util.go new/vendor/github.com/seiflotfy/cuckoofilter/util.go --- old/vendor/github.com/seiflotfy/cuckoofilter/util.go 1970-01-01 01:00:00.000000000 +0100 +++ new/vendor/github.com/seiflotfy/cuckoofilter/util.go 2020-06-21 11:28:44.000000000 +0200 @@ -0,0 +1,51 @@ +package cuckoo + +import ( + metro "github.com/dgryski/go-metro" +) + +var ( + altHash = [256]uint{} + masks = [65]uint{} +) + +func init() { + for i := 0; i < 256; i++ { + altHash[i] = (uint(metro.Hash64([]byte{byte(i)}, 1337))) + } + for i := uint(0); i <= 64; i++ { + masks[i] = (1 << i) - 1 + } +} + +func getAltIndex(fp byte, i uint, bucketPow uint) uint { + mask := masks[bucketPow] + hash := altHash[fp] & mask + return (i & mask) ^ hash +} + +func getFingerprint(data []byte) byte { + fp := byte(metro.Hash64(data, 1335)%255 + 1) + return fp +} + +// getIndicesAndFingerprint returns the 2 bucket indices and fingerprint to be used +func getIndicesAndFingerprint(data []byte, bucketPow uint) (uint, uint, byte) { + hash := metro.Hash64(data, 1337) + f := getFingerprint(data) + i1 := uint(hash) & masks[bucketPow] + i2 := getAltIndex(f, i1, bucketPow) + return i1, i2, f +} + +func getNextPow2(n uint64) uint { + n-- + n |= n >> 1 + n |= n >> 2 + n |= n >> 4 + n |= n >> 8 + n |= n >> 16 + n |= n >> 32 + n++ + return uint(n) +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/golang.org/x/sys/cpu/byteorder.go new/vendor/golang.org/x/sys/cpu/byteorder.go --- old/vendor/golang.org/x/sys/cpu/byteorder.go 2020-06-07 04:38:21.000000000 +0200 +++ new/vendor/golang.org/x/sys/cpu/byteorder.go 2020-06-21 11:28:44.000000000 +0200 @@ -39,20 +39,25 @@ uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56 } -// hostByteOrder returns binary.LittleEndian on little-endian machines and -// binary.BigEndian on big-endian machines. +// hostByteOrder returns littleEndian on little-endian machines and +// bigEndian on big-endian machines. func hostByteOrder() byteOrder { switch runtime.GOARCH { case "386", "amd64", "amd64p32", + "alpha", "arm", "arm64", "mipsle", "mips64le", "mips64p32le", + "nios2", "ppc64le", - "riscv", "riscv64": + "riscv", "riscv64", + "sh": return littleEndian{} case "armbe", "arm64be", + "m68k", "mips", "mips64", "mips64p32", "ppc", "ppc64", "s390", "s390x", + "shbe", "sparc", "sparc64": return bigEndian{} } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/golang.org/x/sys/unix/syscall_linux.go new/vendor/golang.org/x/sys/unix/syscall_linux.go --- old/vendor/golang.org/x/sys/unix/syscall_linux.go 2020-06-07 04:38:21.000000000 +0200 +++ new/vendor/golang.org/x/sys/unix/syscall_linux.go 2020-06-21 11:28:44.000000000 +0200 @@ -1950,6 +1950,20 @@ return int(n), nil } +func isGroupMember(gid int) bool { + groups, err := Getgroups() + if err != nil { + return false + } + + for _, g := range groups { + if g == gid { + return true + } + } + return false +} + //sys faccessat(dirfd int, path string, mode uint32) (err error) func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { @@ -2007,7 +2021,7 @@ gid = Getgid() } - if uint32(gid) == st.Gid { + if uint32(gid) == st.Gid || isGroupMember(gid) { fmode = (st.Mode >> 3) & 7 } else { fmode = st.Mode & 7 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/modules.txt new/vendor/modules.txt --- old/vendor/modules.txt 2020-06-07 04:42:39.000000000 +0200 +++ new/vendor/modules.txt 2020-06-21 11:28:44.000000000 +0200 @@ -1,12 +1,14 @@ +# github.com/dgryski/go-metro v0.0.0-20180109044635-280f6062b5bc +github.com/dgryski/go-metro # github.com/golang/mock v1.2.0 github.com/golang/mock/gomock -# github.com/golang/protobuf v1.3.2 +# github.com/golang/protobuf v1.4.2 github.com/golang/protobuf/proto github.com/golang/protobuf/ptypes github.com/golang/protobuf/ptypes/any github.com/golang/protobuf/ptypes/duration github.com/golang/protobuf/ptypes/timestamp -# github.com/google/go-cmp v0.2.0 +# github.com/google/go-cmp v0.4.0 github.com/google/go-cmp/cmp github.com/google/go-cmp/cmp/cmpopts github.com/google/go-cmp/cmp/internal/diff @@ -20,6 +22,8 @@ # github.com/refraction-networking/utls v0.0.0-20190909200633-43c36d3c1f57 github.com/refraction-networking/utls github.com/refraction-networking/utls/cpu +# github.com/seiflotfy/cuckoofilter v0.0.0-20200511222245-56093a4d3841 +github.com/seiflotfy/cuckoofilter # go.starlark.net v0.0.0-20190919145610-979af19b165c go.starlark.net/internal/compile go.starlark.net/internal/spell @@ -63,7 +67,7 @@ golang.org/x/net/trace # golang.org/x/sync v0.0.0-20190423024810-112230192c58 golang.org/x/sync/errgroup -# golang.org/x/sys v20190412213103-97732733099d +# golang.org/x/sys v0.0.0-20200620081246-981b61492c35 golang.org/x/sys/cpu golang.org/x/sys/internal/unsafeheader golang.org/x/sys/unix @@ -75,9 +79,9 @@ # golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 golang.org/x/xerrors golang.org/x/xerrors/internal -# google.golang.org/genproto v0.0.0-20180831171423-11092d34479b +# google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 google.golang.org/genproto/googleapis/rpc/status -# google.golang.org/grpc v1.24.0 +# google.golang.org/grpc v1.27.0 google.golang.org/grpc google.golang.org/grpc/attributes google.golang.org/grpc/backoff
