Unix Domain Socket: Using datagram communication between one server process and several client processes

Question

I would like to establish an IPC connection between several processes on Linux. I have never used UNIX sockets before, and thus I don't know if this is the correct approach to this problem.

One process receives data (unformated, binary) and shall distribute this data via a local AF_UNIX socket using the datagram protocol (i.e. similar to UDP with AF_INET). The data sent from this process to a local Unix socket shall be received by multiple clients listening on the same socket. The number of receivers may vary.

To achieve this the following code is used to create a socket and send data to it (the server process):

struct sockaddr_un ipcFile; memset(&ipcFile, 0, sizeof(ipcFile)); ipcFile.sun_family = AF_UNIX; strcpy(ipcFile.sun_path, filename.c_str());  int socket = socket(AF_UNIX, SOCK_DGRAM, 0); bind(socket, (struct sockaddr *) &ipcFile, sizeof(ipcFile)); ... // buf contains the data, buflen contains the number of bytes int bytes = write(socket, buf, buflen); ... close(socket); unlink(ipcFile.sun_path); 

This write returns -1 with errno reporting ENOTCONN ("Transport endpoint is not connected"). I guess this is because no receiving process is currently listening to this local socket, correct?

Then, I tried to create a client who connects to this socket.

struct sockaddr_un ipcFile; memset(&ipcFile, 0, sizeof(ipcFile)); ipcFile.sun_family = AF_UNIX; strcpy(ipcFile.sun_path, filename.c_str());  int socket = socket(AF_UNIX, SOCK_DGRAM, 0); bind(socket, (struct sockaddr *) &ipcFile, sizeof(ipcFile)); ... char buf[1024]; int bytes = read(socket, buf, sizeof(buf)); ... close(socket); 

Here, the bind fails ("Address already in use"). So, do I need to set some socket options, or is this generally the wrong approach?

Thanks in advance for any comments / solutions!

Answer 1

There's a trick to using Unix Domain Socket with datagram configuration. Unlike stream sockets (tcp or unix domain socket), datagram sockets need endpoints defined for both the server AND the client. When one establishes a connection in stream sockets, an endpoint for the client is implicitly created by the operating system. Whether this corresponds to an ephemeral TCP/UDP port, or a temporary inode for the unix domain, the endpoint for the client is created for you. Thats why you don't normally need to issue a call to bind() for stream sockets in the client.

The reason you're seeing "Address already in use" is because you're telling the client to bind to the same address as the server. bind() is about asserting external identity. Two sockets can't normally have the same name.

With datagram sockets, specifically unix domain datagram sockets, the client has to bind() to its own endpoint, then connect() to the server's endpoint. Here is your client code, slightly modified, with some other goodies thrown in:

char * server_filename = "/tmp/socket-server"; char * client_filename = "/tmp/socket-client";  struct sockaddr_un server_addr; struct sockaddr_un client_addr; memset(&server_addr, 0, sizeof(server_addr)); server_addr.sun_family = AF_UNIX; strncpy(server_addr.sun_path, server_filename, 104); // XXX: should be limited to about 104 characters, system dependent  memset(&client_addr, 0, sizeof(client_addr)); client_addr.sun_family = AF_UNIX; strncpy(client_addr.sun_path, client_filename, 104);  // get socket int sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);  // bind client to client_filename bind(sockfd, (struct sockaddr *) &client_addr, sizeof(client_addr));  // connect client to server_filename connect(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr));  ... char buf[1024]; int bytes = read(sockfd, buf, sizeof(buf)); ... close(sockfd); 

At this point your socket should be fully setup. I think theoretically you can use read()/write(), but usually I'd use send()/recv() for datagram sockets.

Normally you'll want to check error after each of these calls and issue a perror() afterwards. It will greatly aid you when things go wrong. In general, use a pattern like this:

if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {     perror("socket failed"); } 

This goes for pretty much any C system calls.

The best reference for this is Steven's "Unix Network Programming". In the 3rd edition, section 15.4, pages 415-419 show some examples and lists many of the caveats.

By the way, in reference to

I guess this is because no receiving process is currently listening to this local socket, correct?

I think you're right about the ENOTCONN error from write() in the server. A UDP socket would normally not complain because it has no facility to know if the client process is listening. However, unix domain datagram sockets are different. In fact, the write() will actually block if the client's receive buffer is full rather than drop the packet. This makes unix domain datagram sockets much superior to UDP for IPC because UDP will most certainly drop packets when under load, even on localhost. On the other hand, it means you have to be careful with fast writers and slow readers.

Answer 2

The proximate cause of your error is that write() doesn't know where you want to send the data to. bind() sets the name of your side of the socket - ie. where the data is coming from. To set the destination side of the socket, you can either use connect(); or you can use sendto() instead of write().

The other error ("Address already in use") is because only one process can bind() to an address.

You will need to change your approach to take this into account. Your server will need to listen on a well-known address, set with bind(). Your clients will need to send a message to the server at this address to register their interest in receiving datagrams. The server will recieve the registration messages from clients using recvfrom(), and record the address used by each client. When it wants to send a message, it will have to loop over all the clients it knows about, using sendto() to send the message to each one in turn.

Alternatively, you could use local IP multicast instead of UNIX domain sockets (UNIX domain sockets don't support multicast).