Centralise all command handlers in handlers.go

irc/accountreg.go

@@ -4,18 +4,9 @@
 package irc
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
-	"strconv"
-	"strings"
-	"time"
 
-	"github.com/goshuirc/irc-go/ircfmt"
-	"github.com/goshuirc/irc-go/ircmsg"
-	"github.com/oragono/oragono/irc/passwd"
-	"github.com/oragono/oragono/irc/sno"
 	"github.com/tidwall/buntdb"
 )
 
@@ -60,21 +51,6 @@ func NewAccountRegistration(config AccountRegistrationConfig) (accountReg Accoun
 	return accountReg
 }
 
-// accHandler parses the ACC command.
-func accHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	subcommand := strings.ToLower(msg.Params[0])
-
-	if subcommand == "register" {
-		return accRegisterHandler(server, client, msg)
-	} else if subcommand == "verify" {
-		client.Notice(client.t("VERIFY is not yet implemented"))
-	} else {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "ACC", msg.Params[0], client.t("Unknown subcommand"))
-	}
-
-	return false
-}
-
 // removeFailedAccRegisterData removes the data created by ACC REGISTER if the account creation fails early.
 func removeFailedAccRegisterData(store *buntdb.DB, account string) {
 	// error is ignored here, we can't do much about it anyways
@@ -86,212 +62,3 @@ func removeFailedAccRegisterData(store *buntdb.DB, account string) {
 		return nil
 	})
 }
-
-// accRegisterHandler parses the ACC REGISTER command.
-func accRegisterHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// make sure reg is enabled
-	if !server.accountRegistration.Enabled {
-		client.Send(nil, server.name, ERR_REG_UNSPECIFIED_ERROR, client.nick, "*", client.t("Account registration is disabled"))
-		return false
-	}
-
-	// clients can't reg new accounts if they're already logged in
-	if client.LoggedIntoAccount() {
-		if server.accountRegistration.AllowMultiplePerConnection {
-			client.LogoutOfAccount()
-		} else {
-			client.Send(nil, server.name, ERR_REG_UNSPECIFIED_ERROR, client.nick, "*", client.t("You're already logged into an account"))
-			return false
-		}
-	}
-
-	// get and sanitise account name
-	account := strings.TrimSpace(msg.Params[1])
-	casefoldedAccount, err := CasefoldName(account)
-	// probably don't need explicit check for "*" here... but let's do it anyway just to make sure
-	if err != nil || msg.Params[1] == "*" {
-		client.Send(nil, server.name, ERR_REG_UNSPECIFIED_ERROR, client.nick, account, client.t("Account name is not valid"))
-		return false
-	}
-
-	// check whether account exists
-	// do it all in one write tx to prevent races
-	err = server.store.Update(func(tx *buntdb.Tx) error {
-		accountKey := fmt.Sprintf(keyAccountExists, casefoldedAccount)
-
-		_, err := tx.Get(accountKey)
-		if err != buntdb.ErrNotFound {
-			//TODO(dan): if account verified key doesn't exist account is not verified, calc the maximum time without verification and expire and continue if need be
-			client.Send(nil, server.name, ERR_ACCOUNT_ALREADY_EXISTS, client.nick, account, client.t("Account already exists"))
-			return errAccountCreation
-		}
-
-		registeredTimeKey := fmt.Sprintf(keyAccountRegTime, casefoldedAccount)
-
-		tx.Set(accountKey, "1", nil)
-		tx.Set(fmt.Sprintf(keyAccountName, casefoldedAccount), account, nil)
-		tx.Set(registeredTimeKey, strconv.FormatInt(time.Now().Unix(), 10), nil)
-		return nil
-	})
-
-	// account could not be created and relevant numerics have been dispatched, abort
-	if err != nil {
-		if err != errAccountCreation {
-			client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "ACC", "REGISTER", client.t("Could not register"))
-			log.Println("Could not save registration initial data:", err.Error())
-		}
-		return false
-	}
-
-	// account didn't already exist, continue with account creation and dispatching verification (if required)
-	callback := strings.ToLower(msg.Params[2])
-	var callbackNamespace, callbackValue string
-
-	if callback == "*" {
-		callbackNamespace = "*"
-	} else if strings.Contains(callback, ":") {
-		callbackValues := strings.SplitN(callback, ":", 2)
-		callbackNamespace, callbackValue = callbackValues[0], callbackValues[1]
-	} else {
-		callbackNamespace = server.accountRegistration.EnabledCallbacks[0]
-		callbackValue = callback
-	}
-
-	// ensure the callback namespace is valid
-	// need to search callback list, maybe look at using a map later?
-	var callbackValid bool
-	for _, name := range server.accountRegistration.EnabledCallbacks {
-		if callbackNamespace == name {
-			callbackValid = true
-		}
-	}
-
-	if !callbackValid {
-		client.Send(nil, server.name, ERR_REG_INVALID_CALLBACK, client.nick, account, callbackNamespace, client.t("Callback namespace is not supported"))
-		removeFailedAccRegisterData(server.store, casefoldedAccount)
-		return false
-	}
-
-	// get credential type/value
-	var credentialType, credentialValue string
-
-	if len(msg.Params) > 4 {
-		credentialType = strings.ToLower(msg.Params[3])
-		credentialValue = msg.Params[4]
-	} else if len(msg.Params) == 4 {
-		credentialType = "passphrase" // default from the spec
-		credentialValue = msg.Params[3]
-	} else {
-		client.Send(nil, server.name, ERR_NEEDMOREPARAMS, client.nick, msg.Command, client.t("Not enough parameters"))
-		removeFailedAccRegisterData(server.store, casefoldedAccount)
-		return false
-	}
-
-	// ensure the credential type is valid
-	var credentialValid bool
-	for _, name := range server.accountRegistration.EnabledCredentialTypes {
-		if credentialType == name {
-			credentialValid = true
-		}
-	}
-	if credentialType == "certfp" && client.certfp == "" {
-		client.Send(nil, server.name, ERR_REG_INVALID_CRED_TYPE, client.nick, credentialType, callbackNamespace, client.t("You are not using a TLS certificate"))
-		removeFailedAccRegisterData(server.store, casefoldedAccount)
-		return false
-	}
-
-	if !credentialValid {
-		client.Send(nil, server.name, ERR_REG_INVALID_CRED_TYPE, client.nick, credentialType, callbackNamespace, client.t("Credential type is not supported"))
-		removeFailedAccRegisterData(server.store, casefoldedAccount)
-		return false
-	}
-
-	// store details
-	err = server.store.Update(func(tx *buntdb.Tx) error {
-		// certfp special lookup key
-		if credentialType == "certfp" {
-			assembledKeyCertToAccount := fmt.Sprintf(keyCertToAccount, client.certfp)
-
-			// make sure certfp doesn't already exist because that'd be silly
-			_, err := tx.Get(assembledKeyCertToAccount)
-			if err != buntdb.ErrNotFound {
-				return errCertfpAlreadyExists
-			}
-
-			tx.Set(assembledKeyCertToAccount, casefoldedAccount, nil)
-		}
-
-		// make creds
-		var creds AccountCredentials
-
-		// always set passphrase salt
-		creds.PassphraseSalt, err = passwd.NewSalt()
-		if err != nil {
-			return fmt.Errorf("Could not create passphrase salt: %s", err.Error())
-		}
-
-		if credentialType == "certfp" {
-			creds.Certificate = client.certfp
-		} else if credentialType == "passphrase" {
-			creds.PassphraseHash, err = server.passwords.GenerateFromPassword(creds.PassphraseSalt, credentialValue)
-			if err != nil {
-				return fmt.Errorf("Could not hash password: %s", err)
-			}
-		}
-		credText, err := json.Marshal(creds)
-		if err != nil {
-			return fmt.Errorf("Could not marshal creds: %s", err)
-		}
-		tx.Set(fmt.Sprintf(keyAccountCredentials, account), string(credText), nil)
-
-		return nil
-	})
-
-	// details could not be stored and relevant numerics have been dispatched, abort
-	if err != nil {
-		errMsg := "Could not register"
-		if err == errCertfpAlreadyExists {
-			errMsg = "An account already exists for your certificate fingerprint"
-		}
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "ACC", "REGISTER", errMsg)
-		log.Println("Could not save registration creds:", err.Error())
-		removeFailedAccRegisterData(server.store, casefoldedAccount)
-		return false
-	}
-
-	// automatically complete registration
-	if callbackNamespace == "*" {
-		err = server.store.Update(func(tx *buntdb.Tx) error {
-			tx.Set(fmt.Sprintf(keyAccountVerified, casefoldedAccount), "1", nil)
-
-			// load acct info inside store tx
-			account := ClientAccount{
-				Name:         strings.TrimSpace(msg.Params[1]),
-				RegisteredAt: time.Now(),
-				Clients:      []*Client{client},
-			}
-			//TODO(dan): Consider creating ircd-wide account adding/removing/affecting lock for protecting access to these sorts of variables
-			server.accounts[casefoldedAccount] = &account
-			client.account = &account
-
-			client.Send(nil, server.name, RPL_REGISTRATION_SUCCESS, client.nick, account.Name, client.t("Account created"))
-			client.Send(nil, server.name, RPL_LOGGEDIN, client.nick, client.nickMaskString, account.Name, fmt.Sprintf(client.t("You are now logged in as %s"), account.Name))
-			client.Send(nil, server.name, RPL_SASLSUCCESS, client.nick, client.t("Authentication successful"))
-			server.snomasks.Send(sno.LocalAccounts, fmt.Sprintf(ircfmt.Unescape("Account registered $c[grey][$r%s$c[grey]] by $c[grey][$r%s$c[grey]]"), account.Name, client.nickMaskString))
-			return nil
-		})
-		if err != nil {
-			client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, "ACC", "REGISTER", client.t("Could not register"))
-			log.Println("Could not save verification confirmation (*):", err.Error())
-			removeFailedAccRegisterData(server.store, casefoldedAccount)
-			return false
-		}
-
-		return false
-	}
-
-	// dispatch callback
-	client.Notice(fmt.Sprintf("We should dispatch a real callback here to %s:%s", callbackNamespace, callbackValue))
-
-	return false
-}

irc/accounts.go

@@ -4,17 +4,13 @@
 package irc
 
 import (
-	"bytes"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/goshuirc/irc-go/ircfmt"
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/caps"
 	"github.com/oragono/oragono/irc/sno"
 	"github.com/tidwall/buntdb"
@@ -87,163 +83,6 @@ func loadAccount(server *Server, tx *buntdb.Tx, accountKey string) *ClientAccoun
 	return &accountInfo
 }
 
-// authenticateHandler parses the AUTHENTICATE command (for SASL authentication).
-func authenticateHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// sasl abort
-	if !server.accountAuthenticationEnabled || len(msg.Params) == 1 && msg.Params[0] == "*" {
-		client.Send(nil, server.name, ERR_SASLABORTED, client.nick, client.t("SASL authentication aborted"))
-		client.saslInProgress = false
-		client.saslMechanism = ""
-		client.saslValue = ""
-		return false
-	}
-
-	// start new sasl session
-	if !client.saslInProgress {
-		mechanism := strings.ToUpper(msg.Params[0])
-		_, mechanismIsEnabled := EnabledSaslMechanisms[mechanism]
-
-		if mechanismIsEnabled {
-			client.saslInProgress = true
-			client.saslMechanism = mechanism
-			client.Send(nil, server.name, "AUTHENTICATE", "+")
-		} else {
-			client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed"))
-		}
-
-		return false
-	}
-
-	// continue existing sasl session
-	rawData := msg.Params[0]
-
-	if len(rawData) > 400 {
-		client.Send(nil, server.name, ERR_SASLTOOLONG, client.nick, client.t("SASL message too long"))
-		client.saslInProgress = false
-		client.saslMechanism = ""
-		client.saslValue = ""
-		return false
-	} else if len(rawData) == 400 {
-		client.saslValue += rawData
-		// allow 4 'continuation' lines before rejecting for length
-		if len(client.saslValue) > 400*4 {
-			client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed: Passphrase too long"))
-			client.saslInProgress = false
-			client.saslMechanism = ""
-			client.saslValue = ""
-			return false
-		}
-		return false
-	}
-	if rawData != "+" {
-		client.saslValue += rawData
-	}
-
-	var data []byte
-	var err error
-	if client.saslValue != "+" {
-		data, err = base64.StdEncoding.DecodeString(client.saslValue)
-		if err != nil {
-			client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed: Invalid b64 encoding"))
-			client.saslInProgress = false
-			client.saslMechanism = ""
-			client.saslValue = ""
-			return false
-		}
-	}
-
-	// call actual handler
-	handler, handlerExists := EnabledSaslMechanisms[client.saslMechanism]
-
-	// like 100% not required, but it's good to be safe I guess
-	if !handlerExists {
-		client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed"))
-		client.saslInProgress = false
-		client.saslMechanism = ""
-		client.saslValue = ""
-		return false
-	}
-
-	// let the SASL handler do its thing
-	exiting := handler(server, client, client.saslMechanism, data)
-
-	// wait 'til SASL is done before emptying the sasl vars
-	client.saslInProgress = false
-	client.saslMechanism = ""
-	client.saslValue = ""
-
-	return exiting
-}
-
-// authPlainHandler parses the SASL PLAIN mechanism.
-func authPlainHandler(server *Server, client *Client, mechanism string, value []byte) bool {
-	splitValue := bytes.Split(value, []byte{'\000'})
-
-	var accountKey, authzid string
-
-	if len(splitValue) == 3 {
-		accountKey = string(splitValue[0])
-		authzid = string(splitValue[1])
-
-		if accountKey == "" {
-			accountKey = authzid
-		} else if accountKey != authzid {
-			client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed: authcid and authzid should be the same"))
-			return false
-		}
-	} else {
-		client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed: Invalid auth blob"))
-		return false
-	}
-
-	// keep it the same as in the REG CREATE stage
-	accountKey, err := CasefoldName(accountKey)
-	if err != nil {
-		client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed: Bad account name"))
-		return false
-	}
-
-	// load and check acct data all in one update to prevent races.
-	// as noted elsewhere, change to proper locking for Account type later probably
-	err = server.store.Update(func(tx *buntdb.Tx) error {
-		// confirm account is verified
-		_, err = tx.Get(fmt.Sprintf(keyAccountVerified, accountKey))
-		if err != nil {
-			return errSaslFail
-		}
-
-		creds, err := loadAccountCredentials(tx, accountKey)
-		if err != nil {
-			return err
-		}
-
-		// ensure creds are valid
-		password := string(splitValue[2])
-		if len(creds.PassphraseHash) < 1 || len(creds.PassphraseSalt) < 1 || len(password) < 1 {
-			return errSaslFail
-		}
-		err = server.passwords.CompareHashAndPassword(creds.PassphraseHash, creds.PassphraseSalt, password)
-
-		// succeeded, load account info if necessary
-		account, exists := server.accounts[accountKey]
-		if !exists {
-			account = loadAccount(server, tx, accountKey)
-		}
-
-		client.LoginToAccount(account)
-
-		return err
-	})
-
-	if err != nil {
-		client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed"))
-		return false
-	}
-
-	client.successfulSaslAuth()
-	return false
-}
-
 // LoginToAccount logs the client into the given account.
 func (client *Client) LoginToAccount(account *ClientAccount) {
 	if client.account == account {
@@ -292,58 +131,6 @@ func (client *Client) LogoutOfAccount() {
 	}
 }
 
-// authExternalHandler parses the SASL EXTERNAL mechanism.
-func authExternalHandler(server *Server, client *Client, mechanism string, value []byte) bool {
-	if client.certfp == "" {
-		client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed, you are not connecting with a certificate"))
-		return false
-	}
-
-	err := server.store.Update(func(tx *buntdb.Tx) error {
-		// certfp lookup key
-		accountKey, err := tx.Get(fmt.Sprintf(keyCertToAccount, client.certfp))
-		if err != nil {
-			return errSaslFail
-		}
-
-		// confirm account exists
-		_, err = tx.Get(fmt.Sprintf(keyAccountExists, accountKey))
-		if err != nil {
-			return errSaslFail
-		}
-
-		// confirm account is verified
-		_, err = tx.Get(fmt.Sprintf(keyAccountVerified, accountKey))
-		if err != nil {
-			return errSaslFail
-		}
-
-		// confirm the certfp in that account's credentials
-		creds, err := loadAccountCredentials(tx, accountKey)
-		if err != nil || creds.Certificate != client.certfp {
-			return errSaslFail
-		}
-
-		// succeeded, load account info if necessary
-		account, exists := server.accounts[accountKey]
-		if !exists {
-			account = loadAccount(server, tx, accountKey)
-		}
-
-		client.LoginToAccount(account)
-
-		return nil
-	})
-
-	if err != nil {
-		client.Send(nil, server.name, ERR_SASLFAIL, client.nick, client.t("SASL authentication failed"))
-		return false
-	}
-
-	client.successfulSaslAuth()
-	return false
-}
-
 // successfulSaslAuth means that a SASL auth attempt completed successfully, and is used to dispatch messages.
 func (client *Client) successfulSaslAuth() {
 	client.Send(nil, client.server.name, RPL_LOGGEDIN, client.nick, client.nickMaskString, client.account.Name, fmt.Sprintf("You are now logged in as %s", client.account.Name))

irc/capability.go

@@ -5,9 +5,6 @@
 package irc
 
 import (
-	"strings"
-
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/caps"
 )
 
@@ -32,63 +29,3 @@ const (
 	// CapNegotiated means CAP negotiation has been successfully ended and reg should complete.
 	CapNegotiated CapState = iota
 )
-
-// CAP <subcmd> [<caps>]
-func capHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	subCommand := strings.ToUpper(msg.Params[0])
-	capabilities := caps.NewSet()
-	var capString string
-
-	if len(msg.Params) > 1 {
-		capString = msg.Params[1]
-		strs := strings.Split(capString, " ")
-		for _, str := range strs {
-			if len(str) > 0 {
-				capabilities.Enable(caps.Capability(str))
-			}
-		}
-	}
-
-	switch subCommand {
-	case "LS":
-		if !client.registered {
-			client.capState = CapNegotiating
-		}
-		if len(msg.Params) > 1 && msg.Params[1] == "302" {
-			client.capVersion = 302
-		}
-		// weechat 1.4 has a bug here where it won't accept the CAP reply unless it contains
-		// the server.name source... otherwise it doesn't respond to the CAP message with
-		// anything and just hangs on connection.
-		//TODO(dan): limit number of caps and send it multiline in 3.2 style as appropriate.
-		client.Send(nil, server.name, "CAP", client.nick, subCommand, SupportedCapabilities.String(client.capVersion, CapValues))
-
-	case "LIST":
-		client.Send(nil, server.name, "CAP", client.nick, subCommand, client.capabilities.String(caps.Cap301, CapValues)) // values not sent on LIST so force 3.1
-
-	case "REQ":
-		if !client.registered {
-			client.capState = CapNegotiating
-		}
-
-		// make sure all capabilities actually exist
-		for _, capability := range capabilities.List() {
-			if !SupportedCapabilities.Has(capability) {
-				client.Send(nil, server.name, "CAP", client.nick, "NAK", capString)
-				return false
-			}
-		}
-		client.capabilities.Enable(capabilities.List()...)
-		client.Send(nil, server.name, "CAP", client.nick, "ACK", capString)
-
-	case "END":
-		if !client.registered {
-			client.capState = CapNegotiated
-			server.tryRegister(client)
-		}
-
-	default:
-		client.Send(nil, server.name, ERR_INVALIDCAPCMD, client.nick, subCommand, client.t("Invalid CAP subcommand"))
-	}
-	return false
-}

irc/chanserv.go

@@ -8,16 +8,9 @@ import (
 	"strings"
 
 	"github.com/goshuirc/irc-go/ircfmt"
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/sno"
 )
 
-// csHandler handles the /CS and /CHANSERV commands
-func csHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	server.chanservReceivePrivmsg(client, strings.Join(msg.Params, " "))
-	return false
-}
-
 func (server *Server) chanservReceiveNotice(client *Client, message string) {
 	// do nothing
 }

irc/debug.go

@@ -1,76 +0,0 @@
-// Copyright (c) 2012-2014 Jeremy Latt
-// Copyright (c) 2016 Daniel Oaks <daniel@danieloaks.net>
-// released under the MIT license
-
-package irc
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"runtime/debug"
-	"runtime/pprof"
-	"time"
-
-	"github.com/goshuirc/irc-go/ircmsg"
-)
-
-// DEBUG GCSTATS/NUMGOROUTINE/etc
-func debugHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	if !client.flags[Operator] {
-		return false
-	}
-
-	switch msg.Params[0] {
-	case "GCSTATS":
-		stats := debug.GCStats{
-			Pause:          make([]time.Duration, 10),
-			PauseQuantiles: make([]time.Duration, 5),
-		}
-		debug.ReadGCStats(&stats)
-
-		client.Notice(fmt.Sprintf("last GC:     %s", stats.LastGC.Format(time.RFC1123)))
-		client.Notice(fmt.Sprintf("num GC:      %d", stats.NumGC))
-		client.Notice(fmt.Sprintf("pause total: %s", stats.PauseTotal))
-		client.Notice(fmt.Sprintf("pause quantiles min%%: %s", stats.PauseQuantiles[0]))
-		client.Notice(fmt.Sprintf("pause quantiles 25%%:  %s", stats.PauseQuantiles[1]))
-		client.Notice(fmt.Sprintf("pause quantiles 50%%:  %s", stats.PauseQuantiles[2]))
-		client.Notice(fmt.Sprintf("pause quantiles 75%%:  %s", stats.PauseQuantiles[3]))
-		client.Notice(fmt.Sprintf("pause quantiles max%%: %s", stats.PauseQuantiles[4]))
-
-	case "NUMGOROUTINE":
-		count := runtime.NumGoroutine()
-		client.Notice(fmt.Sprintf("num goroutines: %d", count))
-
-	case "PROFILEHEAP":
-		profFile := "oragono.mprof"
-		file, err := os.Create(profFile)
-		if err != nil {
-			client.Notice(fmt.Sprintf("error: %s", err))
-			break
-		}
-		defer file.Close()
-		pprof.Lookup("heap").WriteTo(file, 0)
-		client.Notice(fmt.Sprintf("written to %s", profFile))
-
-	case "STARTCPUPROFILE":
-		profFile := "oragono.prof"
-		file, err := os.Create(profFile)
-		if err != nil {
-			client.Notice(fmt.Sprintf("error: %s", err))
-			break
-		}
-		if err := pprof.StartCPUProfile(file); err != nil {
-			defer file.Close()
-			client.Notice(fmt.Sprintf("error: %s", err))
-			break
-		}
-
-		client.Notice(fmt.Sprintf("CPU profile writing to %s", profFile))
-
-	case "STOPCPUPROFILE":
-		pprof.StopCPUProfile()
-		client.Notice(fmt.Sprintf("CPU profiling stopped"))
-	}
-	return false
-}

irc/dline.go

@@ -7,18 +7,11 @@ import (
 	"errors"
 	"fmt"
 	"net"
-	"sort"
 	"sync"
 	"time"
 
-	"strings"
-
 	"encoding/json"
 
-	"github.com/goshuirc/irc-go/ircfmt"
-	"github.com/goshuirc/irc-go/ircmsg"
-	"github.com/oragono/oragono/irc/custime"
-	"github.com/oragono/oragono/irc/sno"
 	"github.com/tidwall/buntdb"
 )
 
@@ -216,270 +209,6 @@ func (dm *DLineManager) CheckIP(addr net.IP) (isBanned bool, info *IPBanInfo) {
 	return false, nil
 }
 
-// DLINE [ANDKILL] [MYSELF] [duration] <ip>/<net> [ON <server>] [reason [| oper reason]]
-// DLINE LIST
-func dlineHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// check oper permissions
-	if !client.class.Capabilities["oper:local_ban"] {
-		client.Send(nil, server.name, ERR_NOPRIVS, client.nick, msg.Command, client.t("Insufficient oper privs"))
-		return false
-	}
-
-	currentArg := 0
-
-	// if they say LIST, we just list the current dlines
-	if len(msg.Params) == currentArg+1 && strings.ToLower(msg.Params[currentArg]) == "list" {
-		bans := server.dlines.AllBans()
-
-		if len(bans) == 0 {
-			client.Notice(client.t("No DLINEs have been set!"))
-		}
-
-		for key, info := range bans {
-			client.Notice(fmt.Sprintf(client.t("Ban - %[1]s - added by %[2]s - %[3]s"), key, info.OperName, info.BanMessage("%s")))
-		}
-
-		return false
-	}
-
-	// when setting a ban, if they say "ANDKILL" we should also kill all users who match it
-	var andKill bool
-	if len(msg.Params) > currentArg+1 && strings.ToLower(msg.Params[currentArg]) == "andkill" {
-		andKill = true
-		currentArg++
-	}
-
-	// when setting a ban that covers the oper's current connection, we require them to say
-	// "DLINE MYSELF" so that we're sure they really mean it.
-	var dlineMyself bool
-	if len(msg.Params) > currentArg+1 && strings.ToLower(msg.Params[currentArg]) == "myself" {
-		dlineMyself = true
-		currentArg++
-	}
-
-	// duration
-	duration, err := custime.ParseDuration(msg.Params[currentArg])
-	durationIsUsed := err == nil
-	if durationIsUsed {
-		currentArg++
-	}
-
-	// get host
-	if len(msg.Params) < currentArg+1 {
-		client.Send(nil, server.name, ERR_NEEDMOREPARAMS, client.nick, msg.Command, client.t("Not enough parameters"))
-		return false
-	}
-	hostString := msg.Params[currentArg]
-	currentArg++
-
-	// check host
-	var hostAddr net.IP
-	var hostNet *net.IPNet
-
-	_, hostNet, err = net.ParseCIDR(hostString)
-	if err != nil {
-		hostAddr = net.ParseIP(hostString)
-	}
-
-	if hostAddr == nil && hostNet == nil {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("Could not parse IP address or CIDR network"))
-		return false
-	}
-
-	if hostNet == nil {
-		hostString = hostAddr.String()
-		if !dlineMyself && hostAddr.Equal(client.IP()) {
-			client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("This ban matches you. To DLINE yourself, you must use the command:  /DLINE MYSELF <arguments>"))
-			return false
-		}
-	} else {
-		hostString = hostNet.String()
-		if !dlineMyself && hostNet.Contains(client.IP()) {
-			client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("This ban matches you. To DLINE yourself, you must use the command:  /DLINE MYSELF <arguments>"))
-			return false
-		}
-	}
-
-	// check remote
-	if len(msg.Params) > currentArg && msg.Params[currentArg] == "ON" {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("Remote servers not yet supported"))
-		return false
-	}
-
-	// get comment(s)
-	reason := "No reason given"
-	operReason := "No reason given"
-	if len(msg.Params) > currentArg {
-		tempReason := strings.TrimSpace(msg.Params[currentArg])
-		if len(tempReason) > 0 && tempReason != "|" {
-			tempReasons := strings.SplitN(tempReason, "|", 2)
-			if tempReasons[0] != "" {
-				reason = tempReasons[0]
-			}
-			if len(tempReasons) > 1 && tempReasons[1] != "" {
-				operReason = tempReasons[1]
-			} else {
-				operReason = reason
-			}
-		}
-	}
-	operName := client.operName
-	if operName == "" {
-		operName = server.name
-	}
-
-	// assemble ban info
-	var banTime *IPRestrictTime
-	if durationIsUsed {
-		banTime = &IPRestrictTime{
-			Duration: duration,
-			Expires:  time.Now().Add(duration),
-		}
-	}
-
-	info := IPBanInfo{
-		Reason:     reason,
-		OperReason: operReason,
-		OperName:   operName,
-		Time:       banTime,
-	}
-
-	// save in datastore
-	err = server.store.Update(func(tx *buntdb.Tx) error {
-		dlineKey := fmt.Sprintf(keyDlineEntry, hostString)
-
-		// assemble json from ban info
-		b, err := json.Marshal(info)
-		if err != nil {
-			return err
-		}
-
-		tx.Set(dlineKey, string(b), nil)
-
-		return nil
-	})
-
-	if err != nil {
-		client.Notice(fmt.Sprintf(client.t("Could not successfully save new D-LINE: %s"), err.Error()))
-		return false
-	}
-
-	if hostNet == nil {
-		server.dlines.AddIP(hostAddr, banTime, reason, operReason, operName)
-	} else {
-		server.dlines.AddNetwork(*hostNet, banTime, reason, operReason, operName)
-	}
-
-	var snoDescription string
-	if durationIsUsed {
-		client.Notice(fmt.Sprintf(client.t("Added temporary (%[1]s) D-Line for %[2]s"), duration.String(), hostString))
-		snoDescription = fmt.Sprintf(ircfmt.Unescape("%s [%s]$r added temporary (%s) D-Line for %s"), client.nick, operName, duration.String(), hostString)
-	} else {
-		client.Notice(fmt.Sprintf(client.t("Added D-Line for %s"), hostString))
-		snoDescription = fmt.Sprintf(ircfmt.Unescape("%s [%s]$r added D-Line for %s"), client.nick, operName, hostString)
-	}
-	server.snomasks.Send(sno.LocalXline, snoDescription)
-
-	var killClient bool
-	if andKill {
-		var clientsToKill []*Client
-		var killedClientNicks []string
-		var toKill bool
-
-		for _, mcl := range server.clients.AllClients() {
-			if hostNet == nil {
-				toKill = hostAddr.Equal(mcl.IP())
-			} else {
-				toKill = hostNet.Contains(mcl.IP())
-			}
-
-			if toKill {
-				clientsToKill = append(clientsToKill, mcl)
-				killedClientNicks = append(killedClientNicks, mcl.nick)
-			}
-		}
-
-		for _, mcl := range clientsToKill {
-			mcl.exitedSnomaskSent = true
-			mcl.Quit(fmt.Sprintf(mcl.t("You have been banned from this server (%s)"), reason))
-			if mcl == client {
-				killClient = true
-			} else {
-				// if mcl == client, we kill them below
-				mcl.destroy(false)
-			}
-		}
-
-		// send snomask
-		sort.Strings(killedClientNicks)
-		server.snomasks.Send(sno.LocalKills, fmt.Sprintf(ircfmt.Unescape("%s [%s] killed %d clients with a DLINE $c[grey][$r%s$c[grey]]"), client.nick, operName, len(killedClientNicks), strings.Join(killedClientNicks, ", ")))
-	}
-
-	return killClient
-}
-
-func unDLineHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// check oper permissions
-	if !client.class.Capabilities["oper:local_unban"] {
-		client.Send(nil, server.name, ERR_NOPRIVS, client.nick, msg.Command, client.t("Insufficient oper privs"))
-		return false
-	}
-
-	// get host
-	hostString := msg.Params[0]
-
-	// check host
-	var hostAddr net.IP
-	var hostNet *net.IPNet
-
-	_, hostNet, err := net.ParseCIDR(hostString)
-	if err != nil {
-		hostAddr = net.ParseIP(hostString)
-	}
-
-	if hostAddr == nil && hostNet == nil {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("Could not parse IP address or CIDR network"))
-		return false
-	}
-
-	if hostNet == nil {
-		hostString = hostAddr.String()
-	} else {
-		hostString = hostNet.String()
-	}
-
-	// save in datastore
-	err = server.store.Update(func(tx *buntdb.Tx) error {
-		dlineKey := fmt.Sprintf(keyDlineEntry, hostString)
-
-		// check if it exists or not
-		val, err := tx.Get(dlineKey)
-		if val == "" {
-			return errNoExistingBan
-		} else if err != nil {
-			return err
-		}
-
-		tx.Delete(dlineKey)
-		return nil
-	})
-
-	if err != nil {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, fmt.Sprintf(client.t("Could not remove ban [%s]"), err.Error()))
-		return false
-	}
-
-	if hostNet == nil {
-		server.dlines.RemoveIP(hostAddr)
-	} else {
-		server.dlines.RemoveNetwork(*hostNet)
-	}
-
-	client.Notice(fmt.Sprintf(client.t("Removed D-Line for %s"), hostString))
-	server.snomasks.Send(sno.LocalXline, fmt.Sprintf(ircfmt.Unescape("%s$r removed D-Line for %s"), client.nick, hostString))
-	return false
-}
-
 func (s *Server) loadDLines() {
 	s.dlines = NewDLineManager()
 

irc/gateways.go

@@ -9,11 +9,9 @@ import (
 	"errors"
 	"fmt"
 	"net"
-	"strings"
 
 	"github.com/oragono/oragono/irc/passwd"
 
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/utils"
 )
 
@@ -62,78 +60,6 @@ func isGatewayAllowed(addr net.Addr, gatewaySpec string) bool {
 	return gatewayNet.Contains(ip)
 }
 
-// WEBIRC <password> <gateway> <hostname> <ip> [:flag1 flag2=x flag3]
-func webircHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// only allow unregistered clients to use this command
-	if client.registered || client.proxiedIP != nil {
-		return false
-	}
-
-	// process flags
-	var secure bool
-	if 4 < len(msg.Params) {
-		for _, x := range strings.Split(msg.Params[4], " ") {
-			// split into key=value
-			var key string
-			if strings.Contains(x, "=") {
-				y := strings.SplitN(x, "=", 2)
-				key, _ = y[0], y[1]
-			} else {
-				key = x
-			}
-
-			lkey := strings.ToLower(key)
-			if lkey == "tls" || lkey == "secure" {
-				// only accept "tls" flag if the gateway's connection to us is secure as well
-				if client.flags[TLS] || utils.AddrIsLocal(client.socket.conn.RemoteAddr()) {
-					secure = true
-				}
-			}
-		}
-	}
-
-	for _, info := range server.WebIRCConfig() {
-		for _, gateway := range info.Hosts {
-			if isGatewayAllowed(client.socket.conn.RemoteAddr(), gateway) {
-				// confirm password and/or fingerprint
-				givenPassword := msg.Params[0]
-				if 0 < len(info.Password) && passwd.ComparePasswordString(info.Password, givenPassword) != nil {
-					continue
-				}
-				if 0 < len(info.Fingerprint) && client.certfp != info.Fingerprint {
-					continue
-				}
-
-				proxiedIP := msg.Params[3]
-				return client.ApplyProxiedIP(proxiedIP, secure)
-			}
-		}
-	}
-
-	client.Quit(client.t("WEBIRC command is not usable from your address or incorrect password given"))
-	return true
-}
-
-// PROXY TCP4/6 SOURCEIP DESTIP SOURCEPORT DESTPORT
-// http://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
-func proxyHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// only allow unregistered clients to use this command
-	if client.registered || client.proxiedIP != nil {
-		return false
-	}
-
-	for _, gateway := range server.ProxyAllowedFrom() {
-		if isGatewayAllowed(client.socket.conn.RemoteAddr(), gateway) {
-			proxiedIP := msg.Params[1]
-
-			// assume PROXY connections are always secure
-			return client.ApplyProxiedIP(proxiedIP, true)
-		}
-	}
-	client.Quit(client.t("PROXY command is not usable from your address"))
-	return true
-}
-
 // ApplyProxiedIP applies the given IP to the client.
 func (client *Client) ApplyProxiedIP(proxiedIP string, tls bool) (exiting bool) {
 	// ensure IP is sane

irc/help.go

@@ -7,8 +7,6 @@ import (
 	"fmt"
 	"sort"
 	"strings"
-
-	"github.com/goshuirc/irc-go/ircmsg"
 )
 
 // HelpEntryType represents the different sorts of help entries that can exist.
@@ -687,41 +685,3 @@ func GetHelpIndex(languages []string, helpIndex map[string]string) string {
 	// 'en' always exists
 	return helpIndex["en"]
 }
-
-// helpHandler returns the appropriate help for the given query.
-func helpHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	argument := strings.ToLower(strings.TrimSpace(strings.Join(msg.Params, " ")))
-
-	if len(argument) < 1 {
-		client.sendHelp("HELPOP", client.t(`HELPOP <argument>
-
-Get an explanation of <argument>, or "index" for a list of help topics.`))
-		return false
-	}
-
-	// handle index
-	if argument == "index" {
-		if client.flags[Operator] {
-			client.sendHelp("HELP", GetHelpIndex(client.languages, HelpIndexOpers))
-		} else {
-			client.sendHelp("HELP", GetHelpIndex(client.languages, HelpIndex))
-		}
-		return false
-	}
-
-	helpHandler, exists := Help[argument]
-
-	if exists && (!helpHandler.oper || (helpHandler.oper && client.flags[Operator])) {
-		if helpHandler.textGenerator != nil {
-			client.sendHelp(strings.ToUpper(argument), client.t(helpHandler.textGenerator(client)))
-		} else {
-			client.sendHelp(strings.ToUpper(argument), client.t(helpHandler.text))
-		}
-	} else {
-		args := msg.Params
-		args = append(args, client.t("Help not found"))
-		client.Send(nil, server.name, ERR_HELPNOTFOUND, args...)
-	}
-
-	return false
-}

irc/kline.go

@@ -5,17 +5,9 @@ package irc
 
 import (
 	"encoding/json"
-	"fmt"
-	"sort"
-	"strings"
 	"sync"
-	"time"
 
-	"github.com/goshuirc/irc-go/ircfmt"
 	"github.com/goshuirc/irc-go/ircmatch"
-	"github.com/goshuirc/irc-go/ircmsg"
-	"github.com/oragono/oragono/irc/custime"
-	"github.com/oragono/oragono/irc/sno"
 	"github.com/tidwall/buntdb"
 )
 
@@ -127,233 +119,6 @@ func (km *KLineManager) CheckMasks(masks ...string) (isBanned bool, info *IPBanI
 	return false, nil
 }
 
-// KLINE [ANDKILL] [MYSELF] [duration] <mask> [ON <server>] [reason [| oper reason]]
-// KLINE LIST
-func klineHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// check oper permissions
-	if !client.class.Capabilities["oper:local_ban"] {
-		client.Send(nil, server.name, ERR_NOPRIVS, client.nick, msg.Command, client.t("Insufficient oper privs"))
-		return false
-	}
-
-	currentArg := 0
-
-	// if they say LIST, we just list the current klines
-	if len(msg.Params) == currentArg+1 && strings.ToLower(msg.Params[currentArg]) == "list" {
-		bans := server.klines.AllBans()
-
-		if len(bans) == 0 {
-			client.Notice("No KLINEs have been set!")
-		}
-
-		for key, info := range bans {
-			client.Notice(fmt.Sprintf(client.t("Ban - %s - added by %s - %s"), key, info.OperName, info.BanMessage("%s")))
-		}
-
-		return false
-	}
-
-	// when setting a ban, if they say "ANDKILL" we should also kill all users who match it
-	var andKill bool
-	if len(msg.Params) > currentArg+1 && strings.ToLower(msg.Params[currentArg]) == "andkill" {
-		andKill = true
-		currentArg++
-	}
-
-	// when setting a ban that covers the oper's current connection, we require them to say
-	// "KLINE MYSELF" so that we're sure they really mean it.
-	var klineMyself bool
-	if len(msg.Params) > currentArg+1 && strings.ToLower(msg.Params[currentArg]) == "myself" {
-		klineMyself = true
-		currentArg++
-	}
-
-	// duration
-	duration, err := custime.ParseDuration(msg.Params[currentArg])
-	durationIsUsed := err == nil
-	if durationIsUsed {
-		currentArg++
-	}
-
-	// get mask
-	if len(msg.Params) < currentArg+1 {
-		client.Send(nil, server.name, ERR_NEEDMOREPARAMS, client.nick, msg.Command, client.t("Not enough parameters"))
-		return false
-	}
-	mask := strings.ToLower(msg.Params[currentArg])
-	currentArg++
-
-	// check mask
-	if !strings.Contains(mask, "!") && !strings.Contains(mask, "@") {
-		mask = mask + "!*@*"
-	} else if !strings.Contains(mask, "@") {
-		mask = mask + "@*"
-	}
-
-	matcher := ircmatch.MakeMatch(mask)
-
-	for _, clientMask := range client.AllNickmasks() {
-		if !klineMyself && matcher.Match(clientMask) {
-			client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("This ban matches you. To KLINE yourself, you must use the command:  /KLINE MYSELF <arguments>"))
-			return false
-		}
-	}
-
-	// check remote
-	if len(msg.Params) > currentArg && msg.Params[currentArg] == "ON" {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, client.t("Remote servers not yet supported"))
-		return false
-	}
-
-	// get oper name
-	operName := client.operName
-	if operName == "" {
-		operName = server.name
-	}
-
-	// get comment(s)
-	reason := "No reason given"
-	operReason := "No reason given"
-	if len(msg.Params) > currentArg {
-		tempReason := strings.TrimSpace(msg.Params[currentArg])
-		if len(tempReason) > 0 && tempReason != "|" {
-			tempReasons := strings.SplitN(tempReason, "|", 2)
-			if tempReasons[0] != "" {
-				reason = tempReasons[0]
-			}
-			if len(tempReasons) > 1 && tempReasons[1] != "" {
-				operReason = tempReasons[1]
-			} else {
-				operReason = reason
-			}
-		}
-	}
-
-	// assemble ban info
-	var banTime *IPRestrictTime
-	if durationIsUsed {
-		banTime = &IPRestrictTime{
-			Duration: duration,
-			Expires:  time.Now().Add(duration),
-		}
-	}
-
-	info := IPBanInfo{
-		Reason:     reason,
-		OperReason: operReason,
-		OperName:   operName,
-		Time:       banTime,
-	}
-
-	// save in datastore
-	err = server.store.Update(func(tx *buntdb.Tx) error {
-		klineKey := fmt.Sprintf(keyKlineEntry, mask)
-
-		// assemble json from ban info
-		b, err := json.Marshal(info)
-		if err != nil {
-			return err
-		}
-
-		tx.Set(klineKey, string(b), nil)
-
-		return nil
-	})
-
-	if err != nil {
-		client.Notice(fmt.Sprintf(client.t("Could not successfully save new K-LINE: %s"), err.Error()))
-		return false
-	}
-
-	server.klines.AddMask(mask, banTime, reason, operReason, operName)
-
-	var snoDescription string
-	if durationIsUsed {
-		client.Notice(fmt.Sprintf(client.t("Added temporary (%[1]s) K-Line for %[2]s"), duration.String(), mask))
-		snoDescription = fmt.Sprintf(ircfmt.Unescape("%s [%s]$r added temporary (%s) K-Line for %s"), client.nick, operName, duration.String(), mask)
-	} else {
-		client.Notice(fmt.Sprintf(client.t("Added K-Line for %s"), mask))
-		snoDescription = fmt.Sprintf(ircfmt.Unescape("%s [%s]$r added K-Line for %s"), client.nick, operName, mask)
-	}
-	server.snomasks.Send(sno.LocalXline, snoDescription)
-
-	var killClient bool
-	if andKill {
-		var clientsToKill []*Client
-		var killedClientNicks []string
-
-		for _, mcl := range server.clients.AllClients() {
-			for _, clientMask := range mcl.AllNickmasks() {
-				if matcher.Match(clientMask) {
-					clientsToKill = append(clientsToKill, mcl)
-					killedClientNicks = append(killedClientNicks, mcl.nick)
-				}
-			}
-		}
-
-		for _, mcl := range clientsToKill {
-			mcl.exitedSnomaskSent = true
-			mcl.Quit(fmt.Sprintf(mcl.t("You have been banned from this server (%s)"), reason))
-			if mcl == client {
-				killClient = true
-			} else {
-				// if mcl == client, we kill them below
-				mcl.destroy(false)
-			}
-		}
-
-		// send snomask
-		sort.Strings(killedClientNicks)
-		server.snomasks.Send(sno.LocalKills, fmt.Sprintf(ircfmt.Unescape("%s [%s] killed %d clients with a KLINE $c[grey][$r%s$c[grey]]"), client.nick, operName, len(killedClientNicks), strings.Join(killedClientNicks, ", ")))
-	}
-
-	return killClient
-}
-
-func unKLineHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	// check oper permissions
-	if !client.class.Capabilities["oper:local_unban"] {
-		client.Send(nil, server.name, ERR_NOPRIVS, client.nick, msg.Command, client.t("Insufficient oper privs"))
-		return false
-	}
-
-	// get host
-	mask := msg.Params[0]
-
-	if !strings.Contains(mask, "!") && !strings.Contains(mask, "@") {
-		mask = mask + "!*@*"
-	} else if !strings.Contains(mask, "@") {
-		mask = mask + "@*"
-	}
-
-	// save in datastore
-	err := server.store.Update(func(tx *buntdb.Tx) error {
-		klineKey := fmt.Sprintf(keyKlineEntry, mask)
-
-		// check if it exists or not
-		val, err := tx.Get(klineKey)
-		if val == "" {
-			return errNoExistingBan
-		} else if err != nil {
-			return err
-		}
-
-		tx.Delete(klineKey)
-		return nil
-	})
-
-	if err != nil {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.nick, msg.Command, fmt.Sprintf(client.t("Could not remove ban [%s]"), err.Error()))
-		return false
-	}
-
-	server.klines.RemoveMask(mask)
-
-	client.Notice(fmt.Sprintf(client.t("Removed K-Line for %s"), mask))
-	server.snomasks.Send(sno.LocalXline, fmt.Sprintf(ircfmt.Unescape("%s$r removed K-Line for %s"), client.nick, mask))
-	return false
-}
-
 func (s *Server) loadKLines() {
 	s.klines = NewKLineManager()
 

irc/modes.go

@@ -9,7 +9,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/sno"
 )
 
@@ -209,16 +208,6 @@ func GetLowestChannelModePrefix(prefixes string) *Mode {
 // commands
 //
 
-// MODE <target> [<modestring> [<mode arguments>...]]
-func modeHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	_, errChan := CasefoldChannel(msg.Params[0])
-
-	if errChan == nil {
-		return cmodeHandler(server, client, msg)
-	}
-	return umodeHandler(server, client, msg)
-}
-
 // ParseUserModeChanges returns the valid changes, and the list of unknown chars.
 func ParseUserModeChanges(params ...string) (ModeChanges, map[rune]bool) {
 	changes := make(ModeChanges, 0)
@@ -324,63 +313,6 @@ func (client *Client) applyUserModeChanges(force bool, changes ModeChanges) Mode
 	return applied
 }
 
-// MODE <target> [<modestring> [<mode arguments>...]]
-func umodeHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	nickname, err := CasefoldName(msg.Params[0])
-	target := server.clients.Get(nickname)
-	if err != nil || target == nil {
-		if len(msg.Params[0]) > 0 {
-			client.Send(nil, server.name, ERR_NOSUCHNICK, client.nick, msg.Params[0], client.t("No such nick"))
-		}
-		return false
-	}
-
-	targetNick := target.Nick()
-	hasPrivs := client == target || msg.Command == "SAMODE"
-
-	if !hasPrivs {
-		if len(msg.Params) > 1 {
-			client.Send(nil, server.name, ERR_USERSDONTMATCH, client.nick, client.t("Can't change modes for other users"))
-		} else {
-			client.Send(nil, server.name, ERR_USERSDONTMATCH, client.nick, client.t("Can't view modes for other users"))
-		}
-		return false
-	}
-
-	// applied mode changes
-	applied := make(ModeChanges, 0)
-
-	if 1 < len(msg.Params) {
-		// parse out real mode changes
-		params := msg.Params[1:]
-		changes, unknown := ParseUserModeChanges(params...)
-
-		// alert for unknown mode changes
-		for char := range unknown {
-			client.Send(nil, server.name, ERR_UNKNOWNMODE, client.nick, string(char), client.t("is an unknown mode character to me"))
-		}
-		if len(unknown) == 1 && len(changes) == 0 {
-			return false
-		}
-
-		// apply mode changes
-		applied = target.applyUserModeChanges(msg.Command == "SAMODE", changes)
-	}
-
-	if len(applied) > 0 {
-		client.Send(nil, client.nickMaskString, "MODE", targetNick, applied.String())
-	} else if hasPrivs {
-		client.Send(nil, target.nickMaskString, RPL_UMODEIS, targetNick, target.ModeString())
-		if client.flags[LocalOperator] || client.flags[Operator] {
-			masks := server.snomasks.String(client)
-			if 0 < len(masks) {
-				client.Send(nil, target.nickMaskString, RPL_SNOMASKIS, targetNick, masks, client.t("Server notice masks"))
-			}
-		}
-	}
-	return false
-}
-
 // ParseDefaultChannelModes parses the `default-modes` line of the config
 func ParseDefaultChannelModes(config *Config) Modes {
 	if config.Channels.DefaultModes == nil {
@@ -605,64 +537,3 @@ func (channel *Channel) ApplyChannelModeChanges(client *Client, isSamode bool, c
 
 	return applied
 }
-
-// MODE <target> [<modestring> [<mode arguments>...]]
-func cmodeHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	channelName, err := CasefoldChannel(msg.Params[0])
-	channel := server.channels.Get(channelName)
-
-	if err != nil || channel == nil {
-		client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, msg.Params[0], client.t("No such channel"))
-		return false
-	}
-
-	// applied mode changes
-	applied := make(ModeChanges, 0)
-
-	if 1 < len(msg.Params) {
-		// parse out real mode changes
-		params := msg.Params[1:]
-		changes, unknown := ParseChannelModeChanges(params...)
-
-		// alert for unknown mode changes
-		for char := range unknown {
-			client.Send(nil, server.name, ERR_UNKNOWNMODE, client.nick, string(char), client.t("is an unknown mode character to me"))
-		}
-		if len(unknown) == 1 && len(changes) == 0 {
-			return false
-		}
-
-		// apply mode changes
-		applied = channel.ApplyChannelModeChanges(client, msg.Command == "SAMODE", changes)
-	}
-
-	// save changes to banlist/exceptlist/invexlist
-	var banlistUpdated, exceptlistUpdated, invexlistUpdated bool
-	for _, change := range applied {
-		if change.mode == BanMask {
-			banlistUpdated = true
-		} else if change.mode == ExceptMask {
-			exceptlistUpdated = true
-		} else if change.mode == InviteMask {
-			invexlistUpdated = true
-		}
-	}
-
-	if (banlistUpdated || exceptlistUpdated || invexlistUpdated) && channel.IsRegistered() {
-		go server.channelRegistry.StoreChannel(channel, true)
-	}
-
-	// send out changes
-	if len(applied) > 0 {
-		//TODO(dan): we should change the name of String and make it return a slice here
-		args := append([]string{channel.name}, strings.Split(applied.String(), " ")...)
-		for _, member := range channel.Members() {
-			member.Send(nil, client.nickMaskString, "MODE", args...)
-		}
-	} else {
-		args := append([]string{client.nick, channel.name}, channel.modeStrings(client)...)
-		client.Send(nil, client.nickMaskString, RPL_CHANNELMODEIS, args...)
-		client.Send(nil, client.nickMaskString, RPL_CHANNELCREATED, client.nick, channel.name, strconv.FormatInt(channel.createdTime.Unix(), 10))
-	}
-	return false
-}

irc/monitor.go

@@ -5,12 +5,9 @@ package irc
 
 import (
 	"errors"
-	"strconv"
-	"strings"
 	"sync"
 
 	"github.com/goshuirc/irc-go/ircmsg"
-	"github.com/oragono/oragono/irc/utils"
 )
 
 // MonitorManager keeps track of who's monitoring which nicks.
@@ -118,138 +115,3 @@ var (
 		"s": monitorStatusHandler,
 	}
 )
-
-func monitorHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	handler, exists := metadataSubcommands[strings.ToLower(msg.Params[0])]
-
-	if !exists {
-		client.Send(nil, server.name, ERR_UNKNOWNERROR, client.Nick(), "MONITOR", msg.Params[0], client.t("Unknown subcommand"))
-		return false
-	}
-
-	return handler(server, client, msg)
-}
-
-func monitorRemoveHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	if len(msg.Params) < 2 {
-		client.Send(nil, server.name, ERR_NEEDMOREPARAMS, client.Nick(), msg.Command, client.t("Not enough parameters"))
-		return false
-	}
-
-	targets := strings.Split(msg.Params[1], ",")
-	for _, target := range targets {
-		cfnick, err := CasefoldName(target)
-		if err != nil {
-			continue
-		}
-		server.monitorManager.Remove(client, cfnick)
-	}
-
-	return false
-}
-
-func monitorAddHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	if len(msg.Params) < 2 {
-		client.Send(nil, server.name, ERR_NEEDMOREPARAMS, client.Nick(), msg.Command, client.t("Not enough parameters"))
-		return false
-	}
-
-	var online []string
-	var offline []string
-
-	limit := server.Limits().MonitorEntries
-
-	targets := strings.Split(msg.Params[1], ",")
-	for _, target := range targets {
-		// check name length
-		if len(target) < 1 || len(targets) > server.limits.NickLen {
-			continue
-		}
-
-		// add target
-		casefoldedTarget, err := CasefoldName(target)
-		if err != nil {
-			continue
-		}
-
-		err = server.monitorManager.Add(client, casefoldedTarget, limit)
-		if err == ErrMonitorLimitExceeded {
-			client.Send(nil, server.name, ERR_MONLISTFULL, client.Nick(), strconv.Itoa(server.limits.MonitorEntries), strings.Join(targets, ","))
-			break
-		} else if err != nil {
-			continue
-		}
-
-		// add to online / offline lists
-		if targetClient := server.clients.Get(casefoldedTarget); targetClient == nil {
-			offline = append(offline, target)
-		} else {
-			online = append(online, targetClient.Nick())
-		}
-	}
-
-	if len(online) > 0 {
-		client.Send(nil, server.name, RPL_MONONLINE, client.Nick(), strings.Join(online, ","))
-	}
-	if len(offline) > 0 {
-		client.Send(nil, server.name, RPL_MONOFFLINE, client.Nick(), strings.Join(offline, ","))
-	}
-
-	return false
-}
-
-func monitorClearHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	server.monitorManager.RemoveAll(client)
-	return false
-}
-
-func monitorListHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	monitorList := server.monitorManager.List(client)
-
-	var nickList []string
-	for _, cfnick := range monitorList {
-		replynick := cfnick
-		// report the uncasefolded nick if it's available, i.e., the client is online
-		if mclient := server.clients.Get(cfnick); mclient != nil {
-			replynick = mclient.Nick()
-		}
-		nickList = append(nickList, replynick)
-	}
-
-	for _, line := range utils.ArgsToStrings(maxLastArgLength, nickList, ",") {
-		client.Send(nil, server.name, RPL_MONLIST, client.Nick(), line)
-	}
-
-	client.Send(nil, server.name, RPL_ENDOFMONLIST, "End of MONITOR list")
-
-	return false
-}
-
-func monitorStatusHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	var online []string
-	var offline []string
-
-	monitorList := server.monitorManager.List(client)
-
-	for _, name := range monitorList {
-		target := server.clients.Get(name)
-		if target == nil {
-			offline = append(offline, name)
-		} else {
-			online = append(online, target.Nick())
-		}
-	}
-
-	if len(online) > 0 {
-		for _, line := range utils.ArgsToStrings(maxLastArgLength, online, ",") {
-			client.Send(nil, server.name, RPL_MONONLINE, client.Nick(), line)
-		}
-	}
-	if len(offline) > 0 {
-		for _, line := range utils.ArgsToStrings(maxLastArgLength, offline, ",") {
-			client.Send(nil, server.name, RPL_MONOFFLINE, client.Nick(), line)
-		}
-	}
-
-	return false
-}

irc/nickname.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/goshuirc/irc-go/ircfmt"
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/sno"
 )
 
@@ -21,16 +20,6 @@ var (
 	}
 )
 
-// NICK <nickname>
-func nickHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	if !client.authorized {
-		client.Quit("Bad password")
-		return true
-	}
-
-	return performNickChange(server, client, client, msg.Params[0])
-}
-
 func performNickChange(server *Server, client *Client, target *Client, newnick string) bool {
 	nickname := strings.TrimSpace(newnick)
 	cfnick, err := CasefoldName(nickname)
@@ -77,14 +66,3 @@ func performNickChange(server *Server, client *Client, target *Client, newnick s
 	}
 	return false
 }
-
-// SANICK <oldnick> <nickname>
-func sanickHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	targetNick := strings.TrimSpace(msg.Params[0])
-	target := server.clients.Get(targetNick)
-	if target == nil {
-		client.Send(nil, server.name, ERR_NOSUCHNICK, client.nick, msg.Params[0], client.t("No such nick"))
-		return false
-	}
-	return performNickChange(server, client, target, msg.Params[1])
-}

irc/nickserv.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/goshuirc/irc-go/ircfmt"
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/passwd"
 	"github.com/oragono/oragono/irc/sno"
 	"github.com/tidwall/buntdb"
@@ -28,12 +27,6 @@ To login to an account:
 Leave out [username password] to use your client certificate fingerprint. Otherwise,
 the given username and password will be used.`
 
-// nsHandler handles the /NS and /NICKSERV commands
-func nsHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	server.nickservReceivePrivmsg(client, strings.Join(msg.Params, " "))
-	return false
-}
-
 func (server *Server) nickservReceiveNotice(client *Client, message string) {
 	// do nothing
 }

irc/roleplay.go

@@ -6,7 +6,6 @@ package irc
 import (
 	"fmt"
 
-	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/caps"
 )
 
@@ -15,54 +14,6 @@ const (
 	sceneNickMask = "=Scene=!%s@npc.fakeuser.invalid"
 )
 
-// SCENE <target> <text to be sent>
-func sceneHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	target := msg.Params[0]
-	message := msg.Params[1]
-	sourceString := fmt.Sprintf(sceneNickMask, client.nick)
-
-	sendRoleplayMessage(server, client, sourceString, target, false, message)
-
-	return false
-}
-
-// NPC <target> <sourcenick> <text to be sent>
-func npcHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	target := msg.Params[0]
-	fakeSource := msg.Params[1]
-	message := msg.Params[2]
-
-	_, err := CasefoldName(fakeSource)
-	if err != nil {
-		client.Send(nil, client.server.name, ERR_CANNOTSENDRP, target, client.t("Fake source must be a valid nickname"))
-		return false
-	}
-
-	sourceString := fmt.Sprintf(npcNickMask, fakeSource, client.nick)
-
-	sendRoleplayMessage(server, client, sourceString, target, false, message)
-
-	return false
-}
-
-// NPCA <target> <sourcenick> <text to be sent>
-func npcaHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	target := msg.Params[0]
-	fakeSource := msg.Params[1]
-	message := msg.Params[2]
-	sourceString := fmt.Sprintf(npcNickMask, fakeSource, client.nick)
-
-	_, err := CasefoldName(fakeSource)
-	if err != nil {
-		client.Send(nil, client.server.name, ERR_CANNOTSENDRP, target, client.t("Fake source must be a valid nickname"))
-		return false
-	}
-
-	sendRoleplayMessage(server, client, sourceString, target, true, message)
-
-	return false
-}
-
 func sendRoleplayMessage(server *Server, client *Client, source string, targetString string, isAction bool, message string) {
 	if isAction {
 		message = fmt.Sprintf("\x01ACTION %s (%s)\x01", message, client.nick)