123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223 |
- // Copyright (c) 2012-2014 Jeremy Latt
- // Copyright (c) 2014-2015 Edmund Huber
- // Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
- // released under the MIT license
-
- package irc
-
- import (
- "bufio"
- "context"
- "crypto/tls"
- "encoding/base64"
- "fmt"
- "log"
- "math/rand"
- "net"
- "net/http"
- "os"
- "os/signal"
- "strconv"
- "strings"
- "sync"
- "syscall"
- "time"
-
- "github.com/goshuirc/irc-go/ircfmt"
- "github.com/goshuirc/irc-go/ircmsg"
- "github.com/oragono/oragono/irc/caps"
- "github.com/oragono/oragono/irc/logger"
- "github.com/oragono/oragono/irc/sno"
- "github.com/tidwall/buntdb"
- )
-
- var (
- // common error line to sub values into
- errorMsg, _ = (&[]ircmsg.IrcMessage{ircmsg.MakeMessage(nil, "", "ERROR", "%s ")}[0]).Line()
-
- // common error responses
- couldNotParseIPMsg, _ = (&[]ircmsg.IrcMessage{ircmsg.MakeMessage(nil, "", "ERROR", "Unable to parse your IP address")}[0]).Line()
- )
-
- const (
- // when shutting down the REST server, wait this long
- // before killing active connections. TODO: this might not be
- // necessary at all? but it seems prudent to avoid potential resource
- // leaks
- httpShutdownTimeout = time.Second
- )
-
- // Limits holds the maximum limits for various things such as topic lengths.
- type Limits struct {
- AwayLen int
- ChannelLen int
- KickLen int
- MonitorEntries int
- NickLen int
- TopicLen int
- ChanListModes int
- LineLen LineLenLimits
- }
-
- // LineLenLimits holds the maximum limits for IRC lines.
- type LineLenLimits struct {
- Tags int
- Rest int
- }
-
- // ListenerWrapper wraps a listener so it can be safely reconfigured or stopped
- type ListenerWrapper struct {
- listener net.Listener
- tlsConfig *tls.Config
- shouldStop bool
- // lets the ListenerWrapper inform the server that it has stopped:
- stopEvent chan bool
- // protects atomic update of tlsConfig and shouldStop:
- configMutex sync.Mutex
- }
-
- // Server is the main Oragono server.
- type Server struct {
- accountAuthenticationEnabled bool
- accountRegistration *AccountRegistration
- accounts map[string]*ClientAccount
- channelRegistrationEnabled bool
- channels ChannelNameMap
- channelJoinPartMutex sync.Mutex // used when joining/parting channels to prevent stomping over each others' access and all
- checkIdent bool
- clients *ClientLookupSet
- commands chan Command
- configFilename string
- configurableStateMutex sync.RWMutex // generic protection for server state modified by rehash()
- connectionLimits *ConnectionLimits
- connectionLimitsMutex sync.Mutex // used when affecting the connection limiter, to make sure rehashing doesn't make things go out-of-whack
- connectionThrottle *ConnectionThrottle
- connectionThrottleMutex sync.Mutex // used when affecting the connection limiter, to make sure rehashing doesn't make things go out-of-whack
- ctime time.Time
- defaultChannelModes Modes
- dlines *DLineManager
- isupport *ISupportList
- klines *KLineManager
- limits Limits
- listeners map[string]*ListenerWrapper
- logger *logger.Manager
- MaxSendQBytes uint64
- monitorManager *MonitorManager
- motdLines []string
- name string
- nameCasefolded string
- networkName string
- newConns chan clientConn
- operators map[string]Oper
- operclasses map[string]OperClass
- password []byte
- passwords *PasswordManager
- registeredChannels map[string]*RegisteredChannel
- registeredChannelsMutex sync.RWMutex
- rehashMutex sync.Mutex
- rehashSignal chan os.Signal
- restAPI RestAPIConfig
- restAPIServer *http.Server
- proxyAllowedFrom []string
- signals chan os.Signal
- snomasks *SnoManager
- store *buntdb.DB
- stsEnabled bool
- whoWas *WhoWasList
- }
-
- var (
- // ServerExitSignals are the signals the server will exit on.
- ServerExitSignals = []os.Signal{
- syscall.SIGINT,
- syscall.SIGTERM,
- syscall.SIGQUIT,
- }
- )
-
- type clientConn struct {
- Conn net.Conn
- IsTLS bool
- }
-
- // NewServer returns a new Oragono server.
- func NewServer(config *Config, logger *logger.Manager) (*Server, error) {
- // TODO move this to main?
- if err := GenerateHelpIndices(); err != nil {
- return nil, err
- }
-
- // initialize data structures
- server := &Server{
- accounts: make(map[string]*ClientAccount),
- channels: *NewChannelNameMap(),
- clients: NewClientLookupSet(),
- commands: make(chan Command),
- listeners: make(map[string]*ListenerWrapper),
- logger: logger,
- monitorManager: NewMonitorManager(),
- newConns: make(chan clientConn),
- registeredChannels: make(map[string]*RegisteredChannel),
- rehashSignal: make(chan os.Signal, 1),
- signals: make(chan os.Signal, len(ServerExitSignals)),
- snomasks: NewSnoManager(),
- whoWas: NewWhoWasList(config.Limits.WhowasEntries),
- }
-
- if err := server.applyConfig(config, true); err != nil {
- return nil, err
- }
-
- // Attempt to clean up when receiving these signals.
- signal.Notify(server.signals, ServerExitSignals...)
- signal.Notify(server.rehashSignal, syscall.SIGHUP)
-
- return server, nil
- }
-
- // setISupport sets up our RPL_ISUPPORT reply.
- func (server *Server) setISupport() {
- maxTargetsString := strconv.Itoa(maxTargets)
-
- server.configurableStateMutex.RLock()
-
- // add RPL_ISUPPORT tokens
- isupport := NewISupportList()
- isupport.Add("AWAYLEN", strconv.Itoa(server.limits.AwayLen))
- isupport.Add("CASEMAPPING", casemappingName)
- isupport.Add("CHANMODES", strings.Join([]string{Modes{BanMask, ExceptMask, InviteMask}.String(), "", Modes{UserLimit, Key}.String(), Modes{InviteOnly, Moderated, NoOutside, OpOnlyTopic, ChanRoleplaying, Secret}.String()}, ","))
- isupport.Add("CHANNELLEN", strconv.Itoa(server.limits.ChannelLen))
- isupport.Add("CHANTYPES", "#")
- isupport.Add("ELIST", "U")
- isupport.Add("EXCEPTS", "")
- isupport.Add("INVEX", "")
- isupport.Add("KICKLEN", strconv.Itoa(server.limits.KickLen))
- isupport.Add("MAXLIST", fmt.Sprintf("beI:%s", strconv.Itoa(server.limits.ChanListModes)))
- isupport.Add("MAXTARGETS", maxTargetsString)
- isupport.Add("MODES", "")
- isupport.Add("MONITOR", strconv.Itoa(server.limits.MonitorEntries))
- isupport.Add("NETWORK", server.networkName)
- isupport.Add("NICKLEN", strconv.Itoa(server.limits.NickLen))
- isupport.Add("PREFIX", "(qaohv)~&@%+")
- isupport.Add("RPCHAN", "E")
- isupport.Add("RPUSER", "E")
- isupport.Add("STATUSMSG", "~&@%+")
- isupport.Add("TARGMAX", fmt.Sprintf("NAMES:1,LIST:1,KICK:1,WHOIS:1,USERHOST:10,PRIVMSG:%s,TAGMSG:%s,NOTICE:%s,MONITOR:", maxTargetsString, maxTargetsString, maxTargetsString))
- isupport.Add("TOPICLEN", strconv.Itoa(server.limits.TopicLen))
-
- // account registration
- if server.accountRegistration.Enabled {
- // 'none' isn't shown in the REGCALLBACKS vars
- var enabledCallbacks []string
- for _, name := range server.accountRegistration.EnabledCallbacks {
- if name != "*" {
- enabledCallbacks = append(enabledCallbacks, name)
- }
- }
-
- isupport.Add("REGCOMMANDS", "CREATE,VERIFY")
- isupport.Add("REGCALLBACKS", strings.Join(enabledCallbacks, ","))
- isupport.Add("REGCREDTYPES", "passphrase,certfp")
- }
-
- server.configurableStateMutex.RUnlock()
-
- isupport.RegenerateCachedReply()
-
- server.configurableStateMutex.Lock()
- server.isupport = isupport
- server.configurableStateMutex.Unlock()
- }
-
- func loadChannelList(channel *Channel, list string, maskMode Mode) {
- if list == "" {
- return
- }
- channel.lists[maskMode].AddAll(strings.Split(list, " "))
- }
-
- // Shutdown shuts down the server.
- func (server *Server) Shutdown() {
- //TODO(dan): Make sure we disallow new nicks
- server.clients.ByNickMutex.RLock()
- for _, client := range server.clients.ByNick {
- client.Notice("Server is shutting down")
- }
- server.clients.ByNickMutex.RUnlock()
-
- if err := server.store.Close(); err != nil {
- server.logger.Error("shutdown", fmt.Sprintln("Could not close datastore:", err))
- }
- }
-
- // Run starts the server.
- func (server *Server) Run() {
- // defer closing db/store
- defer server.store.Close()
-
- done := false
- for !done {
- select {
- case <-server.signals:
- server.Shutdown()
- done = true
-
- case <-server.rehashSignal:
- server.logger.Info("rehash", "Rehashing due to SIGHUP")
- go func() {
- err := server.rehash()
- if err != nil {
- server.logger.Error("rehash", fmt.Sprintln("Failed to rehash:", err.Error()))
- }
- }()
-
- case conn := <-server.newConns:
- // check IP address
- ipaddr := net.ParseIP(IPString(conn.Conn.RemoteAddr()))
- if ipaddr == nil {
- conn.Conn.Write([]byte(couldNotParseIPMsg))
- conn.Conn.Close()
- continue
- }
-
- isBanned, banMsg := server.checkBans(ipaddr)
- if isBanned {
- // this might not show up properly on some clients, but our objective here is just to close the connection out before it has a load impact on us
- conn.Conn.Write([]byte(fmt.Sprintf(errorMsg, banMsg)))
- conn.Conn.Close()
- continue
- }
-
- server.logger.Debug("localconnect-ip", fmt.Sprintf("Client connecting from %v", ipaddr))
- // prolly don't need to alert snomasks on this, only on connection reg
-
- go NewClient(server, conn.Conn, conn.IsTLS)
- continue
- }
- }
- }
-
- func (server *Server) checkBans(ipaddr net.IP) (banned bool, message string) {
- // check DLINEs
- isBanned, info := server.dlines.CheckIP(ipaddr)
- if isBanned {
- return true, info.BanMessage("You are banned from this server (%s)")
- }
-
- // check connection limits
- server.connectionLimitsMutex.Lock()
- err := server.connectionLimits.AddClient(ipaddr, false)
- server.connectionLimitsMutex.Unlock()
- if err != nil {
- // too many connections from one client, tell the client and close the connection
- return true, "Too many clients from your network"
- }
-
- // check connection throttle
- server.connectionThrottleMutex.Lock()
- err = server.connectionThrottle.AddClient(ipaddr)
- server.connectionThrottleMutex.Unlock()
- if err != nil {
- // too many connections too quickly from client, tell them and close the connection
- length := &IPRestrictTime{
- Duration: server.connectionThrottle.BanDuration,
- Expires: time.Now().Add(server.connectionThrottle.BanDuration),
- }
- server.dlines.AddIP(ipaddr, length, server.connectionThrottle.BanMessage, "Exceeded automated connection throttle")
-
- // they're DLINE'd for 15 minutes or whatever, so we can reset the connection throttle now,
- // and once their temporary DLINE is finished they can fill up the throttler again
- server.connectionThrottle.ResetFor(ipaddr)
-
- // this might not show up properly on some clients, but our objective here is just to close it out before it has a load impact on us
- return true, server.connectionThrottle.BanMessage
- }
-
- return false, ""
- }
-
- //
- // IRC protocol listeners
- //
-
- // createListener starts the given listeners.
- func (server *Server) createListener(addr string, tlsConfig *tls.Config) *ListenerWrapper {
- // make listener
- listener, err := net.Listen("tcp", addr)
- if err != nil {
- log.Fatal(server, "listen error: ", err)
- }
-
- // throw our details to the server so we can be modified/killed later
- wrapper := ListenerWrapper{
- listener: listener,
- tlsConfig: tlsConfig,
- shouldStop: false,
- stopEvent: make(chan bool, 1),
- }
-
- var shouldStop bool
-
- // setup accept goroutine
- go func() {
- for {
- conn, err := listener.Accept()
-
- // synchronously access config data:
- // whether TLS is enabled and whether we should stop listening
- wrapper.configMutex.Lock()
- shouldStop = wrapper.shouldStop
- tlsConfig = wrapper.tlsConfig
- wrapper.configMutex.Unlock()
-
- if err == nil {
- if tlsConfig != nil {
- conn = tls.Server(conn, tlsConfig)
- }
- newConn := clientConn{
- Conn: conn,
- IsTLS: tlsConfig != nil,
- }
- // hand off the connection
- server.newConns <- newConn
- }
-
- if shouldStop {
- listener.Close()
- wrapper.stopEvent <- true
- return
- }
- }
- }()
-
- return &wrapper
- }
-
- // generateMessageID returns a network-unique message ID.
- func (server *Server) generateMessageID() string {
- return fmt.Sprintf("%s-%s", strconv.FormatInt(time.Now().UTC().UnixNano(), 10), strconv.FormatInt(rand.Int63(), 10))
- }
-
- //
- // server functionality
- //
-
- func (server *Server) tryRegister(c *Client) {
- if c.registered || !c.HasNick() || !c.HasUsername() ||
- (c.capState == CapNegotiating) {
- return
- }
-
- // check KLINEs
- isBanned, info := server.klines.CheckMasks(c.AllNickmasks()...)
- if isBanned {
- reason := info.Reason
- if info.Time != nil {
- reason += fmt.Sprintf(" [%s]", info.Time.Duration.String())
- }
- c.Send(nil, "", "ERROR", fmt.Sprintf("You are banned from this server (%s)", reason))
- c.quitMessageSent = true
- c.destroy()
- return
- }
-
- // continue registration
- server.logger.Debug("localconnect", fmt.Sprintf("Client registered [%s] [u:%s] [r:%s]", c.nick, c.username, c.realname))
- server.snomasks.Send(sno.LocalConnects, fmt.Sprintf(ircfmt.Unescape("Client registered $c[grey][$r%s$c[grey]] [u:$r%s$c[grey]] [h:$r%s$c[grey]] [r:$r%s$c[grey]]"), c.nick, c.username, c.rawHostname, c.realname))
- c.Register()
-
- // send welcome text
- //NOTE(dan): we specifically use the NICK here instead of the nickmask
- // see http://modern.ircdocs.horse/#rplwelcome-001 for details on why we avoid using the nickmask
- c.Send(nil, server.name, RPL_WELCOME, c.nick, fmt.Sprintf("Welcome to the Internet Relay Network %s", c.nick))
- c.Send(nil, server.name, RPL_YOURHOST, c.nick, fmt.Sprintf("Your host is %s, running version %s", server.name, Ver))
- c.Send(nil, server.name, RPL_CREATED, c.nick, fmt.Sprintf("This server was created %s", server.ctime.Format(time.RFC1123)))
- //TODO(dan): Look at adding last optional [<channel modes with a parameter>] parameter
- c.Send(nil, server.name, RPL_MYINFO, c.nick, server.name, Ver, supportedUserModesString, supportedChannelModesString)
- c.RplISupport()
- server.MOTD(c)
- c.Send(nil, c.nickMaskString, RPL_UMODEIS, c.nick, c.ModeString())
- if server.logger.DumpingRawInOut {
- c.Notice("This server is in debug mode and is logging all user I/O. If you do not wish for everything you send to be readable by the server owner(s), please disconnect.")
- }
- }
-
- // MOTD serves the Message of the Day.
- func (server *Server) MOTD(client *Client) {
- server.configurableStateMutex.RLock()
- motdLines := server.motdLines
- server.configurableStateMutex.RUnlock()
-
- if len(motdLines) < 1 {
- client.Send(nil, server.name, ERR_NOMOTD, client.nick, "MOTD File is missing")
- return
- }
-
- client.Send(nil, server.name, RPL_MOTDSTART, client.nick, fmt.Sprintf("- %s Message of the day - ", server.name))
- for _, line := range motdLines {
- client.Send(nil, server.name, RPL_MOTD, client.nick, line)
- }
- client.Send(nil, server.name, RPL_ENDOFMOTD, client.nick, "End of MOTD command")
- }
-
- //
- // registration commands
- //
-
- // PASS <password>
- func passHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- if client.registered {
- client.Send(nil, server.name, ERR_ALREADYREGISTRED, client.nick, "You may not reregister")
- return false
- }
-
- // if no password exists, skip checking
- if len(server.password) == 0 {
- client.authorized = true
- return false
- }
-
- // check the provided password
- password := []byte(msg.Params[0])
- if ComparePassword(server.password, password) != nil {
- client.Send(nil, server.name, ERR_PASSWDMISMATCH, client.nick, "Password incorrect")
- client.Send(nil, server.name, "ERROR", "Password incorrect")
- return true
- }
-
- client.authorized = true
- return false
- }
-
- // USER <username> * 0 <realname>
- func userHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- if client.registered {
- client.Send(nil, server.name, ERR_ALREADYREGISTRED, client.nick, "You may not reregister")
- return false
- }
-
- if !client.authorized {
- client.Quit("Bad password")
- return true
- }
-
- if client.username != "" && client.realname != "" {
- return false
- }
-
- // confirm that username is valid
- //
- _, err := CasefoldName(msg.Params[0])
- if err != nil {
- client.Send(nil, "", "ERROR", "Malformed username")
- return true
- }
-
- if !client.HasUsername() {
- client.username = "~" + msg.Params[0]
- // don't bother updating nickmask here, it's not valid anyway
- }
- if client.realname == "" {
- client.realname = msg.Params[3]
- }
-
- server.tryRegister(client)
-
- return false
- }
-
- // QUIT [<reason>]
- func quitHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- reason := "Quit"
- if len(msg.Params) > 0 {
- reason += ": " + msg.Params[0]
- }
- client.Quit(reason)
- return true
- }
-
- //
- // normal commands
- //
-
- // PING <server1> [<server2>]
- func pingHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- client.Send(nil, server.name, "PONG", msg.Params...)
- return false
- }
-
- // PONG <server> [ <server2> ]
- func pongHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- // client gets touched when they send this command, so we don't need to do anything
- return false
- }
-
- // RENAME <oldchan> <newchan> [<reason>]
- //TODO(dan): Clean up this function so it doesn't look like an eldrich horror... prolly by putting it into a server.renameChannel function.
- func renameHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- // get lots of locks... make sure nobody touches anything while we're doing this
- server.registeredChannelsMutex.Lock()
- defer server.registeredChannelsMutex.Unlock()
- server.channels.ChansLock.Lock()
- defer server.channels.ChansLock.Unlock()
-
- oldName := strings.TrimSpace(msg.Params[0])
- newName := strings.TrimSpace(msg.Params[1])
- reason := "No reason"
- if 2 < len(msg.Params) {
- reason = msg.Params[2]
- }
-
- // check for all the reasons why the rename couldn't happen
- casefoldedOldName, err := CasefoldChannel(oldName)
- if err != nil {
- //TODO(dan): Change this to ERR_CANNOTRENAME
- client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "RENAME", oldName, "Old channel name is invalid")
- return false
- }
-
- channel := server.channels.Chans[casefoldedOldName]
- if channel == nil {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, oldName, "No such channel")
- return false
- }
-
- //TODO(dan): allow IRCops to do this?
- if !channel.ClientIsAtLeast(client, Operator) {
- client.Send(nil, server.name, ERR_CHANOPRIVSNEEDED, client.nick, oldName, "Only chanops can rename channels")
- return false
- }
-
- channel.membersMutex.Lock()
- defer channel.membersMutex.Unlock()
-
- casefoldedNewName, err := CasefoldChannel(newName)
- if err != nil {
- //TODO(dan): Change this to ERR_CANNOTRENAME
- client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "RENAME", newName, "New channel name is invalid")
- return false
- }
-
- newChannel := server.channels.Chans[casefoldedNewName]
- if newChannel != nil {
- //TODO(dan): Change this to ERR_CHANNAMEINUSE
- client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "RENAME", newName, "New channel name is in use")
- return false
- }
-
- var canEdit bool
- server.store.Update(func(tx *buntdb.Tx) error {
- chanReg := server.loadChannelNoMutex(tx, casefoldedOldName)
- if chanReg == nil || !client.LoggedIntoAccount() || client.account.Name == chanReg.Founder {
- canEdit = true
- }
-
- chanReg = server.loadChannelNoMutex(tx, casefoldedNewName)
- if chanReg != nil {
- canEdit = false
- }
- return nil
- })
- if !canEdit {
- //TODO(dan): Change this to ERR_CANNOTRENAME
- client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "RENAME", oldName, "Only channel founders can change registered channels")
- return false
- }
-
- // perform the channel rename
- server.channels.Chans[casefoldedOldName] = nil
- server.channels.Chans[casefoldedNewName] = channel
-
- channel.name = strings.TrimSpace(msg.Params[1])
- channel.nameCasefolded = casefoldedNewName
-
- // rename stored channel info if any exists
- server.store.Update(func(tx *buntdb.Tx) error {
- chanReg := server.loadChannelNoMutex(tx, casefoldedOldName)
- if chanReg == nil {
- return nil
- }
-
- server.deleteChannelNoMutex(tx, casefoldedOldName)
-
- chanReg.Name = newName
-
- server.saveChannelNoMutex(tx, casefoldedNewName, *chanReg)
- return nil
- })
-
- // send RENAME messages
- for mcl := range channel.members {
- if mcl.capabilities.Has(caps.Rename) {
- mcl.Send(nil, client.nickMaskString, "RENAME", oldName, newName, reason)
- } else {
- mcl.Send(nil, mcl.nickMaskString, "PART", oldName, fmt.Sprintf("Channel renamed: %s", reason))
- if mcl.capabilities.Has(caps.ExtendedJoin) {
- accountName := "*"
- if mcl.account != nil {
- accountName = mcl.account.Name
- }
- mcl.Send(nil, mcl.nickMaskString, "JOIN", newName, accountName, mcl.realname)
- } else {
- mcl.Send(nil, mcl.nickMaskString, "JOIN", newName)
- }
- }
- }
-
- return false
- }
-
- // JOIN <channel>{,<channel>} [<key>{,<key>}]
- func joinHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- // kill JOIN 0 requests
- if msg.Params[0] == "0" {
- client.Notice("JOIN 0 is not allowed")
- return false
- }
-
- // handle regular JOINs
- channels := strings.Split(msg.Params[0], ",")
- var keys []string
- if len(msg.Params) > 1 {
- keys = strings.Split(msg.Params[1], ",")
- }
-
- // get lock
- server.channelJoinPartMutex.Lock()
- defer server.channelJoinPartMutex.Unlock()
-
- for i, name := range channels {
- casefoldedName, err := CasefoldChannel(name)
- if err != nil {
- if len(name) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, name, "No such channel")
- }
- continue
- }
-
- channel := server.channels.Get(casefoldedName)
- if channel == nil {
- if len(casefoldedName) > server.getLimits().ChannelLen {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, name, "No such channel")
- continue
- }
- channel = NewChannel(server, name, true)
- }
-
- var key string
- if len(keys) > i {
- key = keys[i]
- }
-
- channel.Join(client, key)
- }
- return false
- }
-
- // PART <channel>{,<channel>} [<reason>]
- func partHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- channels := strings.Split(msg.Params[0], ",")
- var reason string //TODO(dan): if this isn't supplied here, make sure the param doesn't exist in the PART message sent to other users
- if len(msg.Params) > 1 {
- reason = msg.Params[1]
- }
-
- // get lock
- server.channelJoinPartMutex.Lock()
- defer server.channelJoinPartMutex.Unlock()
-
- for _, chname := range channels {
- casefoldedChannelName, err := CasefoldChannel(chname)
- channel := server.channels.Get(casefoldedChannelName)
-
- if err != nil || channel == nil {
- if len(chname) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, chname, "No such channel")
- }
- continue
- }
-
- channel.Part(client, reason)
- }
- return false
- }
-
- // TOPIC <channel> [<topic>]
- func topicHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- name, err := CasefoldChannel(msg.Params[0])
- channel := server.channels.Get(name)
- if err != nil || channel == nil {
- if len(msg.Params[0]) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, msg.Params[0], "No such channel")
- }
- return false
- }
-
- if len(msg.Params) > 1 {
- channel.SetTopic(client, msg.Params[1])
- } else {
- channel.GetTopic(client)
- }
- return false
- }
-
- // wordWrap wraps the given text into a series of lines that don't exceed lineWidth characters.
- func wordWrap(text string, lineWidth int) []string {
- var lines []string
- var cacheLine, cacheWord string
-
- for _, char := range text {
- if char == '\r' {
- continue
- } else if char == '\n' {
- cacheLine += cacheWord
- lines = append(lines, cacheLine)
- cacheWord = ""
- cacheLine = ""
- } else if (char == ' ' || char == '-') && len(cacheLine)+len(cacheWord)+1 < lineWidth {
- // natural word boundary
- cacheLine += cacheWord + string(char)
- cacheWord = ""
- } else if lineWidth <= len(cacheLine)+len(cacheWord)+1 {
- // time to wrap to next line
- if len(cacheLine) < (lineWidth / 2) {
- // this word takes up more than half a line... just split in the middle of the word
- cacheLine += cacheWord + string(char)
- cacheWord = ""
- } else {
- cacheWord += string(char)
- }
- lines = append(lines, cacheLine)
- cacheLine = ""
- } else {
- // normal character
- cacheWord += string(char)
- }
- }
- if 0 < len(cacheWord) {
- cacheLine += cacheWord
- }
- if 0 < len(cacheLine) {
- lines = append(lines, cacheLine)
- }
-
- return lines
- }
-
- // SplitMessage represents a message that's been split for sending.
- type SplitMessage struct {
- For512 []string
- ForMaxLine string
- }
-
- func (server *Server) splitMessage(original string, origIs512 bool) SplitMessage {
- var newSplit SplitMessage
-
- newSplit.ForMaxLine = original
-
- if !origIs512 {
- newSplit.For512 = wordWrap(original, 400)
- } else {
- newSplit.For512 = []string{original}
- }
-
- return newSplit
- }
-
- // PRIVMSG <target>{,<target>} <message>
- func privmsgHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- clientOnlyTags := GetClientOnlyTags(msg.Tags)
- targets := strings.Split(msg.Params[0], ",")
- message := msg.Params[1]
-
- // split privmsg
- splitMsg := server.splitMessage(message, !client.capabilities.Has(caps.MaxLine))
-
- for i, targetString := range targets {
- // max of four targets per privmsg
- if i > maxTargets-1 {
- break
- }
- prefixes, targetString := SplitChannelMembershipPrefixes(targetString)
- lowestPrefix := GetLowestChannelModePrefix(prefixes)
-
- // eh, no need to notify them
- if len(targetString) < 1 {
- continue
- }
-
- target, err := CasefoldChannel(targetString)
- if err == nil {
- channel := server.channels.Get(target)
- if channel == nil {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, targetString, "No such channel")
- continue
- }
- if !channel.CanSpeak(client) {
- client.Send(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, "Cannot send to channel")
- continue
- }
- msgid := server.generateMessageID()
- channel.SplitPrivMsg(msgid, lowestPrefix, clientOnlyTags, client, splitMsg)
- } else {
- target, err = CasefoldName(targetString)
- if target == "chanserv" {
- server.chanservReceivePrivmsg(client, message)
- continue
- } else if target == "nickserv" {
- server.nickservReceivePrivmsg(client, message)
- continue
- }
- user := server.clients.Get(target)
- if err != nil || user == nil {
- if len(target) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHNICK, client.nick, target, "No such nick")
- }
- continue
- }
- if !user.capabilities.Has(caps.MessageTags) {
- clientOnlyTags = nil
- }
- msgid := server.generateMessageID()
- // restrict messages appropriately when +R is set
- // intentionally make the sending user think the message went through fine
- if !user.flags[RegisteredOnly] || client.registered {
- user.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "PRIVMSG", user.nick, splitMsg)
- }
- if client.capabilities.Has(caps.EchoMessage) {
- client.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "PRIVMSG", user.nick, splitMsg)
- }
- if user.flags[Away] {
- //TODO(dan): possibly implement cooldown of away notifications to users
- client.Send(nil, server.name, RPL_AWAY, user.nick, user.awayMessage)
- }
- }
- }
- return false
- }
-
- // TAGMSG <target>{,<target>}
- func tagmsgHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- clientOnlyTags := GetClientOnlyTags(msg.Tags)
- // no client-only tags, so we can drop it
- if clientOnlyTags == nil {
- return false
- }
-
- targets := strings.Split(msg.Params[0], ",")
-
- for i, targetString := range targets {
- // max of four targets per privmsg
- if i > maxTargets-1 {
- break
- }
- prefixes, targetString := SplitChannelMembershipPrefixes(targetString)
- lowestPrefix := GetLowestChannelModePrefix(prefixes)
-
- // eh, no need to notify them
- if len(targetString) < 1 {
- continue
- }
-
- target, err := CasefoldChannel(targetString)
- if err == nil {
- channel := server.channels.Get(target)
- if channel == nil {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, targetString, "No such channel")
- continue
- }
- if !channel.CanSpeak(client) {
- client.Send(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, "Cannot send to channel")
- continue
- }
- msgid := server.generateMessageID()
-
- channel.TagMsg(msgid, lowestPrefix, clientOnlyTags, client)
- } else {
- target, err = CasefoldName(targetString)
- user := server.clients.Get(target)
- if err != nil || user == nil {
- if len(target) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHNICK, client.nick, target, "No such nick")
- }
- continue
- }
- msgid := server.generateMessageID()
-
- // end user can't receive tagmsgs
- if !user.capabilities.Has(caps.MessageTags) {
- continue
- }
- user.SendFromClient(msgid, client, clientOnlyTags, "TAGMSG", user.nick)
- if client.capabilities.Has(caps.EchoMessage) {
- client.SendFromClient(msgid, client, clientOnlyTags, "TAGMSG", user.nick)
- }
- if user.flags[Away] {
- //TODO(dan): possibly implement cooldown of away notifications to users
- client.Send(nil, server.name, RPL_AWAY, user.nick, user.awayMessage)
- }
- }
- }
- return false
- }
-
- // WhoisChannelsNames returns the common channel names between two users.
- func (client *Client) WhoisChannelsNames(target *Client) []string {
- isMultiPrefix := target.capabilities.Has(caps.MultiPrefix)
- var chstrs []string
- index := 0
- for channel := range client.channels {
- channel.membersMutex.RLock()
- defer channel.membersMutex.RUnlock()
-
- // 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)
- index++
- }
- return chstrs
- }
-
- // WHOIS [ <target> ] <mask> *( "," <mask> )
- func whoisHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- var masksString string
- //var target string
-
- if len(msg.Params) > 1 {
- //target = msg.Params[0]
- masksString = msg.Params[1]
- } else {
- masksString = msg.Params[0]
- }
-
- if len(strings.TrimSpace(masksString)) < 1 {
- client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, "No masks given")
- return false
- }
-
- if client.flags[Operator] {
- masks := strings.Split(masksString, ",")
- for _, mask := range masks {
- casefoldedMask, err := Casefold(mask)
- if err != nil {
- client.Send(nil, client.server.name, ERR_NOSUCHNICK, client.nick, mask, "No such nick")
- continue
- }
- matches := server.clients.FindAll(casefoldedMask)
- if len(matches) == 0 {
- client.Send(nil, client.server.name, ERR_NOSUCHNICK, client.nick, mask, "No such nick")
- continue
- }
- for mclient := range matches {
- client.getWhoisOf(mclient)
- }
- }
- } else {
- // only get the first request
- casefoldedMask, err := Casefold(strings.Split(masksString, ",")[0])
- mclient := server.clients.Get(casefoldedMask)
- if err != nil || mclient == nil {
- client.Send(nil, client.server.name, ERR_NOSUCHNICK, client.nick, masksString, "No such nick")
- // fall through, ENDOFWHOIS is always sent
- } else {
- client.getWhoisOf(mclient)
- }
- }
- client.Send(nil, server.name, RPL_ENDOFWHOIS, client.nick, masksString, "End of /WHOIS list")
- return false
- }
-
- func (client *Client) getWhoisOf(target *Client) {
- client.Send(nil, client.server.name, RPL_WHOISUSER, client.nick, target.nick, target.username, target.hostname, "*", target.realname)
-
- whoischannels := client.WhoisChannelsNames(target)
- if whoischannels != nil {
- client.Send(nil, client.server.name, RPL_WHOISCHANNELS, client.nick, target.nick, strings.Join(whoischannels, " "))
- }
- if target.class != nil {
- client.Send(nil, client.server.name, RPL_WHOISOPERATOR, client.nick, target.nick, target.whoisLine)
- }
- if client.flags[Operator] || client == target {
- client.Send(nil, client.server.name, RPL_WHOISACTUALLY, client.nick, target.nick, fmt.Sprintf("%s@%s", target.username, LookupHostname(target.IPString())), target.IPString(), "Actual user@host, Actual IP")
- }
- if target.flags[TLS] {
- client.Send(nil, client.server.name, RPL_WHOISSECURE, client.nick, target.nick, "is using a secure connection")
- }
- if target.certfp != "" && (client.flags[Operator] || client == target) {
- client.Send(nil, client.server.name, RPL_WHOISCERTFP, client.nick, target.nick, fmt.Sprintf("has client certificate fingerprint %s", target.certfp))
- }
- client.Send(nil, client.server.name, RPL_WHOISIDLE, client.nick, target.nick, strconv.FormatUint(target.IdleSeconds(), 10), strconv.FormatInt(target.SignonTime(), 10), "seconds idle, signon time")
- }
-
- // RplWhoReplyNoMutex returns the WHO reply between one user and another channel/user.
- // <channel> <user> <host> <server> <nick> ( "H" / "G" ) ["*"] [ ( "@" / "+" ) ]
- // :<hopcount> <real name>
- func (target *Client) RplWhoReplyNoMutex(channel *Channel, client *Client) {
- channelName := "*"
- flags := ""
-
- if client.flags[Away] {
- flags = "G"
- } else {
- flags = "H"
- }
- if client.flags[Operator] {
- flags += "*"
- }
-
- if channel != nil {
- flags += channel.members[client].Prefixes(target.capabilities.Has(caps.MultiPrefix))
- channelName = channel.name
- }
- target.Send(nil, target.server.name, RPL_WHOREPLY, target.nick, channelName, client.username, client.hostname, client.server.name, client.nick, flags, strconv.Itoa(client.hops)+" "+client.realname)
- }
-
- func whoChannel(client *Client, channel *Channel, friends ClientSet) {
- channel.membersMutex.RLock()
- defer channel.membersMutex.RUnlock()
-
- for member := range channel.members {
- if !client.flags[Invisible] || friends[client] {
- client.RplWhoReplyNoMutex(channel, member)
- }
- }
- }
-
- // WHO [ <mask> [ "o" ] ]
- func whoHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- friends := client.Friends()
-
- var mask string
- if len(msg.Params) > 0 {
- casefoldedMask, err := Casefold(msg.Params[0])
- if err != nil {
- client.Send(nil, server.name, ERR_UNKNOWNERROR, "WHO", "Mask isn't valid")
- return false
- }
- mask = casefoldedMask
- }
-
- //TODO(dan): is this used and would I put this param in the Modern doc?
- // if not, can we remove it?
- //var operatorOnly bool
- //if len(msg.Params) > 1 && msg.Params[1] == "o" {
- // operatorOnly = true
- //}
-
- if mask == "" {
- server.channels.ChansLock.RLock()
- for _, channel := range server.channels.Chans {
- whoChannel(client, channel, friends)
- }
- server.channels.ChansLock.RUnlock()
- } else if mask[0] == '#' {
- // TODO implement wildcard matching
- //TODO(dan): ^ only for opers
- channel := server.channels.Get(mask)
- if channel != nil {
- whoChannel(client, channel, friends)
- }
- } else {
- for mclient := range server.clients.FindAll(mask) {
- client.RplWhoReplyNoMutex(nil, mclient)
- }
- }
-
- client.Send(nil, server.name, RPL_ENDOFWHO, client.nick, mask, "End of WHO list")
- return false
- }
-
- // OPER <name> <password>
- func operHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- name, err := CasefoldName(msg.Params[0])
- if err != nil {
- client.Send(nil, server.name, ERR_PASSWDMISMATCH, client.nick, "Password incorrect")
- return true
- }
- if client.flags[Operator] == true {
- client.Send(nil, server.name, ERR_UNKNOWNERROR, "OPER", "You're already opered-up!")
- return false
- }
- server.configurableStateMutex.RLock()
- oper := server.operators[name]
- server.configurableStateMutex.RUnlock()
-
- password := []byte(msg.Params[1])
- err = ComparePassword(oper.Pass, password)
- if (oper.Pass == nil) || (err != nil) {
- client.Send(nil, server.name, ERR_PASSWDMISMATCH, client.nick, "Password incorrect")
- return true
- }
-
- client.flags[Operator] = true
- client.operName = name
- client.class = oper.Class
- client.whoisLine = oper.WhoisLine
-
- // push new vhost if one is set
- if len(oper.Vhost) > 0 {
- for fClient := range client.Friends(caps.ChgHost) {
- fClient.SendFromClient("", client, nil, "CHGHOST", client.username, oper.Vhost)
- }
- // CHGHOST requires prefix nickmask to have original hostname, so do that before updating nickmask
- client.vhost = oper.Vhost
- client.updateNickMask("")
- }
-
- // set new modes
- var applied ModeChanges
- if 0 < len(oper.Modes) {
- modeChanges, unknownChanges := ParseUserModeChanges(strings.Split(oper.Modes, " ")...)
- applied = client.applyUserModeChanges(true, modeChanges)
- if 0 < len(unknownChanges) {
- var runes string
- for r := range unknownChanges {
- runes += string(r)
- }
- client.Notice(fmt.Sprintf("Could not apply mode changes: +%s", runes))
- }
- }
-
- client.Send(nil, server.name, RPL_YOUREOPER, client.nick, "You are now an IRC operator")
-
- applied = append(applied, ModeChange{
- mode: Operator,
- op: Add,
- })
- client.Send(nil, server.name, "MODE", client.nick, applied.String())
-
- server.snomasks.Send(sno.LocalOpers, fmt.Sprintf(ircfmt.Unescape("Client opered up $c[grey][$r%s$c[grey], $r%s$c[grey]]"), client.nickMaskString, client.operName))
- return false
- }
-
- // rehash reloads the config and applies the changes from the config file.
- func (server *Server) rehash() error {
- server.logger.Debug("rehash", "Starting rehash")
-
- // only let one REHASH go on at a time
- server.rehashMutex.Lock()
- defer server.rehashMutex.Unlock()
-
- server.logger.Debug("rehash", "Got rehash lock")
-
- config, err := LoadConfig(server.configFilename)
- if err != nil {
- return fmt.Errorf("Error loading config file config: %s", err.Error())
- }
-
- err = server.applyConfig(config, false)
- if err != nil {
- return fmt.Errorf("Error applying config changes: %s", err.Error())
- }
-
- return nil
- }
-
- func (server *Server) applyConfig(config *Config, initial bool) error {
- if initial {
- server.ctime = time.Now()
- server.configFilename = config.Filename
- } else {
- // enforce configs that can't be changed after launch:
- if server.limits.LineLen.Tags != config.Limits.LineLen.Tags || server.limits.LineLen.Rest != config.Limits.LineLen.Rest {
- return fmt.Errorf("Maximum line length (linelen) cannot be changed after launching the server, rehash aborted")
- } else if server.name != config.Server.Name {
- return fmt.Errorf("Server name cannot be changed after launching the server, rehash aborted")
- }
- }
-
- casefoldedName, err := Casefold(config.Server.Name)
- if err != nil {
- return fmt.Errorf("Server name isn't valid [%s]: %s", config.Server.Name, err.Error())
- }
-
- // confirm connectionLimits are fine
- connectionLimits, err := NewConnectionLimits(config.Server.ConnectionLimits)
- if err != nil {
- return fmt.Errorf("Error rehashing config file connection-limits: %s", err.Error())
- }
-
- // confirm connectionThrottler is fine
- connectionThrottle, err := NewConnectionThrottle(config.Server.ConnectionThrottle)
- if err != nil {
- return fmt.Errorf("Error rehashing config file connection-throttle: %s", err.Error())
- }
-
- // confirm operator stuff all exists and is fine
- operclasses, err := config.OperatorClasses()
- if err != nil {
- return fmt.Errorf("Error rehashing config file operclasses: %s", err.Error())
- }
- opers, err := config.Operators(operclasses)
- if err != nil {
- return fmt.Errorf("Error rehashing config file opers: %s", err.Error())
- }
-
- // TODO: support rehash of existing operator perms?
-
- // sanity checks complete, start modifying server state
-
- if initial {
- server.name = config.Server.Name
- server.nameCasefolded = casefoldedName
- }
- server.networkName = config.Network.Name
-
- server.configurableStateMutex.Lock()
- if config.Server.Password != "" {
- server.password = config.Server.PasswordBytes()
- } else {
- server.password = nil
- }
- server.configurableStateMutex.Unlock()
-
- // apply new PROXY command restrictions
- server.proxyAllowedFrom = config.Server.ProxyAllowedFrom
-
- // apply new connectionlimits
- server.connectionLimitsMutex.Lock()
- server.connectionLimits = connectionLimits
- server.connectionThrottleMutex.Lock()
- server.connectionThrottle = connectionThrottle
-
- server.clients.ByNickMutex.RLock()
- for _, client := range server.clients.ByNick {
- ipaddr := client.IP()
- if ipaddr != nil {
- server.connectionLimits.AddClient(ipaddr, true)
- }
- }
- server.clients.ByNickMutex.RUnlock()
- server.connectionThrottleMutex.Unlock()
- server.connectionLimitsMutex.Unlock()
-
- // setup new and removed caps
- addedCaps := caps.NewSet()
- removedCaps := caps.NewSet()
- updatedCaps := caps.NewSet()
-
- // SASL
- if config.Accounts.AuthenticationEnabled && !server.accountAuthenticationEnabled {
- // enabling SASL
- SupportedCapabilities.Enable(caps.SASL)
- CapValues.Set(caps.SASL, "PLAIN,EXTERNAL")
- addedCaps.Add(caps.SASL)
- }
- if !config.Accounts.AuthenticationEnabled && server.accountAuthenticationEnabled {
- // disabling SASL
- SupportedCapabilities.Disable(caps.SASL)
- removedCaps.Add(caps.SASL)
- }
- server.accountAuthenticationEnabled = config.Accounts.AuthenticationEnabled
-
- // STS
- stsValue := config.Server.STS.Value()
- var stsDisabled bool
- stsCurrentCapValue, _ := CapValues.Get(caps.STS)
- server.logger.Debug("rehash", "STS Vals", stsCurrentCapValue, stsValue, fmt.Sprintf("server[%v] config[%v]", server.stsEnabled, config.Server.STS.Enabled))
- if config.Server.STS.Enabled && !server.stsEnabled {
- // enabling STS
- SupportedCapabilities.Enable(caps.STS)
- addedCaps.Add(caps.STS)
- CapValues.Set(caps.STS, stsValue)
- } else if !config.Server.STS.Enabled && server.stsEnabled {
- // disabling STS
- SupportedCapabilities.Disable(caps.STS)
- removedCaps.Add(caps.STS)
- stsDisabled = true
- } else if config.Server.STS.Enabled && server.stsEnabled && stsValue != stsCurrentCapValue {
- // STS policy updated
- CapValues.Set(caps.STS, stsValue)
- updatedCaps.Add(caps.STS)
- }
- server.stsEnabled = config.Server.STS.Enabled
-
- // burst new and removed caps
- var capBurstClients ClientSet
- added := make(map[caps.Version]string)
- var removed string
-
- // updated caps get DEL'd and then NEW'd
- // so, we can just add updated ones to both removed and added lists here and they'll be correctly handled
- server.logger.Debug("rehash", "Updated Caps", updatedCaps.String(caps.Cap301, CapValues), strconv.Itoa(updatedCaps.Count()))
- for _, capab := range updatedCaps.List() {
- addedCaps.Enable(capab)
- removedCaps.Enable(capab)
- }
-
- if 0 < addedCaps.Count() || 0 < removedCaps.Count() {
- capBurstClients = server.clients.AllWithCaps(caps.CapNotify)
-
- added[caps.Cap301] = addedCaps.String(caps.Cap301, CapValues)
- added[caps.Cap302] = addedCaps.String(caps.Cap302, CapValues)
- // removed never has values, so we leave it as Cap301
- removed = removedCaps.String(caps.Cap301, CapValues)
- }
-
- for sClient := range capBurstClients {
- if stsDisabled {
- // remove STS policy
- //TODO(dan): this is an ugly hack. we can write this better.
- stsPolicy := "sts=duration=0"
- if 0 < addedCaps.Count() {
- added[caps.Cap302] = added[caps.Cap302] + " " + stsPolicy
- } else {
- addedCaps.Enable(caps.STS)
- added[caps.Cap302] = stsPolicy
- }
- }
- // DEL caps and then send NEW ones so that updated caps get removed/added correctly
- if 0 < removedCaps.Count() {
- sClient.Send(nil, server.name, "CAP", sClient.nick, "DEL", removed)
- }
- if 0 < addedCaps.Count() {
- sClient.Send(nil, server.name, "CAP", sClient.nick, "NEW", added[sClient.capVersion])
- }
- }
-
- // set server options
- server.configurableStateMutex.Lock()
- lineLenConfig := LineLenLimits{
- Tags: config.Limits.LineLen.Tags,
- Rest: config.Limits.LineLen.Rest,
- }
- server.limits = Limits{
- AwayLen: int(config.Limits.AwayLen),
- ChannelLen: int(config.Limits.ChannelLen),
- KickLen: int(config.Limits.KickLen),
- MonitorEntries: int(config.Limits.MonitorEntries),
- NickLen: int(config.Limits.NickLen),
- TopicLen: int(config.Limits.TopicLen),
- ChanListModes: int(config.Limits.ChanListModes),
- LineLen: lineLenConfig,
- }
- server.operclasses = *operclasses
- server.operators = opers
- server.checkIdent = config.Server.CheckIdent
-
- // registration
- accountReg := NewAccountRegistration(config.Accounts.Registration)
- server.accountRegistration = &accountReg
- server.channelRegistrationEnabled = config.Channels.Registration.Enabled
-
- server.defaultChannelModes = ParseDefaultChannelModes(config)
- server.configurableStateMutex.Unlock()
-
- // set new sendqueue size
- if config.Server.MaxSendQBytes != server.MaxSendQBytes {
- server.configurableStateMutex.Lock()
- server.MaxSendQBytes = config.Server.MaxSendQBytes
- server.configurableStateMutex.Unlock()
-
- // update on all clients
- server.clients.ByNickMutex.RLock()
- for _, sClient := range server.clients.ByNick {
- sClient.socket.MaxSendQBytes = config.Server.MaxSendQBytes
- }
- server.clients.ByNickMutex.RUnlock()
- }
-
- // set RPL_ISUPPORT
- oldISupportList := server.isupport
- server.setISupport()
- if oldISupportList != nil {
- newISupportReplies := oldISupportList.GetDifference(server.isupport)
- // push new info to all of our clients
- server.clients.ByNickMutex.RLock()
- for _, sClient := range server.clients.ByNick {
- for _, tokenline := range newISupportReplies {
- // ugly trickery ahead
- sClient.Send(nil, server.name, RPL_ISUPPORT, append([]string{sClient.nick}, tokenline...)...)
- }
- }
- server.clients.ByNickMutex.RUnlock()
- }
-
- server.loadMOTD(config.Server.MOTD)
-
- if initial {
- if err := server.loadDatastore(config.Datastore.Path); err != nil {
- return err
- }
- }
-
- // we are now open for business
- server.setupListeners(config)
- server.setupRestAPI(config)
-
- return nil
- }
-
- func (server *Server) loadMOTD(motdPath string) error {
- server.logger.Debug("rehash", "Loading MOTD")
- motdLines := make([]string, 0)
- if motdPath != "" {
- file, err := os.Open(motdPath)
- 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")
- // "- " is the required prefix for MOTD, we just add it here to make
- // bursting it out to clients easier
- line = fmt.Sprintf("- %s", line)
-
- motdLines = append(motdLines, line)
- }
- } else {
- return err
- }
- }
-
- server.configurableStateMutex.Lock()
- server.motdLines = motdLines
- server.configurableStateMutex.Unlock()
- return nil
- }
-
- func (server *Server) loadDatastore(datastorePath string) error {
- // open the datastore and load server state for which it (rather than config)
- // is the source of truth
-
- server.logger.Debug("startup", "Opening datastore")
- db, err := OpenDatabase(datastorePath)
- if err == nil {
- server.store = db
- } else {
- return fmt.Errorf("Failed to open datastore: %s", err.Error())
- }
-
- // load *lines (from the datastores)
- server.logger.Debug("startup", "Loading D/Klines")
- server.loadDLines()
- server.loadKLines()
-
- // load password manager
- server.logger.Debug("startup", "Loading passwords")
- err = server.store.View(func(tx *buntdb.Tx) error {
- saltString, err := tx.Get(keySalt)
- if err != nil {
- return fmt.Errorf("Could not retrieve salt string: %s", err.Error())
- }
-
- salt, err := base64.StdEncoding.DecodeString(saltString)
- if err != nil {
- return err
- }
-
- pwm := NewPasswordManager(salt)
- server.passwords = &pwm
- return nil
- })
- if err != nil {
- return fmt.Errorf("Could not load salt: %s", err.Error())
- }
- return nil
- }
-
- func (server *Server) setupListeners(config *Config) {
- // update or destroy all existing listeners
- tlsListeners := config.TLSListeners()
- for addr := range server.listeners {
- currentListener := server.listeners[addr]
- var stillConfigured bool
- for _, newaddr := range config.Server.Listen {
- if newaddr == addr {
- stillConfigured = true
- break
- }
- }
-
- // pass new config information to the listener, to be picked up after
- // its next Accept(). this is like sending over a buffered channel of
- // size 1, but where sending a second item overwrites the buffered item
- // instead of blocking.
- currentListener.configMutex.Lock()
- currentListener.shouldStop = !stillConfigured
- currentListener.tlsConfig = tlsListeners[addr]
- currentListener.configMutex.Unlock()
-
- if stillConfigured {
- server.logger.Info("listeners",
- fmt.Sprintf("now listening on %s, tls=%t.", addr, (currentListener.tlsConfig != nil)),
- )
- } else {
- // tell the listener it should stop by interrupting its Accept() call:
- currentListener.listener.Close()
- // TODO(golang1.10) delete stopEvent once issue #21856 is released
- <-currentListener.stopEvent
- delete(server.listeners, addr)
- server.logger.Info("listeners", fmt.Sprintf("stopped listening on %s.", addr))
- }
- }
-
- // create new listeners that were not previously configured
- for _, newaddr := range config.Server.Listen {
- _, exists := server.listeners[newaddr]
- if !exists {
- // make new listener
- server.listeners[newaddr] = server.createListener(newaddr, tlsListeners[newaddr])
- }
- }
-
- if len(tlsListeners) == 0 {
- server.logger.Warning("startup", "You are not exposing an SSL/TLS listening port. You should expose at least one port (typically 6697) to accept TLS connections")
- }
-
- var usesStandardTLSPort bool
- for addr := range config.TLSListeners() {
- if strings.Contains(addr, "6697") {
- usesStandardTLSPort = true
- break
- }
- }
- if 0 < len(tlsListeners) && !usesStandardTLSPort {
- server.logger.Warning("startup", "Port 6697 is the standard TLS port for IRC. You should (also) expose port 6697 as a TLS port to ensure clients can connect securely")
- }
- }
-
- func (server *Server) setupRestAPI(config *Config) {
- restAPIEnabled := config.Server.RestAPI.Enabled
- restAPIStarted := server.restAPIServer != nil
- restAPIListenAddrChanged := server.restAPI.Listen != config.Server.RestAPI.Listen
-
- // stop an existing REST server if it's been disabled or the addr changed
- if restAPIStarted && (!restAPIEnabled || restAPIListenAddrChanged) {
- ctx, _ := context.WithTimeout(context.Background(), httpShutdownTimeout)
- server.restAPIServer.Shutdown(ctx)
- server.restAPIServer.Close()
- server.logger.Info("rehash", "server", fmt.Sprintf("%s rest API stopped on %s.", server.name, server.restAPI.Listen))
- server.restAPIServer = nil
- }
-
- // start a new one if it's enabled or the addr changed
- if restAPIEnabled && (!restAPIStarted || restAPIListenAddrChanged) {
- server.restAPIServer, _ = StartRestAPI(server, config.Server.RestAPI.Listen)
- server.logger.Info(
- "rehash", "server",
- fmt.Sprintf("%s rest API started on %s.", server.name, config.Server.RestAPI.Listen))
- }
-
- // save the config information
- server.restAPI = config.Server.RestAPI
- }
-
- func (server *Server) GetDefaultChannelModes() Modes {
- server.configurableStateMutex.RLock()
- defer server.configurableStateMutex.RUnlock()
- return server.defaultChannelModes
- }
-
- // REHASH
- func rehashHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- server.logger.Info("rehash", fmt.Sprintf("REHASH command used by %s", client.nick))
- err := server.rehash()
-
- if err == nil {
- client.Send(nil, server.name, RPL_REHASHING, client.nick, "ircd.yaml", "Rehashing")
- } else {
- server.logger.Error("rehash", fmt.Sprintln("Failed to rehash:", err.Error()))
- client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "REHASH", err.Error())
- }
- return false
- }
-
- // AWAY [<message>]
- func awayHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- var isAway bool
- var text string
- if len(msg.Params) > 0 {
- isAway = true
- text = msg.Params[0]
- awayLen := server.getLimits().AwayLen
- if len(text) > awayLen {
- text = text[:awayLen]
- }
- }
-
- if isAway {
- client.flags[Away] = true
- } else {
- delete(client.flags, Away)
- }
- client.awayMessage = text
-
- var op ModeOp
- if client.flags[Away] {
- op = Add
- client.Send(nil, server.name, RPL_NOWAWAY, client.nick, "You have been marked as being away")
- } else {
- op = Remove
- client.Send(nil, server.name, RPL_UNAWAY, client.nick, "You are no longer marked as being away")
- }
- //TODO(dan): Should this be sent automagically as part of setting the flag/mode?
- modech := ModeChanges{ModeChange{
- mode: Away,
- op: op,
- }}
- client.Send(nil, server.name, "MODE", client.nick, modech.String())
-
- // dispatch away-notify
- for friend := range client.Friends(caps.AwayNotify) {
- if client.flags[Away] {
- friend.SendFromClient("", client, nil, "AWAY", client.awayMessage)
- } else {
- friend.SendFromClient("", client, nil, "AWAY")
- }
- }
-
- return false
- }
-
- // ISON <nick>{ <nick>}
- func isonHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- var nicks = msg.Params
-
- var err error
- var casefoldedNick string
- ison := make([]string, 0)
- for _, nick := range nicks {
- casefoldedNick, err = CasefoldName(nick)
- if err != nil {
- continue
- }
- if iclient := server.clients.Get(casefoldedNick); iclient != nil {
- ison = append(ison, iclient.nick)
- }
- }
-
- client.Send(nil, server.name, RPL_ISON, client.nick, strings.Join(nicks, " "))
- return false
- }
-
- // MOTD [<target>]
- func motdHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- //TODO(dan): hook this up when we have multiple servers I guess???
- //var target string
- //if len(msg.Params) > 0 {
- // target = msg.Params[0]
- //}
-
- server.MOTD(client)
- return false
- }
-
- // NOTICE <target>{,<target>} <message>
- func noticeHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- clientOnlyTags := GetClientOnlyTags(msg.Tags)
- targets := strings.Split(msg.Params[0], ",")
- message := msg.Params[1]
-
- // split privmsg
- splitMsg := server.splitMessage(message, !client.capabilities.Has(caps.MaxLine))
-
- for i, targetString := range targets {
- // max of four targets per privmsg
- if i > maxTargets-1 {
- break
- }
- prefixes, targetString := SplitChannelMembershipPrefixes(targetString)
- lowestPrefix := GetLowestChannelModePrefix(prefixes)
-
- target, cerr := CasefoldChannel(targetString)
- if cerr == nil {
- channel := server.channels.Get(target)
- if channel == nil {
- // errors silently ignored with NOTICE as per RFC
- continue
- }
- if !channel.CanSpeak(client) {
- // errors silently ignored with NOTICE as per RFC
- continue
- }
- msgid := server.generateMessageID()
- channel.SplitNotice(msgid, lowestPrefix, clientOnlyTags, client, splitMsg)
- } else {
- target, err := CasefoldName(targetString)
- if err != nil {
- continue
- }
- if target == "chanserv" {
- server.chanservReceiveNotice(client, message)
- continue
- } else if target == "nickserv" {
- server.nickservReceiveNotice(client, message)
- continue
- }
-
- user := server.clients.Get(target)
- if user == nil {
- // errors silently ignored with NOTICE as per RFC
- continue
- }
- if !user.capabilities.Has(caps.MessageTags) {
- clientOnlyTags = nil
- }
- msgid := server.generateMessageID()
- // restrict messages appropriately when +R is set
- // intentionally make the sending user think the message went through fine
- if !user.flags[RegisteredOnly] || client.registered {
- user.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "NOTICE", user.nick, splitMsg)
- }
- if client.capabilities.Has(caps.EchoMessage) {
- client.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "NOTICE", user.nick, splitMsg)
- }
- }
- }
- return false
- }
-
- // KICK <channel>{,<channel>} <user>{,<user>} [<comment>]
- func kickHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- channels := strings.Split(msg.Params[0], ",")
- users := strings.Split(msg.Params[1], ",")
- if (len(channels) != len(users)) && (len(users) != 1) {
- client.Send(nil, server.name, ERR_NEEDMOREPARAMS, client.nick, "KICK", "Not enough parameters")
- return false
- }
-
- var kicks [][]string
- for index, channel := range channels {
- if len(users) == 1 {
- kicks = append(kicks, []string{channel, users[0]})
- } else {
- kicks = append(kicks, []string{channel, users[index]})
- }
- }
-
- var comment string
- if len(msg.Params) > 2 {
- comment = msg.Params[2]
- }
- for _, info := range kicks {
- chname := info[0]
- nickname := info[1]
- casefoldedChname, err := CasefoldChannel(chname)
- channel := server.channels.Get(casefoldedChname)
- if err != nil || channel == nil {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, chname, "No such channel")
- continue
- }
-
- casefoldedNickname, err := CasefoldName(nickname)
- target := server.clients.Get(casefoldedNickname)
- if err != nil || target == nil {
- client.Send(nil, server.name, ERR_NOSUCHNICK, client.nick, nickname, "No such nick")
- continue
- }
-
- // make sure client has privs to kick the given user
- //TODO(dan): split this into a separate function that checks if users have privs
- // over other users, useful for things like -aoh as well
- channel.membersMutex.Lock()
-
- 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 {
- if comment == "" {
- comment = nickname
- }
- channel.kickNoMutex(client, target, comment)
- } else {
- client.Send(nil, client.server.name, ERR_CHANOPRIVSNEEDED, chname, "You're not a channel operator")
- }
-
- channel.membersMutex.Unlock()
- }
- return false
- }
-
- // elistMatcher takes and matches ELIST conditions
- type elistMatcher struct {
- MinClientsActive bool
- MinClients int
- MaxClientsActive bool
- MaxClients int
- }
-
- // Matches checks whether the given channel matches our matches.
- func (matcher *elistMatcher) Matches(channel *Channel) bool {
- channel.membersMutex.RLock()
- defer channel.membersMutex.RUnlock()
-
- if matcher.MinClientsActive {
- if len(channel.members) < matcher.MinClients {
- return false
- }
- }
-
- if matcher.MaxClientsActive {
- if matcher.MaxClients < len(channel.members) {
- return false
- }
- }
-
- return true
- }
-
- // LIST [<channel>{,<channel>}] [<elistcond>{,<elistcond>}]
- func listHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- // get channels
- var channels []string
- for _, param := range msg.Params {
- if 0 < len(param) && param[0] == '#' {
- for _, channame := range strings.Split(param, ",") {
- if 0 < len(channame) && channame[0] == '#' {
- channels = append(channels, channame)
- }
- }
- }
- }
-
- // get elist conditions
- var matcher elistMatcher
- for _, param := range msg.Params {
- if len(param) < 1 {
- continue
- }
-
- if param[0] == '<' {
- param = param[1:]
- val, err := strconv.Atoi(param)
- if err != nil {
- continue
- }
- matcher.MaxClientsActive = true
- matcher.MaxClients = val - 1 // -1 because < means less than the given number
- }
- if param[0] == '>' {
- param = param[1:]
- val, err := strconv.Atoi(param)
- if err != nil {
- continue
- }
- matcher.MinClientsActive = true
- matcher.MinClients = val + 1 // +1 because > means more than the given number
- }
- }
-
- if len(channels) == 0 {
- server.channels.ChansLock.RLock()
- for _, channel := range server.channels.Chans {
- if !client.flags[Operator] && channel.flags[Secret] {
- continue
- }
- if matcher.Matches(channel) {
- client.RplList(channel)
- }
- }
- server.channels.ChansLock.RUnlock()
- } else {
- // limit regular users to only listing one channel
- if !client.flags[Operator] {
- channels = channels[:1]
- }
-
- for _, chname := range channels {
- casefoldedChname, err := CasefoldChannel(chname)
- channel := server.channels.Get(casefoldedChname)
- if err != nil || channel == nil || (!client.flags[Operator] && channel.flags[Secret]) {
- if len(chname) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, chname, "No such channel")
- }
- continue
- }
- if matcher.Matches(channel) {
- client.RplList(channel)
- }
- }
- }
- client.Send(nil, server.name, RPL_LISTEND, client.nick, "End of LIST")
- return false
- }
-
- // RplList returns the RPL_LIST numeric for the given channel.
- func (target *Client) RplList(channel *Channel) {
- channel.membersMutex.RLock()
- defer channel.membersMutex.RUnlock()
-
- // get the correct number of channel members
- var memberCount int
- if target.flags[Operator] || channel.members.Has(target) {
- memberCount = len(channel.members)
- } else {
- for member := range channel.members {
- if !member.flags[Invisible] {
- memberCount++
- }
- }
- }
-
- target.Send(nil, target.server.name, RPL_LIST, target.nick, channel.name, strconv.Itoa(memberCount), channel.topic)
- }
-
- // NAMES [<channel>{,<channel>}]
- func namesHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- var channels []string
- if len(msg.Params) > 0 {
- channels = strings.Split(msg.Params[0], ",")
- }
- //var target string
- //if len(msg.Params) > 1 {
- // target = msg.Params[1]
- //}
-
- if len(channels) == 0 {
- server.channels.ChansLock.RLock()
- for _, channel := range server.channels.Chans {
- channel.Names(client)
- }
- server.channels.ChansLock.RUnlock()
- return false
- }
-
- // limit regular users to only listing one channel
- if !client.flags[Operator] {
- channels = channels[:1]
- }
-
- for _, chname := range channels {
- casefoldedChname, err := CasefoldChannel(chname)
- channel := server.channels.Get(casefoldedChname)
- if err != nil || channel == nil {
- if len(chname) > 0 {
- client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, chname, "No such channel")
- }
- continue
- }
- channel.Names(client)
- }
- return false
- }
-
- // VERSION [<server>]
- func versionHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- var target string
- if len(msg.Params) > 0 {
- target = msg.Params[0]
- }
- casefoldedTarget, err := Casefold(target)
- if target != "" && (err != nil || casefoldedTarget != server.nameCasefolded) {
- client.Send(nil, server.name, ERR_NOSUCHSERVER, client.nick, target, "No such server")
- return false
- }
-
- client.Send(nil, server.name, RPL_VERSION, client.nick, Ver, server.name)
- client.RplISupport()
- return false
- }
-
- // INVITE <nickname> <channel>
- func inviteHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- nickname := msg.Params[0]
- channelName := msg.Params[1]
-
- casefoldedNickname, err := CasefoldName(nickname)
- target := server.clients.Get(casefoldedNickname)
- if err != nil || target == nil {
- client.Send(nil, server.name, ERR_NOSUCHNICK, client.nick, nickname, "No such nick")
- return false
- }
-
- casefoldedChannelName, err := CasefoldChannel(channelName)
- channel := server.channels.Get(casefoldedChannelName)
- if err != nil || channel == nil {
- client.Send(nil, server.name, RPL_INVITING, client.nick, target.nick, channelName)
- target.Send(nil, client.nickMaskString, "INVITE", target.nick, channel.name)
- return true
- }
-
- channel.Invite(target, client)
- return false
- }
-
- // TIME [<server>]
- func timeHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- var target string
- if len(msg.Params) > 0 {
- target = msg.Params[0]
- }
- casefoldedTarget, err := Casefold(target)
- if (target != "") && err != nil || (casefoldedTarget != server.nameCasefolded) {
- client.Send(nil, server.name, ERR_NOSUCHSERVER, client.nick, target, "No such server")
- return false
- }
- client.Send(nil, server.name, RPL_TIME, client.nick, server.name, time.Now().Format(time.RFC1123))
- return false
- }
-
- // KILL <nickname> <comment>
- func killHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- nickname := msg.Params[0]
- comment := "<no reason supplied>"
- if len(msg.Params) > 1 {
- comment = msg.Params[1]
- }
-
- casefoldedNickname, err := CasefoldName(nickname)
- target := server.clients.Get(casefoldedNickname)
- if err != nil || target == nil {
- client.Send(nil, client.server.name, ERR_NOSUCHNICK, client.nick, nickname, "No such nick")
- return false
- }
-
- quitMsg := fmt.Sprintf("Killed (%s (%s))", client.nick, comment)
-
- server.snomasks.Send(sno.LocalKills, fmt.Sprintf(ircfmt.Unescape("%s$r was killed by %s $c[grey][$r%s$c[grey]]"), target.nick, client.nick, comment))
- target.exitedSnomaskSent = true
-
- target.Quit(quitMsg)
- target.destroy()
- return false
- }
-
- // WHOWAS <nickname> [<count> [<server>]]
- func whowasHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- nicknames := strings.Split(msg.Params[0], ",")
-
- var count int64
- if len(msg.Params) > 1 {
- count, _ = strconv.ParseInt(msg.Params[1], 10, 64)
- }
- //var target string
- //if len(msg.Params) > 2 {
- // target = msg.Params[2]
- //}
- for _, nickname := range nicknames {
- results := server.whoWas.Find(nickname, count)
- if len(results) == 0 {
- if len(nickname) > 0 {
- client.Send(nil, server.name, ERR_WASNOSUCHNICK, client.nick, nickname, "There was no such nickname")
- }
- } else {
- for _, whoWas := range results {
- client.Send(nil, server.name, RPL_WHOWASUSER, client.nick, whoWas.nickname, whoWas.username, whoWas.hostname, "*", whoWas.realname)
- }
- }
- if len(nickname) > 0 {
- client.Send(nil, server.name, RPL_ENDOFWHOWAS, client.nick, nickname, "End of WHOWAS")
- }
- }
- return false
- }
-
- // LUSERS [<mask> [<server>]]
- func lusersHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- //TODO(vegax87) Fix network statistics and additional parameters
- var totalcount, invisiblecount, opercount int
-
- server.clients.ByNickMutex.RLock()
- defer server.clients.ByNickMutex.RUnlock()
-
- for _, onlineusers := range server.clients.ByNick {
- totalcount++
- if onlineusers.flags[Invisible] {
- invisiblecount++
- }
- if onlineusers.flags[Operator] {
- opercount++
- }
- }
- client.Send(nil, server.name, RPL_LUSERCLIENT, client.nick, fmt.Sprintf("There are %d users and %d invisible on %d server(s)", totalcount, invisiblecount, 1))
- client.Send(nil, server.name, RPL_LUSEROP, client.nick, fmt.Sprintf("%d IRC Operators online", opercount))
- client.Send(nil, server.name, RPL_LUSERCHANNELS, client.nick, fmt.Sprintf("%d channels formed", server.channels.Len()))
- client.Send(nil, server.name, RPL_LUSERME, client.nick, fmt.Sprintf("I have %d clients and %d servers", totalcount, 1))
- return false
- }
-
- // USERHOST <nickname> [<nickname> <nickname> ...]
- func userhostHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- returnedNicks := make(map[string]bool)
-
- for i, nickname := range msg.Params {
- if i >= 10 {
- break
- }
-
- casefoldedNickname, err := CasefoldName(nickname)
- target := server.clients.Get(casefoldedNickname)
- if err != nil || target == nil {
- client.Send(nil, client.server.name, ERR_NOSUCHNICK, client.nick, nickname, "No such nick")
- return false
- }
- if returnedNicks[casefoldedNickname] {
- continue
- }
-
- // to prevent returning multiple results for a single nick
- returnedNicks[casefoldedNickname] = true
-
- var isOper, isAway string
-
- if target.flags[Operator] {
- isOper = "*"
- }
- if target.flags[Away] {
- isAway = "-"
- } else {
- isAway = "+"
- }
- client.Send(nil, client.server.name, RPL_USERHOST, client.nick, fmt.Sprintf("%s%s=%s%s@%s", target.nick, isOper, isAway, target.username, target.hostname))
- }
-
- return false
- }
-
- // PROXY TCP4/6 SOURCEIP DESTIP SOURCEPORT DESTPORT
- // http://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
- func proxyHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
- // only allow unregistered clients to use this command
- if client.registered {
- return false
- }
-
- clientAddress := IPString(client.socket.conn.RemoteAddr())
- clientHostname := client.hostname
- for _, address := range server.proxyAllowedFrom {
- if clientHostname == address || clientAddress == address {
- proxiedIP := msg.Params[1]
-
- // ensure IP is sane
- parsedProxiedIP := net.ParseIP(proxiedIP)
- if parsedProxiedIP == nil {
- client.Quit(fmt.Sprintf("Proxied IP address is not valid: [%s]", proxiedIP))
- return true
- }
-
- isBanned, banMsg := server.checkBans(parsedProxiedIP)
- if isBanned {
- client.Quit(banMsg)
- return true
- }
-
- // override the client's regular IP
- client.proxiedIP = msg.Params[1]
- client.rawHostname = LookupHostname(msg.Params[1])
- client.hostname = client.rawHostname
- return false
- }
- }
- client.Quit("PROXY command is not usable from your address")
- return true
- }
|