You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

server.go 31KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928
  1. // Copyright (c) 2012-2014 Jeremy Latt
  2. // Copyright (c) 2014-2015 Edmund Huber
  3. // Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
  4. // released under the MIT license
  5. package irc
  6. import (
  7. "bufio"
  8. "fmt"
  9. "net"
  10. "net/http"
  11. _ "net/http/pprof"
  12. "os"
  13. "os/signal"
  14. "strconv"
  15. "strings"
  16. "sync"
  17. "syscall"
  18. "time"
  19. "unsafe"
  20. "github.com/goshuirc/irc-go/ircfmt"
  21. "github.com/oragono/oragono/irc/caps"
  22. "github.com/oragono/oragono/irc/connection_limits"
  23. "github.com/oragono/oragono/irc/history"
  24. "github.com/oragono/oragono/irc/logger"
  25. "github.com/oragono/oragono/irc/modes"
  26. "github.com/oragono/oragono/irc/mysql"
  27. "github.com/oragono/oragono/irc/sno"
  28. "github.com/oragono/oragono/irc/utils"
  29. "github.com/tidwall/buntdb"
  30. )
  31. var (
  32. // common error line to sub values into
  33. errorMsg = "ERROR :%s\r\n"
  34. // supportedUserModesString acts as a cache for when we introduce users
  35. supportedUserModesString = modes.SupportedUserModes.String()
  36. // supportedChannelModesString acts as a cache for when we introduce users
  37. supportedChannelModesString = modes.SupportedChannelModes.String()
  38. // whitelist of caps to serve on the STS-only listener. In particular,
  39. // never advertise SASL, to discourage people from sending their passwords:
  40. stsOnlyCaps = caps.NewSet(caps.STS, caps.MessageTags, caps.ServerTime, caps.LabeledResponse, caps.Nope)
  41. // we only have standard channels for now. TODO: any updates to this
  42. // will also need to be reflected in CasefoldChannel
  43. chanTypes = "#"
  44. throttleMessage = "You have attempted to connect too many times within a short duration. Wait a while, and you will be able to connect."
  45. )
  46. // Server is the main Oragono server.
  47. type Server struct {
  48. accounts AccountManager
  49. channels ChannelManager
  50. channelRegistry ChannelRegistry
  51. clients ClientManager
  52. config unsafe.Pointer
  53. configFilename string
  54. connectionLimiter connection_limits.Limiter
  55. ctime time.Time
  56. dlines *DLineManager
  57. helpIndexManager HelpIndexManager
  58. klines *KLineManager
  59. listeners map[string]IRCListener
  60. logger *logger.Manager
  61. monitorManager MonitorManager
  62. name string
  63. nameCasefolded string
  64. rehashMutex sync.Mutex // tier 4
  65. rehashSignal chan os.Signal
  66. pprofServer *http.Server
  67. resumeManager ResumeManager
  68. signals chan os.Signal
  69. snomasks SnoManager
  70. store *buntdb.DB
  71. historyDB mysql.MySQL
  72. torLimiter connection_limits.TorLimiter
  73. whoWas WhoWasList
  74. stats Stats
  75. semaphores ServerSemaphores
  76. }
  77. var (
  78. // ServerExitSignals are the signals the server will exit on.
  79. ServerExitSignals = []os.Signal{
  80. syscall.SIGINT,
  81. syscall.SIGTERM,
  82. syscall.SIGQUIT,
  83. }
  84. )
  85. // NewServer returns a new Oragono server.
  86. func NewServer(config *Config, logger *logger.Manager) (*Server, error) {
  87. // initialize data structures
  88. server := &Server{
  89. ctime: time.Now().UTC(),
  90. listeners: make(map[string]IRCListener),
  91. logger: logger,
  92. rehashSignal: make(chan os.Signal, 1),
  93. signals: make(chan os.Signal, len(ServerExitSignals)),
  94. }
  95. server.clients.Initialize()
  96. server.semaphores.Initialize()
  97. server.resumeManager.Initialize(server)
  98. server.whoWas.Initialize(config.Limits.WhowasEntries)
  99. server.monitorManager.Initialize()
  100. server.snomasks.Initialize()
  101. if err := server.applyConfig(config); err != nil {
  102. return nil, err
  103. }
  104. // Attempt to clean up when receiving these signals.
  105. signal.Notify(server.signals, ServerExitSignals...)
  106. signal.Notify(server.rehashSignal, syscall.SIGHUP)
  107. return server, nil
  108. }
  109. // Shutdown shuts down the server.
  110. func (server *Server) Shutdown() {
  111. //TODO(dan): Make sure we disallow new nicks
  112. for _, client := range server.clients.AllClients() {
  113. client.Notice("Server is shutting down")
  114. }
  115. if err := server.store.Close(); err != nil {
  116. server.logger.Error("shutdown", fmt.Sprintln("Could not close datastore:", err))
  117. }
  118. server.historyDB.Close()
  119. }
  120. // Run starts the server.
  121. func (server *Server) Run() {
  122. // defer closing db/store
  123. defer server.store.Close()
  124. for {
  125. select {
  126. case <-server.signals:
  127. server.Shutdown()
  128. return
  129. case <-server.rehashSignal:
  130. go func() {
  131. server.logger.Info("server", "Rehashing due to SIGHUP")
  132. err := server.rehash()
  133. if err != nil {
  134. server.logger.Error("server", fmt.Sprintln("Failed to rehash:", err.Error()))
  135. }
  136. }()
  137. }
  138. }
  139. }
  140. func (server *Server) checkBans(ipaddr net.IP) (banned bool, message string) {
  141. // check DLINEs
  142. isBanned, info := server.dlines.CheckIP(ipaddr)
  143. if isBanned {
  144. server.logger.Info("connect-ip", fmt.Sprintf("Client from %v rejected by d-line", ipaddr))
  145. return true, info.BanMessage("You are banned from this server (%s)")
  146. }
  147. // check connection limits
  148. err := server.connectionLimiter.AddClient(ipaddr)
  149. if err == connection_limits.ErrLimitExceeded {
  150. // too many connections from one client, tell the client and close the connection
  151. server.logger.Info("connect-ip", fmt.Sprintf("Client from %v rejected for connection limit", ipaddr))
  152. return true, "Too many clients from your network"
  153. } else if err == connection_limits.ErrThrottleExceeded {
  154. duration := server.Config().Server.IPLimits.BanDuration
  155. if duration == 0 {
  156. return false, ""
  157. }
  158. server.dlines.AddIP(ipaddr, duration, throttleMessage, "Exceeded automated connection throttle", "auto.connection.throttler")
  159. // they're DLINE'd for 15 minutes or whatever, so we can reset the connection throttle now,
  160. // and once their temporary DLINE is finished they can fill up the throttler again
  161. server.connectionLimiter.ResetThrottle(ipaddr)
  162. // 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
  163. server.logger.Info(
  164. "connect-ip",
  165. fmt.Sprintf("Client from %v exceeded connection throttle, d-lining for %v", ipaddr, duration))
  166. return true, throttleMessage
  167. } else if err != nil {
  168. server.logger.Warning("internal", "unexpected ban result", err.Error())
  169. }
  170. return false, ""
  171. }
  172. func (server *Server) checkTorLimits() (banned bool, message string) {
  173. switch server.torLimiter.AddClient() {
  174. case connection_limits.ErrLimitExceeded:
  175. return true, "Too many clients from the Tor network"
  176. case connection_limits.ErrThrottleExceeded:
  177. return true, "Exceeded connection throttle for the Tor network"
  178. default:
  179. return false, ""
  180. }
  181. }
  182. //
  183. // server functionality
  184. //
  185. func (server *Server) tryRegister(c *Client, session *Session) (exiting bool) {
  186. // if the session just sent us a RESUME line, try to resume
  187. if session.resumeDetails != nil {
  188. session.tryResume()
  189. return // whether we succeeded or failed, either way `c` is not getting registered
  190. }
  191. // try to complete registration normally
  192. if c.preregNick == "" || !c.HasUsername() || session.capState == caps.NegotiatingState {
  193. return
  194. }
  195. if c.isSTSOnly {
  196. server.playRegistrationBurst(session)
  197. return true
  198. }
  199. // client MUST send PASS if necessary, or authenticate with SASL if necessary,
  200. // before completing the other registration commands
  201. authOutcome := c.isAuthorized(server.Config(), session)
  202. var quitMessage string
  203. switch authOutcome {
  204. case authFailPass:
  205. quitMessage = c.t("Password incorrect")
  206. c.Send(nil, server.name, ERR_PASSWDMISMATCH, "*", quitMessage)
  207. case authFailSaslRequired, authFailTorSaslRequired:
  208. quitMessage = c.t("You must log in with SASL to join this server")
  209. c.Send(nil, c.server.name, "FAIL", "*", "ACCOUNT_REQUIRED", quitMessage)
  210. }
  211. if authOutcome != authSuccess {
  212. c.Quit(quitMessage, nil)
  213. return true
  214. }
  215. // we have the final value of the IP address: do the hostname lookup
  216. // (nickmask will be set below once nickname assignment succeeds)
  217. if session.rawHostname == "" {
  218. session.client.lookupHostname(session, false)
  219. }
  220. rb := NewResponseBuffer(session)
  221. nickError := performNickChange(server, c, c, session, c.preregNick, rb)
  222. rb.Send(true)
  223. if nickError == errInsecureReattach {
  224. c.Quit(c.t("You can't mix secure and insecure connections to this account"), nil)
  225. return true
  226. } else if nickError != nil {
  227. c.preregNick = ""
  228. return false
  229. }
  230. if session.client != c {
  231. // reattached, bail out.
  232. // we'll play the reg burst later, on the new goroutine associated with
  233. // (thisSession, otherClient). This is to avoid having to transfer state
  234. // like nickname, hostname, etc. to show the correct values in the reg burst.
  235. return false
  236. }
  237. // check KLINEs
  238. isBanned, info := server.klines.CheckMasks(c.AllNickmasks()...)
  239. if isBanned {
  240. c.Quit(info.BanMessage(c.t("You are banned from this server (%s)")), nil)
  241. return true
  242. }
  243. // registration has succeeded:
  244. c.SetRegistered()
  245. // count new user in statistics
  246. server.stats.Register()
  247. server.monitorManager.AlertAbout(c, true)
  248. server.playRegistrationBurst(session)
  249. return false
  250. }
  251. func (server *Server) playRegistrationBurst(session *Session) {
  252. c := session.client
  253. // continue registration
  254. d := c.Details()
  255. server.logger.Info("connect", fmt.Sprintf("Client connected [%s] [u:%s] [r:%s]", d.nick, d.username, d.realname))
  256. server.snomasks.Send(sno.LocalConnects, fmt.Sprintf("Client connected [%s] [u:%s] [h:%s] [ip:%s] [r:%s]", d.nick, d.username, session.rawHostname, session.IP().String(), d.realname))
  257. // send welcome text
  258. //NOTE(dan): we specifically use the NICK here instead of the nickmask
  259. // see http://modern.ircdocs.horse/#rplwelcome-001 for details on why we avoid using the nickmask
  260. session.Send(nil, server.name, RPL_WELCOME, d.nick, fmt.Sprintf(c.t("Welcome to the Internet Relay Network %s"), d.nick))
  261. session.Send(nil, server.name, RPL_YOURHOST, d.nick, fmt.Sprintf(c.t("Your host is %[1]s, running version %[2]s"), server.name, Ver))
  262. session.Send(nil, server.name, RPL_CREATED, d.nick, fmt.Sprintf(c.t("This server was created %s"), server.ctime.Format(time.RFC1123)))
  263. //TODO(dan): Look at adding last optional [<channel modes with a parameter>] parameter
  264. session.Send(nil, server.name, RPL_MYINFO, d.nick, server.name, Ver, supportedUserModesString, supportedChannelModesString)
  265. if c.isSTSOnly {
  266. for _, line := range server.Config().Server.STS.bannerLines {
  267. c.Notice(line)
  268. }
  269. return
  270. }
  271. rb := NewResponseBuffer(session)
  272. server.RplISupport(c, rb)
  273. server.Lusers(c, rb)
  274. server.MOTD(c, rb)
  275. rb.Send(true)
  276. modestring := c.ModeString()
  277. if modestring != "+" {
  278. session.Send(nil, server.name, RPL_UMODEIS, d.nick, modestring)
  279. }
  280. c.attemptAutoOper(session)
  281. if server.logger.IsLoggingRawIO() {
  282. session.Send(nil, c.server.name, "NOTICE", d.nick, c.t("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."))
  283. }
  284. // #572: defer nick warnings to the end of the registration burst
  285. session.client.nickTimer.Touch(nil)
  286. }
  287. // RplISupport outputs our ISUPPORT lines to the client. This is used on connection and in VERSION responses.
  288. func (server *Server) RplISupport(client *Client, rb *ResponseBuffer) {
  289. translatedISupport := client.t("are supported by this server")
  290. nick := client.Nick()
  291. config := server.Config()
  292. for _, cachedTokenLine := range config.Server.isupport.CachedReply {
  293. length := len(cachedTokenLine) + 2
  294. tokenline := make([]string, length)
  295. tokenline[0] = nick
  296. copy(tokenline[1:], cachedTokenLine)
  297. tokenline[length-1] = translatedISupport
  298. rb.Add(nil, server.name, RPL_ISUPPORT, tokenline...)
  299. }
  300. }
  301. func (server *Server) Lusers(client *Client, rb *ResponseBuffer) {
  302. nick := client.Nick()
  303. stats := server.stats.GetValues()
  304. rb.Add(nil, server.name, RPL_LUSERCLIENT, nick, fmt.Sprintf(client.t("There are %[1]d users and %[2]d invisible on %[3]d server(s)"), stats.Total-stats.Invisible, stats.Invisible, 1))
  305. rb.Add(nil, server.name, RPL_LUSEROP, nick, strconv.Itoa(stats.Operators), client.t("IRC Operators online"))
  306. rb.Add(nil, server.name, RPL_LUSERUNKNOWN, nick, strconv.Itoa(stats.Unknown), client.t("unregistered connections"))
  307. rb.Add(nil, server.name, RPL_LUSERCHANNELS, nick, strconv.Itoa(server.channels.Len()), client.t("channels formed"))
  308. rb.Add(nil, server.name, RPL_LUSERME, nick, fmt.Sprintf(client.t("I have %[1]d clients and %[2]d servers"), stats.Total, 0))
  309. total := strconv.Itoa(stats.Total)
  310. max := strconv.Itoa(stats.Max)
  311. rb.Add(nil, server.name, RPL_LOCALUSERS, nick, total, max, fmt.Sprintf(client.t("Current local users %[1]s, max %[2]s"), total, max))
  312. rb.Add(nil, server.name, RPL_GLOBALUSERS, nick, total, max, fmt.Sprintf(client.t("Current global users %[1]s, max %[2]s"), total, max))
  313. }
  314. // MOTD serves the Message of the Day.
  315. func (server *Server) MOTD(client *Client, rb *ResponseBuffer) {
  316. motdLines := server.Config().Server.motdLines
  317. if len(motdLines) < 1 {
  318. rb.Add(nil, server.name, ERR_NOMOTD, client.nick, client.t("MOTD File is missing"))
  319. return
  320. }
  321. rb.Add(nil, server.name, RPL_MOTDSTART, client.nick, fmt.Sprintf(client.t("- %s Message of the day - "), server.name))
  322. for _, line := range motdLines {
  323. rb.Add(nil, server.name, RPL_MOTD, client.nick, line)
  324. }
  325. rb.Add(nil, server.name, RPL_ENDOFMOTD, client.nick, client.t("End of MOTD command"))
  326. }
  327. // WhoisChannelsNames returns the common channel names between two users.
  328. func (client *Client) WhoisChannelsNames(target *Client, multiPrefix bool) []string {
  329. var chstrs []string
  330. for _, channel := range target.Channels() {
  331. // channel is secret and the target can't see it
  332. if !client.HasMode(modes.Operator) {
  333. if (target.HasMode(modes.Invisible) || channel.flags.HasMode(modes.Secret)) && !channel.hasClient(client) {
  334. continue
  335. }
  336. }
  337. chstrs = append(chstrs, channel.ClientPrefixes(target, multiPrefix)+channel.name)
  338. }
  339. return chstrs
  340. }
  341. func (client *Client) getWhoisOf(target *Client, rb *ResponseBuffer) {
  342. cnick := client.Nick()
  343. targetInfo := target.Details()
  344. rb.Add(nil, client.server.name, RPL_WHOISUSER, cnick, targetInfo.nick, targetInfo.username, targetInfo.hostname, "*", targetInfo.realname)
  345. tnick := targetInfo.nick
  346. whoischannels := client.WhoisChannelsNames(target, rb.session.capabilities.Has(caps.MultiPrefix))
  347. if whoischannels != nil {
  348. rb.Add(nil, client.server.name, RPL_WHOISCHANNELS, cnick, tnick, strings.Join(whoischannels, " "))
  349. }
  350. tOper := target.Oper()
  351. if tOper != nil {
  352. rb.Add(nil, client.server.name, RPL_WHOISOPERATOR, cnick, tnick, tOper.WhoisLine)
  353. }
  354. if client.HasMode(modes.Operator) || client == target {
  355. rb.Add(nil, client.server.name, RPL_WHOISACTUALLY, cnick, tnick, fmt.Sprintf("%s@%s", targetInfo.username, target.RawHostname()), target.IPString(), client.t("Actual user@host, Actual IP"))
  356. }
  357. if target.HasMode(modes.TLS) {
  358. rb.Add(nil, client.server.name, RPL_WHOISSECURE, cnick, tnick, client.t("is using a secure connection"))
  359. }
  360. if targetInfo.accountName != "*" {
  361. rb.Add(nil, client.server.name, RPL_WHOISACCOUNT, cnick, tnick, targetInfo.accountName, client.t("is logged in as"))
  362. }
  363. if target.HasMode(modes.Bot) {
  364. rb.Add(nil, client.server.name, RPL_WHOISBOT, cnick, tnick, ircfmt.Unescape(fmt.Sprintf(client.t("is a $bBot$b on %s"), client.server.Config().Network.Name)))
  365. }
  366. if client == target || client.HasMode(modes.Operator) {
  367. for _, session := range target.Sessions() {
  368. if session.certfp != "" {
  369. rb.Add(nil, client.server.name, RPL_WHOISCERTFP, cnick, tnick, fmt.Sprintf(client.t("has client certificate fingerprint %s"), session.certfp))
  370. }
  371. }
  372. }
  373. rb.Add(nil, client.server.name, RPL_WHOISIDLE, cnick, tnick, strconv.FormatUint(target.IdleSeconds(), 10), strconv.FormatInt(target.SignonTime(), 10), client.t("seconds idle, signon time"))
  374. if target.Away() {
  375. rb.Add(nil, client.server.name, RPL_AWAY, cnick, tnick, target.AwayMessage())
  376. }
  377. }
  378. // rplWhoReply returns the WHO reply between one user and another channel/user.
  379. // <channel> <user> <host> <server> <nick> ( "H" / "G" ) ["*"] [ ( "@" / "+" ) ]
  380. // :<hopcount> <real name>
  381. func (client *Client) rplWhoReply(channel *Channel, target *Client, rb *ResponseBuffer) {
  382. channelName := "*"
  383. flags := ""
  384. if target.Away() {
  385. flags = "G"
  386. } else {
  387. flags = "H"
  388. }
  389. if target.HasMode(modes.Operator) {
  390. flags += "*"
  391. }
  392. if channel != nil {
  393. // TODO is this right?
  394. flags += channel.ClientPrefixes(target, rb.session.capabilities.Has(caps.MultiPrefix))
  395. channelName = channel.name
  396. }
  397. details := target.Details()
  398. // hardcode a hopcount of 0 for now
  399. rb.Add(nil, client.server.name, RPL_WHOREPLY, client.Nick(), channelName, details.username, details.hostname, client.server.name, details.nick, flags, "0 "+details.realname)
  400. }
  401. // rehash reloads the config and applies the changes from the config file.
  402. func (server *Server) rehash() error {
  403. server.logger.Debug("server", "Starting rehash")
  404. // only let one REHASH go on at a time
  405. server.rehashMutex.Lock()
  406. defer server.rehashMutex.Unlock()
  407. server.logger.Debug("server", "Got rehash lock")
  408. config, err := LoadConfig(server.configFilename)
  409. if err != nil {
  410. return fmt.Errorf("Error loading config file config: %s", err.Error())
  411. }
  412. err = server.applyConfig(config)
  413. if err != nil {
  414. return fmt.Errorf("Error applying config changes: %s", err.Error())
  415. }
  416. return nil
  417. }
  418. func (server *Server) applyConfig(config *Config) (err error) {
  419. oldConfig := server.Config()
  420. initial := oldConfig == nil
  421. if initial {
  422. server.configFilename = config.Filename
  423. server.name = config.Server.Name
  424. server.nameCasefolded = config.Server.nameCasefolded
  425. globalCasemappingSetting = config.Server.Casemapping
  426. } else {
  427. // enforce configs that can't be changed after launch:
  428. if server.name != config.Server.Name {
  429. return fmt.Errorf("Server name cannot be changed after launching the server, rehash aborted")
  430. } else if oldConfig.Datastore.Path != config.Datastore.Path {
  431. return fmt.Errorf("Datastore path cannot be changed after launching the server, rehash aborted")
  432. } else if globalCasemappingSetting != config.Server.Casemapping {
  433. return fmt.Errorf("Casemapping cannot be changed after launching the server, rehash aborted")
  434. } else if oldConfig.Accounts.Multiclient.AlwaysOn != config.Accounts.Multiclient.AlwaysOn {
  435. return fmt.Errorf("Default always-on setting cannot be changed after launching the server, rehash aborted")
  436. }
  437. }
  438. server.logger.Info("server", "Using config file", server.configFilename)
  439. // first, reload config sections for functionality implemented in subpackages:
  440. wasLoggingRawIO := !initial && server.logger.IsLoggingRawIO()
  441. err = server.logger.ApplyConfig(config.Logging)
  442. if err != nil {
  443. return err
  444. }
  445. nowLoggingRawIO := server.logger.IsLoggingRawIO()
  446. // notify existing clients if raw i/o logging was enabled by a rehash
  447. sendRawOutputNotice := !wasLoggingRawIO && nowLoggingRawIO
  448. server.connectionLimiter.ApplyConfig(&config.Server.IPLimits)
  449. tlConf := &config.Server.TorListeners
  450. server.torLimiter.Configure(tlConf.MaxConnections, tlConf.ThrottleDuration, tlConf.MaxConnectionsPerDuration)
  451. // Translations
  452. server.logger.Debug("server", "Regenerating HELP indexes for new languages")
  453. server.helpIndexManager.GenerateIndices(config.languageManager)
  454. if oldConfig != nil {
  455. // if certain features were enabled by rehash, we need to load the corresponding data
  456. // from the store
  457. if !oldConfig.Accounts.NickReservation.Enabled {
  458. server.accounts.buildNickToAccountIndex(config)
  459. }
  460. if !oldConfig.Accounts.VHosts.Enabled {
  461. server.accounts.initVHostRequestQueue(config)
  462. }
  463. if !oldConfig.Channels.Registration.Enabled {
  464. server.channels.loadRegisteredChannels(config)
  465. }
  466. // resize history buffers as needed
  467. if oldConfig.History != config.History {
  468. for _, channel := range server.channels.Channels() {
  469. channel.resizeHistory(config)
  470. }
  471. for _, client := range server.clients.AllClients() {
  472. client.resizeHistory(config)
  473. }
  474. }
  475. if oldConfig.Accounts.Registration.Throttling != config.Accounts.Registration.Throttling {
  476. server.accounts.resetRegisterThrottle(config)
  477. }
  478. }
  479. // activate the new config
  480. server.SetConfig(config)
  481. // burst new and removed caps
  482. addedCaps, removedCaps := config.Diff(oldConfig)
  483. var capBurstSessions []*Session
  484. added := make(map[caps.Version][]string)
  485. var removed []string
  486. if !addedCaps.Empty() || !removedCaps.Empty() {
  487. capBurstSessions = server.clients.AllWithCapsNotify()
  488. added[caps.Cap301] = addedCaps.Strings(caps.Cap301, config.Server.capValues, 0)
  489. added[caps.Cap302] = addedCaps.Strings(caps.Cap302, config.Server.capValues, 0)
  490. // removed never has values, so we leave it as Cap301
  491. removed = removedCaps.Strings(caps.Cap301, config.Server.capValues, 0)
  492. }
  493. for _, sSession := range capBurstSessions {
  494. // DEL caps and then send NEW ones so that updated caps get removed/added correctly
  495. if !removedCaps.Empty() {
  496. for _, capStr := range removed {
  497. sSession.Send(nil, server.name, "CAP", sSession.client.Nick(), "DEL", capStr)
  498. }
  499. }
  500. if !addedCaps.Empty() {
  501. for _, capStr := range added[sSession.capVersion] {
  502. sSession.Send(nil, server.name, "CAP", sSession.client.Nick(), "NEW", capStr)
  503. }
  504. }
  505. }
  506. server.logger.Info("server", "Using datastore", config.Datastore.Path)
  507. if initial {
  508. if err := server.loadDatastore(config); err != nil {
  509. return err
  510. }
  511. } else {
  512. if config.Datastore.MySQL.Enabled && config.Datastore.MySQL != oldConfig.Datastore.MySQL {
  513. server.historyDB.SetConfig(config.Datastore.MySQL)
  514. }
  515. }
  516. server.setupPprofListener(config)
  517. // set RPL_ISUPPORT
  518. var newISupportReplies [][]string
  519. if oldConfig != nil {
  520. newISupportReplies = oldConfig.Server.isupport.GetDifference(&config.Server.isupport)
  521. }
  522. // we are now open for business
  523. err = server.setupListeners(config)
  524. if !initial {
  525. // push new info to all of our clients
  526. for _, sClient := range server.clients.AllClients() {
  527. for _, tokenline := range newISupportReplies {
  528. sClient.Send(nil, server.name, RPL_ISUPPORT, append([]string{sClient.nick}, tokenline...)...)
  529. }
  530. if sendRawOutputNotice {
  531. sClient.Notice(sClient.t("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."))
  532. }
  533. if !oldConfig.Accounts.NickReservation.Enabled && config.Accounts.NickReservation.Enabled {
  534. sClient.nickTimer.Initialize(sClient)
  535. sClient.nickTimer.Touch(nil)
  536. } else if oldConfig.Accounts.NickReservation.Enabled && !config.Accounts.NickReservation.Enabled {
  537. sClient.nickTimer.Stop()
  538. }
  539. }
  540. }
  541. return err
  542. }
  543. func (server *Server) setupPprofListener(config *Config) {
  544. pprofListener := ""
  545. if config.Debug.PprofListener != nil {
  546. pprofListener = *config.Debug.PprofListener
  547. }
  548. if server.pprofServer != nil {
  549. if pprofListener == "" || (pprofListener != server.pprofServer.Addr) {
  550. server.logger.Info("server", "Stopping pprof listener", server.pprofServer.Addr)
  551. server.pprofServer.Close()
  552. server.pprofServer = nil
  553. }
  554. }
  555. if pprofListener != "" && server.pprofServer == nil {
  556. ps := http.Server{
  557. Addr: pprofListener,
  558. }
  559. go func() {
  560. if err := ps.ListenAndServe(); err != nil {
  561. server.logger.Error("server", "pprof listener failed", err.Error())
  562. }
  563. }()
  564. server.pprofServer = &ps
  565. server.logger.Info("server", "Started pprof listener", server.pprofServer.Addr)
  566. }
  567. }
  568. func (config *Config) loadMOTD() (err error) {
  569. if config.Server.MOTD != "" {
  570. file, err := os.Open(config.Server.MOTD)
  571. if err == nil {
  572. defer file.Close()
  573. reader := bufio.NewReader(file)
  574. for {
  575. line, err := reader.ReadString('\n')
  576. if err != nil {
  577. break
  578. }
  579. line = strings.TrimRight(line, "\r\n")
  580. if config.Server.MOTDFormatting {
  581. line = ircfmt.Unescape(line)
  582. }
  583. // "- " is the required prefix for MOTD, we just add it here to make
  584. // bursting it out to clients easier
  585. line = fmt.Sprintf("- %s", line)
  586. config.Server.motdLines = append(config.Server.motdLines, line)
  587. }
  588. }
  589. }
  590. return
  591. }
  592. func (server *Server) loadDatastore(config *Config) error {
  593. // open the datastore and load server state for which it (rather than config)
  594. // is the source of truth
  595. _, err := os.Stat(config.Datastore.Path)
  596. if os.IsNotExist(err) {
  597. server.logger.Warning("server", "database does not exist, creating it", config.Datastore.Path)
  598. err = initializeDB(config.Datastore.Path)
  599. if err != nil {
  600. return err
  601. }
  602. }
  603. db, err := OpenDatabase(config)
  604. if err == nil {
  605. server.store = db
  606. } else {
  607. return fmt.Errorf("Failed to open datastore: %s", err.Error())
  608. }
  609. // load *lines (from the datastores)
  610. server.logger.Debug("server", "Loading D/Klines")
  611. server.loadDLines()
  612. server.loadKLines()
  613. server.channelRegistry.Initialize(server)
  614. server.channels.Initialize(server)
  615. server.accounts.Initialize(server)
  616. if config.Datastore.MySQL.Enabled {
  617. server.historyDB.Initialize(server.logger, config.Datastore.MySQL)
  618. err = server.historyDB.Open()
  619. if err != nil {
  620. server.logger.Error("internal", "could not connect to mysql", err.Error())
  621. return err
  622. }
  623. }
  624. return nil
  625. }
  626. func (server *Server) setupListeners(config *Config) (err error) {
  627. logListener := func(addr string, config utils.ListenerConfig) {
  628. server.logger.Info("listeners",
  629. fmt.Sprintf("now listening on %s, tls=%t, tlsproxy=%t, tor=%t, websocket=%t.", addr, (config.TLSConfig != nil), config.RequireProxy, config.Tor, config.WebSocket),
  630. )
  631. }
  632. // update or destroy all existing listeners
  633. for addr := range server.listeners {
  634. currentListener := server.listeners[addr]
  635. newConfig, stillConfigured := config.Server.trueListeners[addr]
  636. if stillConfigured {
  637. reloadErr := currentListener.Reload(newConfig)
  638. // attempt to stop and replace the listener if the reload failed
  639. if reloadErr != nil {
  640. currentListener.Stop()
  641. newListener, newErr := NewListener(server, addr, newConfig, config.Server.UnixBindMode)
  642. if newErr == nil {
  643. server.listeners[addr] = newListener
  644. } else {
  645. delete(server.listeners, addr)
  646. return newErr
  647. }
  648. }
  649. logListener(addr, newConfig)
  650. } else {
  651. currentListener.Stop()
  652. delete(server.listeners, addr)
  653. server.logger.Info("listeners", fmt.Sprintf("stopped listening on %s.", addr))
  654. }
  655. }
  656. publicPlaintextListener := ""
  657. // create new listeners that were not previously configured
  658. for newAddr, newConfig := range config.Server.trueListeners {
  659. if strings.HasPrefix(newAddr, ":") && !newConfig.Tor && !newConfig.STSOnly && newConfig.TLSConfig == nil {
  660. publicPlaintextListener = newAddr
  661. }
  662. _, exists := server.listeners[newAddr]
  663. if !exists {
  664. // make a new listener
  665. newListener, newErr := NewListener(server, newAddr, newConfig, config.Server.UnixBindMode)
  666. if newErr == nil {
  667. server.listeners[newAddr] = newListener
  668. logListener(newAddr, newConfig)
  669. } else {
  670. server.logger.Error("server", "couldn't listen on", newAddr, newErr.Error())
  671. err = newErr
  672. }
  673. }
  674. }
  675. if publicPlaintextListener != "" {
  676. server.logger.Warning("listeners", fmt.Sprintf("Your server is configured with public plaintext listener %s. Consider disabling it for improved security and privacy.", publicPlaintextListener))
  677. }
  678. return
  679. }
  680. // Gets the abstract sequence from which we're going to query history;
  681. // we may already know the channel we're querying, or we may have
  682. // to look it up via a string query. This function is responsible for
  683. // privilege checking.
  684. func (server *Server) GetHistorySequence(providedChannel *Channel, client *Client, query string) (channel *Channel, sequence history.Sequence, err error) {
  685. config := server.Config()
  686. // 4 cases: {persistent, ephemeral} x {normal, conversation}
  687. // with ephemeral history, target is implicit in the choice of `hist`,
  688. // and correspondent is "" if we're retrieving a channel or *, and the correspondent's name
  689. // if we're retrieving a DM conversation ("query buffer"). with persistent history,
  690. // target is always nonempty, and correspondent is either empty or nonempty as before.
  691. var status HistoryStatus
  692. var target, correspondent string
  693. var hist *history.Buffer
  694. channel = providedChannel
  695. if channel == nil {
  696. if strings.HasPrefix(query, "#") {
  697. channel = server.channels.Get(query)
  698. if channel == nil {
  699. return
  700. }
  701. }
  702. }
  703. if channel != nil {
  704. if !channel.hasClient(client) {
  705. err = errInsufficientPrivs
  706. return
  707. }
  708. status, target = channel.historyStatus(config)
  709. switch status {
  710. case HistoryEphemeral:
  711. hist = &channel.history
  712. case HistoryPersistent:
  713. // already set `target`
  714. default:
  715. return
  716. }
  717. } else {
  718. status, target = client.historyStatus(config)
  719. if query != "*" {
  720. correspondent, err = CasefoldName(query)
  721. if err != nil {
  722. return
  723. }
  724. }
  725. switch status {
  726. case HistoryEphemeral:
  727. hist = &client.history
  728. case HistoryPersistent:
  729. // already set `target`, and `correspondent` if necessary
  730. default:
  731. return
  732. }
  733. }
  734. var cutoff time.Time
  735. if config.History.Restrictions.ExpireTime != 0 {
  736. cutoff = time.Now().UTC().Add(-time.Duration(config.History.Restrictions.ExpireTime))
  737. }
  738. // #836: registration date cutoff is always enforced for DMs
  739. if config.History.Restrictions.EnforceRegistrationDate || channel == nil {
  740. regCutoff := client.historyCutoff()
  741. // take the later of the two cutoffs
  742. if regCutoff.After(cutoff) {
  743. cutoff = regCutoff
  744. }
  745. }
  746. // #836 again: grace period is never applied to DMs
  747. if !cutoff.IsZero() && channel != nil {
  748. cutoff = cutoff.Add(-time.Duration(config.History.Restrictions.GracePeriod))
  749. }
  750. if hist != nil {
  751. sequence = hist.MakeSequence(correspondent, cutoff)
  752. } else if target != "" {
  753. sequence = server.historyDB.MakeSequence(target, correspondent, cutoff)
  754. }
  755. return
  756. }
  757. // elistMatcher takes and matches ELIST conditions
  758. type elistMatcher struct {
  759. MinClientsActive bool
  760. MinClients int
  761. MaxClientsActive bool
  762. MaxClients int
  763. }
  764. // Matches checks whether the given channel matches our matches.
  765. func (matcher *elistMatcher) Matches(channel *Channel) bool {
  766. if matcher.MinClientsActive {
  767. if len(channel.Members()) < matcher.MinClients {
  768. return false
  769. }
  770. }
  771. if matcher.MaxClientsActive {
  772. if len(channel.Members()) < len(channel.members) {
  773. return false
  774. }
  775. }
  776. return true
  777. }
  778. // RplList returns the RPL_LIST numeric for the given channel.
  779. func (target *Client) RplList(channel *Channel, rb *ResponseBuffer) {
  780. // get the correct number of channel members
  781. var memberCount int
  782. if target.HasMode(modes.Operator) || channel.hasClient(target) {
  783. memberCount = len(channel.Members())
  784. } else {
  785. for _, member := range channel.Members() {
  786. if !member.HasMode(modes.Invisible) {
  787. memberCount++
  788. }
  789. }
  790. }
  791. // #704: some channels are kept around even with no members
  792. if memberCount != 0 {
  793. rb.Add(nil, target.server.name, RPL_LIST, target.nick, channel.name, strconv.Itoa(memberCount), channel.topic)
  794. }
  795. }
  796. var (
  797. infoString1 = strings.Split(` ▄▄▄ ▄▄▄· ▄▄ • ▐ ▄
  798. ▪ ▀▄ █·▐█ ▀█ ▐█ ▀ ▪▪ •█▌▐█▪
  799. ▄█▀▄ ▐▀▀▄ ▄█▀▀█ ▄█ ▀█▄ ▄█▀▄▪▐█▐▐▌ ▄█▀▄
  800. ▐█▌.▐▌▐█•█▌▐█ ▪▐▌▐█▄▪▐█▐█▌ ▐▌██▐█▌▐█▌.▐▌
  801. ▀█▄▀▪.▀ ▀ ▀ ▀ ·▀▀▀▀ ▀█▄▀ ▀▀ █▪ ▀█▄▀▪
  802. https://oragono.io/
  803. https://github.com/oragono/oragono
  804. https://crowdin.com/project/oragono
  805. `, "\n")
  806. infoString2 = strings.Split(` Daniel Oakley, DanielOaks, <daniel@danieloaks.net>
  807. Shivaram Lingamneni, slingamn, <slingamn@cs.stanford.edu>
  808. `, "\n")
  809. infoString3 = strings.Split(` Jeremy Latt, jlatt
  810. Edmund Huber, edmund-huber
  811. `, "\n")
  812. )