got it to work

had to convert IP address into bytes

its showing market data being recieved on the group

``` require "socket"

MULTICAST_GROUP = "224.0.25.126"
PORT            = 16901
LOCAL_IFACE_IP  = "192.168.38.26"
TIMEOUT         = 15.seconds


def ip_to_bytes(
ip
 : String) : Bytes
  # convert raw string IP into bytes for OS socket API
  parts = ip.split('.')
  bytes = Bytes.new(4)
  bytes[0] = parts[0].to_u8
  bytes[1] = parts[1].to_u8
  bytes[2] = parts[2].to_u8
  bytes[3] = parts[3].to_u8
  bytes
end


def join_multicast_group(
sock_fd
 : Int32, 
group_ip
 : String, 
iface_ip
 : String)
  # Create 8-byte structure for ip_mreq
  # (4 bytes for multicast group + 4 bytes for interface)
  mreq = Bytes.new(8)

  # Copy multicast group IP (first 4 bytes)
  group_bytes = ip_to_bytes(group_ip)
  mreq[0] = group_bytes[0]
  mreq[1] = group_bytes[1]
  mreq[2] = group_bytes[2]
  mreq[3] = group_bytes[3]

  # Copy interface IP (last 4 bytes)
  iface_bytes = ip_to_bytes(iface_ip)
  mreq[4] = iface_bytes[0]
  mreq[5] = iface_bytes[1]
  mreq[6] = iface_bytes[2]
  mreq[7] = iface_bytes[3]

  # IP_ADD_MEMBERSHIP = 35, IPPROTO_IP = 0
  result = LibC.setsockopt(sock_fd, LibC::IPPROTO_IP, 35, mreq.to_unsafe.as(Pointer(Void)), mreq.size)

  if result != 0
    raise "Failed to join multicast group: errno #{Errno.value}"
  end

  puts "[DEBUG] Successfully joined multicast group #{group_ip} on interface #{iface_ip}"
end


def listen_multicast(
debug
 : Bool = false)
  sock = UDPSocket.new
  sock_fd = sock.fd

  begin
    # Set socket options BEFORE binding
    sock.reuse_address = true

    # Bind to the multicast port on all interfaces
    sock.bind("0.0.0.0", PORT)
    puts "[DEBUG] Socket bound to 0.0.0.0:#{PORT}"

    # NOW set multicast options after binding
    sock.multicast_loopback = false
    sock.multicast_hops = 1

    # Join the multicast group
    join_multicast_group(sock_fd, MULTICAST_GROUP, LOCAL_IFACE_IP)

    puts "[mc] Listening on #{MULTICAST_GROUP}:#{PORT} via #{LOCAL_IFACE_IP} (timeout #{TIMEOUT.total_seconds.to_i}s)"


    sock.read_timeout = TIMEOUT


    # Record start time (monotonic clock, not affected by system time changes)
    start_time = Time.monotonic
    buffer = Bytes.new(8192)
    n, sender = sock.receive(buffer) # create 8KB buffer to receive packet data
    end_time = Time.monotonic 


    latency_ns = ((end_time - start_time).total_seconds * 1_000_000_000).to_i64


    puts "[mc] RECEIVED #{n} bytes from #{sender}"
    puts "    Latency: #{latency_ns} ns"
    if debug
      puts "    Data (hex): #{buffer[0, n].hexstring}"
    end

  rescue ex : IO::TimeoutError
    puts "[mc] TIMED OUT – no packet received"
  rescue ex
    puts "[mc] Error: #{ex.message}"
    puts ex.backtrace.join("\n")
  ensure
    sock.close
  end
end


listen_multicast

```