Swift multicast multiple connection to the same port

I have two applications installed on the same device and they trying to connect to a multicast group the first application has a succeed connection the second one has error : listener failed with error Group entered state failed(POSIXErrorCode(rawValue: 48): Address already in use) I thought that allowLocalEndpointReuse allows several clients to connect to the same port

but it doesn't work.

    let port = NWEndpoint.Port(portUdp) ?? NWEndpoint.Port(5353)
    let host = NWEndpoint.Host(urlUdp)
    guard let multicast = try? NWMulticastGroup(for:
     [ .hostPort(host: host, port: port) ])
     else {
         stateMultiCast = "Error with url and port"
     return
     }
    
    let parameters = NWParameters.udp
    parameters.allowLocalEndpointReuse = true
    parameters.allowLocalEndpointReuse
    let group = NWConnectionGroup(with: multicast, using: parameters)

    
    group.setReceiveHandler(maximumMessageSize: 16384, rejectOversizedMessages: true) 
  { (message, content, isComplete) in
        ....
    }
    
    group.stateUpdateHandler = { (newState) in
        print("Group entered state \(String(describing: newState))")
    }
    group.start(queue: .main)

How can i use the same port for several application so this application can receive all the same message sent by udp server ?

Thank you for your help

I found a solution different of multicast group that apple recommand :

func setupMulticastSocket(urlUdp : String, portUdp : String) -> Int32 {

    let multicastAddress = urlUdp
    let multicastPort: UInt16 = UInt16(portUdp) ?? 0
    // Create a UDP socket
    let socketFileDescriptor = socket(AF_INET, SOCK_DGRAM, 0)
    guard socketFileDescriptor != -1 else {
        print("Failed to create socket")
        exit(1)
    }
    // Enable multicast loopback
    var loop: UInt32 = 1
    guard setsockopt(socketFileDescriptor, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, socklen_t(MemoryLayout<UInt32>.size)) != -1 else {
        print("Failed to enable multicast loopback")
        exit(1)
    }
    
    var reuseFlag: Int32 = 1
    let reuseOption = withUnsafePointer(to: &reuseFlag) { ptr in
        return UnsafeRawPointer(ptr).assumingMemoryBound(to: Int32.self)
    }
    
    if setsockopt(socketFileDescriptor, SOL_SOCKET, SO_REUSEPORT, reuseOption, socklen_t(MemoryLayout<Int32>.size)) == -1 {
        print("Error setting SO_REUSEPORT: \(String(describing: strerror(errno)))")
        return -1
    }
    
    if setsockopt(socketFileDescriptor, SOL_SOCKET, SO_REUSEADDR, reuseOption, socklen_t(MemoryLayout<Int32>.size)) == -1 {
        print("Error setting SO_REUSEADDR: \(String(describing: strerror(errno)))")
        return -1
    }

    // Bind the socket to a specific address and port
    var socketAddress = sockaddr_in()
    socketAddress.sin_len = __uint8_t(MemoryLayout<sockaddr_in>.size)
    socketAddress.sin_family = sa_family_t(AF_INET)
    socketAddress.sin_port = multicastPort.bigEndian
    socketAddress.sin_addr.s_addr = CFSwapInt32HostToBig(INADDR_ANY)

    withUnsafePointer(to: &socketAddress) { pointer in
        let bindResult = pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { addrPointer in
            bind(socketFileDescriptor, addrPointer, socklen_t(MemoryLayout<sockaddr_in>.size))
        }
        guard bindResult != -1 else {
            print("Failed to bind socket")
            exit(1)
        }
    }

    // Join the multicast group
    var multicastRequest = ip_mreq()
    multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastAddress)
    multicastRequest.imr_interface.s_addr = CFSwapInt32HostToBig(INADDR_ANY)

    guard setsockopt(socketFileDescriptor, IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicastRequest, socklen_t(MemoryLayout<ip_mreq>.size)) != -1 else {
        print("Failed to join multicast group")
        exit(1)
    }




    
    return socketFileDescriptor
}

I call the function like that :

           let socketFD = setupMulticastSocket(urlUdp: urlUdp, portUdp: portUdp)
    if socketFD != -1 {
        print("Multicast socket set up successfully.")
    } else {
        print("Failed to set up multicast socket.")
    }
    let bufferSize = 1024
       var buffer = [UInt8](repeating: 0, count: bufferSize)
      // Reading message received
    while true {
        let bytesRead = recv(socketFD, &buffer, buffer.count, 0)
        if bytesRead > 0 {
            let messageData = Data(bytes: buffer, count: bytesRead)
            let hexString = messageData.reduce("") { $0 + String(format: "%02x", $1) }
            let decodedData = Data(hexString: hexString)!
            if let decodedData = Data(hexString: hexString){
                newDataRsaReceived(decodedData ?? Data())
            }
        }
    }

With this solution multiple client (application) can connect to the same port