Init

network/udp/listen_unix.go

@@ -4,64 +4,64 @@
 package udp
 
 import (
+	"context"
 	"fmt"
 	"net"
+	"syscall"
 
 	"golang.org/x/sys/unix"
 )
 
+// listenUDP crée workerCount sockets UDP distinctes avec SO_REUSEPORT activé.
+// Chaque socket écoute sur bindAddr et sera utilisée par un worker.
 func listenUDP(bindAddr string, workerCount int) ([]*net.UDPConn, error) {
-	addr, err := net.ResolveUDPAddr("udp", bindAddr)
+	if workerCount <= 0 {
-	if err != nil {
+		workerCount = 1
-		return nil, fmt.Errorf("cannot resolve address: %w", err)
 	}
 
-	conns := make([]*net.UDPConn, 0, workerCount)
+	var conns []*net.UDPConn
 
-	for i := 0; i < workerCount; i++ {
+	closeAll := func() {
-		conn, err := net.ListenUDP("udp", addr)
-		if err != nil {
-			// En cas d’erreur, on ferme ce qu’on a ouvert.
 		for _, c := range conns {
 			_ = c.Close()
 		}
-			return nil, fmt.Errorf("cannot listen on address (worker %d): %w", i, err)
-		}
-
-		rawConn, err := conn.SyscallConn()
-		if err != nil {
-			_ = conn.Close()
-			for _, c := range conns {
-				_ = c.Close()
-			}
-			return nil, fmt.Errorf("cannot get raw connection (worker %d): %w", i, err)
 	}
 
+	lc := net.ListenConfig{
+		Control: func(network, address string, c syscall.RawConn) error {
 			var sockErr error
-		err = rawConn.Control(func(fd uintptr) {
+			err := c.Control(func(fd uintptr) {
-			sockErr = unix.SetsockoptInt(
+				if err := unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
-				int(fd),
+					sockErr = fmt.Errorf("set SO_REUSEADDR: %w", err)
-				unix.SOL_SOCKET,
+					return
-				unix.SO_REUSEPORT,
+				}
-				1,
+				if err := unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1); err != nil {
-			)
+					sockErr = fmt.Errorf("set SO_REUSEPORT: %w", err)
+					return
+				}
 			})
 			if err != nil {
-			_ = conn.Close()
+				return err
-			for _, c := range conns {
-				_ = c.Close()
 			}
-			return nil, fmt.Errorf("control error (worker %d): %w", i, err)
+			return sockErr
-		}
+		},
-		if sockErr != nil {
-			_ = conn.Close()
-			for _, c := range conns {
-				_ = c.Close()
-			}
-			return nil, fmt.Errorf("cannot set SO_REUSEPORT (worker %d): %w", i, sockErr)
 	}
 
-		conns = append(conns, conn)
+	for i := 0; i < workerCount; i++ {
+		pc, err := lc.ListenPacket(context.Background(), "udp", bindAddr)
+		if err != nil {
+			closeAll()
+			return nil, fmt.Errorf("worker %d: listen failed on %q: %w", i, bindAddr, err)
+		}
+
+		udpConn, ok := pc.(*net.UDPConn)
+		if !ok {
+			pc.Close()
+			closeAll()
+			return nil, fmt.Errorf("worker %d: PacketConn is not *net.UDPConn", i)
+		}
+
+		conns = append(conns, udpConn)
 	}
 
 	return conns, nil

network/udp/listen_windows.go

@@ -8,17 +8,18 @@ import (
 	"net"
 )
 
+// listenUDP sur Windows crée une seule socket UDP qui sera partagée par tous
+// les workers (tous les workerID utiliseront conns[0]).
 func listenUDP(bindAddr string, workerCount int) ([]*net.UDPConn, error) {
 	addr, err := net.ResolveUDPAddr("udp", bindAddr)
 	if err != nil {
-		return nil, fmt.Errorf("cannot resolve address: %w", err)
+		return nil, fmt.Errorf("cannot resolve address %q: %w", bindAddr, err)
 	}
 
 	conn, err := net.ListenUDP("udp", addr)
 	if err != nil {
-		return nil, fmt.Errorf("cannot listen on address: %w", err)
+		return nil, fmt.Errorf("cannot listen on address %q: %w", bindAddr, err)
 	}
 
-	// Un seul conn partagé par tous les workers.
 	return []*net.UDPConn{conn}, nil
 }

network/udp/routing_table.go

@@ -7,49 +7,61 @@ import (
 	mapset "github.com/deckarep/golang-set/v2"
 )
 
+// ... existing code ...
+
 type RoutingTable struct {
 	mu     sync.RWMutex
 	routes map[string]mapset.Set[*net.UDPAddr]
 }
 
+// NewRoutingTable crée une table vide.
 func NewRoutingTable() *RoutingTable {
 	return &RoutingTable{
 		routes: make(map[string]mapset.Set[*net.UDPAddr]),
 	}
 }
 
-func (rt *RoutingTable) AddClient(channelID string, addr *net.UDPAddr) {
+// Add enregistre un client dans un channel.
+func (rt *RoutingTable) Add(channel string, addr *net.UDPAddr) {
 	rt.mu.Lock()
 	defer rt.mu.Unlock()
 
-	if rt.routes[channelID] == nil {
+	set, ok := rt.routes[channel]
-		rt.routes[channelID] = mapset.NewSet[*net.UDPAddr]()
+	if !ok {
+		set = mapset.NewSet[*net.UDPAddr]()
+		rt.routes[channel] = set
 	}
-	rt.routes[channelID].Add(addr)
+	set.Add(addr)
 }
 
-func (rt *RoutingTable) RemoveClient(channelID string, addr *net.UDPAddr) {
+// Remove supprime un client d'un channel.
+func (rt *RoutingTable) Remove(channel string, addr *net.UDPAddr) {
 	rt.mu.Lock()
 	defer rt.mu.Unlock()
 
-	if clients, exists := rt.routes[channelID]; exists {
+	set, ok := rt.routes[channel]
-		clients.Remove(addr)
+	if !ok {
-		if clients.Cardinality() == 0 {
+		return
-			delete(rt.routes, channelID)
 	}
+	set.Remove(addr)
+	if set.Cardinality() == 0 {
+		delete(rt.routes, channel)
 	}
 }
 
-// GetClients returns the clients connected to the given channelID
+// GetAddrs renvoie une copie de la liste des clients d'un channel.
-// don't modify the returned set!
+func (rt *RoutingTable) GetAddrs(channel string) []*net.UDPAddr {
-func (rt *RoutingTable) GetClients(channelID string) mapset.Set[*net.UDPAddr] {
 	rt.mu.RLock()
 	defer rt.mu.RUnlock()
 
-	clients, exists := rt.routes[channelID]
+	set, ok := rt.routes[channel]
-	if !exists {
+	if !ok {
 		return nil
 	}
 
-	return clients
+	addrs := make([]*net.UDPAddr, 0, set.Cardinality())
+	for addr := range set.Iter() {
+		addrs = append(addrs, addr)
+	}
+	return addrs
 }

network/udp/server.go

@@ -23,12 +23,21 @@ func NewServer(bindAddr string) *Server {
 
 	return &Server{
 		bindAddr:     bindAddr,
+		routingTable: NewRoutingTable(),
 		ctx:          ctx,
 		cancel:       cancel,
 	}
 }
 
+func (s *Server) Router() *RoutingTable {
+	return s.routingTable
+}
+
 func (s *Server) Run() error {
+	if s.bindAddr == "" {
+		return fmt.Errorf("bind address is empty")
+	}
+
 	workerCount := runtime.NumCPU()
 
 	conns, err := listenUDP(s.bindAddr, workerCount)
@@ -41,78 +50,102 @@ func (s *Server) Run() error {
 	s.conns = conns
 
 	for _, conn := range s.conns {
-		conn.SetReadBuffer(8 * 1024 * 1024)
+		_ = conn.SetReadBuffer(8 * 1024 * 1024)
-		conn.SetWriteBuffer(8 * 1024 * 1024)
+		_ = conn.SetWriteBuffer(8 * 1024 * 1024)
 	}
 
-	fmt.Println("Listening on", s.bindAddr)
+	fmt.Println("[udp] listening on", s.bindAddr, "with", len(s.conns), "worker(s)")
 
-	for i, conn := range s.conns {
+	for workerID, conn := range s.conns {
 		s.wg.Add(1)
-		go s.workerLoop(i, conn)
+		go s.workerLoop(workerID, conn)
 	}
 
 	return nil
 }
 
-func (s *Server) sendTo(data []byte, addr *net.UDPAddr) error {
+func (s *Server) Stop() {
-	if len(s.conns) == 0 || s.conns[0] == nil {
+	s.cancel()
-		return fmt.Errorf("server not started")
+	for _, c := range s.conns {
+		_ = c.Close()
+	}
+	s.wg.Wait()
 }
 
-	// On utilise la première conn pour l’envoi (c’est suffisant pour UDP).
+func (s *Server) workerLoop(workerID int, conn *net.UDPConn) {
-	_, err := s.conns[0].WriteToUDP(data, addr)
-	return err
-}
-
-func (s *Server) workerLoop(id int, conn *net.UDPConn) {
 	defer s.wg.Done()
 
-	buffer := make([]byte, 1500)
+	buf := make([]byte, 1500)
-	fmt.Println("Worker", id, "started")
+	fmt.Println("[udp] worker", workerID, "started")
 
 	for {
 		select {
 		case <-s.ctx.Done():
-			fmt.Println("Worker", id, "stopped")
+			fmt.Println("[udp] worker", workerID, "stopped")
 			return
 		default:
-			size, addr, err := conn.ReadFromUDP(buffer)
+			n, addr, err := conn.ReadFromUDP(buf)
 			if err != nil {
 				if s.ctx.Err() != nil {
 					return
 				}
-				if opErr, ok := err.(*net.OpError); ok && opErr.Temporary() {
+				if ne, ok := err.(net.Error); ok && ne.Timeout() {
 					continue
 				}
-				fmt.Printf("Error reading from UDP (worker %d): %v\n", id, err)
+				fmt.Printf("[udp] worker %d: read error: %v\n", workerID, err)
 				continue
 			}
 
-			s.handlePacket(buffer[:size], addr)
+			// Le worker qui lit est aussi celui qui traite et qui écrit.
+			s.handlePacket(conn, buf[:n], addr)
 		}
 	}
 }
 
-func (s *Server) handlePacket(data []byte, addr *net.UDPAddr) {
+// handlePacket reçoit maintenant directement la conn du worker.
+// Aucun hop supplémentaire : le paquet reste dans la goroutine/conn du worker.
+func (s *Server) handlePacket(conn *net.UDPConn, data []byte, addr *net.UDPAddr) {
 	if len(data) == 0 {
 		return
 	}
 
 	pt := PacketType(data[0])
+
 	switch pt {
 	case PacketTypePing:
-		_ = s.sendTo([]byte{byte(PacketTypePing)}, addr)
+		// exemple simple : echo du ping
-		return
+		_, _ = conn.WriteToUDP([]byte{byte(PacketTypePing)}, addr)
+
 	case PacketTypeConnect:
+		if len(data) < 2 {
 			return
+		}
+		channelID := string(data[1:])
+		s.routingTable.Add(channelID, addr)
+
 	case PacketTypeDisconnect:
+		if len(data) < 2 {
 			return
+		}
+		channelID := string(data[1:])
+		s.routingTable.Remove(channelID, addr)
+
 	case PacketTypeVoiceData:
-		// todo : déterminer le format du packet
+		if len(data) < 2 {
-		// channelID := string(data[1:5])
 			return
+		}
+		channelID := string(data[1:]) // à adapter selon ton vrai format
+		recipients := s.routingTable.GetAddrs(channelID)
+
+		for _, dst := range recipients {
+			// optionnel: ne pas renvoyer à la source
+			if dst.IP.Equal(addr.IP) && dst.Port == addr.Port {
+				continue
+			}
+			_, _ = conn.WriteToUDP(data, dst)
+		}
+
 	default:
-		return
+		// type inconnu -> ignore
 	}
 }