From 103704b183cbfeab341ecf4314b4d82694b07ce1 Mon Sep 17 00:00:00 2001 From: Přemysl Eric Janouch Date: Mon, 26 Sep 2022 13:36:19 +0200 Subject: Punt hid back where it came from --- hid/main.go | 3530 ----------------------------------------------------------- 1 file changed, 3530 deletions(-) delete mode 100644 hid/main.go (limited to 'hid/main.go') diff --git a/hid/main.go b/hid/main.go deleted file mode 100644 index 40f47bc..0000000 --- a/hid/main.go +++ /dev/null @@ -1,3530 +0,0 @@ -// -// Copyright (c) 2014 - 2022, Přemysl Eric Janouch -// -// 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. -// - -// hid 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 = "hid" - // 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 "./hid-gen-replies.sh > hid-replies.go < hid-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() - } -} -- cgit v1.2.3-70-g09d2