2012-04-07 20:44:59 +02:00
|
|
|
package irc
|
|
|
|
|
|
|
|
import (
|
2014-02-12 01:35:32 +01:00
|
|
|
"bufio"
|
2016-04-13 12:45:09 +02:00
|
|
|
"crypto/tls"
|
2014-02-25 20:11:34 +01:00
|
|
|
"database/sql"
|
2014-02-09 02:10:04 +01:00
|
|
|
"fmt"
|
2012-04-07 20:44:59 +02:00
|
|
|
"log"
|
|
|
|
"net"
|
2015-05-04 07:47:26 +02:00
|
|
|
"net/http"
|
2014-02-12 01:35:32 +01:00
|
|
|
"os"
|
2014-02-25 20:11:34 +01:00
|
|
|
"os/signal"
|
2014-02-18 03:10:52 +01:00
|
|
|
"strings"
|
2014-03-02 20:36:00 +01:00
|
|
|
"syscall"
|
2012-04-18 07:21:41 +02:00
|
|
|
"time"
|
2012-04-07 20:44:59 +02:00
|
|
|
)
|
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
type ServerCommand interface {
|
|
|
|
Command
|
|
|
|
HandleServer(*Server)
|
|
|
|
}
|
|
|
|
|
|
|
|
type RegServerCommand interface {
|
|
|
|
Command
|
|
|
|
HandleRegServer(*Server)
|
|
|
|
}
|
2014-03-08 23:20:36 +01:00
|
|
|
|
2012-04-07 20:44:59 +02:00
|
|
|
type Server struct {
|
2014-02-09 19:07:40 +01:00
|
|
|
channels ChannelNameMap
|
2014-03-06 20:56:32 +01:00
|
|
|
clients *ClientLookupSet
|
2014-02-14 05:08:16 +01:00
|
|
|
commands chan Command
|
2014-02-09 19:07:40 +01:00
|
|
|
ctime time.Time
|
2014-02-25 20:11:34 +01:00
|
|
|
db *sql.DB
|
2014-02-18 20:22:56 +01:00
|
|
|
idle chan *Client
|
2016-04-13 07:49:30 +02:00
|
|
|
motdLines []string
|
2014-03-09 21:45:36 +01:00
|
|
|
name Name
|
2014-02-20 22:03:33 +01:00
|
|
|
newConns chan net.Conn
|
2014-03-09 21:45:36 +01:00
|
|
|
operators map[Name][]byte
|
2014-02-24 07:21:39 +01:00
|
|
|
password []byte
|
2014-02-25 20:11:34 +01:00
|
|
|
signals chan os.Signal
|
2014-03-06 22:55:25 +01:00
|
|
|
whoWas *WhoWasList
|
2014-03-13 09:55:46 +01:00
|
|
|
theaters map[Name][]byte
|
2016-04-12 07:38:42 +02:00
|
|
|
isupport *ISupportList
|
2012-04-18 03:16:57 +02:00
|
|
|
}
|
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
var (
|
|
|
|
SERVER_SIGNALS = []os.Signal{syscall.SIGINT, syscall.SIGHUP,
|
|
|
|
syscall.SIGTERM, syscall.SIGQUIT}
|
|
|
|
)
|
|
|
|
|
2014-02-09 16:53:42 +01:00
|
|
|
func NewServer(config *Config) *Server {
|
2012-12-09 21:51:50 +01:00
|
|
|
server := &Server{
|
2014-02-09 19:07:40 +01:00
|
|
|
channels: make(ChannelNameMap),
|
2014-03-06 20:56:32 +01:00
|
|
|
clients: NewClientLookupSet(),
|
2014-03-08 23:20:36 +01:00
|
|
|
commands: make(chan Command),
|
2014-02-09 19:07:40 +01:00
|
|
|
ctime: time.Now(),
|
2014-03-02 20:41:24 +01:00
|
|
|
db: OpenDB(config.Server.Database),
|
2014-03-08 23:20:36 +01:00
|
|
|
idle: make(chan *Client),
|
2014-03-09 21:45:36 +01:00
|
|
|
name: NewName(config.Server.Name),
|
2014-03-08 23:20:36 +01:00
|
|
|
newConns: make(chan net.Conn),
|
2014-03-01 23:34:51 +01:00
|
|
|
operators: config.Operators(),
|
2014-03-08 23:20:36 +01:00
|
|
|
signals: make(chan os.Signal, len(SERVER_SIGNALS)),
|
2014-03-06 22:55:25 +01:00
|
|
|
whoWas: NewWhoWasList(100),
|
2014-03-13 09:55:46 +01:00
|
|
|
theaters: config.Theaters(),
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
2014-02-09 19:07:40 +01:00
|
|
|
|
2016-04-15 07:57:08 +02:00
|
|
|
// ensure that there is a minimum number of args specified for every command
|
|
|
|
for name, _ := range parseCommandFuncs {
|
|
|
|
_, exists := commandMinimumArgs[name]
|
|
|
|
if !exists {
|
|
|
|
log.Fatal("commandMinArgs not found for ", name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-13 07:49:30 +02:00
|
|
|
if config.Server.MOTD != "" {
|
|
|
|
file, err := os.Open(config.Server.MOTD)
|
|
|
|
if err == nil {
|
|
|
|
defer file.Close()
|
|
|
|
|
|
|
|
reader := bufio.NewReader(file)
|
|
|
|
for {
|
|
|
|
line, err := reader.ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
line = strings.TrimRight(line, "\r\n")
|
|
|
|
|
|
|
|
server.motdLines = append(server.motdLines, line)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-06 20:00:48 +01:00
|
|
|
if config.Server.Password != "" {
|
|
|
|
server.password = config.Server.PasswordBytes()
|
|
|
|
}
|
|
|
|
|
2014-02-26 00:57:35 +01:00
|
|
|
server.loadChannels()
|
|
|
|
|
2014-03-01 23:34:51 +01:00
|
|
|
for _, addr := range config.Server.Listen {
|
2016-04-13 12:45:09 +02:00
|
|
|
server.listen(addr, config.SSLListeners())
|
2014-02-26 00:57:35 +01:00
|
|
|
}
|
|
|
|
|
2015-05-04 07:47:26 +02:00
|
|
|
if config.Server.Wslisten != "" {
|
|
|
|
server.wslisten(config.Server.Wslisten)
|
|
|
|
}
|
|
|
|
|
2014-03-08 23:20:36 +01:00
|
|
|
signal.Notify(server.signals, SERVER_SIGNALS...)
|
2014-03-02 20:51:29 +01:00
|
|
|
|
2016-04-12 07:38:42 +02:00
|
|
|
// add RPL_ISUPPORT tokens
|
|
|
|
server.isupport = NewISupportList()
|
|
|
|
server.isupport.Add("CASEMAPPING", "ascii")
|
2016-04-12 17:01:53 +02:00
|
|
|
// server.isupport.Add("CHANMODES", "") //TODO(dan): Channel mode list here
|
|
|
|
// server.isupport.Add("CHANNELLEN", "") //TODO(dan): Support channel length
|
2016-04-12 07:38:42 +02:00
|
|
|
server.isupport.Add("CHANTYPES", "#")
|
|
|
|
server.isupport.Add("EXCEPTS", "")
|
|
|
|
server.isupport.Add("INVEX", "")
|
2016-04-12 17:01:53 +02:00
|
|
|
// server.isupport.Add("KICKLEN", "") //TODO(dan): Support kick length?
|
|
|
|
// server.isupport.Add("MAXLIST", "") //TODO(dan): Support max list length?
|
|
|
|
// server.isupport.Add("MODES", "") //TODO(dan): Support max modes?
|
2016-04-12 07:44:00 +02:00
|
|
|
server.isupport.Add("NETWORK", config.Network.Name)
|
2016-04-12 17:01:53 +02:00
|
|
|
// server.isupport.Add("NICKLEN", "") //TODO(dan): Support nick length
|
2016-04-14 01:35:36 +02:00
|
|
|
server.isupport.Add("PREFIX", "(qaohv)~&@%+")
|
2016-04-12 07:51:51 +02:00
|
|
|
// server.isupport.Add("STATUSMSG", "@+") //TODO(dan): Autogenerate based on PREFIXes, support STATUSMSG
|
2016-04-12 17:01:53 +02:00
|
|
|
// server.isupport.Add("TARGMAX", "") //TODO(dan): Support this
|
|
|
|
// server.isupport.Add("TOPICLEN", "") //TODO(dan): Support topic length
|
2016-04-12 07:38:42 +02:00
|
|
|
server.isupport.RegenerateCachedReply()
|
|
|
|
|
2014-02-26 00:57:35 +01:00
|
|
|
return server
|
|
|
|
}
|
|
|
|
|
2014-03-08 03:14:02 +01:00
|
|
|
func loadChannelList(channel *Channel, list string, maskMode ChannelMode) {
|
|
|
|
if list == "" {
|
|
|
|
return
|
|
|
|
}
|
2014-03-09 21:45:36 +01:00
|
|
|
channel.lists[maskMode].AddAll(NewNames(strings.Split(list, " ")))
|
2014-03-08 03:14:02 +01:00
|
|
|
}
|
|
|
|
|
2014-02-26 00:57:35 +01:00
|
|
|
func (server *Server) loadChannels() {
|
|
|
|
rows, err := server.db.Query(`
|
2014-03-08 03:14:02 +01:00
|
|
|
SELECT name, flags, key, topic, user_limit, ban_list, except_list,
|
|
|
|
invite_list
|
2014-02-25 20:11:34 +01:00
|
|
|
FROM channel`)
|
|
|
|
if err != nil {
|
2014-03-06 08:07:55 +01:00
|
|
|
log.Fatal("error loading channels: ", err)
|
2014-02-25 20:11:34 +01:00
|
|
|
}
|
|
|
|
for rows.Next() {
|
2014-03-13 21:18:40 +01:00
|
|
|
var name, flags, key, topic string
|
2014-02-25 20:11:34 +01:00
|
|
|
var userLimit uint64
|
2014-03-08 03:14:02 +01:00
|
|
|
var banList, exceptList, inviteList string
|
|
|
|
err = rows.Scan(&name, &flags, &key, &topic, &userLimit, &banList,
|
|
|
|
&exceptList, &inviteList)
|
2014-02-25 20:11:34 +01:00
|
|
|
if err != nil {
|
2014-03-08 03:14:02 +01:00
|
|
|
log.Println("Server.loadChannels:", err)
|
2014-02-25 20:11:34 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-03-13 21:18:40 +01:00
|
|
|
channel := NewChannel(server, NewName(name))
|
2014-02-26 00:57:35 +01:00
|
|
|
for _, flag := range flags {
|
2014-02-25 20:11:34 +01:00
|
|
|
channel.flags[ChannelMode(flag)] = true
|
|
|
|
}
|
2014-03-13 21:18:40 +01:00
|
|
|
channel.key = NewText(key)
|
|
|
|
channel.topic = NewText(topic)
|
2014-02-25 20:11:34 +01:00
|
|
|
channel.userLimit = userLimit
|
2014-03-08 03:14:02 +01:00
|
|
|
loadChannelList(channel, banList, BanMask)
|
|
|
|
loadChannelList(channel, exceptList, ExceptMask)
|
|
|
|
loadChannelList(channel, inviteList, InviteMask)
|
2014-02-25 20:11:34 +01:00
|
|
|
}
|
2013-06-03 07:07:50 +02:00
|
|
|
}
|
|
|
|
|
2014-02-25 02:45:04 +01:00
|
|
|
func (server *Server) processCommand(cmd Command) {
|
2014-02-24 04:13:45 +01:00
|
|
|
client := cmd.Client()
|
|
|
|
|
2016-04-15 07:57:08 +02:00
|
|
|
numCmd, ok := cmd.(*NeedMoreParamsCommand)
|
|
|
|
if ok {
|
|
|
|
client.ErrNeedMoreParams(numCmd.code)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
if !client.registered {
|
2014-02-24 04:13:45 +01:00
|
|
|
regCmd, ok := cmd.(RegServerCommand)
|
|
|
|
if !ok {
|
|
|
|
client.Quit("unexpected command")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
regCmd.HandleRegServer(server)
|
2014-03-13 01:52:25 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-24 04:13:45 +01:00
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
srvCmd, ok := cmd.(ServerCommand)
|
|
|
|
if !ok {
|
|
|
|
client.ErrUnknownCommand(cmd.Code())
|
|
|
|
return
|
|
|
|
}
|
2014-04-15 17:49:52 +02:00
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
switch srvCmd.(type) {
|
|
|
|
case *PingCommand, *PongCommand:
|
|
|
|
client.Touch()
|
2014-02-24 04:13:45 +01:00
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
case *QuitCommand:
|
|
|
|
// no-op
|
2014-02-24 04:13:45 +01:00
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
default:
|
|
|
|
client.Active()
|
|
|
|
client.Touch()
|
2014-02-24 04:13:45 +01:00
|
|
|
}
|
2014-04-15 17:49:52 +02:00
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
srvCmd.HandleServer(server)
|
2014-02-24 04:13:45 +01:00
|
|
|
}
|
|
|
|
|
2014-03-02 20:36:00 +01:00
|
|
|
func (server *Server) Shutdown() {
|
|
|
|
server.db.Close()
|
2014-03-06 20:56:32 +01:00
|
|
|
for _, client := range server.clients.byNick {
|
2014-03-02 20:36:00 +01:00
|
|
|
client.Reply(RplNotice(server, client, "shutting down"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-24 04:13:45 +01:00
|
|
|
func (server *Server) Run() {
|
2014-02-25 20:11:34 +01:00
|
|
|
done := false
|
|
|
|
for !done {
|
2014-02-17 07:38:43 +01:00
|
|
|
select {
|
2014-02-25 20:11:34 +01:00
|
|
|
case <-server.signals:
|
2014-03-02 20:36:00 +01:00
|
|
|
server.Shutdown()
|
2014-02-25 20:11:34 +01:00
|
|
|
done = true
|
|
|
|
|
2014-02-20 22:03:33 +01:00
|
|
|
case conn := <-server.newConns:
|
|
|
|
NewClient(server, conn)
|
|
|
|
|
2014-02-24 07:21:39 +01:00
|
|
|
case cmd := <-server.commands:
|
2014-02-25 02:45:04 +01:00
|
|
|
server.processCommand(cmd)
|
2014-02-24 07:21:39 +01:00
|
|
|
|
2014-02-18 20:22:56 +01:00
|
|
|
case client := <-server.idle:
|
|
|
|
client.Idle()
|
2014-02-15 03:28:36 +01:00
|
|
|
}
|
2014-02-14 03:39:33 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-20 04:30:49 +01:00
|
|
|
//
|
|
|
|
// listen goroutine
|
|
|
|
//
|
|
|
|
|
2016-04-13 12:45:09 +02:00
|
|
|
func (s *Server) listen(addr string, ssl map[Name]*tls.Config) {
|
|
|
|
config, listenSSL := ssl[NewName(addr)]
|
|
|
|
|
2014-03-01 23:34:51 +01:00
|
|
|
listener, err := net.Listen("tcp", addr)
|
2012-04-07 20:44:59 +02:00
|
|
|
if err != nil {
|
2014-02-18 19:22:40 +01:00
|
|
|
log.Fatal(s, "listen error: ", err)
|
2012-04-07 20:44:59 +02:00
|
|
|
}
|
|
|
|
|
2016-04-13 12:45:09 +02:00
|
|
|
if listenSSL {
|
|
|
|
listener = tls.NewListener(listener, config)
|
|
|
|
}
|
|
|
|
Log.info.Printf("%s listening on %s. ssl: %t", s, addr, listenSSL)
|
2012-12-09 07:54:58 +01:00
|
|
|
|
2014-03-14 01:19:39 +01:00
|
|
|
go func() {
|
|
|
|
for {
|
|
|
|
conn, err := listener.Accept()
|
|
|
|
if err != nil {
|
|
|
|
Log.error.Printf("%s accept error: %s", s, err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
Log.debug.Printf("%s accept: %s", s, conn.RemoteAddr())
|
2014-02-17 07:30:01 +01:00
|
|
|
|
2014-03-14 01:19:39 +01:00
|
|
|
s.newConns <- conn
|
|
|
|
}
|
|
|
|
}()
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
2015-05-04 07:47:26 +02:00
|
|
|
//
|
|
|
|
// websocket listen goroutine
|
|
|
|
//
|
|
|
|
|
|
|
|
func (s *Server) wslisten(addr string) {
|
2016-04-13 12:45:09 +02:00
|
|
|
//TODO(dan): open a https websocket here if ssl/tls details are setup in the config for the wslistener
|
2015-05-04 07:47:26 +02:00
|
|
|
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
if r.Method != "GET" {
|
|
|
|
Log.error.Printf("%s method not allowed", s)
|
|
|
|
return
|
|
|
|
}
|
2015-06-07 00:11:59 +02:00
|
|
|
|
|
|
|
// We don't have any subprotocols, so if someone attempts to `new
|
|
|
|
// WebSocket(server, "subprotocol")` they'll break here, instead of
|
|
|
|
// getting the default, ambiguous, response from gorilla.
|
|
|
|
if v, ok := r.Header["Sec-Websocket-Protocol"]; ok {
|
|
|
|
http.Error(w, fmt.Sprintf("WebSocket subprocotols (e.g. %s) not supported", v), 400)
|
|
|
|
}
|
|
|
|
|
2015-05-04 07:47:26 +02:00
|
|
|
ws, err := upgrader.Upgrade(w, r, nil)
|
|
|
|
if err != nil {
|
|
|
|
Log.error.Printf("%s websocket upgrade error: %s", s, err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-06-07 01:11:06 +02:00
|
|
|
s.newConns <- WSContainer{ws}
|
2015-05-04 07:47:26 +02:00
|
|
|
})
|
|
|
|
go func() {
|
|
|
|
Log.info.Printf("%s listening on %s", s, addr)
|
|
|
|
err := http.ListenAndServe(addr, nil)
|
|
|
|
if err != nil {
|
|
|
|
Log.error.Printf("%s listenAndServe error: %s", s, err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2014-02-15 03:28:36 +01:00
|
|
|
//
|
2012-12-09 07:54:58 +01:00
|
|
|
// server functionality
|
2014-02-15 03:28:36 +01:00
|
|
|
//
|
2012-12-09 07:54:58 +01:00
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
func (s *Server) tryRegister(c *Client) {
|
2014-03-13 01:52:25 +01:00
|
|
|
if c.registered || !c.HasNick() || !c.HasUsername() ||
|
|
|
|
(c.capState == CapNegotiating) {
|
|
|
|
return
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
2014-03-13 01:52:25 +01:00
|
|
|
|
|
|
|
c.Register()
|
|
|
|
c.RplWelcome()
|
|
|
|
c.RplYourHost()
|
|
|
|
c.RplCreated()
|
|
|
|
c.RplMyInfo()
|
2016-04-12 07:38:42 +02:00
|
|
|
c.RplISupport()
|
2014-03-13 01:52:25 +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) {
|
2016-04-13 07:49:30 +02:00
|
|
|
if len(server.motdLines) < 1 {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoMOTD()
|
2014-02-12 01:35:32 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplMOTDStart()
|
2016-04-13 07:49:30 +02:00
|
|
|
for _, line := range server.motdLines {
|
2016-04-12 05:03:59 +02:00
|
|
|
client.RplMOTD(line)
|
2014-02-12 01:35:32 +01:00
|
|
|
}
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplMOTDEnd()
|
2014-02-12 00:33:02 +01:00
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (s *Server) Id() Name {
|
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-03-09 21:45:36 +01:00
|
|
|
return s.name.String()
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (s *Server) Nick() Name {
|
2014-02-09 02:10:04 +01:00
|
|
|
return s.Id()
|
2012-12-17 04:13:53 +01:00
|
|
|
}
|
|
|
|
|
2014-04-15 17:49:52 +02:00
|
|
|
func (server *Server) Reply(target *Client, message string) {
|
|
|
|
target.Reply(RplPrivMsg(server, target, NewText(message)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (server *Server) Replyf(target *Client, format string, args ...interface{}) {
|
|
|
|
server.Reply(target, fmt.Sprintf(format, args...))
|
|
|
|
}
|
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
//
|
2014-03-01 04:21:33 +01:00
|
|
|
// registration commands
|
2012-12-15 23:34:20 +01:00
|
|
|
//
|
|
|
|
|
2014-03-01 04:21:33 +01:00
|
|
|
func (msg *PassCommand) HandleRegServer(server *Server) {
|
2014-02-24 07:21:39 +01:00
|
|
|
client := msg.Client()
|
2014-02-24 18:41:09 +01:00
|
|
|
if msg.err != nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrPasswdMismatch()
|
2014-02-24 02:04:24 +01:00
|
|
|
client.Quit("bad password")
|
2014-02-15 03:28:36 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-03-01 04:21:33 +01:00
|
|
|
client.authorized = true
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2014-02-24 02:04:24 +01:00
|
|
|
func (msg *ProxyCommand) HandleRegServer(server *Server) {
|
|
|
|
msg.Client().hostname = msg.hostname
|
|
|
|
}
|
|
|
|
|
2014-02-18 07:10:48 +01:00
|
|
|
func (msg *RFC1459UserCommand) HandleRegServer(server *Server) {
|
2014-03-01 04:21:33 +01:00
|
|
|
client := msg.Client()
|
|
|
|
if !client.authorized {
|
|
|
|
client.ErrPasswdMismatch()
|
|
|
|
client.Quit("bad password")
|
|
|
|
return
|
|
|
|
}
|
2014-03-07 02:07:23 +01:00
|
|
|
msg.setUserInfo(server)
|
2014-02-18 07:10:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (msg *RFC2812UserCommand) HandleRegServer(server *Server) {
|
|
|
|
client := msg.Client()
|
2014-03-01 04:21:33 +01:00
|
|
|
if !client.authorized {
|
|
|
|
client.ErrPasswdMismatch()
|
|
|
|
client.Quit("bad password")
|
|
|
|
return
|
|
|
|
}
|
2014-02-18 07:10:48 +01:00
|
|
|
flags := msg.Flags()
|
|
|
|
if len(flags) > 0 {
|
2014-03-13 21:18:40 +01:00
|
|
|
for _, mode := range flags {
|
2014-02-18 07:10:48 +01:00
|
|
|
client.flags[mode] = true
|
|
|
|
}
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplUModeIs(client)
|
2014-02-18 07:10:48 +01:00
|
|
|
}
|
2014-03-07 02:07:23 +01:00
|
|
|
msg.setUserInfo(server)
|
2014-02-18 07:10:48 +01:00
|
|
|
}
|
|
|
|
|
2014-03-07 02:07:23 +01:00
|
|
|
func (msg *UserCommand) setUserInfo(server *Server) {
|
2014-02-17 07:20:42 +01:00
|
|
|
client := msg.Client()
|
2014-03-07 02:44:37 +01:00
|
|
|
|
2014-03-07 01:51:33 +01:00
|
|
|
server.clients.Remove(client)
|
2014-02-18 07:10:48 +01:00
|
|
|
client.username, client.realname = msg.username, msg.realname
|
2014-03-07 01:51:33 +01:00
|
|
|
server.clients.Add(client)
|
2014-03-07 02:44:37 +01:00
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
server.tryRegister(client)
|
2014-02-15 03:28:36 +01:00
|
|
|
}
|
|
|
|
|
2014-02-18 22:25:21 +01:00
|
|
|
func (msg *QuitCommand) HandleRegServer(server *Server) {
|
|
|
|
msg.Client().Quit(msg.message)
|
|
|
|
}
|
|
|
|
|
2014-02-15 03:28:36 +01:00
|
|
|
//
|
|
|
|
// normal commands
|
|
|
|
//
|
|
|
|
|
|
|
|
func (m *PassCommand) HandleServer(s *Server) {
|
2014-02-20 07:20:34 +01:00
|
|
|
m.Client().ErrAlreadyRegistered()
|
2014-02-15 03:28:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *PingCommand) HandleServer(s *Server) {
|
2014-04-15 17:49:52 +02:00
|
|
|
client := m.Client()
|
|
|
|
client.Reply(RplPong(client, m.server.Text()))
|
2014-02-15 03:28:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *PongCommand) HandleServer(s *Server) {
|
|
|
|
// no-op
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2014-02-18 07:10:48 +01:00
|
|
|
func (m *UserCommand) HandleServer(s *Server) {
|
2014-02-20 07:20:34 +01:00
|
|
|
m.Client().ErrAlreadyRegistered()
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
func (msg *QuitCommand) HandleServer(server *Server) {
|
2014-02-18 08:58:02 +01:00
|
|
|
msg.Client().Quit(msg.message)
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2013-05-09 18:12:03 +02:00
|
|
|
func (m *JoinCommand) HandleServer(s *Server) {
|
2014-02-17 07:20:42 +01:00
|
|
|
client := m.Client()
|
2012-12-17 04:13:53 +01:00
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
if m.zero {
|
2014-02-17 07:20:42 +01:00
|
|
|
for channel := range client.channels {
|
2014-03-09 21:45:36 +01:00
|
|
|
channel.Part(client, client.Nick().Text())
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
2012-12-17 04:13:53 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-19 04:31:59 +01:00
|
|
|
for name, key := range m.channels {
|
2014-03-09 21:45:36 +01:00
|
|
|
if !name.IsChannel() {
|
2014-02-22 02:19:02 +01:00
|
|
|
client.ErrNoSuchChannel(name)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := s.channels.Get(name)
|
2014-02-22 02:19:02 +01:00
|
|
|
if channel == nil {
|
|
|
|
channel = NewChannel(s, name)
|
|
|
|
}
|
2014-02-19 04:31:59 +01:00
|
|
|
channel.Join(client, key)
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-16 05:20:37 +01:00
|
|
|
func (m *PartCommand) HandleServer(server *Server) {
|
2014-02-17 07:20:42 +01:00
|
|
|
client := m.Client()
|
2012-12-15 23:34:20 +01:00
|
|
|
for _, chname := range m.channels {
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(chname)
|
2012-12-15 23:34:20 +01:00
|
|
|
|
|
|
|
if channel == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
m.Client().ErrNoSuchChannel(chname)
|
2012-12-15 23:34:20 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
channel.Part(client, m.Message())
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
func (msg *TopicCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(msg.channel)
|
2012-12-17 04:13:53 +01:00
|
|
|
if channel == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchChannel(msg.channel)
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
if msg.setTopic {
|
|
|
|
channel.SetTopic(client, msg.topic)
|
|
|
|
} else {
|
|
|
|
channel.GetTopic(client)
|
|
|
|
}
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
func (msg *PrivMsgCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
2014-03-09 21:45:36 +01:00
|
|
|
if msg.target.IsChannel() {
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(msg.target)
|
2012-12-15 23:34:20 +01:00
|
|
|
if channel == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchChannel(msg.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
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
channel.PrivMsg(client, msg.message)
|
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-26 05:17:26 +01:00
|
|
|
target := server.clients.Get(msg.target)
|
2012-12-17 04:13:53 +01:00
|
|
|
if target == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchNick(msg.target)
|
2012-12-15 23:34:20 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-22 20:40:32 +01:00
|
|
|
target.Reply(RplPrivMsg(client, target, msg.message))
|
2014-02-17 22:22:35 +01:00
|
|
|
if target.flags[Away] {
|
2014-02-25 16:28:09 +01:00
|
|
|
client.RplAway(target)
|
2014-02-12 00:44:58 +01:00
|
|
|
}
|
2012-04-07 20:44:59 +02:00
|
|
|
}
|
2012-12-13 08:27:17 +01:00
|
|
|
|
2016-04-14 14:33:38 +02:00
|
|
|
func (client *Client) WhoisChannelsNames(target *Client) []string {
|
|
|
|
isMultiPrefix := target.capabilities[MultiPrefix]
|
|
|
|
var chstrs []string
|
2014-02-20 07:20:34 +01:00
|
|
|
index := 0
|
|
|
|
for channel := range client.channels {
|
2016-04-14 14:33:38 +02:00
|
|
|
// channel is secret and the target can't see it
|
|
|
|
if !target.flags[Operator] && channel.flags[Secret] && !channel.members.Has(target) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
chstrs = append(chstrs, channel.members[client].Prefixes(isMultiPrefix)+channel.name.String())
|
|
|
|
index++
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
|
|
|
return chstrs
|
|
|
|
}
|
|
|
|
|
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 {
|
2014-03-06 20:56:32 +01:00
|
|
|
matches := server.clients.FindAll(mask)
|
|
|
|
if len(matches) == 0 {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchNick(mask)
|
2014-02-18 04:08:57 +01:00
|
|
|
continue
|
|
|
|
}
|
2014-03-06 20:56:32 +01:00
|
|
|
for mclient := range matches {
|
|
|
|
client.RplWhois(mclient)
|
2014-02-09 02:43:59 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-02-09 03:14:39 +01:00
|
|
|
|
2014-03-06 20:56:32 +01:00
|
|
|
func whoChannel(client *Client, channel *Channel, friends ClientSet) {
|
2014-02-09 03:49:52 +01:00
|
|
|
for member := range channel.members {
|
2014-03-06 20:56:32 +01:00
|
|
|
if !client.flags[Invisible] || friends[client] {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplWhoReply(channel, member)
|
2014-02-18 06:30:14 +01:00
|
|
|
}
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (msg *WhoCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
2014-03-06 20:56:32 +01:00
|
|
|
friends := client.Friends()
|
|
|
|
mask := msg.mask
|
2014-02-09 03:49:52 +01:00
|
|
|
|
2014-02-09 07:42:14 +01:00
|
|
|
if mask == "" {
|
2014-02-09 03:49:52 +01:00
|
|
|
for _, channel := range server.channels {
|
2014-03-06 20:56:32 +01:00
|
|
|
whoChannel(client, channel, friends)
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
2014-03-09 21:45:36 +01:00
|
|
|
} else if mask.IsChannel() {
|
2014-03-06 20:56:32 +01:00
|
|
|
// TODO implement wildcard matching
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(mask)
|
2014-02-09 03:49:52 +01:00
|
|
|
if channel != nil {
|
2014-03-06 20:56:32 +01:00
|
|
|
whoChannel(client, channel, friends)
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
|
|
|
} else {
|
2014-03-06 20:56:32 +01:00
|
|
|
for mclient := range server.clients.FindAll(mask) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplWhoReply(nil, mclient)
|
2014-02-09 03:49:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplEndOfWho(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()
|
|
|
|
|
2014-02-24 18:41:09 +01:00
|
|
|
if (msg.hash == nil) || (msg.err != nil) {
|
2014-02-24 07:21:39 +01:00
|
|
|
client.ErrPasswdMismatch()
|
|
|
|
return
|
|
|
|
}
|
2014-02-09 19:07:40 +01:00
|
|
|
|
2014-02-24 07:21:39 +01:00
|
|
|
client.flags[Operator] = true
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplYoureOper()
|
2014-04-15 17:49:52 +02:00
|
|
|
client.Reply(RplModeChanges(client, client, ModeChanges{&ModeChange{
|
|
|
|
mode: Operator,
|
|
|
|
op: Add,
|
|
|
|
}}))
|
2014-02-09 19:07:40 +01:00
|
|
|
}
|
2014-02-10 20:14:34 +01:00
|
|
|
|
2014-02-12 00:44:58 +01:00
|
|
|
func (msg *AwayCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
2014-04-15 17:49:52 +02:00
|
|
|
if len(msg.text) > 0 {
|
2014-02-17 22:22:35 +01:00
|
|
|
client.flags[Away] = true
|
|
|
|
} else {
|
|
|
|
delete(client.flags, Away)
|
|
|
|
}
|
2014-02-12 00:44:58 +01:00
|
|
|
client.awayMessage = msg.text
|
|
|
|
|
2014-04-15 17:49:52 +02:00
|
|
|
var op ModeOp
|
2014-02-17 22:22:35 +01:00
|
|
|
if client.flags[Away] {
|
2014-04-15 17:49:52 +02:00
|
|
|
op = Add
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplNowAway()
|
2014-02-12 00:44:58 +01:00
|
|
|
} else {
|
2014-04-15 17:49:52 +02:00
|
|
|
op = Remove
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplUnAway()
|
2014-02-12 00:44:58 +01:00
|
|
|
}
|
2014-04-15 17:49:52 +02:00
|
|
|
client.Reply(RplModeChanges(client, client, ModeChanges{&ModeChange{
|
|
|
|
mode: Away,
|
|
|
|
op: op,
|
|
|
|
}}))
|
2014-02-12 00:44:58 +01:00
|
|
|
}
|
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 {
|
2014-02-18 02:58:22 +01:00
|
|
|
if iclient := server.clients.Get(nick); iclient != nil {
|
2014-03-09 21:45:36 +01:00
|
|
|
ison = append(ison, iclient.Nick().String())
|
2014-02-12 00:58:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplIsOn(ison)
|
2014-02-12 00:58:54 +01:00
|
|
|
}
|
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) {
|
2014-02-17 07:20:42 +01:00
|
|
|
client := msg.Client()
|
2014-03-09 21:45:36 +01:00
|
|
|
if msg.target.IsChannel() {
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(msg.target)
|
2014-02-12 02:11:59 +01:00
|
|
|
if channel == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchChannel(msg.target)
|
2014-02-12 02:11:59 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
channel.Notice(client, msg.message)
|
2014-02-12 02:11:59 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-18 02:58:22 +01:00
|
|
|
target := server.clients.Get(msg.target)
|
2014-02-12 02:11:59 +01:00
|
|
|
if target == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchNick(msg.target)
|
2014-02-12 02:11:59 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-22 20:40:32 +01:00
|
|
|
target.Reply(RplNotice(client, target, msg.message))
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
2014-02-17 08:29:11 +01:00
|
|
|
|
|
|
|
func (msg *KickCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
for chname, nickname := range msg.kicks {
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(chname)
|
2014-02-17 08:29:11 +01:00
|
|
|
if channel == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchChannel(chname)
|
2014-02-17 08:29:11 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-02-26 05:17:26 +01:00
|
|
|
target := server.clients.Get(nickname)
|
2014-02-17 08:29:11 +01:00
|
|
|
if target == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchNick(nickname)
|
2014-02-17 08:29:11 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2016-04-14 01:35:36 +02:00
|
|
|
// make sure client has privs to kick the given user
|
|
|
|
var hasPrivs bool
|
|
|
|
for _, mode := range ChannelPrivModes {
|
|
|
|
if channel.members[client][mode] {
|
|
|
|
hasPrivs = true
|
|
|
|
|
|
|
|
// admins cannot kick other admins
|
|
|
|
if mode == ChannelAdmin && channel.members[target][ChannelAdmin] {
|
|
|
|
hasPrivs = false
|
|
|
|
}
|
|
|
|
|
|
|
|
break
|
|
|
|
} else if channel.members[target][mode] {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if hasPrivs {
|
|
|
|
channel.Kick(client, target, msg.Comment())
|
|
|
|
} else {
|
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
|
|
|
}
|
2014-02-17 08:29:11 +01:00
|
|
|
}
|
|
|
|
}
|
2014-02-17 08:51:27 +01:00
|
|
|
|
|
|
|
func (msg *ListCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
|
|
|
|
// TODO target server
|
|
|
|
if msg.target != "" {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchServer(msg.target)
|
2014-02-17 08:51:27 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(msg.channels) == 0 {
|
|
|
|
for _, channel := range server.channels {
|
2016-04-14 14:33:38 +02:00
|
|
|
if !client.flags[Operator] && channel.flags[Secret] {
|
2014-02-17 08:51:27 +01:00
|
|
|
continue
|
|
|
|
}
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplList(channel)
|
2014-02-17 08:51:27 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for _, chname := range msg.channels {
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(chname)
|
2016-04-14 14:33:38 +02:00
|
|
|
if channel == nil || (!client.flags[Operator] && channel.flags[Secret]) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchChannel(chname)
|
2014-02-17 08:51:27 +01:00
|
|
|
continue
|
|
|
|
}
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplList(channel)
|
2014-02-17 08:51:27 +01:00
|
|
|
}
|
|
|
|
}
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplListEnd(server)
|
2014-02-17 08:51:27 +01:00
|
|
|
}
|
2014-02-18 03:10:52 +01:00
|
|
|
|
2014-02-18 06:02:03 +01:00
|
|
|
func (msg *NamesCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
if len(server.channels) == 0 {
|
|
|
|
for _, channel := range server.channels {
|
|
|
|
channel.Names(client)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, chname := range msg.channels {
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(chname)
|
2014-02-18 06:02:03 +01:00
|
|
|
if channel == nil {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNoSuchChannel(chname)
|
2014-02-18 06:02:03 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
channel.Names(client)
|
|
|
|
}
|
|
|
|
}
|
2014-02-23 19:04:31 +01:00
|
|
|
|
2014-02-25 07:04:11 +01:00
|
|
|
func (msg *VersionCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
if (msg.target != "") && (msg.target != server.name) {
|
|
|
|
client.ErrNoSuchServer(msg.target)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
client.RplVersion()
|
2016-04-14 01:55:22 +02:00
|
|
|
client.RplISupport()
|
2014-02-25 07:04:11 +01:00
|
|
|
}
|
2014-02-25 16:28:09 +01:00
|
|
|
|
|
|
|
func (msg *InviteCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
|
|
|
|
target := server.clients.Get(msg.nickname)
|
|
|
|
if target == nil {
|
|
|
|
client.ErrNoSuchNick(msg.nickname)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-26 05:17:26 +01:00
|
|
|
channel := server.channels.Get(msg.channel)
|
2014-02-25 16:28:09 +01:00
|
|
|
if channel == nil {
|
2014-03-06 07:54:50 +01:00
|
|
|
client.RplInviting(target, msg.channel)
|
|
|
|
target.Reply(RplInviteMsg(client, target, msg.channel))
|
2014-02-25 16:28:09 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
channel.Invite(target, client)
|
|
|
|
}
|
2014-02-25 16:45:40 +01:00
|
|
|
|
|
|
|
func (msg *TimeCommand) HandleServer(server *Server) {
|
2014-02-25 18:10:16 +01:00
|
|
|
client := msg.Client()
|
2014-02-25 16:45:40 +01:00
|
|
|
if (msg.target != "") && (msg.target != server.name) {
|
2014-02-25 18:10:16 +01:00
|
|
|
client.ErrNoSuchServer(msg.target)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
client.RplTime()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (msg *KillCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
if !client.flags[Operator] {
|
|
|
|
client.ErrNoPrivileges()
|
2014-02-25 16:45:40 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-25 18:10:16 +01:00
|
|
|
|
|
|
|
target := server.clients.Get(msg.nickname)
|
|
|
|
if target == nil {
|
|
|
|
client.ErrNoSuchNick(msg.nickname)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
quitMsg := fmt.Sprintf("KILLed by %s: %s", client.Nick(), msg.comment)
|
2014-03-09 21:45:36 +01:00
|
|
|
target.Quit(NewText(quitMsg))
|
2014-02-25 16:45:40 +01:00
|
|
|
}
|
2014-03-06 20:56:32 +01:00
|
|
|
|
2014-03-06 21:14:21 +01:00
|
|
|
func (msg *WhoWasCommand) HandleServer(server *Server) {
|
|
|
|
client := msg.Client()
|
|
|
|
for _, nickname := range msg.nicknames {
|
2014-03-06 22:55:25 +01:00
|
|
|
results := server.whoWas.Find(nickname, msg.count)
|
|
|
|
if len(results) == 0 {
|
|
|
|
client.ErrWasNoSuchNick(nickname)
|
|
|
|
} else {
|
|
|
|
for _, whoWas := range results {
|
|
|
|
client.RplWhoWasUser(whoWas)
|
|
|
|
}
|
|
|
|
}
|
2014-03-06 21:14:21 +01:00
|
|
|
client.RplEndOfWhoWas(nickname)
|
|
|
|
}
|
|
|
|
}
|