116 lines
2.1 KiB
Go
116 lines
2.1 KiB
Go
package udp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"runtime"
|
|
"sync"
|
|
)
|
|
|
|
type Server struct {
|
|
bindAddr string
|
|
routingTable *RoutingTable
|
|
|
|
conn *net.UDPConn
|
|
wg sync.WaitGroup
|
|
ctx context.Context
|
|
cancel context.CancelFunc
|
|
}
|
|
|
|
func NewServer(bindAddr string) (*Server, error) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
return &Server{
|
|
bindAddr: bindAddr,
|
|
ctx: ctx,
|
|
cancel: cancel,
|
|
}, nil
|
|
}
|
|
|
|
func (s *Server) run() error {
|
|
add, err := net.ResolveUDPAddr("udp", s.bindAddr)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot resolve address: %w", err)
|
|
}
|
|
|
|
s.conn, err = net.ListenUDP("udp", add)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot listen on address: %w", err)
|
|
}
|
|
|
|
s.conn.SetReadBuffer(8 * 1024 * 1024)
|
|
s.conn.SetWriteBuffer(8 * 1024 * 1024)
|
|
fmt.Println("Listening on", s.bindAddr)
|
|
|
|
for i := 0; i < runtime.NumCPU(); i++ {
|
|
s.wg.Add(1)
|
|
// todo : add so_reuseport option when on unix like system
|
|
go s.workerLoop(i)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) sendTo(data []byte, addr *net.UDPAddr) error {
|
|
if s.conn == nil {
|
|
return fmt.Errorf("server not started")
|
|
}
|
|
|
|
_, err := s.conn.WriteToUDP(data, addr)
|
|
return err
|
|
}
|
|
|
|
func (s *Server) workerLoop(id int) {
|
|
defer s.wg.Done()
|
|
|
|
buffer := make([]byte, 1500)
|
|
fmt.Println("Worker", id, "started")
|
|
|
|
for {
|
|
select {
|
|
case <-s.ctx.Done():
|
|
fmt.Println("Worker", id, "stopped")
|
|
return
|
|
default:
|
|
size, addr, err := s.conn.ReadFromUDP(buffer)
|
|
if err != nil {
|
|
if s.ctx.Err() != nil {
|
|
return
|
|
}
|
|
if opErr, ok := err.(*net.OpError); ok && opErr.Temporary() {
|
|
continue
|
|
}
|
|
fmt.Printf("Error reading from UDP: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
s.handlePacket(buffer[:size], addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) handlePacket(data []byte, addr *net.UDPAddr) {
|
|
pt := PacketType(data[0])
|
|
switch pt {
|
|
case PacketTypePing:
|
|
err := s.sendTo([]byte{byte(PacketTypePing)}, addr)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
case PacketTypeConnect:
|
|
return
|
|
case PacketTypeDisconnect:
|
|
return
|
|
case PacketTypeVoiceData:
|
|
// todo : déterminer le format du packet
|
|
//channelID := string(data[1:5])
|
|
return
|
|
default:
|
|
return
|
|
|
|
}
|
|
|
|
}
|