What version of Go are you using (go version)?

go version go1.9 linux/amd64

Does this issue reproduce with the latest release?

Yes

What operating system and processor architecture are you using (go env)?

GOOS="linux" GOARCH="amd64"
But the issue seems to be present on every linux system (also tested on armv7)

What did you do?

I have a C server process which creates an unix domain socket with the following code:

/* beginning of function omitted */
struct sockaddr_un addr_un;
memset(&addr_un, 0, sizeof(addr_un));
snprintf(addr_un.sun_path, sizeof(addr_un.sun_path), "@something");
addr_un.sun_path[0] = '\0';
bind(sockfd, (struct sockaddr *)&addr_un, sizeof(addr_un));
/* end of function omitted */

By calling the bind() function with the full sizeof(addr_un) as the size, it creates an abstract unix socket whose name is actually 108 bytes long (one starting null byte, the socket name, and more null bytes as padding at the end). While not a good practice, that kind of code does exists in the wild.

I tried to make net.Dial() connection to this server from a go program

What did you expect to see?

Obviously, net.Dial("unix", "@something") fails. This is expected behaviour because the abstract unix socket name length (10 in this case) does not match the server size (108), but I expected the following code to work:

package main

import "net"
import "fmt"

func dialFillZero(network, name string) (net.Conn, error) {
    raw := []byte(name)
    addr_b := make([]byte, 108)
    for i, c := range raw {
        addr_b[i] = c
    }
    addr := string(addr_b)
    return net.Dial(network, addr)
}

func main() {
    conn, err := dialFillZero("unix", "@something")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("OK")
}

What did you see instead?

This code also fails because the func (sa *SockaddrUnix) sockaddr() function in src/syscall/syscall_linux.go returns an EINVAL error if the sockaddr name is greater or equal to the length of the sockaddr raw path (declared as 108 for linux).

This limit makes sense for non-abstract unix domain sockets, as the path have to be a null terminated string, but as the abstract unix domain sockets does not have this limitation, it artificially forbids connection to any socket with len(name) == len(sa.raw.Path)

I made the following change to my go distribution, which seems to solve the problem without creating any other visible issues (all tests are still OK):

diff --git a/src/syscall/syscall_linux.go b/src/syscall/syscall_linux.go
index 3c7d378..1ee8979 100644
--- a/src/syscall/syscall_linux.go
+++ b/src/syscall/syscall_linux.go
@@ -295,7 +295,10 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
        name := sa.Name
        n := len(name)
-       if n >= len(sa.raw.Path) {
+       if n > len(sa.raw.Path) {
+               return nil, 0, EINVAL
+       }
+       if n == len(sa.raw.Path) && int8(name[0]) != '@' {
                return nil, 0, EINVAL
        }
        sa.raw.Family = AF_UNIX

If the patch seams reasonable, I can submit it properly to Gerrit.