112 lines
2.8 KiB
Go
112 lines
2.8 KiB
Go
package pnyx
|
|
|
|
import (
|
|
"slices"
|
|
"fmt"
|
|
)
|
|
|
|
type ChannelID uint32
|
|
|
|
const (
|
|
MODE_CHANNEL ModeID = iota
|
|
MODE_RAW
|
|
|
|
CHANNEL_JOIN byte = iota
|
|
CHANNEL_LEAVE
|
|
CHANNEL_MEMBERS
|
|
|
|
RAW_DATA = iota
|
|
)
|
|
|
|
type ModeID uint8
|
|
type CommandID uint8
|
|
type Permission string
|
|
|
|
type Channel struct {
|
|
id ChannelID
|
|
modes map[ModeID]Mode
|
|
sessions []SessionID
|
|
}
|
|
|
|
func(channel *Channel) Data(session *Session, mode ModeID, data []byte) []SendPacket {
|
|
m, has_mode := channel.modes[mode]
|
|
if has_mode == false {
|
|
return nil
|
|
} else {
|
|
return m.Data(session, channel, data)
|
|
}
|
|
}
|
|
|
|
func(channel *Channel) Command(session *Session, mode ModeID, command byte, data []byte) ([]SendPacket, error) {
|
|
if mode == MODE_CHANNEL {
|
|
switch command {
|
|
case CHANNEL_JOIN:
|
|
if slices.Contains(channel.sessions, session.ID) {
|
|
return nil, fmt.Errorf("Session %s already in channel %d, can't join", session.ID, channel.id)
|
|
} else {
|
|
channel.sessions = append(channel.sessions, session.ID)
|
|
return nil, nil
|
|
}
|
|
case CHANNEL_LEAVE:
|
|
idx := slices.Index(channel.sessions, session.ID)
|
|
if idx == -1 {
|
|
return nil, fmt.Errorf("Session %s not in channel %d, can't leave", session.ID, channel.id)
|
|
} else {
|
|
channel.sessions = slices.Delete(channel.sessions, idx, idx+1)
|
|
return nil, nil
|
|
}
|
|
default:
|
|
return nil, fmt.Errorf("Unknown MODE_CHANNEL command: 0x%02x", command)
|
|
}
|
|
} else {
|
|
mode, has_mode := channel.modes[mode]
|
|
if has_mode == false {
|
|
return nil, fmt.Errorf("Channel has no mode 0x%02x", mode)
|
|
} else {
|
|
return mode.Command(session, channel, command, data)
|
|
}
|
|
}
|
|
}
|
|
|
|
type SendPacket struct {
|
|
Packet *Packet
|
|
Session SessionID
|
|
}
|
|
|
|
type Mode interface {
|
|
// Process takes incoming packets from a session and returns a list of packets to send
|
|
Command(session *Session, channel *Channel, command byte, data []byte) ([]SendPacket, error)
|
|
Data(session *Session, channel *Channel, data []byte) []SendPacket
|
|
}
|
|
|
|
func multiplex(session *Session, packet *Packet, sessions []SessionID) []SendPacket {
|
|
send_packets := make([]SendPacket, len(sessions))
|
|
for i, session_id := range(sessions) {
|
|
if session_id == session.ID {
|
|
continue
|
|
}
|
|
|
|
send_packets[i] = SendPacket{
|
|
Packet: packet,
|
|
Session: session_id,
|
|
}
|
|
}
|
|
|
|
return send_packets
|
|
}
|
|
|
|
type RawMode struct {
|
|
}
|
|
|
|
func(mode *RawMode) Command(session *Session, channel *Channel, command byte, data []byte) ([]SendPacket, error) {
|
|
return nil, fmt.Errorf("unknown raw mode command 0x%02x", command)
|
|
}
|
|
|
|
func(mode *RawMode) Data(session *Session, channel *Channel, data []byte) []SendPacket {
|
|
if slices.Contains(channel.sessions, session.ID) {
|
|
new_packet := NewChannelPeerPacket(session.Peer, channel.id, MODE_RAW, data)
|
|
return multiplex(session, new_packet, channel.sessions)
|
|
}
|
|
return nil
|
|
}
|