Can not connect to Linux "abstract" unix socket

While I was posting this question, and re-reading unix(7) man page, this wording caught my attention:

an abstract socket address is distinguished by the fact that sun_path[0] is a null byte (’\0’). All of the remaining bytes in sun_path define the "name" of the socket

So, if I bzero'ed the sun_path before filling in my name into it, things started to work. I figured that's not necessarily straight-forward. Additionally, as rightfully pointed out by @davmac and @StoneThrow, the number of those "remaining bytes" can be reduced by specifying only enough length of the socket address structure to cover the bytes you want to consider as your address. One way to do that is to use SUN_LEN macro, however, the first byte of the sun_path will have to be set to !0, as SUN_LEN uses strlen.

elaboration

If sun_path[0] is \0, The kernel uses the entirety of the remainder of sun_path as the name of the socket, whether it's \0-terminated or not, so all of that remainder counts. In my original code I would zero the first byte, and then strcpy() the socket name into the sun_path at position 1. Whatever gibberish that was in sun_path when the structure was allocated (especially likely to contain gibberish since it's allocated on the stack), and was included in the length of the socket structure (as passed to the syscalls), counted as the name of the socket, and was different in bind() and connect().

IMHO, strace should fix the way it displays abstract socket names, and display all the sun_path bytes from 1 to whatever the structure length that was supplied, if sun_path[0] is 0

The key of making sockets in abstract namespace work is providing the proper length to 'bind' and 'connect' commands. To avoid setting '\0' at the end of the address in sockaddr_un it should be copied with strncpy or alike.

It is already explained in Pawel's answer so I'm just going to give an example.

Server:

int main(int argc, char** argv){  //to remove warning for unused variables.  int dummy = argc;  dummy = (int)argv;  int fdServer = 0;  int fdClient = 0;  int iErr     = 0;  int n = 0;  socklen_t addr_len = 0;  char buff[1024];  char resp[1024];  const char* const pcSocketName = "/tmp/test";  struct sockaddr_un serv_addr;   //set the structure with 'x' instead of 0 so that we're able   //to see the full socket name by 'cat /proc/net/unix'  //you may try playing with addr_len and see the actual name   //reported in /proc/net/unix  memset(&serv_addr, 'x', sizeof(serv_addr));  serv_addr.sun_family = AF_UNIX;  serv_addr.sun_path[0] = '\0';  //sizeof(pcSocketName) returns the size of 'char*' this is why I use strlen  strncpy(serv_addr.sun_path+1, pcSocketName, strlen(pcSocketName));  fdServer = socket(PF_UNIX, SOCK_STREAM, 0);  if(-1 == fdServer) {    printf("socket() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  iErr = bind(fdServer, (struct sockaddr*)&serv_addr, offsetof(struct sockaddr_un, sun_path) + 1/*\0*/ + strlen(pcSocketName));  if(0 != iErr) {    printf("bind() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  iErr = listen(fdServer, 1);  if(0 != iErr) {    printf("listen() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  addr_len = sizeof(pcSocketName);  while(1) {    fdClient = accept(fdServer, (struct sockaddr*) &serv_addr, &addr_len);    if(0 >= fdClient) {      printf("accept() failed: [%d][%s]\n", errno, strerror(errno));      return(-1);    }    memset(resp, 0, sizeof(resp));    memset(buff, 0, sizeof(buff));    n = recv(fdClient, buff, sizeof(buff), 0);    if(0 > n) {      printf("recv() failed: [%d][%s]\n", errno, strerror(errno));      return(-1);    }    printf("[client]: %s\n", buff);    sprintf(resp, "echo >> %s", buff);    n = send(fdClient, resp, sizeof(resp), 0);    if(0 > n) {      printf("send() failed: [%d][%s]\n", errno, strerror(errno));      return(-1);    }    printf("[server]: %s\n", resp);  }  close(fdServer);  return(0);}

Client:

int main(int argc, char** argv) {  //to remove warning for unused variables.  int dummy = argc;  dummy = (int)argv;  int fdClient = 0;  struct sockaddr_un serv_addr;  int iErr     = 0;  const char* const pcSocketName = "/tmp/test";  char buff[1024];  memset(&serv_addr, 0, sizeof(serv_addr));  serv_addr.sun_family = AF_UNIX;  serv_addr.sun_path[0] = '\0';  strncpy(serv_addr.sun_path+1, pcSocketName, strlen(pcSocketName));  fdClient = socket(PF_UNIX, SOCK_STREAM, 0);  if(-1 == fdClient) {    printf("socket() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  iErr = connect(fdClient, (struct sockaddr*) &serv_addr, offsetof(struct sockaddr_un, sun_path) + 1/*\0*/ + strlen(pcSocketName));  if(0 != iErr) {    printf("connect() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  memset(buff, 0, sizeof(buff));  sprintf(buff, "Hello from client!");  printf("[client]: %s\n", buff);  iErr = send(fdClient, buff, sizeof(buff), 0);  if(0 > iErr){    printf("write() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  iErr = recv(fdClient, buff, sizeof(buff), 0);  if(0 > iErr){    printf("read() failed: [%d][%s]\n", errno, strerror(errno));    return(-1);  }  printf("[server]: %s\n", buff);  return(0);}

In my case, replacing strncpy() to snprintf() and increasing copy size to UNIX_PATH_MAX solved the problem.

Original

strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(SOCKET_PATH));

Modified

snprintf(server_addr.sun_path, UNIX_PATH_MAX, SOCKET_PATH);

Hope it helps.