Unix-domain socket

Unix-domain socket code is akin to its network counterpart, and they share one readwrite() function. So I only list the caveats during creating Unix-domain socket connection:

(1) Like network socket, Unix-domain socket also supports connection & connection-less services; instead of using IP address + port, Unix-domain should bind to a filesystem pathname. Check unix_bind function: 

  1. /*
  2.  * unix_bind()
  3.  * Returns a unix socket bound to the given path
  4.  */
  5. int
  6. unix_bind(char *path, int flags)
  7. {
  8.     struct sockaddr_un s_un;
  9.     int s, save_errno;
  11.     /* Create unix domain socket. */
  12.     if ((s = socket(AF_UNIX, flags | (uflag ? SOCK_DGRAM : SOCK_STREAM),
  13.         0)) < 0)
  14.         return -1;
  16.     memset(&s_un, 0, sizeof(struct sockaddr_un));
  17.     s_un.sun_family = AF_UNIX;
  19.     if (strlcpy(s_un.sun_path, path, sizeof(s_un.sun_path)) >=
  20.         sizeof(s_un.sun_path)) {
  21.         close(s);
  22.         errno = ENAMETOOLONG;
  23.         return -1;
  24.     }
  26.     if (bind(s, (struct sockaddr *)&s_un, sizeof(s_un)) < 0) {
  27.         save_errno = errno;
  28.         close(s);
  29.         errno = save_errno;
  30.         return -1;
  31.     }
  33.     return s;
  34. }

(2) The biggest surprise is connection-less Unix-domain client also needs to be bound to a pathname: 

  1. ......
  2. /* Get name of temporary socket for unix datagram client */
  3. if ((family == AF_UNIX) && uflag && !lflag) {
  4.     if (sflag) {
  5.         unix_dg_tmp_socket = sflag;
  6.     } else {
  7.         strlcpy(unix_dg_tmp_socket_buf, "/tmp/nc.XXXXXXXXXX",
  8.             UNIX_DG_TMP_SOCKET_SIZE);
  9.         if (mktemp(unix_dg_tmp_socket_buf) == NULL)
  10.             err(1, "mktemp");
  11.         unix_dg_tmp_socket = unix_dg_tmp_socket_buf;
  12.     }
  13. }
  14. ......

sflag will be set with -s source option: 

  1. ......
  2. char   *sflag;                    /* Source Address */
  3. ......

So if user doesn’t specify a pathname for client, the client will create a temporary socket.

Therefore, the connection-less client also needs to call unix_bind() before connecting server: 

  1. /*
  2.  * unix_connect()
  3.  * Returns a socket connected to a local unix socket. Returns -1 on failure.
  4.  */
  5. int
  6. unix_connect(char *path)
  7. {
  8.     struct sockaddr_un s_un;
  9.     int s, save_errno;
  11.     if (uflag) {
  12.         if ((s = unix_bind(unix_dg_tmp_socket, SOCK_CLOEXEC)) < 0)
  13.             return -1;
  14.     } else {
  15.         if ((s = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)) < 0)
  16.             return -1;
  17.     }
  19.     ......
  20.     if (connect(s, (struct sockaddr *)&s_un, sizeof(s_un)) < 0) {
  21.         ......
  22.     }
  23.     return s;
  25. }

For the connection-less server part, there is also one more step needed: 

  1. ......
  2. if (family == AF_UNIX && uflag) {
  3.     if (connect(s, NULL, 0) < 0)
  4.         err(1, "connect");
  5. }
  6. ......