summaryrefslogtreecommitdiff
path: root/xS/main.go
diff options
context:
space:
mode:
Diffstat (limited to 'xS/main.go')
-rw-r--r--xS/main.go3529
1 files changed, 0 insertions, 3529 deletions
diff --git a/xS/main.go b/xS/main.go
deleted file mode 100644
index 21851f1..0000000
--- a/xS/main.go
+++ /dev/null
@@ -1,3529 +0,0 @@
-//
-// Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name>
-//
-// Permission to use, copy, modify, and/or distribute this software for any
-// purpose with or without fee is hereby granted.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
-// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
-// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-//
-
-// xS is a straight-forward port of xD IRCd from C.
-package main
-
-import (
- "bufio"
- "bytes"
- "crypto/sha256"
- "crypto/tls"
- "encoding/hex"
- "errors"
- "flag"
- "fmt"
- "io"
- "io/ioutil"
- "log/syslog"
- "net"
- "os"
- "os/signal"
- "os/user"
- "path/filepath"
- "regexp"
- "strconv"
- "strings"
- "syscall"
- "time"
-)
-
-var debugMode = false
-
-const (
- projectName = "xS"
- // TODO: Consider using the same version number for all subprojects.
- projectVersion = "0"
-)
-
-// --- Logging -----------------------------------------------------------------
-
-type logPrio int
-
-const (
- prioFatal logPrio = iota
- prioError
- prioWarning
- prioStatus
- prioDebug
-)
-
-func (lp logPrio) prefix() string {
- switch lp {
- case prioFatal:
- return "fatal: "
- case prioError:
- return "error: "
- case prioWarning:
- return "warning: "
- case prioStatus:
- return ""
- case prioDebug:
- return "debug: "
- default:
- panic("unhandled log priority")
- }
-}
-
-func (lp logPrio) syslogPrio() syslog.Priority {
- switch lp {
- case prioFatal:
- return syslog.LOG_ERR
- case prioError:
- return syslog.LOG_ERR
- case prioWarning:
- return syslog.LOG_WARNING
- case prioStatus:
- return syslog.LOG_INFO
- case prioDebug:
- return syslog.LOG_DEBUG
- default:
- panic("unhandled log priority")
- }
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-func logMessageStdio(prio logPrio, format string, args ...interface{}) {
- // TODO: isatty-enabled colors based on prio.
- os.Stderr.WriteString(time.Now().Format("2006-01-02 15:04:05 ") +
- prio.prefix() + fmt.Sprintf(format, args...) + "\n")
-}
-
-func logMessageSystemd(prio logPrio, format string, args ...interface{}) {
- if prio == prioFatal {
- // There is no corresponding syslog severity.
- format = "fatal: " + format
- }
- fmt.Fprintf(os.Stderr, "<%d>%s\n",
- prio.syslogPrio(), fmt.Sprintf(format, args...))
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-var logMessage = logMessageStdio
-
-func printDebug(format string, args ...interface{}) {
- if debugMode {
- logMessage(prioDebug, format, args...)
- }
-}
-
-func printStatus(format string, args ...interface{}) {
- logMessage(prioStatus, format, args...)
-}
-func printWarning(format string, args ...interface{}) {
- logMessage(prioWarning, format, args...)
-}
-func printError(format string, args ...interface{}) {
- logMessage(prioError, format, args...)
-}
-
-// "fatal" is reserved for failures that would harm further operation.
-
-func printFatal(format string, args ...interface{}) {
- logMessage(prioFatal, format, args...)
-}
-
-func exitFatal(format string, args ...interface{}) {
- printFatal(format, args...)
- os.Exit(1)
-}
-
-// --- Utilities ---------------------------------------------------------------
-
-// Split a string by a set of UTF-8 delimiters, optionally ignoring empty items.
-func splitString(s, delims string, ignoreEmpty bool) (result []string) {
- for {
- end := strings.IndexAny(s, delims)
- if end < 0 {
- break
- }
- if !ignoreEmpty || end != 0 {
- result = append(result, s[:end])
- }
- s = s[end+1:]
- }
- if !ignoreEmpty || s != "" {
- result = append(result, s)
- }
- return
-}
-
-// Trivial SSL/TLS autodetection. The first block of data returned by Recvfrom
-// must be at least three octets long for this to work reliably, but that should
-// not pose a problem in practice. We might try waiting for them.
-//
-// SSL2: 1xxx xxxx | xxxx xxxx | <1>
-// (message length) (client hello)
-// SSL3/TLS: <22> | <3> | xxxx xxxx
-// (handshake)| (protocol version)
-//
-// Note that Go 1.12's crypto/tls offers a slightly more straight-forward
-// solution: "If a client sends an initial message that does not look like TLS,
-// the server will no longer reply with an alert, and it will expose the
-// underlying net.Conn in the new field Conn of RecordHeaderError."
-func detectTLS(sysconn syscall.RawConn) (isTLS bool) {
- sysconn.Read(func(fd uintptr) (done bool) {
- var buf [3]byte
- n, _, err := syscall.Recvfrom(int(fd), buf[:], syscall.MSG_PEEK)
- switch {
- case n == 3:
- isTLS = buf[0]&0x80 != 0 && buf[2] == 1
- fallthrough
- case n == 2:
- isTLS = isTLS || buf[0] == 22 && buf[1] == 3
- case n == 1:
- isTLS = buf[0] == 22
- case err == syscall.EAGAIN:
- return false
- }
- return true
- })
- return isTLS
-}
-
-// --- File system -------------------------------------------------------------
-
-// Look up the value of an XDG path from environment, or fall back to a default.
-func getXDGHomeDir(name, def string) string {
- env := os.Getenv(name)
- if env != "" && env[0] == filepath.Separator {
- return env
- }
-
- home := ""
- if v, ok := os.LookupEnv("HOME"); ok {
- home = v
- } else if u, _ := user.Current(); u != nil {
- home = u.HomeDir
- }
- return filepath.Join(home, def)
-}
-
-func resolveRelativeFilenameGeneric(paths []string, filename string) string {
- for _, path := range paths {
- // As per XDG spec, relative paths are ignored.
- if path == "" || path[0] != filepath.Separator {
- continue
- }
-
- file := filepath.Join(path, filename)
- if _, err := os.Stat(file); err == nil {
- return file
- }
- }
- return ""
-}
-
-// Retrieve all XDG base directories for configuration files.
-func getXDGConfigDirs() (result []string) {
- home := getXDGHomeDir("XDG_CONFIG_HOME", ".config")
- if home != "" {
- result = append(result, home)
- }
- dirs := os.Getenv("XDG_CONFIG_DIRS")
- if dirs == "" {
- dirs = "/etc/xdg"
- }
- for _, path := range strings.Split(dirs, ":") {
- if path != "" {
- result = append(result, path)
- }
- }
- return
-}
-
-func resolveRelativeConfigFilename(filename string) string {
- return resolveRelativeFilenameGeneric(getXDGConfigDirs(),
- filepath.Join(projectName, filename))
-}
-
-func findTildeHome(username string) string {
- if username != "" {
- if u, _ := user.Lookup(username); u != nil {
- return u.HomeDir
- }
- } else if u, _ := user.Current(); u != nil {
- return u.HomeDir
- } else if v, ok := os.LookupEnv("HOME"); ok {
- return v
- }
- printDebug("failed to expand the home directory for %s", username)
- return "~" + username
-}
-
-func resolveFilename(filename string, relativeCB func(string) string) string {
- // Absolute path is absolute.
- if filename == "" || filename[0] == filepath.Separator {
- return filename
- }
- if filename[0] != '~' {
- return relativeCB(filename)
- }
-
- // Paths to home directories ought to be absolute.
- var n int
- for n = 0; n < len(filename); n++ {
- if filename[n] == filepath.Separator {
- break
- }
- }
- return findTildeHome(filename[1:n]) + filename[n:]
-}
-
-// --- Simple file I/O ---------------------------------------------------------
-
-// Overwrites filename contents with data; creates directories as needed.
-func writeFile(path string, data []byte) error {
- if dir := filepath.Dir(path); dir != "." {
- if err := os.MkdirAll(dir, 0755); err != nil {
- return err
- }
- }
- return ioutil.WriteFile(path, data, 0644)
-}
-
-// Wrapper for writeFile that makes sure that the new data has been written
-// to disk in its entirety before overriding the old file.
-func writeFileSafe(path string, data []byte) error {
- temp := path + ".new"
- if err := writeFile(temp, data); err != nil {
- return err
- }
- return os.Rename(temp, path)
-}
-
-// --- Simple configuration ----------------------------------------------------
-
-// This is the bare minimum to make an application configurable.
-// Keys are stripped of surrounding whitespace, values are not.
-
-type simpleConfigItem struct {
- key string // INI key
- def string // default value
- description string // documentation
-}
-
-type simpleConfig map[string]string
-
-func (sc simpleConfig) loadDefaults(table []simpleConfigItem) {
- for _, item := range table {
- sc[item.key] = item.def
- }
-}
-
-func (sc simpleConfig) updateFromFile() error {
- basename := projectName + ".conf"
- path := resolveFilename(basename, resolveRelativeConfigFilename)
- if path == "" {
- return &os.PathError{
- Op: "cannot find",
- Path: basename,
- Err: os.ErrNotExist,
- }
- }
-
- f, err := os.Open(path)
- if err != nil {
- return err
- }
- defer f.Close()
-
- scanner := bufio.NewScanner(f)
- for lineNo := 1; scanner.Scan(); lineNo++ {
- line := strings.TrimLeft(scanner.Text(), " \t")
- if line == "" || strings.HasPrefix(line, "#") {
- continue
- }
-
- equals := strings.IndexByte(line, '=')
- if equals <= 0 {
- return fmt.Errorf("%s:%d: malformed line", path, lineNo)
- }
-
- sc[strings.TrimRight(line[:equals], " \t")] = line[equals+1:]
- }
- return scanner.Err()
-}
-
-func writeConfigurationFile(pathHint string, data []byte) (string, error) {
- path := pathHint
- if path == "" {
- path = filepath.Join(getXDGHomeDir("XDG_CONFIG_HOME", ".config"),
- projectName, projectName+".conf")
- }
-
- if err := writeFileSafe(path, data); err != nil {
- return "", err
- }
- return path, nil
-}
-
-func simpleConfigWriteDefault(pathHint string, prolog string,
- table []simpleConfigItem) (string, error) {
- data := []byte(prolog)
- for _, item := range table {
- data = append(data, fmt.Sprintf("# %s\n%s=%s\n",
- item.description, item.key, item.def)...)
- }
- return writeConfigurationFile(pathHint, data)
-}
-
-// Convenience wrapper suitable for most simple applications.
-func callSimpleConfigWriteDefault(pathHint string, table []simpleConfigItem) {
- prologLines := []string{
- `# ` + projectName + ` ` + projectVersion + ` configuration file`,
- "#",
- `# Relative paths are searched for in ${XDG_CONFIG_HOME:-~/.config}`,
- `# /` + projectName + ` as well as in $XDG_CONFIG_DIRS/` + projectName,
- ``,
- ``,
- }
-
- path, err := simpleConfigWriteDefault(
- pathHint, strings.Join(prologLines, "\n"), table)
- if err != nil {
- exitFatal("%s", err)
- }
-
- printStatus("configuration written to `%s'", path)
-}
-
-// --- Configuration -----------------------------------------------------------
-
-var configTable = []simpleConfigItem{
- {"server_name", "", "Server name"},
- {"server_info", "My server", "Brief server description"},
- {"motd", "", "MOTD filename"},
- {"catalog", "", "Localisation catalog"},
-
- {"bind", ":6667", "Bind addresses of the IRC server"},
- {"tls_cert", "", "Server TLS certificate (PEM)"},
- {"tls_key", "", "Server TLS private key (PEM)"},
- {"webirc_password", "", "Password for WebIRC"},
-
- {"operators", "", "IRCop TLS certificate SHA-256 fingerprints"},
-
- {"max_connections", "0", "Global connection limit"},
- {"ping_interval", "180", "Interval between PINGs (sec)"},
-}
-
-// --- Rate limiter ------------------------------------------------------------
-
-type floodDetector struct {
- interval time.Duration // interval for the limit in seconds
- limit uint // maximum number of events allowed
- timestamps []time.Time // timestamps of last events
- pos uint // index of the oldest event
-}
-
-func newFloodDetector(interval time.Duration, limit uint) *floodDetector {
- return &floodDetector{
- interval: interval,
- limit: limit,
- timestamps: make([]time.Time, limit+1),
- pos: 0,
- }
-}
-
-func (fd *floodDetector) check() bool {
- now := time.Now()
- fd.timestamps[fd.pos] = now
-
- fd.pos++
- if fd.pos > fd.limit {
- fd.pos = 0
- }
-
- var count uint
- begin := now.Add(-fd.interval)
- for _, ts := range fd.timestamps {
- if ts.After(begin) {
- count++
- }
- }
- return count <= fd.limit
-}
-
-// --- IRC protocol ------------------------------------------------------------
-
-//go:generate sh -c "LC_ALL=C awk -f xS-gen-replies.awk > xS-replies.go < xS-replies"
-
-func ircToLower(c byte) byte {
- switch c {
- case '[':
- return '{'
- case ']':
- return '}'
- case '\\':
- return '|'
- case '~':
- return '^'
- }
- if c >= 'A' && c <= 'Z' {
- return c + ('a' - 'A')
- }
- return c
-}
-
-func ircToUpper(c byte) byte {
- switch c {
- case '{':
- return '['
- case '}':
- return ']'
- case '|':
- return '\\'
- case '^':
- return '~'
- }
- if c >= 'a' && c <= 'z' {
- return c - ('a' - 'A')
- }
- return c
-}
-
-// Convert identifier to a canonical form for case-insensitive comparisons.
-// ircToUpper is used so that statically initialized maps can be in uppercase.
-func ircToCanon(ident string) string {
- var canon []byte
- for _, c := range []byte(ident) {
- canon = append(canon, ircToUpper(c))
- }
- return string(canon)
-}
-
-func ircEqual(s1, s2 string) bool {
- return ircToCanon(s1) == ircToCanon(s2)
-}
-
-func ircFnmatch(pattern string, s string) bool {
- pattern, s = ircToCanon(pattern), ircToCanon(s)
- // FIXME: This should not support [] ranges and handle '/' specially.
- // We could translate the pattern to a regular expression.
- matched, _ := filepath.Match(pattern, s)
- return matched
-}
-
-var reMsg = regexp.MustCompile(
- `^(?:@([^ ]*) +)?(?::([^! ]*)(?:!([^@]*)@([^ ]*))? +)?([^ ]+)(.*)?$`)
-var reArgs = regexp.MustCompile(`:.*| [^: ][^ ]*`)
-
-type message struct {
- tags map[string]string // IRC 3.2 message tags
- nick string // optional nickname
- user string // optional username
- host string // optional hostname or IP address
- command string // command name
- params []string // arguments
-}
-
-func ircUnescapeMessageTag(value string) string {
- var buf []byte
- escape := false
- for i := 0; i < len(value); i++ {
- if escape {
- switch value[i] {
- case ':':
- buf = append(buf, ';')
- case 's':
- buf = append(buf, ' ')
- case 'r':
- buf = append(buf, '\r')
- case 'n':
- buf = append(buf, '\n')
- default:
- buf = append(buf, value[i])
- }
- escape = false
- } else if value[i] == '\\' {
- escape = true
- } else {
- buf = append(buf, value[i])
- }
- }
- return string(buf)
-}
-
-func ircParseMessageTags(tags string, out map[string]string) {
- for _, tag := range splitString(tags, ";", true /* ignoreEmpty */) {
- if equal := strings.IndexByte(tag, '='); equal < 0 {
- out[tag] = ""
- } else {
- out[tag[:equal]] = ircUnescapeMessageTag(tag[equal+1:])
- }
- }
-}
-
-func ircParseMessage(line string) *message {
- m := reMsg.FindStringSubmatch(line)
- if m == nil {
- return nil
- }
-
- msg := message{nil, m[2], m[3], m[4], m[5], nil}
- if m[1] != "" {
- msg.tags = make(map[string]string)
- ircParseMessageTags(m[1], msg.tags)
- }
- for _, x := range reArgs.FindAllString(m[6], -1) {
- msg.params = append(msg.params, x[1:])
- }
- return &msg
-
-}
-
-// --- IRC token validation ----------------------------------------------------
-
-// Everything as per RFC 2812
-const (
- ircMaxNickname = 9
- ircMaxHostname = 63
- ircMaxChannelName = 50
- ircMaxMessageLength = 510
-)
-
-const (
- reClassSpecial = "\\[\\]\\\\`_^{|}"
- // "shortname" from RFC 2812 doesn't work how its author thought it would.
- reShortname = "[0-9A-Za-z](-*[0-9A-Za-z])*"
-)
-
-var (
- reHostname = regexp.MustCompile(
- `^` + reShortname + `(\.` + reShortname + `)*$`)
-
- // Extending ASCII to the whole range of Unicode letters.
- reNickname = regexp.MustCompile(
- `^[\pL` + reClassSpecial + `][\pL` + reClassSpecial + `0-9-]*$`)
-
- // Notably, this won't match invalid UTF-8 characters, although the
- // behaviour seems to be unstated in the documentation.
- reUsername = regexp.MustCompile(`^[^\0\r\n @]+$`)
-
- reChannelName = regexp.MustCompile(`^[^\0\007\r\n ,:]+$`)
- reKey = regexp.MustCompile(`^[^\r\n\f\t\v ]{1,23}$`)
- reUserMask = regexp.MustCompile(`^[^!@]+![^!@]+@[^@!]+$`)
- reFingerprint = regexp.MustCompile(`^[a-fA-F0-9]{64}$`)
-)
-
-func ircValidateHostname(hostname string) error {
- if hostname == "" {
- return errors.New("the value is empty")
- }
- if !reHostname.MatchString(hostname) {
- return errors.New("invalid format")
- }
- if len(hostname) > ircMaxHostname {
- return errors.New("the value is too long")
- }
- return nil
-}
-
-func ircIsValidNickname(nickname string) bool {
- return len(nickname) <= ircMaxNickname && reNickname.MatchString(nickname)
-}
-
-func ircIsValidUsername(username string) bool {
- // XXX: We really should put a limit on this
- // despite the RFC not mentioning one.
- return reUsername.MatchString(username)
-}
-
-func ircIsValidChannelName(name string) bool {
- return len(name) <= ircMaxChannelName && reChannelName.MatchString(name)
-}
-
-func ircIsValidKey(key string) bool {
- // XXX: Should be 7-bit as well but whatever.
- return reKey.MatchString(key)
-}
-
-func ircIsValidUserMask(mask string) bool {
- return reUserMask.MatchString(mask)
-}
-
-func ircIsValidFingerprint(fp string) bool {
- return reFingerprint.MatchString(fp)
-}
-
-// --- Clients (equals users) --------------------------------------------------
-
-type connCloseWriter interface {
- net.Conn
- CloseWrite() error
-}
-
-const ircSupportedUserModes = "aiwros"
-
-const (
- ircUserModeInvisible uint = 1 << iota
- ircUserModeRxWallops
- ircUserModeRestricted
- ircUserModeOperator
- ircUserModeRxServerNotices
-)
-
-const (
- ircCapMultiPrefix uint = 1 << iota
- ircCapInviteNotify
- ircCapEchoMessage
- ircCapUserhostInNames
- ircCapServerTime
-)
-
-type client struct {
- transport net.Conn // underlying connection
- tls *tls.Conn // TLS, if detected
- conn connCloseWriter // high-level connection
- recvQ []byte // unprocessed input
- sendQ []byte // unprocessed output
- reading bool // whether a reading goroutine is running
- writing bool // whether a writing goroutine is running
- closing bool // whether we're closing the connection
- killTimer *time.Timer // hard kill timeout
-
- opened time.Time // when the connection was opened
- nSentMessages uint // number of sent messages total
- sentBytes int // number of sent bytes total
- nReceivedMessages uint // number of received messages total
- receivedBytes int // number of received bytes total
-
- hostname string // hostname or IP shown to the network
- port string // port of the peer as a string
- address string // full network address
-
- pingTimer *time.Timer // we should send a PING
- timeoutTimer *time.Timer // connection seems to be dead
- registered bool // the user has registered
- capNegotiating bool // negotiating capabilities
- capsEnabled uint // enabled capabilities
- capVersion uint // CAP protocol version
-
- tlsCertFingerprint string // client certificate fingerprint
-
- nickname string // IRC nickname (main identifier)
- username string // IRC username
- realname string // IRC realname (or e-mail)
-
- mode uint // user's mode
- awayMessage string // away message
- lastActive time.Time // last PRIVMSG, to get idle time
- invites map[string]bool // channel invitations by operators
- antiflood *floodDetector // flood detector
-}
-
-// --- Channels ----------------------------------------------------------------
-
-const ircSupportedChanModes = "ov" + "beI" + "imnqpst" + "kl"
-
-const (
- ircChanModeInviteOnly uint = 1 << iota
- ircChanModeModerated
- ircChanModeNoOutsideMsgs
- ircChanModeQuiet
- ircChanModePrivate
- ircChanModeSecret
- ircChanModeProtectedTopic
-
- ircChanModeOperator
- ircChanModeVoice
-)
-
-type channel struct {
- name string // channel name
- modes uint // channel modes
- key string // channel key
- userLimit int // user limit or -1
- created time.Time // creation time
-
- topic string // channel topic
- topicWho string // who set the topic
- topicTime time.Time // when the topic was set
-
- userModes map[*client]uint // modes for all channel users
-
- banList []string // ban list
- exceptionList []string // exceptions from bans
- inviteList []string // exceptions from +I
-}
-
-func (ch *channel) getMode(discloseSecrets bool) string {
- var buf []byte
- if 0 != ch.modes&ircChanModeInviteOnly {
- buf = append(buf, 'i')
- }
- if 0 != ch.modes&ircChanModeModerated {
- buf = append(buf, 'm')
- }
- if 0 != ch.modes&ircChanModeNoOutsideMsgs {
- buf = append(buf, 'n')
- }
- if 0 != ch.modes&ircChanModeQuiet {
- buf = append(buf, 'q')
- }
- if 0 != ch.modes&ircChanModePrivate {
- buf = append(buf, 'p')
- }
- if 0 != ch.modes&ircChanModeSecret {
- buf = append(buf, 's')
- }
- if 0 != ch.modes&ircChanModeProtectedTopic {
- buf = append(buf, 'r')
- }
-
- if ch.userLimit != -1 {
- buf = append(buf, 'l')
- }
- if ch.key != "" {
- buf = append(buf, 'k')
- }
-
- // XXX: Is it correct to split it? Try it on an existing implementation.
- if discloseSecrets {
- if ch.userLimit != -1 {
- buf = append(buf, fmt.Sprintf(" %d", ch.userLimit)...)
- }
- if ch.key != "" {
- buf = append(buf, fmt.Sprintf(" %s", ch.key)...)
- }
- }
- return string(buf)
-}
-
-// --- IRC server context ------------------------------------------------------
-
-type whowasInfo struct {
- nickname, username, realname, hostname string
-}
-
-func newWhowasInfo(c *client) *whowasInfo {
- return &whowasInfo{
- nickname: c.nickname,
- username: c.username,
- realname: c.realname,
- hostname: c.hostname,
- }
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-type ircCommand struct {
- requiresRegistration bool
- handler func(*message, *client)
-
- nReceived uint // number of commands received
- bytesReceived int // number of bytes received total
-}
-
-type preparedEvent struct {
- client *client
- host string // client's hostname or literal IP address
- isTLS bool // the client seems to use TLS
-}
-
-type readEvent struct {
- client *client
- data []byte // new data from the client
- err error // read error
-}
-
-type writeEvent struct {
- client *client
- written int // amount of bytes written
- err error // write error
-}
-
-// TODO: Maybe we want to keep it in a struct?
-// A better question might be: can we run multiple instances of it?
-var (
- // network
-
- listeners []net.Listener
- clients = make(map[*client]bool)
-
- // IRC state
-
- // XXX: Beware that maps with identifier keys need to be indexed correctly.
- // We might want to enforce accessor functions for users and channels.
-
- started time.Time // when the server has been started
- users = make(map[string]*client) // maps nicknames to clients
- channels = make(map[string]*channel) // maps channel names to data
- whowas = make(map[string]*whowasInfo) // WHOWAS registry
-
- // event loop
-
- quitting bool
- quitTimer <-chan time.Time
-
- sigs = make(chan os.Signal, 1)
- conns = make(chan net.Conn)
- prepared = make(chan preparedEvent)
- reads = make(chan readEvent)
- writes = make(chan writeEvent)
- timers = make(chan func())
-
- // configuration
-
- config simpleConfig // server configuration
- tlsConf *tls.Config // TLS connection configuration
- serverName string // our server name
- pingInterval time.Duration // ping interval
- maxConnections int // max connections allowed or 0
- motd []string // MOTD (none if empty)
- catalog map[int]string // message catalog for server msgs
- operators map[string]bool // TLS certificate fingerprints for IRCops
-)
-
-// Forcefully tear down all connections.
-func forceQuit(reason string) {
- if !quitting {
- exitFatal("forceQuit called without initiateQuit")
- }
-
- printStatus("forced shutdown (%s)", reason)
- for c := range clients {
- // initiateQuit has already unregistered the client.
- c.kill("Shutting down")
- }
-}
-
-// Initiate a clean shutdown of the whole daemon.
-func initiateQuit() {
- printStatus("shutting down")
- for _, ln := range listeners {
- if err := ln.Close(); err != nil {
- printError("%s", err)
- }
- }
- for c := range clients {
- c.closeLink("Shutting down")
- }
-
- quitTimer = time.After(5 * time.Second)
- quitting = true
-}
-
-func ircChannelCreate(name string) *channel {
- ch := &channel{
- name: name,
- userLimit: -1,
- created: time.Now(),
- userModes: make(map[*client]uint),
- }
- channels[ircToCanon(name)] = ch
- return ch
-}
-
-func ircChannelDestroyIfEmpty(ch *channel) {
- if len(ch.userModes) == 0 {
- delete(channels, ircToCanon(ch.name))
- }
-}
-
-func ircNotifyRoommates(c *client, message string) {
- targets := make(map[*client]bool)
- for _, ch := range channels {
- _, present := ch.userModes[c]
- if !present || 0 != ch.modes&ircChanModeQuiet {
- continue
- }
- for client := range ch.userModes {
- targets[client] = true
- }
- }
-
- for roommate := range targets {
- if roommate != c {
- roommate.send(message)
- }
- }
-}
-
-// --- Clients (continued) -----------------------------------------------------
-
-func (c *client) printDebug(format string, args ...interface{}) {
- if debugMode {
- printDebug("(%s) %s", c.address, fmt.Sprintf(format, args...))
- }
-}
-
-func ircAppendClientModes(m uint, mode []byte) []byte {
- if 0 != m&ircUserModeInvisible {
- mode = append(mode, 'i')
- }
- if 0 != m&ircUserModeRxWallops {
- mode = append(mode, 'w')
- }
- if 0 != m&ircUserModeRestricted {
- mode = append(mode, 'r')
- }
- if 0 != m&ircUserModeOperator {
- mode = append(mode, 'o')
- }
- if 0 != m&ircUserModeRxServerNotices {
- mode = append(mode, 's')
- }
- return mode
-}
-
-func (c *client) getMode() string {
- var mode []byte
- if c.awayMessage != "" {
- mode = append(mode, 'a')
- }
- return string(ircAppendClientModes(c.mode, mode))
-}
-
-func (c *client) send(line string) {
- if c.conn == nil || c.closing {
- return
- }
-
- oldSendQLen := len(c.sendQ)
-
- // So far there's only one message tag we use, so we can do it simple;
- // note that a 1024-character limit applies to messages with tags on.
- if 0 != c.capsEnabled&ircCapServerTime {
- c.sendQ = time.Now().UTC().
- AppendFormat(c.sendQ, "@time=2006-01-02T15:04:05.000Z ")
- }
-
- bytes := []byte(line)
- if len(bytes) > ircMaxMessageLength {
- bytes = bytes[:ircMaxMessageLength]
- }
-
- c.printDebug("<- %s", bytes)
-
- // TODO: Kill the connection above some "SendQ" threshold (careful!)
- c.sendQ = append(c.sendQ, bytes...)
- c.sendQ = append(c.sendQ, "\r\n"...)
- c.flushSendQ()
-
- // Technically we haven't sent it yet but that's a minor detail
- c.nSentMessages++
- c.sentBytes += len(c.sendQ) - oldSendQLen
-}
-
-func (c *client) sendf(format string, a ...interface{}) {
- c.send(fmt.Sprintf(format, a...))
-}
-
-func (c *client) addToWhowas() {
- // Only keeping one entry for each nickname.
- // TODO: Make sure this list doesn't get too long, for example by
- // putting them in a linked list ordered by time.
- whowas[ircToCanon(c.nickname)] = newWhowasInfo(c)
-}
-
-func (c *client) nicknameOrStar() string {
- if c.nickname == "" {
- return "*"
- }
- return c.nickname
-}
-
-func (c *client) unregister(reason string) {
- if !c.registered {
- return
- }
-
- ircNotifyRoommates(c, fmt.Sprintf(":%s!%s@%s QUIT :%s",
- c.nickname, c.username, c.hostname, reason))
-
- // The QUIT message will take care of state on clients.
- for _, ch := range channels {
- delete(ch.userModes, c)
- ircChannelDestroyIfEmpty(ch)
- }
-
- c.addToWhowas()
- delete(users, ircToCanon(c.nickname))
- c.nickname = ""
- c.registered = false
-}
-
-// Close the connection and forget about the client.
-func (c *client) kill(reason string) {
- if reason == "" {
- c.unregister("Client exited")
- } else {
- c.unregister(reason)
- }
-
- c.printDebug("client destroyed (%s)", reason)
-
- // Try to send a "close notify" alert if the TLS object is ready,
- // otherwise just tear down the transport.
- if c.conn != nil {
- _ = c.conn.Close()
- } else {
- _ = c.transport.Close()
- }
-
- c.cancelTimers()
- delete(clients, c)
-}
-
-// Tear down the client connection, trying to do so in a graceful manner.
-func (c *client) closeLink(reason string) {
- // Let's just cut the connection, the client can try again later.
- // We also want to avoid accidentally writing to the socket before
- // address resolution has finished.
- if c.conn == nil {
- c.kill(reason)
- return
- }
- if c.closing {
- return
- }
-
- // We push an "ERROR" message to the write buffer and let the writer send
- // it, with some arbitrary timeout. The "closing" state makes sure
- // that a/ we ignore any successive messages, and b/ that the connection
- // is killed after the write buffer is transferred and emptied.
- // (Since we send this message, we don't need to call CloseWrite here.)
- c.sendf("ERROR :Closing link: %s[%s] (%s)",
- c.nicknameOrStar(), c.hostname /* TODO host IP? */, reason)
- c.closing = true
-
- c.unregister(reason)
- c.setKillTimer()
-}
-
-func (c *client) inMaskList(masks []string) bool {
- client := fmt.Sprintf("%s!%s@%s", c.nickname, c.username, c.hostname)
- for _, mask := range masks {
- if ircFnmatch(mask, client) {
- return true
- }
- }
- return false
-}
-
-func (c *client) getTLSCertFingerprint() string {
- if c.tls == nil {
- return ""
- }
-
- peerCerts := c.tls.ConnectionState().PeerCertificates
- if len(peerCerts) == 0 {
- return ""
- }
-
- hash := sha256.Sum256(peerCerts[0].Raw)
- return hex.EncodeToString(hash[:])
-}
-
-// --- Timers ------------------------------------------------------------------
-
-// Free the resources of timers that haven't fired yet and for timers that are
-// in between firing and being collected by the event loop, mark that the event
-// should not be acted upon.
-func (c *client) cancelTimers() {
- for _, timer := range []**time.Timer{
- &c.killTimer, &c.timeoutTimer, &c.pingTimer,
- } {
- if *timer != nil {
- (*timer).Stop()
- *timer = nil
- }
- }
-}
-
-// Arrange for a function to be called later from the main goroutine.
-func (c *client) setTimer(timer **time.Timer, delay time.Duration, cb func()) {
- c.cancelTimers()
-
- var identityCapture *time.Timer
- identityCapture = time.AfterFunc(delay, func() {
- timers <- func() {
- // The timer might have been cancelled or even replaced.
- // When the client is killed, this will be nil.
- if *timer == identityCapture {
- cb()
- }
- }
- })
-
- *timer = identityCapture
-}
-
-func (c *client) setKillTimer() {
- c.setTimer(&c.killTimer, pingInterval, func() {
- c.kill("Timeout")
- })
-}
-
-func (c *client) setTimeoutTimer() {
- c.setTimer(&c.timeoutTimer, pingInterval, func() {
- c.closeLink(fmt.Sprintf("Ping timeout: >%d seconds",
- pingInterval/time.Second))
- })
-}
-
-func (c *client) setPingTimer() {
- c.setTimer(&c.pingTimer, pingInterval, func() {
- c.sendf("PING :%s", serverName)
- c.setTimeoutTimer()
- })
-}
-
-// --- IRC command handling ----------------------------------------------------
-
-func (c *client) makeReply(id int, ap ...interface{}) string {
- s := fmt.Sprintf(":%s %03d %s ", serverName, id, c.nicknameOrStar())
- if reply, ok := catalog[id]; ok {
- return s + fmt.Sprintf(reply, ap...)
- }
- return s + fmt.Sprintf(defaultReplies[id], ap...)
-}
-
-// XXX: This way simple static analysis cannot typecheck the arguments, so we
-// need to be careful.
-func (c *client) sendReply(id int, args ...interface{}) {
- c.send(c.makeReply(id, args...))
-}
-
-// Send a space-separated list of words across as many replies as needed.
-func (c *client) sendReplyVector(id int, items []string, args ...interface{}) {
- common := c.makeReply(id, args...)
-
- // We always send at least one message (there might be a client that
- // expects us to send this message at least once).
- if len(items) == 0 {
- items = append(items, "")
- }
-
- for len(items) > 0 {
- // If not even a single item fits in the limit (which may happen,
- // in theory) it just gets cropped. We could also skip it.
- reply := append([]byte(common), items[0]...)
- items = items[1:]
-
- // Append as many items as fits in a single message.
- for len(items) > 0 &&
- len(reply)+1+len(items[0]) <= ircMaxMessageLength {
- reply = append(reply, ' ')
- reply = append(reply, items[0]...)
- items = items[1:]
- }
-
- c.send(string(reply))
- }
-}
-
-func (c *client) sendMOTD() {
- if len(motd) == 0 {
- c.sendReply(ERR_NOMOTD)
- return
- }
-
- c.sendReply(RPL_MOTDSTART, serverName)
- for _, line := range motd {
- c.sendReply(RPL_MOTD, line)
- }
- c.sendReply(RPL_ENDOFMOTD)
-}
-
-func (c *client) sendLUSERS() {
- nUsers, nServices, nOpers, nUnknown := 0, 0, 0, 0
- for c := range clients {
- if c.registered {
- nUsers++
- } else {
- nUnknown++
- }
- if 0 != c.mode&ircUserModeOperator {
- nOpers++
- }
- }
-
- nChannels := 0
- for _, ch := range channels {
- if 0 != ch.modes&ircChanModeSecret {
- nChannels++
- }
- }
-
- c.sendReply(RPL_LUSERCLIENT, nUsers, nServices, 1 /* servers total */)
- if nOpers != 0 {
- c.sendReply(RPL_LUSEROP, nOpers)
- }
- if nUnknown != 0 {
- c.sendReply(RPL_LUSERUNKNOWN, nUnknown)
- }
- if nChannels != 0 {
- c.sendReply(RPL_LUSERCHANNELS, nChannels)
- }
- c.sendReply(RPL_LUSERME, nUsers+nServices+nUnknown, 0 /* peer servers */)
-}
-
-func ircIsThisMe(target string) bool {
- // Target servers can also be matched by their users
- if ircFnmatch(target, serverName) {
- return true
- }
- _, ok := users[ircToCanon(target)]
- return ok
-}
-
-func (c *client) sendISUPPORT() {
- // Only # channels, +e supported, +I supported, unlimited arguments to MODE.
- c.sendReply(RPL_ISUPPORT, fmt.Sprintf("CHANTYPES=# EXCEPTS INVEX MODES"+
- " TARGMAX=WHOIS:,LIST:,NAMES:,PRIVMSG:1,NOTICE:1,KICK:"+
- " NICKLEN=%d CHANNELLEN=%d", ircMaxNickname, ircMaxChannelName))
-}
-
-func (c *client) tryFinishRegistration() {
- if c.registered || c.capNegotiating {
- return
- }
- if c.nickname == "" || c.username == "" {
- return
- }
-
- c.registered = true
- c.sendReply(RPL_WELCOME, c.nickname, c.username, c.hostname)
-
- c.sendReply(RPL_YOURHOST, serverName, projectVersion)
- // The purpose of this message eludes me.
- c.sendReply(RPL_CREATED, started.Format("Mon, 02 Jan 2006"))
- c.sendReply(RPL_MYINFO, serverName, projectVersion,
- ircSupportedUserModes, ircSupportedChanModes)
-
- c.sendISUPPORT()
- c.sendLUSERS()
- c.sendMOTD()
-
- if mode := c.getMode(); mode != "" {
- c.sendf(":%s MODE %s :+%s", c.nickname, c.nickname, mode)
- }
-
- c.tlsCertFingerprint = c.getTLSCertFingerprint()
- if c.tlsCertFingerprint != "" {
- c.sendf(":%s NOTICE %s :Your TLS client certificate fingerprint is %s",
- serverName, c.nickname, c.tlsCertFingerprint)
- }
-
- delete(whowas, ircToCanon(c.nickname))
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-// IRCv3 capability negotiation. See http://ircv3.org for details.
-
-type ircCapArgs struct {
- subcommand string // the subcommand being processed
- fullParams string // whole parameter string
- params []string // split parameters
- target string // target parameter for replies
-}
-
-var ircCapTable = []struct {
- flag uint // flag
- name string // name of the capability
-}{
- {ircCapMultiPrefix, "multi-prefix"},
- {ircCapInviteNotify, "invite-notify"},
- {ircCapEchoMessage, "echo-message"},
- {ircCapUserhostInNames, "userhost-in-names"},
- {ircCapServerTime, "server-time"},
-}
-
-func (c *client) handleCAPLS(a *ircCapArgs) {
- if len(a.params) == 1 {
- if ver, err := strconv.ParseUint(a.params[0], 10, 32); err != nil {
- c.sendReply(ERR_INVALIDCAPCMD, a.subcommand,
- "Ignoring invalid protocol version number")
- } else {
- c.capVersion = uint(ver)
- }
- }
-
- c.capNegotiating = true
- c.sendf(":%s CAP %s LS :multi-prefix invite-notify echo-message"+
- " userhost-in-names server-time", serverName, a.target)
-}
-
-func (c *client) handleCAPLIST(a *ircCapArgs) {
- caps := []string{}
- for _, cap := range ircCapTable {
- if 0 != c.capsEnabled&cap.flag {
- caps = append(caps, cap.name)
- }
- }
-
- c.sendf(":%s CAP %s LIST :%s", serverName, a.target,
- strings.Join(caps, " "))
-}
-
-func ircDecodeCapability(name string) uint {
- for _, cap := range ircCapTable {
- if cap.name == name {
- return cap.flag
- }
- }
- return 0
-}
-
-func (c *client) handleCAPREQ(a *ircCapArgs) {
- c.capNegotiating = true
-
- newCaps := c.capsEnabled
- ok := true
- for _, param := range a.params {
- removing := false
- name := param
- if name[:1] == "-" {
- removing = true
- name = name[1:]
- }
-
- if cap := ircDecodeCapability(name); cap == 0 {
- ok = false
- } else if removing {
- newCaps &= ^cap
- } else {
- newCaps |= cap
- }
- }
-
- if ok {
- c.capsEnabled = newCaps
- c.sendf(":%s CAP %s ACK :%s", serverName, a.target, a.fullParams)
- } else {
- c.sendf(":%s CAP %s NAK :%s", serverName, a.target, a.fullParams)
- }
-}
-
-func (c *client) handleCAPACK(a *ircCapArgs) {
- if len(a.params) > 0 {
- c.sendReply(ERR_INVALIDCAPCMD, a.subcommand,
- "No acknowledgable capabilities supported")
- }
-}
-
-func (c *client) handleCAPEND(a *ircCapArgs) {
- c.capNegotiating = false
- c.tryFinishRegistration()
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-var ircCapHandlers = map[string]func(*client, *ircCapArgs){
- "LS": (*client).handleCAPLS,
- "LIST": (*client).handleCAPLIST,
- "REQ": (*client).handleCAPREQ,
- "ACK": (*client).handleCAPACK,
- "END": (*client).handleCAPEND,
-}
-
-// XXX: Maybe these also deserve to be methods for client? They operate on
-// global state, though.
-
-func ircParseWEBIRCOptions(options string, out map[string]string) {
- for _, option := range strings.Split(options, " ") {
- if equal := strings.IndexByte(option, '='); equal < 0 {
- out[option] = ""
- } else {
- out[option[:equal]] = ircUnescapeMessageTag(option[equal+1:])
- }
- }
-}
-
-func ircHandleWEBIRC(msg *message, c *client) {
- if len(msg.params) < 4 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- password, gateway, hostname := msg.params[0], msg.params[1], msg.params[2]
- if config["webirc_password"] != password {
- c.closeLink("Invalid WebIRC password")
- return
- }
-
- options := make(map[string]string)
- if len(msg.params) >= 5 {
- ircParseWEBIRCOptions(msg.params[4], options)
- }
-
- c.hostname = hostname
- c.port = "WebIRC-" + gateway
- c.address = net.JoinHostPort(hostname, c.port)
-
- // Note that this overrides the gateway's certificate, conditionally.
- fp, _ := options["certfp-sha-256"]
- if _, secure := options["secure"]; secure && ircIsValidFingerprint(fp) {
- c.tlsCertFingerprint = strings.ToLower(fp)
- }
-}
-
-func ircHandleCAP(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- args := &ircCapArgs{
- target: c.nicknameOrStar(),
- subcommand: msg.params[0],
- fullParams: "",
- params: []string{},
- }
-
- if len(msg.params) > 1 {
- args.fullParams = msg.params[1]
- args.params = splitString(args.fullParams, " ", true)
- }
-
- if fn, ok := ircCapHandlers[ircToCanon(args.subcommand)]; !ok {
- c.sendReply(ERR_INVALIDCAPCMD, args.subcommand,
- "Invalid CAP subcommand")
- } else {
- fn(c, args)
- }
-}
-
-func ircHandlePASS(msg *message, c *client) {
- if c.registered {
- c.sendReply(ERR_ALREADYREGISTERED)
- } else if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- }
-
- // We have TLS client certificates for this purpose; ignoring.
-}
-
-func ircHandleNICK(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NONICKNAMEGIVEN)
- return
- }
-
- nickname := msg.params[0]
- if !ircIsValidNickname(nickname) {
- c.sendReply(ERR_ERRONEOUSNICKNAME, nickname)
- return
- }
-
- nicknameCanon := ircToCanon(nickname)
- if client, ok := users[nicknameCanon]; ok && client != c {
- c.sendReply(ERR_NICKNAMEINUSE, nickname)
- return
- }
-
- if c.registered {
- c.addToWhowas()
-
- message := fmt.Sprintf(":%s!%s@%s NICK :%s",
- c.nickname, c.username, c.hostname, nickname)
- ircNotifyRoommates(c, message)
- c.send(message)
- }
-
- // Release the old nickname and allocate a new one.
- if c.nickname != "" {
- delete(users, ircToCanon(c.nickname))
- }
-
- c.nickname = nickname
- users[nicknameCanon] = c
-
- c.tryFinishRegistration()
-}
-
-func ircHandleUSER(msg *message, c *client) {
- if c.registered {
- c.sendReply(ERR_ALREADYREGISTERED)
- return
- }
- if len(msg.params) < 4 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- username, mode, realname := msg.params[0], msg.params[1], msg.params[3]
-
- // Unfortunately, the protocol doesn't give us any means of rejecting it.
- if !ircIsValidUsername(username) {
- username = "*"
- }
-
- c.username = username
- c.realname = realname
-
- c.mode = 0
- if m, err := strconv.ParseUint(mode, 10, 32); err != nil {
- if 0 != m&4 {
- c.mode |= ircUserModeRxWallops
- }
- if 0 != m&8 {
- c.mode |= ircUserModeInvisible
- }
- }
-
- c.tryFinishRegistration()
-}
-
-func ircHandleUSERHOST(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- var reply []byte
- for i := 0; i < 5 && i < len(msg.params); i++ {
- nick := msg.params[i]
- target := users[ircToCanon(nick)]
- if target == nil {
- continue
- }
- if i != 0 {
- reply = append(reply, ' ')
- }
-
- reply = append(reply, nick...)
- if 0 != target.mode&ircUserModeOperator {
- reply = append(reply, '*')
- }
-
- if target.awayMessage != "" {
- reply = append(reply, "=-"...)
- } else {
- reply = append(reply, "=+"...)
- }
- reply = append(reply, (target.username + "@" + target.hostname)...)
- }
- c.sendReply(RPL_USERHOST, string(reply))
-}
-
-func ircHandleLUSERS(msg *message, c *client) {
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[1]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
- return
- }
- c.sendLUSERS()
-}
-
-func ircHandleMOTD(msg *message, c *client) {
- if len(msg.params) > 0 && !ircIsThisMe(msg.params[0]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
- return
- }
- c.sendMOTD()
-}
-
-func ircHandlePING(msg *message, c *client) {
- // XXX: The RFC is pretty incomprehensible about the exact usage.
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[1]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
- } else if len(msg.params) < 1 {
- c.sendReply(ERR_NOORIGIN)
- } else {
- c.sendf(":%s PONG :%s", serverName, msg.params[0])
- }
-}
-
-func ircHandlePONG(msg *message, c *client) {
- // We are the only server, so we don't have to care too much.
- if len(msg.params) < 1 {
- c.sendReply(ERR_NOORIGIN)
- return
- }
-
- // Set a new timer to send another PING
- c.setPingTimer()
-}
-
-func ircHandleQUIT(msg *message, c *client) {
- reason := c.nickname
- if len(msg.params) > 0 {
- reason = msg.params[0]
- }
-
- c.closeLink("Quit: " + reason)
-}
-
-func ircHandleTIME(msg *message, c *client) {
- if len(msg.params) > 0 && !ircIsThisMe(msg.params[0]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[0])
- return
- }
-
- c.sendReply(RPL_TIME, serverName,
- time.Now().Format("Mon Jan _2 2006 15:04:05"))
-}
-
-func ircHandleVERSION(msg *message, c *client) {
- if len(msg.params) > 0 && !ircIsThisMe(msg.params[0]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[0])
- return
- }
-
- postVersion := 0
- if debugMode {
- postVersion = 1
- }
-
- c.sendReply(RPL_VERSION, projectVersion, postVersion, serverName,
- projectName+" "+projectVersion)
- c.sendISUPPORT()
-}
-
-func ircChannelMulticast(ch *channel, msg string, except *client) {
- for c := range ch.userModes {
- if c != except {
- c.send(msg)
- }
- }
-}
-
-func ircModifyMode(mask *uint, mode uint, add bool) bool {
- orig := *mask
- if add {
- *mask |= mode
- } else {
- *mask &= ^mode
- }
- return *mask != orig
-}
-
-func ircUpdateUserMode(c *client, newMode uint) {
- oldMode := c.mode
- c.mode = newMode
-
- added, removed := newMode & ^oldMode, oldMode & ^newMode
-
- var diff []byte
- if added != 0 {
- diff = append(diff, '+')
- diff = ircAppendClientModes(added, diff)
- }
- if removed != 0 {
- diff = append(diff, '-')
- diff = ircAppendClientModes(removed, diff)
- }
-
- if len(diff) > 0 {
- c.sendf(":%s MODE %s :%s", c.nickname, c.nickname, string(diff))
- }
-}
-
-func ircHandleUserModeChange(c *client, modeString string) {
- newMode := c.mode
- adding := true
-
- for _, flag := range modeString {
- switch flag {
- case '+':
- adding = true
- case '-':
- adding = false
-
- case 'a':
- // Ignore, the client should use AWAY.
- case 'i':
- ircModifyMode(&newMode, ircUserModeInvisible, adding)
- case 'w':
- ircModifyMode(&newMode, ircUserModeRxWallops, adding)
- case 'r':
- // It's not possible ot un-restrict yourself.
- if adding {
- newMode |= ircUserModeRestricted
- }
- case 'o':
- if !adding {
- newMode &= ^ircUserModeOperator
- } else if operators[c.tlsCertFingerprint] {
- newMode |= ircUserModeOperator
- } else {
- c.sendf(":%s NOTICE %s :Either you're not using an TLS"+
- " client certificate, or the fingerprint doesn't match",
- serverName, c.nickname)
- }
- case 's':
- ircModifyMode(&newMode, ircUserModeRxServerNotices, adding)
- default:
- c.sendReply(ERR_UMODEUNKNOWNFLAG)
- return
- }
- }
- ircUpdateUserMode(c, newMode)
-}
-
-func ircSendChannelList(c *client, channelName string, list []string,
- reply, endReply int) {
- for _, line := range list {
- c.sendReply(reply, channelName, line)
- }
- c.sendReply(endReply, channelName)
-}
-
-func ircCheckExpandUserMask(mask string) string {
- var result []byte
- result = append(result, mask...)
-
- // Make sure it is a complete mask.
- if bytes.IndexByte(result, '!') < 0 {
- result = append(result, "!*"...)
- }
- if bytes.IndexByte(result, '@') < 0 {
- result = append(result, "@*"...)
- }
-
- // And validate whatever the result is.
- s := string(result)
- if !ircIsValidUserMask(s) {
- return ""
- }
-
- return s
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-// Channel MODE command handling. This is by far the worst command to implement
-// from the whole RFC; don't blame me if it doesn't work exactly as expected.
-
-type modeProcessor struct {
- params []string // mode string parameters
-
- c *client // who does the changes
- ch *channel // the channel we're modifying
- present bool // c present on ch
- modes uint // channel user modes
-
- adding bool // currently adding modes
- modeChar byte // currently processed mode char
-
- added []byte // added modes
- removed []byte // removed modes
- output *[]byte // "added" or "removed"
-
- addedParams []string // params for added modes
- removedParams []string // params for removed modes
- outputParams *[]string // "addedParams" or "removedParams"
-}
-
-func (mp *modeProcessor) nextParam() string {
- if len(mp.params) == 0 {
- return ""
- }
-
- param := mp.params[0]
- mp.params = mp.params[1:]
- return param
-}
-
-func (mp *modeProcessor) checkOperator() bool {
- if (mp.present && 0 != mp.modes&ircChanModeOperator) ||
- 0 != mp.c.mode&ircUserModeOperator {
- return true
- }
-
- mp.c.sendReply(ERR_CHANOPRIVSNEEDED, mp.ch.name)
- return false
-}
-
-func (mp *modeProcessor) doUser(mode uint) {
- target := mp.nextParam()
- if !mp.checkOperator() || target == "" {
- return
- }
-
- if client := users[ircToCanon(target)]; client == nil {
- mp.c.sendReply(ERR_NOSUCHNICK, target)
- } else if modes, present := mp.ch.userModes[client]; !present {
- mp.c.sendReply(ERR_USERNOTINCHANNEL, target, mp.ch.name)
- } else if ircModifyMode(&modes, mode, mp.adding) {
- mp.ch.userModes[client] = modes
- *mp.output = append(*mp.output, mp.modeChar)
- *mp.outputParams = append(*mp.outputParams, client.nickname)
- }
-}
-
-func (mp *modeProcessor) doChan(mode uint) bool {
- if !mp.checkOperator() || !ircModifyMode(&mp.ch.modes, mode, mp.adding) {
- return false
- }
- *mp.output = append(*mp.output, mp.modeChar)
- return true
-}
-
-func (mp *modeProcessor) doChanRemove(modeChar byte, mode uint) {
- if mp.adding && ircModifyMode(&mp.ch.modes, mode, false) {
- mp.removed = append(mp.removed, modeChar)
- }
-}
-
-func (mp *modeProcessor) doList(list *[]string, listMsg, endMsg int) {
- target := mp.nextParam()
- if target == "" {
- if mp.adding {
- ircSendChannelList(mp.c, mp.ch.name, *list, listMsg, endMsg)
- }
- return
- }
-
- if !mp.checkOperator() {
- return
- }
-
- mask := ircCheckExpandUserMask(target)
- if mask == "" {
- return
- }
-
- var i int
- for i = 0; i < len(*list); i++ {
- if ircEqual((*list)[i], mask) {
- break
- }
- }
-
- found := i < len(*list)
- if found != mp.adding {
- if mp.adding {
- *list = append(*list, mask)
- } else {
- *list = append((*list)[:i], (*list)[i+1:]...)
- }
-
- *mp.output = append(*mp.output, mp.modeChar)
- *mp.outputParams = append(*mp.outputParams, mask)
- }
-}
-
-func (mp *modeProcessor) doKey() {
- target := mp.nextParam()
- if !mp.checkOperator() || target == "" {
- return
- }
-
- if !mp.adding {
- if mp.ch.key == "" || !ircEqual(target, mp.ch.key) {
- return
- }
-
- mp.removed = append(mp.removed, mp.modeChar)
- mp.removedParams = append(mp.removedParams, mp.ch.key)
- mp.ch.key = ""
- } else if !ircIsValidKey(target) {
- // TODO: We should notify the user somehow.
- return
- } else if mp.ch.key != "" {
- mp.c.sendReply(ERR_KEYSET, mp.ch.name)
- } else {
- mp.ch.key = target
- mp.added = append(mp.added, mp.modeChar)
- mp.addedParams = append(mp.addedParams, mp.ch.key)
- }
-}
-
-func (mp *modeProcessor) doLimit() {
- if !mp.checkOperator() {
- return
- }
-
- if !mp.adding {
- if mp.ch.userLimit == -1 {
- return
- }
-
- mp.ch.userLimit = -1
- mp.removed = append(mp.removed, mp.modeChar)
- } else if target := mp.nextParam(); target != "" {
- if x, err := strconv.ParseInt(target, 10, 32); err == nil && x > 0 {
- mp.ch.userLimit = int(x)
- mp.added = append(mp.added, mp.modeChar)
- mp.addedParams = append(mp.addedParams, target)
- }
- }
-}
-
-func (mp *modeProcessor) step(modeChar byte) bool {
- mp.modeChar = modeChar
- switch mp.modeChar {
- case '+':
- mp.adding = true
- mp.output = &mp.added
- mp.outputParams = &mp.addedParams
- case '-':
- mp.adding = false
- mp.output = &mp.removed
- mp.outputParams = &mp.removedParams
-
- case 'o':
- mp.doUser(ircChanModeOperator)
- case 'v':
- mp.doUser(ircChanModeVoice)
-
- case 'i':
- mp.doChan(ircChanModeInviteOnly)
- case 'm':
- mp.doChan(ircChanModeModerated)
- case 'n':
- mp.doChan(ircChanModeNoOutsideMsgs)
- case 'q':
- mp.doChan(ircChanModeQuiet)
- case 't':
- mp.doChan(ircChanModeProtectedTopic)
-
- case 'p':
- if mp.doChan(ircChanModePrivate) {
- mp.doChanRemove('s', ircChanModeSecret)
- }
- case 's':
- if mp.doChan(ircChanModeSecret) {
- mp.doChanRemove('p', ircChanModePrivate)
- }
-
- case 'b':
- mp.doList(&mp.ch.banList, RPL_BANLIST, RPL_ENDOFBANLIST)
- case 'e':
- mp.doList(&mp.ch.banList, RPL_EXCEPTLIST, RPL_ENDOFEXCEPTLIST)
- case 'I':
- mp.doList(&mp.ch.banList, RPL_INVITELIST, RPL_ENDOFINVITELIST)
-
- case 'k':
- mp.doKey()
- case 'l':
- mp.doLimit()
-
- default:
- // It's not safe to continue, results could be undesired.
- mp.c.sendReply(ERR_UNKNOWNMODE, modeChar, mp.ch.name)
- return false
- }
- return true
-}
-
-func ircHandleChanModeChange(c *client, ch *channel, params []string) {
- modes, present := ch.userModes[c]
- mp := &modeProcessor{
- c: c,
- ch: ch,
- present: present,
- modes: modes,
- params: params,
- }
-
-Outer:
- for {
- modeString := mp.nextParam()
- if modeString == "" {
- break
- }
-
- mp.step('+')
- for _, modeChar := range []byte(modeString) {
- if !mp.step(modeChar) {
- break Outer
- }
- }
- }
-
- // TODO: Limit to three changes with parameter per command.
- if len(mp.added) > 0 || len(mp.removed) > 0 {
- buf := []byte(fmt.Sprintf(":%s!%s@%s MODE %s ",
- mp.c.nickname, mp.c.username, mp.c.hostname, mp.ch.name))
- if len(mp.added) > 0 {
- buf = append(buf, '+')
- buf = append(buf, mp.added...)
- }
- if len(mp.removed) > 0 {
- buf = append(buf, '-')
- buf = append(buf, mp.removed...)
- }
- for _, param := range mp.addedParams {
- buf = append(buf, ' ')
- buf = append(buf, param...)
- }
- for _, param := range mp.removedParams {
- buf = append(buf, ' ')
- buf = append(buf, param...)
- }
- ircChannelMulticast(mp.ch, string(buf), nil)
- }
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-func ircHandleMODE(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- target := msg.params[0]
- client := users[ircToCanon(target)]
- ch := channels[ircToCanon(target)]
-
- if client != nil {
- if !ircEqual(target, c.nickname) {
- c.sendReply(ERR_USERSDONTMATCH)
- return
- }
-
- if len(msg.params) < 2 {
- c.sendReply(RPL_UMODEIS, c.getMode())
- } else {
- ircHandleUserModeChange(c, msg.params[1])
- }
- } else if ch != nil {
- if len(msg.params) < 2 {
- _, present := ch.userModes[c]
- c.sendReply(RPL_CHANNELMODEIS, target, ch.getMode(present))
- c.sendReply(RPL_CREATIONTIME, target, ch.created.Unix())
- } else {
- ircHandleChanModeChange(c, ch, msg.params[1:])
- }
- } else {
- c.sendReply(ERR_NOSUCHNICK, target)
- }
-}
-
-func ircHandleUserMessage(msg *message, c *client,
- command string, allowAwayReply bool) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NORECIPIENT, msg.command)
- return
- }
- if len(msg.params) < 2 || msg.params[1] == "" {
- c.sendReply(ERR_NOTEXTTOSEND)
- return
- }
-
- target, text := msg.params[0], msg.params[1]
- message := fmt.Sprintf(":%s!%s@%s %s %s :%s",
- c.nickname, c.username, c.hostname, command, target, text)
-
- if client := users[ircToCanon(target)]; client != nil {
- client.send(message)
- if allowAwayReply && client.awayMessage != "" {
- c.sendReply(RPL_AWAY, target, client.awayMessage)
- }
-
- // Acknowledging a message from the client to itself would be silly.
- if client != c && (0 != c.capsEnabled&ircCapEchoMessage) {
- c.send(message)
- }
- } else if ch := channels[ircToCanon(target)]; ch != nil {
- modes, present := ch.userModes[c]
-
- outsider := !present && 0 != ch.modes&ircChanModeNoOutsideMsgs
- moderated := 0 != ch.modes&ircChanModeModerated &&
- 0 == modes&(ircChanModeVoice|ircChanModeOperator)
- banned := c.inMaskList(ch.banList) && !c.inMaskList(ch.exceptionList)
-
- if outsider || moderated || banned {
- c.sendReply(ERR_CANNOTSENDTOCHAN, target)
- return
- }
-
- except := c
- if 0 != c.capsEnabled&ircCapEchoMessage {
- except = nil
- }
-
- ircChannelMulticast(ch, message, except)
- } else {
- c.sendReply(ERR_NOSUCHNICK, target)
- }
-}
-
-func ircHandlePRIVMSG(msg *message, c *client) {
- ircHandleUserMessage(msg, c, "PRIVMSG", true /* allowAwayReply */)
- c.lastActive = time.Now()
-}
-
-func ircHandleNOTICE(msg *message, c *client) {
- ircHandleUserMessage(msg, c, "NOTICE", false /* allowAwayReply */)
-}
-
-func ircHandleLIST(msg *message, c *client) {
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[1]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
- return
- }
-
- // XXX: Maybe we should skip ircUserModeInvisible from user counts.
- if len(msg.params) == 0 {
- for _, ch := range channels {
- if _, present := ch.userModes[c]; present ||
- 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret) {
- c.sendReply(RPL_LIST, ch.name, len(ch.userModes), ch.topic)
- }
- }
- } else {
- for _, target := range splitString(msg.params[0], ",", true) {
- if ch := channels[ircToCanon(target)]; ch != nil &&
- 0 == ch.modes&ircChanModeSecret {
- c.sendReply(RPL_LIST, ch.name, len(ch.userModes), ch.topic)
- }
- }
- }
- c.sendReply(RPL_LISTEND)
-}
-
-func ircAppendPrefixes(c *client, modes uint, buf []byte) []byte {
- var all []byte
- if 0 != modes&ircChanModeOperator {
- all = append(all, '@')
- }
- if 0 != modes&ircChanModeVoice {
- all = append(all, '+')
- }
-
- if len(all) > 0 {
- if 0 != c.capsEnabled&ircCapMultiPrefix {
- buf = append(buf, all...)
- } else {
- buf = append(buf, all[0])
- }
- }
- return buf
-}
-
-func ircMakeRPLNAMREPLYItem(c, target *client, modes uint) string {
- result := string(ircAppendPrefixes(c, modes, nil)) + target.nickname
- if 0 != c.capsEnabled&ircCapUserhostInNames {
- result += fmt.Sprintf("!%s@%s", target.username, target.hostname)
- }
- return result
-}
-
-func ircSendRPLNAMREPLY(c *client, ch *channel, usedNicks map[*client]bool) {
- kind := '='
- if 0 != ch.modes&ircChanModeSecret {
- kind = '@'
- } else if 0 != ch.modes&ircChanModePrivate {
- kind = '*'
- }
-
- _, present := ch.userModes[c]
-
- var nicks []string
- for client, modes := range ch.userModes {
- if !present && 0 != client.mode&ircUserModeInvisible {
- continue
- }
- if usedNicks != nil {
- usedNicks[client] = true
- }
- nicks = append(nicks, ircMakeRPLNAMREPLYItem(c, client, modes))
- }
- c.sendReplyVector(RPL_NAMREPLY, nicks, kind, ch.name, "")
-}
-
-func ircSendDisassociatedNames(c *client, usedNicks map[*client]bool) {
- var nicks []string
- for _, client := range users {
- if 0 == client.mode&ircUserModeInvisible && !usedNicks[client] {
- nicks = append(nicks, ircMakeRPLNAMREPLYItem(c, client, 0))
- }
- }
- if len(nicks) > 0 {
- c.sendReplyVector(RPL_NAMREPLY, nicks, '*', "*", "")
- }
-}
-
-func ircHandleNAMES(msg *message, c *client) {
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[1]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
- return
- }
-
- if len(msg.params) == 0 {
- usedNicks := make(map[*client]bool)
- for _, ch := range channels {
- if _, present := ch.userModes[c]; present ||
- 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret) {
- ircSendRPLNAMREPLY(c, ch, usedNicks)
- }
- }
-
- // Also send all visible users we haven't listed yet.
- ircSendDisassociatedNames(c, usedNicks)
- c.sendReply(RPL_ENDOFNAMES, "*")
- } else {
- for _, target := range splitString(msg.params[0], ",", true) {
- if ch := channels[ircToCanon(target)]; ch == nil {
- } else if _, present := ch.userModes[c]; present ||
- 0 == ch.modes&ircChanModeSecret {
- ircSendRPLNAMREPLY(c, ch, nil)
- c.sendReply(RPL_ENDOFNAMES, target)
- }
- }
- }
-}
-
-func ircSendRPLWHOREPLY(c *client, ch *channel, target *client) {
- var chars []byte
- if target.awayMessage != "" {
- chars = append(chars, 'G')
- } else {
- chars = append(chars, 'H')
- }
-
- if 0 != target.mode&ircUserModeOperator {
- chars = append(chars, '*')
- }
-
- channelName := "*"
- if ch != nil {
- channelName = ch.name
- if modes, present := ch.userModes[target]; present {
- chars = ircAppendPrefixes(c, modes, chars)
- }
- }
-
- c.sendReply(RPL_WHOREPLY, channelName,
- target.username, target.hostname, serverName,
- target.nickname, string(chars), 0 /* hop count */, target.realname)
-}
-
-func ircMatchSendRPLWHOREPLY(c, target *client, mask string) {
- isRoommate := false
- for _, ch := range channels {
- _, presentClient := ch.userModes[c]
- _, presentTarget := ch.userModes[target]
- if presentClient && presentTarget {
- isRoommate = true
- break
- }
- }
- if !isRoommate && 0 != target.mode&ircUserModeInvisible {
- return
- }
-
- if !ircFnmatch(mask, target.hostname) &&
- !ircFnmatch(mask, target.nickname) &&
- !ircFnmatch(mask, target.realname) &&
- !ircFnmatch(mask, serverName) {
- return
- }
-
- // Try to find a channel they're on that's visible to us.
- var userCh *channel
- for _, ch := range channels {
- _, presentClient := ch.userModes[c]
- _, presentTarget := ch.userModes[target]
- if presentTarget && (presentClient ||
- 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret)) {
- userCh = ch
- break
- }
- }
- ircSendRPLWHOREPLY(c, userCh, target)
-}
-
-func ircHandleWHO(msg *message, c *client) {
- onlyOps := len(msg.params) > 1 && msg.params[1] == "o"
-
- shownMask, usedMask := "*", "*"
- if len(msg.params) > 0 {
- shownMask = msg.params[0]
- if shownMask != "0" {
- usedMask = shownMask
- }
- }
-
- if ch := channels[ircToCanon(usedMask)]; ch != nil {
- _, present := ch.userModes[c]
- if present || 0 == ch.modes&ircChanModeSecret {
- for client := range ch.userModes {
- if (present || 0 == client.mode&ircUserModeInvisible) &&
- (!onlyOps || 0 != client.mode&ircUserModeOperator) {
- ircSendRPLWHOREPLY(c, ch, client)
- }
- }
- }
- } else {
- for _, client := range users {
- if !onlyOps || 0 != client.mode&ircUserModeOperator {
- ircMatchSendRPLWHOREPLY(c, client, usedMask)
- }
- }
- }
- c.sendReply(RPL_ENDOFWHO, shownMask)
-}
-
-func ircSendWHOISReply(c, target *client) {
- nick := target.nickname
- c.sendReply(RPL_WHOISUSER, nick,
- target.username, target.hostname, target.realname)
- c.sendReply(RPL_WHOISSERVER, nick, serverName, config["server_info"])
- if 0 != target.mode&ircUserModeOperator {
- c.sendReply(RPL_WHOISOPERATOR, nick)
- }
- c.sendReply(RPL_WHOISIDLE, nick,
- time.Now().Sub(target.lastActive)/time.Second)
- if target.awayMessage != "" {
- c.sendReply(RPL_AWAY, nick, target.awayMessage)
- }
-
- var chans []string
- for _, ch := range channels {
- _, presentClient := ch.userModes[c]
- modes, presentTarget := ch.userModes[target]
- if presentTarget && (presentClient ||
- 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret)) {
- // TODO: Deduplicate, ircAppendPrefixes just also cuts prefixes.
- var all []byte
- if 0 != modes&ircChanModeOperator {
- all = append(all, '@')
- }
- if 0 != modes&ircChanModeVoice {
- all = append(all, '+')
- }
- chans = append(chans, string(all)+ch.name)
- }
- }
- c.sendReplyVector(RPL_WHOISCHANNELS, chans, nick, "")
- c.sendReply(RPL_ENDOFWHOIS, nick)
-}
-
-func ircHandleWHOIS(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[0]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[0])
- return
- }
-
- masksStr := msg.params[0]
- if len(msg.params) > 1 {
- masksStr = msg.params[1]
- }
-
- for _, mask := range splitString(masksStr, ",", true /* ignoreEmpty */) {
- if strings.IndexAny(mask, "*?") < 0 {
- if target := users[ircToCanon(mask)]; target == nil {
- c.sendReply(ERR_NOSUCHNICK, mask)
- } else {
- ircSendWHOISReply(c, target)
- }
- } else {
- found := false
- for _, target := range users {
- if ircFnmatch(mask, target.nickname) {
- ircSendWHOISReply(c, target)
- found = true
- }
- }
- if !found {
- c.sendReply(ERR_NOSUCHNICK, mask)
- }
- }
- }
-}
-
-func ircHandleWHOWAS(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
- if len(msg.params) > 2 && !ircIsThisMe(msg.params[2]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[2])
- return
- }
- // The "count" parameter is ignored, we only store one entry for a nick.
-
- for _, nick := range splitString(msg.params[0], ",", true) {
- if info := whowas[ircToCanon(nick)]; info == nil {
- c.sendReply(ERR_WASNOSUCHNICK, nick)
- } else {
- c.sendReply(RPL_WHOWASUSER, nick,
- info.username, info.hostname, info.realname)
- c.sendReply(RPL_WHOISSERVER, nick,
- serverName, config["server_info"])
- }
- c.sendReply(RPL_ENDOFWHOWAS, nick)
- }
-}
-
-func ircSendRPLTOPIC(c *client, ch *channel) {
- if ch.topic == "" {
- c.sendReply(RPL_NOTOPIC, ch.name)
- } else {
- c.sendReply(RPL_TOPIC, ch.name, ch.topic)
- c.sendReply(RPL_TOPICWHOTIME,
- ch.name, ch.topicWho, ch.topicTime.Unix())
- }
-}
-
-func ircHandleTOPIC(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- channelName := msg.params[0]
- ch := channels[ircToCanon(channelName)]
- if ch == nil {
- c.sendReply(ERR_NOSUCHCHANNEL, channelName)
- return
- }
-
- if len(msg.params) < 2 {
- ircSendRPLTOPIC(c, ch)
- return
- }
-
- modes, present := ch.userModes[c]
- if !present {
- c.sendReply(ERR_NOTONCHANNEL, channelName)
- return
- }
-
- if 0 != ch.modes&ircChanModeProtectedTopic &&
- 0 == modes&ircChanModeOperator {
- c.sendReply(ERR_CHANOPRIVSNEEDED, channelName)
- return
- }
-
- ch.topic = msg.params[1]
- ch.topicWho = fmt.Sprintf("%s@%s@%s", c.nickname, c.username, c.hostname)
- ch.topicTime = time.Now()
-
- message := fmt.Sprintf(":%s!%s@%s TOPIC %s :%s",
- c.nickname, c.username, c.hostname, channelName, ch.topic)
- ircChannelMulticast(ch, message, nil)
-}
-
-func ircTryPart(c *client, channelName string, reason string) {
- if reason == "" {
- reason = c.nickname
- }
-
- ch := channels[ircToCanon(channelName)]
- if ch == nil {
- c.sendReply(ERR_NOSUCHCHANNEL, channelName)
- return
- }
-
- if _, present := ch.userModes[c]; !present {
- c.sendReply(ERR_NOTONCHANNEL, channelName)
- return
- }
-
- message := fmt.Sprintf(":%s@%s@%s PART %s :%s",
- c.nickname, c.username, c.hostname, channelName, reason)
- if 0 == ch.modes&ircChanModeQuiet {
- ircChannelMulticast(ch, message, nil)
- } else {
- c.send(message)
- }
-
- delete(ch.userModes, c)
- ircChannelDestroyIfEmpty(ch)
-}
-
-func ircPartAllChannels(c *client) {
- for _, ch := range channels {
- if _, present := ch.userModes[c]; present {
- ircTryPart(c, ch.name, "")
- }
- }
-}
-
-func ircHandlePART(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- reason := ""
- if len(msg.params) > 1 {
- reason = msg.params[1]
- }
-
- for _, channelName := range splitString(msg.params[0], ",", true) {
- ircTryPart(c, channelName, reason)
- }
-}
-
-func ircTryKick(c *client, channelName, nick, reason string) {
- ch := channels[ircToCanon(channelName)]
- if ch == nil {
- c.sendReply(ERR_NOSUCHCHANNEL, channelName)
- return
- }
-
- if modes, present := ch.userModes[c]; !present {
- c.sendReply(ERR_NOTONCHANNEL, channelName)
- return
- } else if 0 == modes&ircChanModeOperator {
- c.sendReply(ERR_CHANOPRIVSNEEDED, channelName)
- return
- }
-
- client := users[ircToCanon(nick)]
- if _, present := ch.userModes[client]; client == nil || !present {
- c.sendReply(ERR_USERNOTINCHANNEL, nick, channelName)
- return
- }
-
- message := fmt.Sprintf(":%s@%s@%s KICK %s %s :%s",
- c.nickname, c.username, c.hostname, channelName, nick, reason)
- if 0 == ch.modes&ircChanModeQuiet {
- ircChannelMulticast(ch, message, nil)
- } else {
- c.send(message)
- }
-
- delete(ch.userModes, client)
- ircChannelDestroyIfEmpty(ch)
-}
-
-func ircHandleKICK(msg *message, c *client) {
- if len(msg.params) < 2 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- reason := c.nickname
- if len(msg.params) > 2 {
- reason = msg.params[2]
- }
-
- targetChannels := splitString(msg.params[0], ",", true)
- targetUsers := splitString(msg.params[1], ",", true)
-
- if len(channels) == 1 {
- for i := 0; i < len(targetUsers); i++ {
- ircTryKick(c, targetChannels[0], targetUsers[i], reason)
- }
- } else {
- for i := 0; i < len(channels) && i < len(targetUsers); i++ {
- ircTryKick(c, targetChannels[i], targetUsers[i], reason)
- }
- }
-}
-
-func ircSendInviteNotifications(ch *channel, c, target *client) {
- for client := range ch.userModes {
- if client != target && 0 != client.capsEnabled&ircCapInviteNotify {
- client.sendf(":%s!%s@%s INVITE %s %s",
- c.nickname, c.username, c.hostname, target.nickname, ch.name)
- }
- }
-}
-
-func ircHandleINVITE(msg *message, c *client) {
- if len(msg.params) < 2 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- target, channelName := msg.params[0], msg.params[1]
- client := users[ircToCanon(target)]
- if client == nil {
- c.sendReply(ERR_NOSUCHNICK, target)
- return
- }
-
- if ch := channels[ircToCanon(channelName)]; ch != nil {
- invitingModes, invitingPresent := ch.userModes[c]
- if !invitingPresent {
- c.sendReply(ERR_NOTONCHANNEL, channelName)
- return
- }
- if _, present := ch.userModes[client]; present {
- c.sendReply(ERR_USERONCHANNEL, target, channelName)
- return
- }
-
- if 0 != invitingModes&ircChanModeOperator {
- client.invites[ircToCanon(channelName)] = true
- } else if 0 != ch.modes&ircChanModeInviteOnly {
- c.sendReply(ERR_CHANOPRIVSNEEDED, channelName)
- return
- }
-
- // It's not specified when and how we should send out invite-notify.
- if 0 != ch.modes&ircChanModeInviteOnly {
- ircSendInviteNotifications(ch, c, client)
- }
- }
-
- client.sendf(":%s!%s@%s INVITE %s %s",
- c.nickname, c.username, c.hostname, client.nickname, channelName)
- if client.awayMessage != "" {
- c.sendReply(RPL_AWAY, client.nickname, client.awayMessage)
- }
- c.sendReply(RPL_INVITING, client.nickname, channelName)
-}
-
-func ircTryJoin(c *client, channelName, key string) {
- ch := channels[ircToCanon(channelName)]
- var userMode uint
- if ch == nil {
- if !ircIsValidChannelName(channelName) {
- c.sendReply(ERR_BADCHANMASK, channelName)
- return
- }
- ch = ircChannelCreate(channelName)
- userMode = ircChanModeOperator
- } else if _, present := ch.userModes[c]; present {
- return
- }
-
- _, invitedByChanop := c.invites[ircToCanon(channelName)]
- if 0 != ch.modes&ircChanModeInviteOnly && c.inMaskList(ch.inviteList) &&
- !invitedByChanop {
- c.sendReply(ERR_INVITEONLYCHAN, channelName)
- return
- }
- if ch.key != "" && (key == "" || key != ch.key) {
- c.sendReply(ERR_BADCHANNELKEY, channelName)
- return
- }
- if ch.userLimit != -1 && len(ch.userModes) >= ch.userLimit {
- c.sendReply(ERR_CHANNELISFULL, channelName)
- return
- }
- if c.inMaskList(ch.banList) && !c.inMaskList(ch.exceptionList) &&
- !invitedByChanop {
- c.sendReply(ERR_BANNEDFROMCHAN, channelName)
- return
- }
-
- // Destroy any invitation as there's no other way to get rid of it.
- delete(c.invites, ircToCanon(channelName))
-
- ch.userModes[c] = userMode
-
- message := fmt.Sprintf(":%s!%s@%s JOIN %s",
- c.nickname, c.username, c.hostname, channelName)
- if 0 == ch.modes&ircChanModeQuiet {
- ircChannelMulticast(ch, message, nil)
- } else {
- c.send(message)
- }
-
- ircSendRPLTOPIC(c, ch)
- ircSendRPLNAMREPLY(c, ch, nil)
- c.sendReply(RPL_ENDOFNAMES, ch.name)
-}
-
-func ircHandleJOIN(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- if msg.params[0] == "0" {
- ircPartAllChannels(c)
- return
- }
-
- targetChannels := splitString(msg.params[0], ",", true)
-
- var keys []string
- if len(msg.params) > 1 {
- keys = splitString(msg.params[1], ",", true)
- }
-
- for i, name := range targetChannels {
- key := ""
- if i < len(keys) {
- key = keys[i]
- }
- ircTryJoin(c, name, key)
- }
-}
-
-func ircHandleSUMMON(msg *message, c *client) {
- c.sendReply(ERR_SUMMONDISABLED)
-}
-
-func ircHandleUSERS(msg *message, c *client) {
- c.sendReply(ERR_USERSDISABLED)
-}
-
-func ircHandleAWAY(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.awayMessage = ""
- c.sendReply(RPL_UNAWAY)
- } else {
- c.awayMessage = msg.params[0]
- c.sendReply(RPL_NOWAWAY)
- }
-}
-
-func ircHandleISON(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- var on []string
- for _, nick := range msg.params {
- if client := users[ircToCanon(nick)]; client != nil {
- on = append(on, nick)
- }
- }
- c.sendReply(RPL_ISON, strings.Join(on, " "))
-}
-
-func ircHandleADMIN(msg *message, c *client) {
- if len(msg.params) > 0 && !ircIsThisMe(msg.params[0]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[0])
- return
- }
- c.sendReply(ERR_NOADMININFO, serverName)
-}
-
-func ircHandleStatsLinks(c *client, msg *message) {
- // There is only an "l" query in RFC 2812 but we cannot link,
- // so instead we provide the "L" query giving information for all users.
- filter := ""
- if len(msg.params) > 1 {
- filter = msg.params[1]
- }
-
- for _, client := range users {
- if filter != "" && !ircEqual(client.nickname, filter) {
- continue
- }
- c.sendReply(RPL_STATSLINKINFO,
- client.address, // linkname
- len(client.sendQ), // sendq
- client.nSentMessages, client.sentBytes/1024,
- client.nReceivedMessages, client.receivedBytes/1024,
- time.Now().Sub(client.opened)/time.Second)
- }
-}
-
-func ircHandleStatsCommands(c *client) {
- for name, handler := range ircHandlers {
- if handler.nReceived > 0 {
- c.sendReply(RPL_STATSCOMMANDS, name,
- handler.nReceived, handler.bytesReceived, 0)
- }
- }
-}
-
-// We need to do it this way because of an initialization loop concerning
-// ircHandlers. Workaround proposed by rsc in go #1817.
-var ircHandleStatsCommandsIndirect func(c *client)
-
-func init() {
- ircHandleStatsCommandsIndirect = ircHandleStatsCommands
-}
-
-func ircHandleStatsUptime(c *client) {
- uptime := time.Now().Sub(started) / time.Second
-
- days := uptime / 60 / 60 / 24
- hours := (uptime % (60 * 60 * 24)) / 60 / 60
- mins := (uptime % (60 * 60)) / 60
- secs := uptime % 60
-
- c.sendReply(RPL_STATSUPTIME, days, hours, mins, secs)
-}
-
-func ircHandleSTATS(msg *message, c *client) {
- var query byte
- if len(msg.params) > 0 && len(msg.params[0]) > 0 {
- query = msg.params[0][0]
- }
-
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[1]) {
- c.sendReply(ERR_NOSUCHSERVER, msg.params[0])
- return
- }
- if 0 == c.mode&ircUserModeOperator {
- c.sendReply(ERR_NOPRIVILEGES)
- return
- }
-
- switch query {
- case 'L':
- ircHandleStatsLinks(c, msg)
- case 'm':
- ircHandleStatsCommandsIndirect(c)
- case 'u':
- ircHandleStatsUptime(c)
- }
- c.sendReply(RPL_ENDOFSTATS, query)
-}
-
-func ircHandleLINKS(msg *message, c *client) {
- if len(msg.params) > 1 && !ircIsThisMe(msg.params[0]) {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
-
- mask := "*"
- if len(msg.params) > 0 {
- if len(msg.params) > 1 {
- mask = msg.params[1]
- } else {
- mask = msg.params[0]
- }
- }
-
- if ircFnmatch(mask, serverName) {
- c.sendReply(RPL_LINKS, mask, serverName,
- 0 /* hop count */, config["server_info"])
- }
- c.sendReply(RPL_ENDOFLINKS, mask)
-}
-
-func ircHandleWALLOPS(msg *message, c *client) {
- if len(msg.params) < 1 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
- if 0 == c.mode&ircUserModeOperator {
- c.sendReply(ERR_NOPRIVILEGES)
- return
- }
-
- // Our interpretation: anonymize the sender,
- // and target all users who want to receive these messages.
- for _, client := range users {
- if client == c || 0 != client.mode&ircUserModeRxWallops {
- client.sendf(":%s WALLOPS :%s", serverName, msg.params[0])
- }
- }
-}
-
-func ircHandleKILL(msg *message, c *client) {
- if len(msg.params) < 2 {
- c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
- return
- }
- if 0 == c.mode&ircUserModeOperator {
- c.sendReply(ERR_NOPRIVILEGES)
- return
- }
-
- target := users[ircToCanon(msg.params[0])]
- if target == nil {
- c.sendReply(ERR_NOSUCHNICK, msg.params[0])
- return
- }
-
- c.sendf(":%s!%s@%s KILL %s :%s",
- c.nickname, c.username, c.hostname, target.nickname, msg.params[1])
- target.closeLink(fmt.Sprintf("Killed by %s: %s", c.nickname, msg.params[1]))
-}
-
-func ircHandleDIE(msg *message, c *client) {
- if 0 == c.mode&ircUserModeOperator {
- c.sendReply(ERR_NOPRIVILEGES)
- } else if !quitting {
- initiateQuit()
- }
-}
-
-// -----------------------------------------------------------------------------
-
-// TODO: Add an index for ERR_NOSUCHSERVER validation?
-// TODO: Add a minimal parameter count?
-// TODO: Add a field for oper-only commands? Use flags?
-var ircHandlers = map[string]*ircCommand{
- "WEBIRC": {false, ircHandleWEBIRC, 0, 0},
- "CAP": {false, ircHandleCAP, 0, 0},
- "PASS": {false, ircHandlePASS, 0, 0},
- "NICK": {false, ircHandleNICK, 0, 0},
- "USER": {false, ircHandleUSER, 0, 0},
-
- "USERHOST": {true, ircHandleUSERHOST, 0, 0},
- "LUSERS": {true, ircHandleLUSERS, 0, 0},
- "MOTD": {true, ircHandleMOTD, 0, 0},
- "PING": {true, ircHandlePING, 0, 0},
- "PONG": {false, ircHandlePONG, 0, 0},
- "QUIT": {false, ircHandleQUIT, 0, 0},
- "TIME": {true, ircHandleTIME, 0, 0},
- "VERSION": {true, ircHandleVERSION, 0, 0},
- "USERS": {true, ircHandleUSERS, 0, 0},
- "SUMMON": {true, ircHandleSUMMON, 0, 0},
- "AWAY": {true, ircHandleAWAY, 0, 0},
- "ADMIN": {true, ircHandleADMIN, 0, 0},
- "STATS": {true, ircHandleSTATS, 0, 0},
- "LINKS": {true, ircHandleLINKS, 0, 0},
- "WALLOPS": {true, ircHandleWALLOPS, 0, 0},
-
- "MODE": {true, ircHandleMODE, 0, 0},
- "PRIVMSG": {true, ircHandlePRIVMSG, 0, 0},
- "NOTICE": {true, ircHandleNOTICE, 0, 0},
- "JOIN": {true, ircHandleJOIN, 0, 0},
- "PART": {true, ircHandlePART, 0, 0},
- "KICK": {true, ircHandleKICK, 0, 0},
- "INVITE": {true, ircHandleINVITE, 0, 0},
- "TOPIC": {true, ircHandleTOPIC, 0, 0},
- "LIST": {true, ircHandleLIST, 0, 0},
- "NAMES": {true, ircHandleNAMES, 0, 0},
- "WHO": {true, ircHandleWHO, 0, 0},
- "WHOIS": {true, ircHandleWHOIS, 0, 0},
- "WHOWAS": {true, ircHandleWHOWAS, 0, 0},
- "ISON": {true, ircHandleISON, 0, 0},
-
- "KILL": {true, ircHandleKILL, 0, 0},
- "DIE": {true, ircHandleDIE, 0, 0},
-}
-
-func ircProcessMessage(c *client, msg *message, raw string) {
- if c.closing {
- return
- }
-
- c.nReceivedMessages++
- c.receivedBytes += len(raw) + 2
-
- if !c.antiflood.check() {
- c.closeLink("Excess flood")
- return
- }
-
- if cmd, ok := ircHandlers[ircToCanon(msg.command)]; !ok {
- c.sendReply(ERR_UNKNOWNCOMMAND, msg.command)
- } else {
- cmd.nReceived++
- cmd.bytesReceived += len(raw) + 2
-
- if cmd.requiresRegistration && !c.registered {
- c.sendReply(ERR_NOTREGISTERED)
- } else {
- cmd.handler(msg, c)
- }
- }
-}
-
-// --- Network I/O -------------------------------------------------------------
-
-// Handle the results from initializing the client's connection.
-func (c *client) onPrepared(host string, isTLS bool) {
- c.printDebug("client resolved to %s, TLS %t", host, isTLS)
- if !isTLS {
- c.conn = c.transport.(connCloseWriter)
- } else if tlsConf != nil {
- c.tls = tls.Server(c.transport, tlsConf)
- c.conn = c.tls
- } else {
- c.printDebug("could not initialize TLS: disabled")
- c.kill("TLS support disabled")
- return
- }
-
- c.hostname = host
- c.address = net.JoinHostPort(host, c.port)
-
- // If we tried to send any data before now, we would need to flushSendQ.
- go read(c)
- c.reading = true
- c.setPingTimer()
-}
-
-// Handle the results from trying to read from the client connection.
-func (c *client) onRead(data []byte, readErr error) {
- if !c.reading {
- // Abusing the flag to emulate CloseRead and skip over data, see below.
- return
- }
-
- c.recvQ = append(c.recvQ, data...)
- for {
- // XXX: This accepts even simple LF newlines, even though they're not
- // really allowed by the protocol.
- advance, token, _ := bufio.ScanLines(c.recvQ, false /* atEOF */)
- if advance == 0 {
- break
- }
-
- // XXX: And since it accepts LF, we miscalculate receivedBytes within.
- c.recvQ = c.recvQ[advance:]
- line := string(token)
- c.printDebug("-> %s", line)
-
- if msg := ircParseMessage(line); msg == nil {
- c.printDebug("error: invalid line")
- } else {
- ircProcessMessage(c, msg, line)
- }
- }
-
- if readErr != nil {
- c.reading = false
-
- if readErr != io.EOF {
- c.printDebug("%s", readErr)
- c.kill(readErr.Error())
- } else if c.closing {
- // Disregarding whether a clean shutdown has happened or not.
- c.printDebug("client finished shutdown")
- c.kill("")
- } else {
- c.printDebug("client EOF")
- c.closeLink("")
- }
- } else if len(c.recvQ) > 8192 {
- c.closeLink("recvQ overrun")
-
- // tls.Conn doesn't have the CloseRead method (and it needs to be able
- // to read from the TCP connection even for writes, so there isn't much
- // sense in expecting the implementation to do anything useful),
- // otherwise we'd use it to block incoming packet data.
- c.reading = false
- }
-}
-
-// Spawn a goroutine to flush the sendQ if possible and necessary.
-func (c *client) flushSendQ() {
- if !c.writing && c.conn != nil {
- go write(c, c.sendQ)
- c.writing = true
- }
-}
-
-// Handle the results from trying to write to the client connection.
-func (c *client) onWrite(written int, writeErr error) {
- c.sendQ = c.sendQ[written:]
- c.writing = false
-
- if writeErr != nil {
- c.printDebug("%s", writeErr)
- c.kill(writeErr.Error())
- } else if len(c.sendQ) > 0 {
- c.flushSendQ()
- } else if c.closing {
- if c.reading {
- c.conn.CloseWrite()
- } else {
- c.kill("")
- }
- }
-}
-
-// --- Worker goroutines -------------------------------------------------------
-
-func accept(ln net.Listener) {
- for {
- // Error handling here may be tricky, see go #6163, #24808.
- if conn, err := ln.Accept(); err != nil {
- // See go #4373, they're being dicks. Another solution would be to
- // pass a done channel to this function and close it before closing
- // all the listeners, returning from here if it's readable.
- if strings.Contains(err.Error(),
- "use of closed network connection") {
- return
- }
- // XXX: net.Error.Temporary() has been deprecated in 1.18.
- if op, ok := err.(net.Error); !ok || !op.Temporary() {
- exitFatal("%s", err)
- } else {
- printError("%s", err)
- }
- } else {
- // TCP_NODELAY is set by default on TCPConns.
- conns <- conn
- }
- }
-}
-
-func prepare(client *client) {
- conn, host := client.transport, client.hostname
-
- // The Cgo resolver doesn't pthread_cancel getnameinfo threads, so not
- // bothering with pointless contexts.
- ch := make(chan string, 1)
- go func() {
- defer close(ch)
- if names, err := net.LookupAddr(host); err != nil {
- printError("%s", err)
- } else {
- ch <- names[0]
- }
- }()
-
- // While we can't cancel it, we still want to set a timeout on it.
- select {
- case <-time.After(5 * time.Second):
- case resolved, ok := <-ch:
- if ok {
- host = resolved
- }
- }
-
- // Note that in this demo application the autodetection prevents non-TLS
- // clients from receiving any messages until they send something.
- isTLS := false
- if sysconn, err := conn.(syscall.Conn).SyscallConn(); err != nil {
- // This is just for the TLS detection and doesn't need to be fatal.
- printError("%s", err)
- } else {
- isTLS = detectTLS(sysconn)
- }
-
- prepared <- preparedEvent{client, host, isTLS}
-}
-
-func read(client *client) {
- // A new buffer is allocated each time we receive some bytes, because of
- // thread-safety. Therefore the buffer shouldn't be too large, or we'd
- // need to copy it each time into a precisely sized new buffer.
- var err error
- for err == nil {
- var (
- buf [512]byte
- n int
- )
- n, err = client.conn.Read(buf[:])
- reads <- readEvent{client, buf[:n], err}
- }
-}
-
-// Flush sendQ, which is passed by parameter so that there are no data races.
-func write(client *client, data []byte) {
- // We just write as much as we can, the main goroutine does the looping.
- n, err := client.conn.Write(data)
- writes <- writeEvent{client, n, err}
-}
-
-// --- Event loop --------------------------------------------------------------
-
-func processOneEvent() {
- select {
- case <-sigs:
- if quitting {
- forceQuit("requested by user")
- } else {
- initiateQuit()
- }
-
- case <-quitTimer:
- forceQuit("timeout")
-
- case callback := <-timers:
- callback()
-
- case conn := <-conns:
- if maxConnections > 0 && len(clients) >= maxConnections {
- printDebug("connection limit reached, refusing connection")
- conn.Close()
- break
- }
-
- address := conn.RemoteAddr().String()
- host, port, err := net.SplitHostPort(address)
- if err != nil {
- // In effect, we require TCP/UDP, as they have port numbers.
- exitFatal("%s", err)
- }
-
- c := &client{
- transport: conn,
- address: address,
- hostname: host,
- port: port,
- capVersion: 301,
- opened: time.Now(),
- lastActive: time.Now(),
- // TODO: Make this configurable and more fine-grained.
- antiflood: newFloodDetector(10*time.Second, 20),
- }
-
- clients[c] = true
- c.printDebug("new client")
- go prepare(c)
-
- // The TLS autodetection in prepare needs to have a timeout.
- c.setKillTimer()
-
- case ev := <-prepared:
- if _, ok := clients[ev.client]; ok {
- ev.client.onPrepared(ev.host, ev.isTLS)
- }
-
- case ev := <-reads:
- if _, ok := clients[ev.client]; ok {
- ev.client.onRead(ev.data, ev.err)
- }
-
- case ev := <-writes:
- if _, ok := clients[ev.client]; ok {
- ev.client.onWrite(ev.written, ev.err)
- }
- }
-}
-
-// --- Application setup -------------------------------------------------------
-
-func ircInitializeTLS() error {
- configCert, configKey := config["tls_cert"], config["tls_key"]
-
- // Only try to enable SSL support if the user configures it; it is not
- // a failure if no one has requested it.
- if configCert == "" && configKey == "" {
- return nil
- } else if configCert == "" {
- return errors.New("no TLS certificate set")
- } else if configKey == "" {
- return errors.New("no TLS private key set")
- }
-
- pathCert := resolveFilename(configCert, resolveRelativeConfigFilename)
- if pathCert == "" {
- return fmt.Errorf("cannot find file: %s", configCert)
- }
-
- pathKey := resolveFilename(configKey, resolveRelativeConfigFilename)
- if pathKey == "" {
- return fmt.Errorf("cannot find file: %s", configKey)
- }
-
- cert, err := tls.LoadX509KeyPair(pathCert, pathKey)
- if err != nil {
- return err
- }
-
- tlsConf = &tls.Config{
- Certificates: []tls.Certificate{cert},
- ClientAuth: tls.RequestClientCert,
- SessionTicketsDisabled: true,
- }
- return nil
-}
-
-func ircInitializeCatalog() error {
- configCatalog := config["catalog"]
- if configCatalog == "" {
- return nil
- }
-
- path := resolveFilename(configCatalog, resolveRelativeConfigFilename)
- if path == "" {
- return fmt.Errorf("cannot find file: %s", configCatalog)
- }
-
- f, err := os.Open(path)
- if err != nil {
- return fmt.Errorf("failed reading the MOTD file: %s", err)
- }
- defer f.Close()
-
- scanner := bufio.NewScanner(f)
- catalog = make(map[int]string)
- for lineNo := 1; scanner.Scan(); lineNo++ {
- line := strings.TrimLeft(scanner.Text(), " \t")
- if line == "" || strings.HasPrefix(line, "#") {
- continue
- }
-
- delim := strings.IndexAny(line, " \t")
- if delim < 0 {
- return fmt.Errorf("%s:%d: malformed line", path, lineNo)
- }
-
- id, err := strconv.ParseUint(line[:delim], 10, 16)
- if err != nil {
- return fmt.Errorf("%s:%d: %s", path, lineNo, err)
- }
-
- catalog[int(id)] = line[delim+1:]
- }
- return scanner.Err()
-}
-
-func ircInitializeMOTD() error {
- configMOTD := config["motd"]
- if configMOTD == "" {
- return nil
- }
-
- path := resolveFilename(configMOTD, resolveRelativeConfigFilename)
- if path == "" {
- return fmt.Errorf("cannot find file: %s", configMOTD)
- }
-
- f, err := os.Open(path)
- if err != nil {
- return fmt.Errorf("failed reading the MOTD file: %s", err)
- }
- defer f.Close()
-
- scanner := bufio.NewScanner(f)
- motd = nil
- for scanner.Scan() {
- motd = append(motd, scanner.Text())
- }
- return scanner.Err()
-}
-
-type configProcessor struct {
- err error // any error that has occurred so far
-}
-
-func (cp *configProcessor) read(name string, process func(string) string) {
- if cp.err != nil {
- return
- }
- if err := process(config[name]); err != "" {
- cp.err = fmt.Errorf("invalid configuration value for `%s': %s",
- name, err)
- }
-}
-
-// This function handles values that require validation before their first use,
-// or some kind of a transformation (such as conversion to an integer) needs
-// to be done before they can be used directly.
-func ircParseConfig() error {
- cp := &configProcessor{}
- cp.read("ping_interval", func(value string) string {
- if u, err := strconv.ParseUint(
- config["ping_interval"], 10, 32); err != nil {
- return err.Error()
- } else if u < 1 {
- return "the value is out of range"
- } else {
- pingInterval = time.Second * time.Duration(u)
- }
- return ""
- })
- cp.read("max_connections", func(value string) string {
- if i, err := strconv.ParseInt(
- value, 10, 32); err != nil {
- return err.Error()
- } else if i < 0 {
- return "the value is out of range"
- } else {
- maxConnections = int(i)
- }
- return ""
- })
- cp.read("operators", func(value string) string {
- operators = make(map[string]bool)
- for _, fp := range splitString(value, ",", true) {
- if !ircIsValidFingerprint(fp) {
- return "invalid fingerprint value"
- }
- operators[strings.ToLower(fp)] = true
- }
- return ""
- })
- return cp.err
-}
-
-func ircInitializeServerName() error {
- if value := config["server_name"]; value != "" {
- if err := ircValidateHostname(value); err != nil {
- return err
- }
- serverName = value
- return nil
- }
-
- if hostname, err := os.Hostname(); err != nil {
- return err
- } else if err := ircValidateHostname(hostname); err != nil {
- return err
- } else {
- serverName = hostname
- }
- return nil
-}
-
-func ircSetupListenFDs() error {
- for _, address := range splitString(config["bind"], ",", true) {
- ln, err := net.Listen("tcp", address)
- if err != nil {
- return err
- }
- listeners = append(listeners, ln)
- printStatus("listening on %s", address)
- }
- if len(listeners) == 0 {
- return errors.New("network setup failed: no ports to listen on")
- }
- for _, ln := range listeners {
- go accept(ln)
- }
- return nil
-}
-
-// --- Main --------------------------------------------------------------------
-
-func main() {
- flag.BoolVar(&debugMode, "debug", false, "run in verbose debug mode")
- version := flag.Bool("version", false, "show version and exit")
- writeDefaultCfg := flag.Bool("writedefaultcfg", false,
- "write a default configuration file and exit")
- systemd := flag.Bool("systemd", false, "log in systemd format")
-
- flag.Parse()
-
- if *version {
- fmt.Printf("%s %s\n", projectName, projectVersion)
- return
- }
- if *writeDefaultCfg {
- callSimpleConfigWriteDefault("", configTable)
- return
- }
- if *systemd {
- logMessage = logMessageSystemd
- }
- if flag.NArg() > 0 {
- flag.Usage()
- os.Exit(2)
- }
-
- // Note that this has become unnecessary since Go 1.19.
- var limit syscall.Rlimit
- if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err == nil &&
- limit.Cur != limit.Max {
- limit.Cur = limit.Max
- syscall.Setrlimit(syscall.RLIMIT_NOFILE, &limit)
- }
-
- config = make(simpleConfig)
- config.loadDefaults(configTable)
- if err := config.updateFromFile(); err != nil && !os.IsNotExist(err) {
- printError("error loading configuration: %s", err)
- os.Exit(1)
- }
-
- started = time.Now()
- signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
-
- for _, fn := range []func() error{
- ircInitializeTLS,
- ircInitializeServerName,
- ircInitializeMOTD,
- ircInitializeCatalog,
- ircParseConfig,
- ircSetupListenFDs,
- } {
- if err := fn(); err != nil {
- exitFatal("%s", err)
- }
- }
-
- for !quitting || len(clients) > 0 {
- processOneEvent()
- }
-}