2012-04-07 20:44:59 +02:00
|
|
|
package irc
|
|
|
|
|
|
|
|
import (
|
2014-02-12 01:35:32 +01:00
|
|
|
"bufio"
|
2014-02-09 02:10:04 +01:00
|
|
|
"crypto/rand"
|
2014-02-10 04:41:00 +01:00
|
|
|
"crypto/tls"
|
2014-02-09 02:10:04 +01:00
|
|
|
"encoding/binary"
|
|
|
|
"fmt"
|
2012-04-07 20:44:59 +02:00
|
|
|
"log"
|
|
|
|
"net"
|
2014-02-12 01:35:32 +01:00
|
|
|
"os"
|
2012-04-18 07:21:41 +02:00
|
|
|
"time"
|
2012-04-07 20:44:59 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
type Server struct {
|
2014-02-09 19:07:40 +01:00
|
|
|
channels ChannelNameMap
|
|
|
|
commands chan<- Command
|
|
|
|
ctime time.Time
|
2014-02-12 01:35:32 +01:00
|
|
|
motdFile string
|
2014-02-09 19:07:40 +01:00
|
|
|
name string
|
|
|
|
operators map[string]string
|
|
|
|
password string
|
|
|
|
clients ClientNameMap
|
2012-04-18 03:16:57 +02:00
|
|
|
}
|
|
|
|
|
2014-02-09 16:53:42 +01:00
|
|
|
func NewServer(config *Config) *Server {
|
2013-06-03 01:53:06 +02:00
|
|
|
commands := make(chan Command)
|
2012-12-09 21:51:50 +01:00
|
|
|
server := &Server{
|
2014-02-09 19:07:40 +01:00
|
|
|
channels: make(ChannelNameMap),
|
|
|
|
clients: make(ClientNameMap),
|
|
|
|
commands: commands,
|
|
|
|
ctime: time.Now(),
|
2014-02-12 01:35:32 +01:00
|
|
|
motdFile: config.MOTD,
|
2014-02-09 19:07:40 +01:00
|
|
|
name: config.Name,
|
|
|
|
operators: make(map[string]string),
|
|
|
|
password: config.Password,
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
2014-02-09 19:07:40 +01:00
|
|
|
|
|
|
|
for _, opConf := range config.Operators {
|
|
|
|
server.operators[opConf.Name] = opConf.Password
|
|
|
|
}
|
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
go server.receiveCommands(commands)
|
2014-02-10 04:41:00 +01:00
|
|
|
|
|
|
|
for _, listenerConf := range config.Listeners {
|
|
|
|
go server.listen(listenerConf)
|
|
|
|
}
|
|
|
|
|
2013-06-03 07:07:50 +02:00
|
|
|
return server
|
|
|
|
}
|
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
func (server *Server) receiveCommands(commands <-chan Command) {
|
|
|
|
for command := range commands {
|
2013-05-11 23:43:06 +02:00
|
|
|
if DEBUG_SERVER {
|
2014-02-11 23:32:17 +01:00
|
|
|
log.Printf("%s → %s %s", command.Client(), server, command)
|
2013-05-11 23:43:06 +02:00
|
|
|
}
|
2014-02-09 17:48:11 +01:00
|
|
|
client := command.Client()
|
2014-02-09 21:13:09 +01:00
|
|
|
client.Touch()
|
|
|
|
|
2014-02-09 17:48:11 +01:00
|
|
|
if !client.serverPass {
|
|
|
|
if server.password == "" {
|
|
|
|
client.serverPass = true
|
|
|
|
|
2014-02-10 20:14:34 +01:00
|
|
|
} else {
|
|
|
|
switch command.(type) {
|
2014-02-11 03:40:06 +01:00
|
|
|
case *PassCommand, *CapCommand, *ProxyCommand:
|
|
|
|
// no-op
|
2014-02-10 20:14:34 +01:00
|
|
|
default:
|
|
|
|
client.Reply(ErrPasswdMismatch(server))
|
|
|
|
client.Destroy()
|
|
|
|
return
|
|
|
|
}
|
2014-02-09 17:48:11 +01:00
|
|
|
}
|
|
|
|
}
|
2013-05-09 18:12:03 +02:00
|
|
|
command.HandleServer(server)
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-10 04:41:00 +01:00
|
|
|
func newListener(config ListenerConfig) (net.Listener, error) {
|
|
|
|
if config.IsTLS() {
|
|
|
|
certificate, err := tls.LoadX509KeyPair(config.Certificate, config.Key)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return tls.Listen("tcp", config.Address, &tls.Config{
|
|
|
|
Certificates: []tls.Certificate{certificate},
|
|
|
|
PreferServerCipherSuites: true,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
return net.Listen("tcp", config.Address)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) listen(config ListenerConfig) {
|
|
|
|
listener, err := newListener(config)
|
2012-04-07 20:44:59 +02:00
|
|
|
if err != nil {
|
2012-04-08 08:32:08 +02:00
|
|
|
log.Fatal("Server.Listen: ", err)
|
2012-04-07 20:44:59 +02:00
|
|
|
}
|
|
|
|
|
2014-02-10 04:41:00 +01:00
|
|
|
log.Print("Server.Listen: listening on ", config.Address)
|
2012-12-09 07:54:58 +01:00
|
|
|
|
2012-04-07 20:44:59 +02:00
|
|
|
for {
|
|
|
|
conn, err := listener.Accept()
|
|
|
|
if err != nil {
|
2014-02-09 02:10:04 +01:00
|
|
|
log.Print("Server.Accept: ", err)
|
2012-04-07 20:44:59 +02:00
|
|
|
continue
|
|
|
|
}
|
2014-02-08 22:18:11 +01:00
|
|
|
if DEBUG_SERVER {
|
2014-02-09 02:10:04 +01:00
|
|
|
log.Print("Server.Accept: ", conn.RemoteAddr())
|
2014-02-08 22:18:11 +01:00
|
|
|
}
|
2014-02-11 02:54:35 +01:00
|
|
|
go NewClient(s, conn)
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) GetOrMakeChannel(name string) *Channel {
|
|
|
|
channel := s.channels[name]
|
|
|
|
|
|
|
|
if channel == nil {
|
|
|
|
channel = NewChannel(s, name)
|
|
|
|
s.channels[name] = channel
|
|
|
|
}
|
|
|
|
|
|
|
|
return channel
|
|
|
|
}
|
|
|
|
|
2014-02-09 02:10:04 +01:00
|
|
|
func (s *Server) GenerateGuestNick() string {
|
|
|
|
bytes := make([]byte, 8)
|
|
|
|
for {
|
|
|
|
_, err := rand.Read(bytes)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
randInt, n := binary.Uvarint(bytes)
|
|
|
|
if n <= 0 {
|
|
|
|
continue // TODO handle error
|
|
|
|
}
|
|
|
|
nick := fmt.Sprintf("guest%d", randInt)
|
|
|
|
if s.clients[nick] == nil {
|
|
|
|
return nick
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
}
|
2012-04-07 20:44:59 +02:00
|
|
|
}
|
|
|
|
|
2012-12-09 07:54:58 +01:00
|
|
|
// server functionality
|
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
func (s *Server) tryRegister(c *Client) {
|
2014-02-09 17:48:11 +01:00
|
|
|
if !c.registered && c.HasNick() && c.HasUsername() {
|
2012-12-15 23:34:20 +01:00
|
|
|
c.registered = true
|
2014-02-12 00:33:02 +01:00
|
|
|
c.Reply(
|
2013-05-12 20:20:55 +02:00
|
|
|
RplWelcome(s, c),
|
2013-06-03 07:07:50 +02:00
|
|
|
RplYourHost(s),
|
2013-05-12 20:20:55 +02:00
|
|
|
RplCreated(s),
|
2014-02-12 00:33:02 +01:00
|
|
|
RplMyInfo(s))
|
2014-02-12 00:44:58 +01:00
|
|
|
s.MOTD(c)
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-12 00:33:02 +01:00
|
|
|
func (server *Server) MOTD(client *Client) {
|
2014-02-12 01:35:32 +01:00
|
|
|
if server.motdFile == "" {
|
|
|
|
client.Reply(ErrNoMOTD(server))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
file, err := os.Open(server.motdFile)
|
|
|
|
if err != nil {
|
|
|
|
client.Reply(ErrNoMOTD(server))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
|
|
|
|
client.Reply(RplMOTDStart(server))
|
|
|
|
reader := bufio.NewReader(file)
|
|
|
|
for {
|
|
|
|
line, err := reader.ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(line) > 80 {
|
|
|
|
for len(line) > 80 {
|
|
|
|
client.Reply(RplMOTD(server, line[0:80]))
|
|
|
|
line = line[80:]
|
|
|
|
}
|
|
|
|
if len(line) > 0 {
|
|
|
|
client.Reply(RplMOTD(server, line))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
client.Reply(RplMOTD(server, line))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
client.Reply(RplMOTDEnd(server))
|
2014-02-12 00:33:02 +01:00
|
|
|
}
|
|
|
|
|
2013-05-12 20:20:55 +02:00
|
|
|
func (s *Server) Id() string {
|
2013-05-11 22:55:01 +02:00
|
|
|
return s.name
|
|
|
|
}
|
|
|
|
|
2013-05-12 03:28:18 +02:00
|
|
|
func (s *Server) String() string {
|
2014-02-09 02:10:04 +01:00
|
|
|
return s.name
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2013-05-12 03:28:18 +02:00
|
|
|
func (s *Server) Nick() string {
|
2014-02-09 02:10:04 +01:00
|
|
|
return s.Id()
|
2012-12-17 04:13:53 +01:00
|
|
|
}
|
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
//
|
|
|
|
// commands
|
|
|
|
//
|
|
|
|
|
2013-05-12 03:28:18 +02:00
|
|
|
func (m *UnknownCommand) HandleServer(s *Server) {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(ErrUnknownCommand(s, m.command))
|
2012-12-17 04:13:53 +01:00
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *PingCommand) HandleServer(s *Server) {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(RplPong(s, m.Client()))
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *PongCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
// no-op
|
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *PassCommand) HandleServer(s *Server) {
|
2014-02-08 22:18:11 +01:00
|
|
|
if s.password != m.password {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(ErrPasswdMismatch(s))
|
2014-02-09 08:15:05 +01:00
|
|
|
m.Client().Destroy()
|
2012-12-09 07:54:58 +01:00
|
|
|
return
|
2012-04-09 16:57:55 +02:00
|
|
|
}
|
2012-12-09 07:54:58 +01:00
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
m.Client().serverPass = true
|
|
|
|
// no reply?
|
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *NickCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
c := m.Client()
|
2014-02-05 04:28:24 +01:00
|
|
|
|
|
|
|
if s.clients[m.nickname] != nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
c.Reply(ErrNickNameInUse(s, m.nickname))
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
2012-12-09 21:51:50 +01:00
|
|
|
|
2014-02-09 17:48:11 +01:00
|
|
|
if !c.HasNick() {
|
|
|
|
c.nick = m.nickname
|
|
|
|
}
|
2014-02-05 04:28:24 +01:00
|
|
|
reply := RplNick(c, m.nickname)
|
2014-02-11 23:32:17 +01:00
|
|
|
iclients := c.InterestedClients()
|
|
|
|
iclients.Add(c)
|
|
|
|
for iclient := range iclients {
|
2014-02-09 17:48:11 +01:00
|
|
|
iclient.Reply(reply)
|
2013-05-12 20:20:55 +02:00
|
|
|
}
|
|
|
|
|
2014-02-09 08:15:05 +01:00
|
|
|
s.clients.Remove(c)
|
2014-02-05 04:28:24 +01:00
|
|
|
c.nick = m.nickname
|
2014-02-09 08:15:05 +01:00
|
|
|
s.clients.Add(c)
|
2014-02-05 04:28:24 +01:00
|
|
|
|
|
|
|
s.tryRegister(c)
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *UserMsgCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
c := m.Client()
|
2014-02-05 04:28:24 +01:00
|
|
|
if c.registered {
|
2014-02-09 17:48:11 +01:00
|
|
|
c.Reply(ErrAlreadyRegistered(s))
|
2012-12-09 07:54:58 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
c.username, c.realname = m.user, m.realname
|
2012-12-09 21:51:50 +01:00
|
|
|
s.tryRegister(c)
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *QuitCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
c := m.Client()
|
2012-12-17 04:13:53 +01:00
|
|
|
|
2014-02-09 08:15:05 +01:00
|
|
|
s.clients.Remove(c)
|
2014-02-09 02:10:04 +01:00
|
|
|
for channel := range c.channels {
|
2014-02-09 08:15:05 +01:00
|
|
|
channel.members.Remove(c)
|
2014-02-09 02:10:04 +01:00
|
|
|
}
|
|
|
|
|
2014-02-09 17:48:11 +01:00
|
|
|
c.Reply(RplError(s, c))
|
2014-02-09 02:10:04 +01:00
|
|
|
c.Destroy()
|
|
|
|
|
2014-02-05 04:28:24 +01:00
|
|
|
reply := RplQuit(c, m.message)
|
2014-02-09 02:10:04 +01:00
|
|
|
for client := range c.InterestedClients() {
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(reply)
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *JoinCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
c := m.Client()
|
2012-12-17 04:13:53 +01:00
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
if m.zero {
|
2014-02-09 08:51:51 +01:00
|
|
|
cmd := &PartCommand{}
|
|
|
|
cmd.SetClient(c)
|
2014-02-05 04:28:24 +01:00
|
|
|
for channel := range c.channels {
|
|
|
|
channel.commands <- cmd
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
2012-12-17 04:13:53 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for name := range m.channels {
|
2014-02-05 04:28:24 +01:00
|
|
|
s.GetOrMakeChannel(name).commands <- m
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *PartCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
for _, chname := range m.channels {
|
|
|
|
channel := s.channels[chname]
|
|
|
|
|
|
|
|
if channel == nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(ErrNoSuchChannel(s, channel.name))
|
2012-12-15 23:34:20 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-02-05 04:28:24 +01:00
|
|
|
channel.commands <- m
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *TopicCommand) HandleServer(s *Server) {
|
2012-12-17 04:13:53 +01:00
|
|
|
channel := s.channels[m.channel]
|
|
|
|
if channel == nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(ErrNoSuchChannel(s, m.channel))
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-05 04:28:24 +01:00
|
|
|
channel.commands <- m
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *PrivMsgCommand) HandleServer(s *Server) {
|
2012-12-15 23:34:20 +01:00
|
|
|
if m.TargetIsChannel() {
|
|
|
|
channel := s.channels[m.target]
|
|
|
|
if channel == nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(ErrNoSuchChannel(s, m.target))
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
2012-12-15 23:34:20 +01:00
|
|
|
|
2013-06-03 07:07:50 +02:00
|
|
|
channel.commands <- m
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
2012-12-15 23:34:20 +01:00
|
|
|
|
2014-02-05 04:28:24 +01:00
|
|
|
target := s.clients[m.target]
|
2012-12-17 04:13:53 +01:00
|
|
|
if target == nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
m.Client().Reply(ErrNoSuchNick(s, m.target))
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-09 17:48:11 +01:00
|
|
|
target.Reply(RplPrivMsg(m.Client(), target, m.message))
|
2014-02-12 00:44:58 +01:00
|
|
|
if target.away {
|
|
|
|
m.Client().Reply(RplAway(s, target))
|
|
|
|
}
|
2012-04-07 20:44:59 +02:00
|
|
|
}
|
2012-12-13 08:27:17 +01:00
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *ModeCommand) HandleServer(s *Server) {
|
2014-02-09 02:10:04 +01:00
|
|
|
client := m.Client()
|
2014-02-13 03:14:19 +01:00
|
|
|
target := s.clients[m.nickname]
|
|
|
|
if client == target {
|
2014-02-09 02:10:04 +01:00
|
|
|
for _, change := range m.changes {
|
|
|
|
if change.mode == Invisible {
|
2014-02-09 07:42:14 +01:00
|
|
|
switch change.op {
|
|
|
|
case Add:
|
|
|
|
client.invisible = true
|
|
|
|
case Remove:
|
|
|
|
client.invisible = false
|
|
|
|
}
|
2014-02-09 02:10:04 +01:00
|
|
|
}
|
2014-02-08 23:20:23 +01:00
|
|
|
}
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(RplUModeIs(s, client))
|
2014-02-09 02:10:04 +01:00
|
|
|
return
|
2014-02-08 23:20:23 +01:00
|
|
|
}
|
2014-02-09 02:10:04 +01:00
|
|
|
|
2014-02-13 03:14:19 +01:00
|
|
|
client.Reply(ErrUsersDontMatch(s))
|
2012-12-13 08:27:17 +01:00
|
|
|
}
|
2014-02-09 02:43:59 +01:00
|
|
|
|
|
|
|
func (m *WhoisCommand) HandleServer(server *Server) {
|
|
|
|
client := m.Client()
|
|
|
|
|
|
|
|
// TODO implement target query
|
|
|
|
|
|
|
|
for _, mask := range m.masks {
|
|
|
|
// TODO implement wildcard matching
|
|
|
|
mclient := server.clients[mask]
|
|
|
|
if mclient != nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(RplWhoisUser(server, mclient))
|
2014-02-09 02:43:59 +01:00
|
|
|
}
|
|
|
|
}
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(RplEndOfWhois(server))
|
2014-02-09 02:43:59 +01:00
|
|
|
}
|
2014-02-09 03:14:39 +01:00
|
|
|
|
|
|
|
func (msg *ChannelModeCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
channel := server.channels[msg.channel]
|
|
|
|
if channel == nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(ErrNoSuchChannel(server, msg.channel))
|
2014-02-09 03:14:39 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-09 07:06:10 +01:00
|
|
|
channel.commands <- msg
|
2014-02-09 03:14:39 +01:00
|
|
|
}
|
2014-02-09 03:49:52 +01:00
|
|
|
|
|
|
|
func whoChannel(client *Client, server *Server, channel *Channel) {
|
|
|
|
for member := range channel.members {
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(RplWhoReply(server, channel, member))
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (msg *WhoCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
// TODO implement wildcard matching
|
|
|
|
|
2014-02-09 07:42:14 +01:00
|
|
|
mask := string(msg.mask)
|
|
|
|
if mask == "" {
|
2014-02-09 03:49:52 +01:00
|
|
|
for _, channel := range server.channels {
|
|
|
|
whoChannel(client, server, channel)
|
|
|
|
}
|
2014-02-09 07:42:14 +01:00
|
|
|
} else if IsChannel(mask) {
|
|
|
|
channel := server.channels[mask]
|
2014-02-09 03:49:52 +01:00
|
|
|
if channel != nil {
|
|
|
|
whoChannel(client, server, channel)
|
|
|
|
}
|
|
|
|
} else {
|
2014-02-09 07:42:14 +01:00
|
|
|
mclient := server.clients[mask]
|
2014-02-09 03:49:52 +01:00
|
|
|
if mclient != nil {
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(RplWhoReply(server, mclient.channels.First(), mclient))
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-09 17:48:11 +01:00
|
|
|
client.Reply(RplEndOfWho(server, mask))
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
2014-02-09 19:07:40 +01:00
|
|
|
|
|
|
|
func (msg *OperCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
|
|
|
|
if server.operators[msg.name] != msg.password {
|
|
|
|
client.Reply(ErrPasswdMismatch(server))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
client.operator = true
|
|
|
|
|
|
|
|
client.Reply(RplYoureOper(server))
|
|
|
|
client.Reply(RplUModeIs(server, client))
|
|
|
|
}
|
2014-02-10 20:14:34 +01:00
|
|
|
|
|
|
|
func (msg *CapCommand) HandleServer(server *Server) {
|
|
|
|
// TODO
|
|
|
|
}
|
2014-02-11 03:40:06 +01:00
|
|
|
|
|
|
|
func (msg *ProxyCommand) HandleServer(server *Server) {
|
2014-02-11 04:39:53 +01:00
|
|
|
msg.Client().hostname = LookupHostname(msg.sourceIP)
|
2014-02-11 03:40:06 +01:00
|
|
|
}
|
2014-02-12 00:44:58 +01:00
|
|
|
|
|
|
|
func (msg *AwayCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
client.away = msg.away
|
|
|
|
client.awayMessage = msg.text
|
|
|
|
|
|
|
|
if client.away {
|
|
|
|
client.Reply(RplNowAway(server))
|
|
|
|
} else {
|
|
|
|
client.Reply(RplUnAway(server))
|
|
|
|
}
|
|
|
|
}
|
2014-02-12 00:58:54 +01:00
|
|
|
|
|
|
|
func (msg *IsOnCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
|
|
|
|
ison := make([]string, 0)
|
|
|
|
for _, nick := range msg.nicks {
|
|
|
|
if _, ok := server.clients[nick]; ok {
|
|
|
|
ison = append(ison, nick)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
client.Reply(RplIsOn(server, ison))
|
|
|
|
}
|
2014-02-12 01:35:32 +01:00
|
|
|
|
|
|
|
func (msg *MOTDCommand) HandleServer(server *Server) {
|
|
|
|
server.MOTD(msg.Client())
|
|
|
|
}
|
2014-02-12 02:11:59 +01:00
|
|
|
|
|
|
|
func (msg *NoticeCommand) HandleServer(server *Server) {
|
|
|
|
if IsChannel(msg.target) {
|
|
|
|
channel := server.channels[msg.target]
|
|
|
|
if channel == nil {
|
|
|
|
msg.Client().Reply(ErrNoSuchChannel(server, msg.target))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
channel.commands <- msg
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
target := server.clients[msg.target]
|
|
|
|
if target == nil {
|
|
|
|
msg.Client().Reply(ErrNoSuchNick(server, msg.target))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
target.Reply(RplPrivMsg(msg.Client(), target, msg.message))
|
|
|
|
}
|