Skip to content

G
go
Commit 2a0fc9e7 authored by Mikio Hara's avatar Mikio Hara Committed by Brad Fitzpatrick
Browse files
Options

Revert "net, internal/syscall/unix: add SocketConn, SocketPacketConn" 

This reverts commit 6f7961da.

Russ suggests changing the frozon syscall package and obviously it's a
better solution. Perhaps he will also let me know the way how to get the
project owners to agree later.

Fixes #11492.

Change-Id: I98f9f366b72b85db54b4acfc3a604b62fb6d783c
Reviewed-on: https://go-review.googlesource.com/11854
Run-TryBot: Mikio Hara <mikioh.mikioh@gmail.com>
Reviewed-by: default avatarRob Pike <r@golang.org>
Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
parent 85938714
Show whitespace changes
Inline Side-by-side
Showing with 30 additions and 609 deletions
src/go/build/deps_test.go
View file @ 2a0fc9e7
......@@ -244,7 +244,7 @@ var pkgDeps = map[string][]string{
// Basic networking.
// Because net must be used by any package that wants to
// do networking portably, it must have a small dependency set: just L1+basic os.
"net": {"L1", "CGO", "os", "syscall", "time", "internal/syscall/unix", "internal/syscall/windows", "internal/singleflight"},
"net": {"L1", "CGO", "os", "syscall", "time", "internal/syscall/windows", "internal/singleflight"},
// NET enables use of basic network-related packages.
"NET": {
......
src/internal/syscall/unix/socket.go deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
package unix
// Getsockname copies the binary encoding of the current address for s
// into addr.
func Getsockname(s int, addr []byte) error {
return getsockname(s, addr)
}
// Getpeername copies the binary encoding of the peer address for s
// into addr.
func Getpeername(s int, addr []byte) error {
return getpeername(s, addr)
}
var emptyPayload uintptr
// Recvfrom receives a message from s, copying the message into b.
// The socket address addr must be large enough for storing the source
// address of the message.
// Flags must be operation control flags or 0.
// It retunrs the number of bytes copied into b.
func Recvfrom(s int, b []byte, flags int, addr []byte) (int, error) {
return recvfrom(s, b, flags, addr)
}
// Sendto sends a message to the socket address addr, copying the
// message from b.
// The socket address addr must be suitable for s.
// Flags must be operation control flags or 0.
// It retunrs the number of bytes copied from b.
func Sendto(s int, b []byte, flags int, addr []byte) (int, error) {
return sendto(s, b, flags, addr)
}
src/internal/syscall/unix/socket_linux_386.go deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package unix
import (
"syscall"
"unsafe"
)
const (
sysGETSOCKNAME = 0x6
sysGETPEERNAME = 0x7
sysSENDTO = 0xb
sysRECVFROM = 0xc
)
func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno)
func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno)
func getsockname(s int, addr []byte) error {
l := uint32(len(addr))
_, errno := rawsocketcall(sysGETSOCKNAME, uintptr(s), uintptr(unsafe.Pointer(&addr[0])), uintptr(unsafe.Pointer(&l)), 0, 0, 0)
if errno != 0 {
return error(errno)
}
return nil
}
func getpeername(s int, addr []byte) error {
l := uint32(len(addr))
_, errno := rawsocketcall(sysGETPEERNAME, uintptr(s), uintptr(unsafe.Pointer(&addr[0])), uintptr(unsafe.Pointer(&l)), 0, 0, 0)
if errno != 0 {
return error(errno)
}
return nil
}
func recvfrom(s int, b []byte, flags int, from []byte) (int, error) {
var p unsafe.Pointer
if len(b) > 0 {
p = unsafe.Pointer(&b[0])
} else {
p = unsafe.Pointer(&emptyPayload)
}
l := uint32(len(from))
n, errno := socketcall(sysRECVFROM, uintptr(s), uintptr(p), uintptr(len(b)), uintptr(flags), uintptr(unsafe.Pointer(&from[0])), uintptr(unsafe.Pointer(&l)))
if errno != 0 {
return int(n), error(errno)
}
return int(n), nil
}
func sendto(s int, b []byte, flags int, to []byte) (int, error) {
var p unsafe.Pointer
if len(b) > 0 {
p = unsafe.Pointer(&b[0])
} else {
p = unsafe.Pointer(&emptyPayload)
}
n, errno := socketcall(sysSENDTO, uintptr(s), uintptr(p), uintptr(len(b)), uintptr(flags), uintptr(unsafe.Pointer(&to[0])), uintptr(len(to)))
if errno != 0 {
return int(n), error(errno)
}
return int(n), nil
}
src/internal/syscall/unix/socket_linux_386.s deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#include "textflag.h"
TEXT ·socketcall(SB),NOSPLIT,$0-36
JMP syscall·socketcall(SB)
TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
JMP syscall·socketcall(SB)
src/internal/syscall/unix/socket_stub.go deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build nacl solaris
package unix
import "syscall"
func getsockname(s int, addr []byte) error {
return syscall.EOPNOTSUPP
}
func getpeername(s int, addr []byte) error {
return syscall.EOPNOTSUPP
}
func recvfrom(s int, b []byte, flags int, from []byte) (int, error) {
return 0, syscall.EOPNOTSUPP
}
func sendto(s int, b []byte, flags int, to []byte) (int, error) {
return 0, syscall.EOPNOTSUPP
}
src/internal/syscall/unix/socket_unix.go deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build darwin dragonfly freebsd linux,!386 netbsd openbsd
package unix
import (
"syscall"
"unsafe"
)
func getsockname(s int, addr []byte) error {
l := uint32(len(addr))
_, _, errno := syscall.RawSyscall(syscall.SYS_GETSOCKNAME, uintptr(s), uintptr(unsafe.Pointer(&addr[0])), uintptr(unsafe.Pointer(&l)))
if errno != 0 {
return error(errno)
}
return nil
}
func getpeername(s int, addr []byte) error {
l := uint32(len(addr))
_, _, errno := syscall.RawSyscall(syscall.SYS_GETPEERNAME, uintptr(s), uintptr(unsafe.Pointer(&addr[0])), uintptr(unsafe.Pointer(&l)))
if errno != 0 {
return error(errno)
}
return nil
}
func recvfrom(s int, b []byte, flags int, from []byte) (int, error) {
var p unsafe.Pointer
if len(b) > 0 {
p = unsafe.Pointer(&b[0])
} else {
p = unsafe.Pointer(&emptyPayload)
}
l := uint32(len(from))
n, _, errno := syscall.Syscall6(syscall.SYS_RECVFROM, uintptr(s), uintptr(p), uintptr(len(b)), uintptr(flags), uintptr(unsafe.Pointer(&from[0])), uintptr(unsafe.Pointer(&l)))
if errno != 0 {
return int(n), error(errno)
}
return int(n), nil
}
func sendto(s int, b []byte, flags int, to []byte) (int, error) {
var p unsafe.Pointer
if len(b) > 0 {
p = unsafe.Pointer(&b[0])
} else {
p = unsafe.Pointer(&emptyPayload)
}
n, _, errno := syscall.Syscall6(syscall.SYS_SENDTO, uintptr(s), uintptr(p), uintptr(len(b)), uintptr(flags), uintptr(unsafe.Pointer(&to[0])), uintptr(len(to)))
if errno != 0 {
return int(n), error(errno)
}
return int(n), nil
}
src/net/fd_unix.go
View file @ 2a0fc9e7
......@@ -7,7 +7,6 @@
package net
import (
"internal/syscall/unix"
"io"
"os"
"runtime"
......@@ -271,33 +270,6 @@ func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
return
}
func (fd *netFD) recvFrom(b []byte, flags int, from []byte) (n int, err error) {
if err := fd.readLock(); err != nil {
return 0, err
}
defer fd.readUnlock()
if err := fd.pd.PrepareRead(); err != nil {
return 0, err
}
for {
n, err = unix.Recvfrom(fd.sysfd, b, flags, from)
if err != nil {
n = 0
if err == syscall.EAGAIN {
if err = fd.pd.WaitRead(); err == nil {
continue
}
}
}
err = fd.eofError(n, err)
break
}
if _, ok := err.(syscall.Errno); ok {
err = os.NewSyscallError("recvfrom", err)
}
return
}
func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
if err := fd.readLock(); err != nil {
return 0, 0, 0, nil, err
......@@ -387,29 +359,6 @@ func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
return
}
func (fd *netFD) sendTo(b []byte, flags int, to []byte) (n int, err error) {
if err := fd.writeLock(); err != nil {
return 0, err
}
defer fd.writeUnlock()
if err := fd.pd.PrepareWrite(); err != nil {
return 0, err
}
for {
n, err = unix.Sendto(fd.sysfd, b, flags, to)
if err == syscall.EAGAIN {
if err = fd.pd.WaitWrite(); err == nil {
continue
}
}
break
}
if _, ok := err.(syscall.Errno); ok {
err = os.NewSyscallError("sendto", err)
}
return
}
func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
if err := fd.writeLock(); err != nil {
return 0, 0, err
......
src/net/file.go
View file @ 2a0fc9e7
......@@ -46,47 +46,3 @@ func FilePacketConn(f *os.File) (c PacketConn, err error) {
}
return
}
// A SocketAddr is used with SocketConn or SocketPacketConn to
// implement a user-configured socket address.
// The net package does not provide any implementations of SocketAddr;
// the caller of SocketConn or SocketPacketConn is expected to provide
// one.
type SocketAddr interface {
// Addr takes a platform-specific socket address and returns
// a net.Addr. The result may be nil when the syscall package,
// system call or underlying protocol does not support the
// socket address.
Addr([]byte) Addr
// Raw takes a net.Addr and returns a platform-specific socket
// address. The result may be nil when the syscall package,
// system call or underlying protocol does not support the
// socket address.
Raw(Addr) []byte
}
// SocketConn returns a copy of the network connection corresponding
// to the open file f and user-defined socket address sa.
// It is the caller's responsibility to close f when finished.
// Closing c does not affect f, and closing f does not affect c.
func SocketConn(f *os.File, sa SocketAddr) (c Conn, err error) {
c, err = socketConn(f, sa)
if err != nil {
err = &OpError{Op: "file", Net: "file+net", Source: nil, Addr: fileAddr(f.Name()), Err: err}
}
return
}
// SocketPacketConn returns a copy of the packet network connection
// corresponding to the open file f and user-defined socket address
// sa.
// It is the caller's responsibility to close f when finished.
// Closing c does not affect f, and closing f does not affect c.
func SocketPacketConn(f *os.File, sa SocketAddr) (c PacketConn, err error) {
c, err = socketPacketConn(f, sa)
if err != nil {
err = &OpError{Op: "file", Net: "file+net", Source: nil, Addr: fileAddr(f.Name()), Err: err}
}
return
}
src/net/file_bsd_test.go deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build darwin dragonfly freebsd netbsd openbsd
package net
import (
"os"
"runtime"
"strings"
"sync"
"syscall"
"testing"
"unsafe"
)
type routeAddr struct{}
func (a *routeAddr) Network() string { return "route" }
func (a *routeAddr) String() string { return "<nil>" }
func (a *routeAddr) Addr(rsa []byte) Addr { return &routeAddr{} }
func (a *routeAddr) Raw(addr Addr) []byte { return nil }
func TestSocketConn(t *testing.T) {
var freebsd32o64 bool
if runtime.GOOS == "freebsd" && runtime.GOARCH == "386" {
archs, _ := syscall.Sysctl("kern.supported_archs")
for _, s := range strings.Split(archs, " ") {
if strings.TrimSpace(s) == "amd64" {
freebsd32o64 = true
break
}
}
}
s, err := syscall.Socket(syscall.AF_ROUTE, syscall.SOCK_RAW, syscall.AF_UNSPEC)
if err != nil {
t.Fatal(err)
}
f := os.NewFile(uintptr(s), "route")
c, err := SocketConn(f, &routeAddr{})
f.Close()
if err != nil {
t.Fatal(err)
}
defer c.Close()
const N = 3
var wg sync.WaitGroup
wg.Add(2 * N)
for i := 0; i < N; i++ {
go func(i int) {
defer wg.Done()
l := syscall.SizeofRtMsghdr + syscall.SizeofSockaddrInet4
if freebsd32o64 {
l += syscall.SizeofRtMetrics // see syscall/route_freebsd_32bit.go
}
b := make([]byte, l)
h := (*syscall.RtMsghdr)(unsafe.Pointer(&b[0]))
h.Msglen = uint16(len(b))
h.Version = syscall.RTM_VERSION
h.Type = syscall.RTM_GET
h.Addrs = syscall.RTA_DST
h.Pid = int32(os.Getpid())
h.Seq = int32(i)
p := (*syscall.RawSockaddrInet4)(unsafe.Pointer(&b[syscall.SizeofRtMsghdr]))
p.Len = syscall.SizeofSockaddrInet4
p.Family = syscall.AF_INET
p.Addr = [4]byte{127, 0, 0, 1}
if _, err := c.Write(b); err != nil {
t.Error(err)
return
}
}(i + 1)
}
for i := 0; i < N; i++ {
go func() {
defer wg.Done()
b := make([]byte, os.Getpagesize())
n, err := c.Read(b)
if err != nil {
t.Error(err)
return
}
if _, err := syscall.ParseRoutingMessage(b[:n]); err != nil {
t.Error(err)
return
}
}()
}
wg.Wait()
}
src/net/file_linux_test.go deleted 100644 → 0
View file @ 85938714
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package net
import (
"fmt"
"os"
"sync"
"syscall"
"testing"
"unsafe"
)
type netlinkAddr struct {
PID uint32
Groups uint32
}
func (a *netlinkAddr) Network() string { return "netlink" }
func (a *netlinkAddr) String() string { return fmt.Sprintf("%x:%x", a.PID, a.Groups) }
func (a *netlinkAddr) Addr(rsa []byte) Addr {
if len(rsa) < syscall.SizeofSockaddrNetlink {
return nil
}
var addr netlinkAddr
b := (*[unsafe.Sizeof(addr)]byte)(unsafe.Pointer(&addr))
copy(b[0:4], rsa[4:8])
copy(b[4:8], rsa[8:12])
return &addr
}
func (a *netlinkAddr) Raw(addr Addr) []byte {
if addr, ok := addr.(*netlinkAddr); ok {
rsa := &syscall.RawSockaddrNetlink{Family: syscall.AF_NETLINK, Pid: addr.PID, Groups: addr.Groups}
return (*[unsafe.Sizeof(*rsa)]byte)(unsafe.Pointer(rsa))[:]
}
return nil
}
func TestSocketPacketConn(t *testing.T) {
s, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_RAW, syscall.NETLINK_ROUTE)
if err != nil {
t.Fatal(err)
}
lsa := syscall.SockaddrNetlink{Family: syscall.AF_NETLINK}
if err := syscall.Bind(s, &lsa); err != nil {
syscall.Close(s)
t.Fatal(err)
}
f := os.NewFile(uintptr(s), "netlink")
c, err := SocketPacketConn(f, &netlinkAddr{})
f.Close()
if err != nil {
t.Fatal(err)
}
defer c.Close()
const N = 3
var wg sync.WaitGroup
wg.Add(2 * N)
dst := &netlinkAddr{PID: 0}
for i := 0; i < N; i++ {
go func() {
defer wg.Done()
l := syscall.NLMSG_HDRLEN + syscall.SizeofRtGenmsg
b := make([]byte, l)
*(*uint32)(unsafe.Pointer(&b[0:4][0])) = uint32(l)
*(*uint16)(unsafe.Pointer(&b[4:6][0])) = uint16(syscall.RTM_GETLINK)
*(*uint16)(unsafe.Pointer(&b[6:8][0])) = uint16(syscall.NLM_F_DUMP | syscall.NLM_F_REQUEST)
*(*uint32)(unsafe.Pointer(&b[8:12][0])) = uint32(1)
*(*uint32)(unsafe.Pointer(&b[12:16][0])) = uint32(0)
b[16] = byte(syscall.AF_UNSPEC)
if _, err := c.WriteTo(b, dst); err != nil {
t.Error(err)
return
}
}()
}
for i := 0; i < N; i++ {
go func() {
defer wg.Done()
b := make([]byte, os.Getpagesize())
n, _, err := c.ReadFrom(b)
if err != nil {
t.Error(err)
return
}
if _, err := syscall.ParseNetlinkMessage(b[:n]); err != nil {
t.Error(err)
return
}
}()
}
wg.Wait()
}
src/net/file_plan9.go
View file @ 2a0fc9e7
......@@ -135,11 +135,3 @@ func fileListener(f *os.File) (Listener, error) {
func filePacketConn(f *os.File) (PacketConn, error) {
return nil, syscall.EPLAN9
}
func socketConn(f *os.File, sa SocketAddr) (Conn, error) {
return nil, syscall.EPLAN9
}
func socketPacketConn(f *os.File, sa SocketAddr) (PacketConn, error) {
return nil, syscall.EPLAN9
}
src/net/file_stub.go
View file @ 2a0fc9e7
......@@ -14,5 +14,3 @@ import (
func fileConn(f *os.File) (Conn, error) { return nil, syscall.ENOPROTOOPT }
func fileListener(f *os.File) (Listener, error) { return nil, syscall.ENOPROTOOPT }
func filePacketConn(f *os.File) (PacketConn, error) { return nil, syscall.ENOPROTOOPT }
func socketConn(f *os.File, sa SocketAddr) (Conn, error) { return nil, syscall.ENOPROTOOPT }
func socketPacketConn(f *os.File, sa SocketAddr) (PacketConn, error) { return nil, syscall.ENOPROTOOPT }
src/net/file_unix.go
View file @ 2a0fc9e7
......@@ -7,7 +7,6 @@
package net
import (
"internal/syscall/unix"
"os"
"syscall"
)
......@@ -24,29 +23,13 @@ func dupSocket(f *os.File) (int, error) {
return s, nil
}
func newFileFD(f *os.File, sa SocketAddr) (*netFD, error) {
func newFileFD(f *os.File) (*netFD, error) {
s, err := dupSocket(f)
if err != nil {
return nil, err
}
var laddr, raddr Addr
var fd *netFD
if sa != nil {
lsa := make([]byte, syscall.SizeofSockaddrAny)
if err := unix.Getsockname(s, lsa); err != nil {
lsa = nil
}
rsa := make([]byte, syscall.SizeofSockaddrAny)
if err := unix.Getpeername(s, rsa); err != nil {
rsa = nil
}
laddr = sa.Addr(lsa)
raddr = sa.Addr(rsa)
fd, err = newFD(s, -1, -1, laddr.Network())
} else {
family := syscall.AF_UNSPEC
var sotype int
sotype, err = syscall.GetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_TYPE)
sotype, err := syscall.GetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_TYPE)
if err != nil {
closeFunc(s)
return nil, os.NewSyscallError("getsockopt", err)
......@@ -64,15 +47,14 @@ func newFileFD(f *os.File, sa SocketAddr) (*netFD, error) {
closeFunc(s)
return nil, syscall.EPROTONOSUPPORT
}
fd, err = newFD(s, family, sotype, "")
laddr = fd.addrFunc()(lsa)
raddr = fd.addrFunc()(rsa)
fd.net = laddr.Network()
}
fd, err := newFD(s, family, sotype, "")
if err != nil {
closeFunc(s)
return nil, err
}
laddr := fd.addrFunc()(lsa)
raddr := fd.addrFunc()(rsa)
fd.net = laddr.Network()
if err := fd.init(); err != nil {
fd.Close()
return nil, err
......@@ -82,7 +64,7 @@ func newFileFD(f *os.File, sa SocketAddr) (*netFD, error) {
}
func fileConn(f *os.File) (Conn, error) {
fd, err := newFileFD(f, nil)
fd, err := newFileFD(f)
if err != nil {
return nil, err
}
......@@ -101,7 +83,7 @@ func fileConn(f *os.File) (Conn, error) {
}
func fileListener(f *os.File) (Listener, error) {
fd, err := newFileFD(f, nil)
fd, err := newFileFD(f)
if err != nil {
return nil, err
}
......@@ -116,7 +98,7 @@ func fileListener(f *os.File) (Listener, error) {
}
func filePacketConn(f *os.File) (PacketConn, error) {
fd, err := newFileFD(f, nil)
fd, err := newFileFD(f)
if err != nil {
return nil, err
}
......@@ -131,55 +113,3 @@ func filePacketConn(f *os.File) (PacketConn, error) {
fd.Close()
return nil, syscall.EINVAL
}
func socketConn(f *os.File, sa SocketAddr) (Conn, error) {
fd, err := newFileFD(f, sa)
if err != nil {
return nil, err
}
return &socketFile{conn: conn{fd}, SocketAddr: sa}, nil
}
func socketPacketConn(f *os.File, sa SocketAddr) (PacketConn, error) {
fd, err := newFileFD(f, sa)
if err != nil {
return nil, err
}
return &socketFile{conn: conn{fd}, SocketAddr: sa}, nil
}
var (
_ Conn = &socketFile{}
_ PacketConn = &socketFile{}
)
// A socketFile is a placeholder that holds a user-specified socket
// descriptor and a profile of socket address encoding.
// It implements both Conn and PacketConn interfaces.
type socketFile struct {
conn
SocketAddr
}
func (c *socketFile) ReadFrom(b []byte) (int, Addr, error) {
if !c.ok() {
return 0, nil, syscall.EINVAL
}
from := make([]byte, syscall.SizeofSockaddrAny)
n, err := c.fd.recvFrom(b, 0, from)
if err != nil {
return n, nil, &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
}
return n, c.SocketAddr.Addr(from), nil
}
func (c *socketFile) WriteTo(b []byte, addr Addr) (int, error) {
if !c.ok() {
return 0, syscall.EINVAL
}
n, err := c.fd.sendTo(b, 0, c.SocketAddr.Raw(addr))
if err != nil {
return n, &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
}
return n, nil
}
src/net/file_windows.go
View file @ 2a0fc9e7
......@@ -23,13 +23,3 @@ func filePacketConn(f *os.File) (PacketConn, error) {
// TODO: Implement this
return nil, syscall.EWINDOWS
}
func socketConn(f *os.File, sa SocketAddr) (Conn, error) {
// TODO: Implement this
return nil, syscall.EWINDOWS
}
func socketPacketConn(f *os.File, sa SocketAddr) (PacketConn, error) {
// TODO: Implement this
return nil, syscall.EWINDOWS
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7