Dish socket should bind on multicast group IP instead of INADDR_ANY

[NoAnyLove]

Issue description

For dish socket with UDP multicast, if it binds on INADDR_ANY (see code here), it will receive messages from other multicast IPs on the same port.

Given an example, we have 4 apps,

• R1 multicast on udp://224.1.1.1:9000 with group events/notification
• R2 multicast on udp://224.1.1.2:9000 with group events/notification
• D1 receives udp://224.1.1.1:9000 with group events/notification
• D2 receives udp://224.1.1.2:9000 with group events/notification

Note: D1 and D2 are on the same box

We expect D1 only receives messages from R1, and D2 only from R2. But in fact, D1 will receive messages from both R1 and R2, so does D2.

This prevents us to segregate the traffic with the same port, as mentioned in issue lcm-proj/lcm#186.

Can we change the bind to the multicast IP, which prevents us from receiving messages from other multicast addresses?

Quote from UNIX Network Programming, Volume 1,

Recall that we could just bind the wildcard IP address and port 8888, but binding the multicast address prevents the socket from receiving any other datagrams that might arrive destined for port 8888.

I'm more than happy to submit a PR if you agree with this change.

Reference:

• bind()ing to the multicast group IP instead of INADDR_ANY in the udpm driver lcm-proj/lcm#186
• https://stackoverflow.com/a/10739443
• UNIX Network Programming: The sockets networking API, Volume 1, page 576

Environment

• libzmq version (commit hash if unreleased): v4.3.4
• OS: Linux

Minimal test code / Steps to reproduce the issue

N/A

[ljluestc]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>

#define MULTICAST_GROUP_1 "224.1.1.1"
#define MULTICAST_GROUP_2 "224.1.1.2"
#define PORT 9000
#define BUFSIZE 1024

void receive_multicast(const char* multicast_group) {
    int sock;
    struct sockaddr_in local_addr;
    char buffer[BUFSIZE];
    int n;

    // Create a socket
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // Set up the local address structure
    memset(&local_addr, 0, sizeof(local_addr));
    local_addr.sin_family = AF_INET;
    local_addr.sin_port = htons(PORT);
    // Bind to the specific multicast address
    inet_pton(AF_INET, multicast_group, &local_addr.sin_addr);

    // Bind the socket
    if (bind(sock, (struct sockaddr*)&local_addr, sizeof(local_addr)) < 0) {
        perror("bind");
        close(sock);
        exit(EXIT_FAILURE);
    }

    // Join the multicast group
    struct ip_mreq mreq;
    inet_pton(AF_INET, multicast_group, &mreq.imr_multiaddr);
    mreq.imr_interface.s_addr = htonl(INADDR_ANY); // Local interface
    if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
        perror("setsockopt");
        close(sock);
        exit(EXIT_FAILURE);
    }

    printf("Receiving messages on multicast group: %s\n", multicast_group);

    while (1) {
        n = recv(sock, buffer, BUFSIZE, 0);
        if (n < 0) {
            perror("recv");
            close(sock);
            exit(EXIT_FAILURE);
        }
        buffer[n] = '\0'; // Null-terminate the received data
        printf("Received: %s\n", buffer);
    }

    close(sock);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <multicast_group>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    receive_multicast(argv[1]);
    return 0;
}

[NoAnyLove]

Let me add a simple example and code to reproduce the issue.

Steps to reproduce,

1. Compile the radio.c and dish.c below
2. Open a terminal, run ./dish udp://224.1.1.1:9000 event
3. Open another terminal, run ./dish udp://224.2.2.2:9000 event
4. Open yet another terminal, run ./radio R1 udp://224.1.1.1:9000 event

Expected behavior: only the 1st dish process will receive messages

Actual behavior: both dish processes will receive messages, as shown in the screenshot.

---

radio.c:

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <zmq.h>

int main(int argc, char *argv[]) {
  /*

  Usage: ./radio [name] [endpoint] [group]

  */
  assert(argc == 4);
  char *name = argv[1];
  char *endpoint = argv[2];
  char *group = argv[3];
  printf("%s publish to %s with grou %s\n", name, endpoint, group);

  void *context = zmq_ctx_new();
  void *radio = zmq_socket(context, ZMQ_RADIO);
  int rc = zmq_connect(radio, endpoint);
  assert(rc == 0);

  char buffer[64];
  int tick = 0;
  while (1) {
    sprintf(buffer, "radio from %s tick %d", name, tick++);
    printf(">> %s\n", buffer);
    zmq_msg_t msg;
    rc = zmq_msg_init_buffer(&msg, buffer, strlen(buffer) + 1);
    assert(rc == 0);

    rc = zmq_msg_set_group(&msg, group);
    assert(rc == 0);

    rc = zmq_msg_send(&msg, radio, 0);
    assert(rc > 0);

    zmq_msg_close(&msg);
    sleep(1);
  }
  return 0;
}

dish.c:

#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <zmq.h>

int main(int argc, char *argv[]) {
  /*

  Usage: ./dish [endpoint] [group]

  */
  assert(argc == 3);
  char *endpoint = argv[1];
  char *group = argv[2];
  printf("subscribe to %s with group %s\n", endpoint, group);

  void *context = zmq_ctx_new();
  void *dish = zmq_socket(context, ZMQ_DISH);
  int rc = zmq_bind(dish, endpoint);
  assert(rc == 0);

  rc = zmq_join(dish, group);
  assert(rc == 0);

  char buffer[64];
  while (1) {
    rc = zmq_recv(dish, buffer, sizeof(buffer), 0);
    printf("<< %s\n", buffer);
  }
  return 0;
}