Update documentation, clean up

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()
-	}
-}