Merge pull request #1590 from slingamn/ircgo_bump

bump irc-go again

go.mod

 	github.com/go-sql-driver/mysql v1.5.0
 	github.com/go-test/deep v1.0.6 // indirect
 	github.com/gorilla/websocket v1.4.2
-	github.com/goshuirc/irc-go v0.0.0-20210304031553-cf78e9176f96
+	github.com/goshuirc/irc-go v0.0.0-20210311004346-ea7a188a73fe
 	github.com/onsi/ginkgo v1.12.0 // indirect
 	github.com/onsi/gomega v1.9.0 // indirect
 	github.com/oragono/confusables v0.0.0-20201108231250-4ab98ab61fb1

go.sum

 github.com/goshuirc/irc-go v0.0.0-20210301225436-2c4b83d64847/go.mod h1:q/JhvvKLmif3y9q8MDQM+gRCnjEKnu5ClF298TTXJug=
 github.com/goshuirc/irc-go v0.0.0-20210304031553-cf78e9176f96 h1:sihI3HsrJWyS4MtBmxh5W4gDZD34SWodkWyUvJltswY=
 github.com/goshuirc/irc-go v0.0.0-20210304031553-cf78e9176f96/go.mod h1:q/JhvvKLmif3y9q8MDQM+gRCnjEKnu5ClF298TTXJug=
+github.com/goshuirc/irc-go v0.0.0-20210311004346-ea7a188a73fe h1:5UsPgeXJBkFgJK3Ml0nj6ljasjd26xiUxALnDJHmipE=
+github.com/goshuirc/irc-go v0.0.0-20210311004346-ea7a188a73fe/go.mod h1:q/JhvvKLmif3y9q8MDQM+gRCnjEKnu5ClF298TTXJug=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=

irc/client.go

 	return session.SendRawMessage(msg, blocking)
 }
 
-func composeMultilineBatch(batchID, fromNickMask, fromAccount string, tags map[string]string, command, target string, message utils.SplitMessage) (result []ircmsg.IRCMessage) {
+func composeMultilineBatch(batchID, fromNickMask, fromAccount string, tags map[string]string, command, target string, message utils.SplitMessage) (result []ircmsg.Message) {
 	batchStart := ircmsg.MakeMessage(tags, fromNickMask, "BATCH", "+"+batchID, caps.MultilineBatchType, target)
 	batchStart.SetTag("time", message.Time.Format(IRCv3TimestampFormat))
 	batchStart.SetTag("msgid", message.Msgid)
 )
 
 // SendRawMessage sends a raw message to the client.
-func (session *Session) SendRawMessage(message ircmsg.IRCMessage, blocking bool) error {
+func (session *Session) SendRawMessage(message ircmsg.Message, blocking bool) error {
 	// use dumb hack to force the last param to be a trailing param if required
 	config := session.client.server.Config()
 	if config.Server.Compatibility.forceTrailing && commandsThatMustUseTrailing[message.Command] {
 	return session.SendRawMessage(msg, false)
 }
 
-func (session *Session) setTimeTag(msg *ircmsg.IRCMessage, serverTime time.Time) {
+func (session *Session) setTimeTag(msg *ircmsg.Message, serverTime time.Time) {
 	if session.capabilities.Has(caps.ServerTime) && !msg.HasTag("time") {
 		if serverTime.IsZero() {
 			serverTime = time.Now()

irc/commands.go

 
 // Command represents a command accepted from a client.
 type Command struct {
-	handler        func(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool
+	handler        func(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool
 	usablePreReg   bool
 	allowedInBatch bool // allowed in client-to-server batches
 	minParams      int
 }
 
 // Run runs this command with the given client/message.
-func (cmd *Command) Run(server *Server, client *Client, session *Session, msg ircmsg.IRCMessage) (exiting bool) {
+func (cmd *Command) Run(server *Server, client *Client, session *Session, msg ircmsg.Message) (exiting bool) {
 	rb := NewResponseBuffer(session)
 	rb.Label = GetLabel(msg)
 

irc/handlers.go

 }
 
 // AUTHENTICATE [<mechanism>|<data>|*]
-func authenticateHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func authenticateHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	session := rb.session
 	config := server.Config()
 	details := client.Details()
 }
 
 // AWAY [<message>]
-func awayHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func awayHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	var isAway bool
 	var awayMessage string
 	if len(msg.Params) > 0 {
 }
 
 // BATCH {+,-}reference-tag type [params...]
-func batchHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func batchHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	tag := msg.Params[0]
 	fail := false
 	sendErrors := rb.session.batch.command != "NOTICE"
 }
 
 // BRB [message]
-func brbHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func brbHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	success, duration := client.brbTimer.Enable()
 	if !success {
 		rb.Add(nil, server.name, "FAIL", "BRB", "CANNOT_BRB", client.t("Your client does not support BRB"))
 }
 
 // CAP <subcmd> [<caps>]
-func capHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func capHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	details := client.Details()
 	subCommand := strings.ToUpper(msg.Params[0])
 	toAdd := caps.NewSet()
 // e.g., CHATHISTORY #ircv3 AFTER id=ytNBbt565yt4r3err3 10
 // CHATHISTORY <target> BETWEEN <query> <query> <direction> [<limit>]
 // e.g., CHATHISTORY #ircv3 BETWEEN timestamp=YYYY-MM-DDThh:mm:ss.sssZ timestamp=YYYY-MM-DDThh:mm:ss.sssZ + 100
-func chathistoryHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) (exiting bool) {
+func chathistoryHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) (exiting bool) {
 	var items []history.Item
 	unknown_command := false
 	var target string
 }
 
 // DEBUG <subcmd>
-func debugHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func debugHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	param := strings.ToUpper(msg.Params[0])
 
 	switch param {
 	return false
 }
 
-func defconHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func defconHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if len(msg.Params) > 0 {
 		level, err := strconv.Atoi(msg.Params[0])
 		if err == nil && 1 <= level && level <= 5 {
 
 // DLINE [ANDKILL] [MYSELF] [duration] <ip>/<net> [ON <server>] [reason [| oper reason]]
 // DLINE LIST
-func dlineHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func dlineHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	// check oper permissions
 	oper := client.Oper()
 	if !oper.HasRoleCapab("ban") {
 }
 
 // EXTJWT <target> [service_name]
-func extjwtHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func extjwtHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	accountName := client.AccountName()
 	if accountName == "*" {
 		accountName = ""
 
 // HELP [<query>]
 // HELPOP [<query>]
-func helpHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func helpHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if len(msg.Params) == 0 {
 		client.sendHelp("HELPOP", client.t(`HELPOP <argument>
 
 // e.g., HISTORY #ubuntu 10
 // HISTORY me 15
 // HISTORY #darwin 1h
-func historyHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func historyHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	config := server.Config()
 	if !config.History.Enabled {
 		rb.Notice(client.t("This command has been disabled by the server administrators"))
 }
 
 // INFO
-func infoHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func infoHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	nick := client.Nick()
 	// we do the below so that the human-readable lines in info can be translated.
 	for _, line := range infoString1 {
 
 // INVITE <nickname> <channel>
 // UNINVITE <nickname> <channel>
-func inviteHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func inviteHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	invite := msg.Command == "INVITE"
 	nickname := msg.Params[0]
 	channelName := msg.Params[1]
 }
 
 // ISON <nick>{ <nick>}
-func isonHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func isonHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	var nicks = msg.Params
 
 	ison := make([]string, 0, len(msg.Params))
 }
 
 // JOIN <channel>{,<channel>} [<key>{,<key>}]
-func joinHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func joinHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	// #1417: allow `JOIN 0` with a confirmation code
 	if msg.Params[0] == "0" {
 		expectedCode := utils.ConfirmationCode("", rb.session.ctime)
 }
 
 // SAJOIN [nick] #channel{,#channel}
-func sajoinHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func sajoinHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	var target *Client
 	var channelString string
 	if strings.HasPrefix(msg.Params[0], "#") {
 }
 
 // KICK <channel>{,<channel>} <user>{,<user>} [<comment>]
-func kickHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func kickHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	hasPrivs := client.HasRoleCapabs("samode")
 	channels := strings.Split(msg.Params[0], ",")
 	users := strings.Split(msg.Params[1], ",")
 }
 
 // KILL <nickname> <comment>
-func killHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func killHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	nickname := msg.Params[0]
 	comment := "<no reason supplied>"
 	if len(msg.Params) > 1 {
 
 // KLINE [ANDKILL] [MYSELF] [duration] <mask> [ON <server>] [reason [| oper reason]]
 // KLINE LIST
-func klineHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func klineHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	details := client.Details()
 	// check oper permissions
 	oper := client.Oper()
 }
 
 // LANGUAGE <code>{ <code>}
-func languageHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func languageHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	nick := client.Nick()
 	alreadyDoneLanguages := make(map[string]bool)
 	var appliedLanguages []string
 }
 
 // LIST [<channel>{,<channel>}] [<elistcond>{,<elistcond>}]
-func listHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func listHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	config := server.Config()
 	if time.Since(client.ctime) < config.Channels.ListDelay && client.Account() == "" && !client.HasMode(modes.Operator) {
 		remaining := time.Until(client.ctime.Add(config.Channels.ListDelay))
 }
 
 // LUSERS [<mask> [<server>]]
-func lusersHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func lusersHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	server.Lusers(client, rb)
 	return false
 }
 
 // MODE <target> [<modestring> [<mode arguments>...]]
-func modeHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func modeHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if 0 < len(msg.Params[0]) && msg.Params[0][0] == '#' {
 		return cmodeHandler(server, client, msg, rb)
 	}
 }
 
 // MODE <channel> [<modestring> [<mode arguments>...]]
-func cmodeHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func cmodeHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	channel := server.channels.Get(msg.Params[0])
 
 	if channel == nil {
 }
 
 // MODE <client> [<modestring> [<mode arguments>...]]
-func umodeHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func umodeHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	cDetails := client.Details()
 	target := server.clients.Get(msg.Params[0])
 	if target == nil {
 }
 
 // MONITOR <subcmd> [params...]
-func monitorHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func monitorHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	handler, exists := monitorSubcommands[strings.ToLower(msg.Params[0])]
 
 	if !exists {
 }
 
 // MONITOR - <target>{,<target>}
-func monitorRemoveHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func monitorRemoveHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if len(msg.Params) < 2 {
 		rb.Add(nil, server.name, ERR_NEEDMOREPARAMS, client.Nick(), msg.Command, client.t("Not enough parameters"))
 		return false
 }
 
 // MONITOR + <target>{,<target>}
-func monitorAddHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func monitorAddHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if len(msg.Params) < 2 {
 		rb.Add(nil, server.name, ERR_NEEDMOREPARAMS, client.Nick(), msg.Command, client.t("Not enough parameters"))
 		return false
 }
 
 // MONITOR C
-func monitorClearHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func monitorClearHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	server.monitorManager.RemoveAll(rb.session)
 	return false
 }
 
 // MONITOR L
-func monitorListHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func monitorListHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	nick := client.Nick()
 	monitorList := server.monitorManager.List(rb.session)
 
 }
 
 // MONITOR S
-func monitorStatusHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func monitorStatusHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	var online []string
 	var offline []string
 
 }
 
 // MOTD
-func motdHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func motdHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	server.MOTD(client, rb)
 	return false
 }
 
 // NAMES [<channel>{,<channel>} [target]]
-func namesHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func namesHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	var channels []string
 	if len(msg.Params) > 0 {
 		channels = strings.Split(msg.Params[0], ",")
 }
 
 // NICK <nickname>
-func nickHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func nickHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if client.registered {
 		if client.account == "" && server.Config().Accounts.NickReservation.ForbidAnonNickChanges {
 			rb.Add(nil, server.name, ERR_UNKNOWNERROR, client.Nick(), client.t("You may not change your nickname"))
 }
 
 // helper to store a batched PRIVMSG in the session object
-func absorbBatchedMessage(server *Server, client *Client, msg ircmsg.IRCMessage, batchTag string, histType history.ItemType, rb *ResponseBuffer) {
+func absorbBatchedMessage(server *Server, client *Client, msg ircmsg.Message, batchTag string, histType history.ItemType, rb *ResponseBuffer) {
 	var errorCode, errorMessage string
 	defer func() {
 		if errorCode != "" {
 // NOTICE <target>{,<target>} <message>
 // PRIVMSG <target>{,<target>} <message>
 // TAGMSG <target>{,<target>}
-func messageHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func messageHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	histType, err := msgCommandToHistType(msg.Command)
 	if err != nil {
 		return false
 }
 
 // NPC <target> <sourcenick> <message>
-func npcHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func npcHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	target := msg.Params[0]
 	fakeSource := msg.Params[1]
 	message := msg.Params[2:]
 }
 
 // NPCA <target> <sourcenick> <message>
-func npcaHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func npcaHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	target := msg.Params[0]
 	fakeSource := msg.Params[1]
 	message := msg.Params[2:]
 }
 
 // OPER <name> [password]
-func operHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func operHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if client.HasMode(modes.Operator) {
 		rb.Add(nil, server.name, ERR_UNKNOWNERROR, client.Nick(), "OPER", client.t("You're already opered-up!"))
 		return false
 }
 
 // DEOPER
-func deoperHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func deoperHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if client.Oper() == nil {
 		rb.Notice(client.t("Insufficient oper privs"))
 		return false
 }
 
 // PART <channel>{,<channel>} [<reason>]
-func partHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func partHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	channels := strings.Split(msg.Params[0], ",")
 	var reason string
 	if len(msg.Params) > 1 {
 }
 
 // PASS <password>
-func passHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func passHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if client.registered {
 		rb.Add(nil, server.name, ERR_ALREADYREGISTRED, client.nick, client.t("You may not reregister"))
 		return false
 }
 
 // PING [params...]
-func pingHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func pingHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, "PONG", server.name, msg.Params[0])
 	return false
 }
 
 // PONG [params...]
-func pongHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func pongHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	// client gets touched when they send this command, so we don't need to do anything
 	return false
 }
 
 // QUIT [<reason>]
-func quitHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func quitHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	reason := "Quit"
 	if len(msg.Params) > 0 {
 		reason += ": " + msg.Params[0]
 }
 
 // REGISTER < email | * > <password>
-func registerHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) (exiting bool) {
+func registerHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) (exiting bool) {
 	accountName := client.Nick()
 	if accountName == "*" {
 		accountName = client.preregNick
 }
 
 // VERIFY <account> <code>
-func verifyHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) (exiting bool) {
+func verifyHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) (exiting bool) {
 	config := server.Config()
 	if !config.Accounts.Registration.Enabled {
 		rb.Add(nil, server.name, "FAIL", "VERIFY", "DISALLOWED", client.t("Account registration is disabled"))
 }
 
 // REHASH
-func rehashHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func rehashHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	nick := client.Nick()
 	server.logger.Info("server", "REHASH command used by", nick)
 	err := server.rehash()
 }
 
 // RELAYMSG <channel> <spoofed nick> :<message>
-func relaymsgHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) (result bool) {
+func relaymsgHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) (result bool) {
 	config := server.Config()
 	if !config.Server.Relaymsg.Enabled {
 		rb.Add(nil, server.name, "FAIL", "RELAYMSG", "NOT_ENABLED", client.t("RELAYMSG has been disabled"))
 }
 
 // RENAME <oldchan> <newchan> [<reason>]
-func renameHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func renameHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	oldName, newName := msg.Params[0], msg.Params[1]
 	var reason string
 	if 2 < len(msg.Params) {
 }
 
 // RESUME <token> [timestamp]
-func resumeHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func resumeHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	details := ResumeDetails{
 		PresentedToken: msg.Params[0],
 	}
 }
 
 // SANICK <oldnick> <nickname>
-func sanickHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func sanickHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	targetNick := msg.Params[0]
 	target := server.clients.Get(targetNick)
 	if target == nil {
 }
 
 // SCENE <target> <message>
-func sceneHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func sceneHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	target := msg.Params[0]
 	message := msg.Params[1:]
 
 }
 
 // SETNAME <realname>
-func setnameHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func setnameHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	realname := msg.Params[0]
 	if len(msg.Params) != 1 {
 		// workaround for clients that turn unknown commands into raw IRC lines,
 }
 
 // SUMMON [parameters]
-func summonHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func summonHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, ERR_SUMMONDISABLED, client.Nick(), client.t("SUMMON has been disabled"))
 	return false
 }
 
 // TIME
-func timeHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func timeHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, RPL_TIME, client.nick, server.name, time.Now().UTC().Format(time.RFC1123))
 	return false
 }
 
 // TOPIC <channel> [<topic>]
-func topicHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func topicHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	channel := server.channels.Get(msg.Params[0])
 	if channel == nil {
 		rb.Add(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, utils.SafeErrorParam(msg.Params[0]), client.t("No such channel"))
 }
 
 // UNDLINE <ip>|<net>
-func unDLineHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func unDLineHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	// check oper permissions
 	oper := client.Oper()
 	if !oper.HasRoleCapab("ban") {
 }
 
 // UNKLINE <mask>
-func unKLineHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func unKLineHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	details := client.Details()
 	// check oper permissions
 	oper := client.Oper()
 }
 
 // USER <username> * 0 <realname>
-func userHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func userHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	if client.registered {
 		rb.Add(nil, server.name, ERR_ALREADYREGISTRED, client.Nick(), client.t("You may not reregister"))
 		return false
 }
 
 // USERHOST <nickname>{ <nickname>}
-func userhostHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func userhostHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	hasPrivs := client.HasMode(modes.Operator)
 	returnedClients := make(ClientSet)
 
 }
 
 // USERS [parameters]
-func usersHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func usersHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, ERR_USERSDISABLED, client.Nick(), client.t("USERS has been disabled"))
 	return false
 }
 
 // VERSION
-func versionHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func versionHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, RPL_VERSION, client.nick, Ver, server.name)
 	server.RplISupport(client, rb)
 	return false
 }
 
 // WEBIRC <password> <gateway> <hostname> <ip> [:flag1 flag2=x flag3]
-func webircHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func webircHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	// only allow unregistered clients to use this command
 	if client.registered || client.proxiedIP != nil {
 		return false
 }
 
 // WHO <mask> [<filter>%<fields>,<type>]
-func whoHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func whoHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	mask := msg.Params[0]
 	var err error
 	if mask == "" {
 }
 
 // WHOIS [<target>] <mask>{,<mask>}
-func whoisHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func whoisHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	var masksString string
 	//var target string
 
 }
 
 // WHOWAS <nickname> [<count> [<server>]]
-func whowasHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func whowasHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	nicknames := strings.Split(msg.Params[0], ",")
 
 	// 0 means "all the entries", as does a negative number
 }
 
 // ZNC <module> [params]
-func zncHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func zncHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	params := msg.Params[1:]
 	// #1205: compatibility with Palaver, which sends `ZNC *playback :play ...`
 	if len(params) == 1 && strings.IndexByte(params[0], ' ') != -1 {
 }
 
 // fake handler for unknown commands
-func unknownCommandHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func unknownCommandHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, ERR_UNKNOWNCOMMAND, client.Nick(), utils.SafeErrorParam(msg.Command), client.t("Unknown command"))
 	return false
 }
 
 // fake handler for invalid utf8
-func invalidUtf8Handler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func invalidUtf8Handler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	rb.Add(nil, server.name, "FAIL", utils.SafeErrorParam(msg.Command), "INVALID_UTF8", client.t("Message rejected for containing invalid UTF-8"))
 	return false
 }

irc/ircconn.go

 type IRCStreamConn struct {
 	conn *utils.WrappedConn
 
-	reader ircreader.IRCReader
+	reader ircreader.Reader
 }
 
 func NewIRCStreamConn(conn *utils.WrappedConn) *IRCStreamConn {

irc/message_cache.go

 	splitMessage utils.SplitMessage
 }
 
-func addAllTags(msg *ircmsg.IRCMessage, tags map[string]string, serverTime time.Time, msgid, accountName string) {
+func addAllTags(msg *ircmsg.Message, tags map[string]string, serverTime time.Time, msgid, accountName string) {
 	msg.UpdateTags(tags)
 	msg.SetTag("time", serverTime.Format(IRCv3TimestampFormat))
 	if accountName != "*" {
 	m.command = command
 	m.params = params
 
-	var msg ircmsg.IRCMessage
+	var msg ircmsg.Message
 	config := server.Config()
 	if config.Server.Compatibility.forceTrailing && commandsThatMustUseTrailing[command] {
 		msg.ForceTrailing()
 
 	if message.Is512() {
 		isTagmsg := command == "TAGMSG"
-		var msg ircmsg.IRCMessage
+		var msg ircmsg.Message
 		if forceTrailing {
 			msg.ForceTrailing()
 		}
 			return
 		}
 	} else {
-		var msg ircmsg.IRCMessage
+		var msg ircmsg.Message
 		if forceTrailing {
 			msg.ForceTrailing()
 		}

irc/monitor.go

 }
 
 var (
-	monitorSubcommands = map[string]func(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool{
+	monitorSubcommands = map[string]func(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool{
 		"-": monitorRemoveHandler,
 		"+": monitorAddHandler,
 		"c": monitorClearHandler,

irc/responsebuffer.go

 	// nested batch.)
 	nestedBatches []string
 
-	messages  []ircmsg.IRCMessage
+	messages  []ircmsg.Message
 	finalized bool
 	target    *Client
 	session   *Session
 }
 
 // GetLabel returns the label from the given message.
-func GetLabel(msg ircmsg.IRCMessage) string {
+func GetLabel(msg ircmsg.Message) string {
 	_, value := msg.GetTag(caps.LabelTagName)
 	return value
 }
 	}
 }
 
-func (rb *ResponseBuffer) AddMessage(msg ircmsg.IRCMessage) {
+func (rb *ResponseBuffer) AddMessage(msg ircmsg.Message) {
 	if rb.finalized {
 		rb.target.server.logger.Error("internal", "message added to finalized ResponseBuffer, undefined behavior")
 		debug.PrintStack()
 	rb.messages = append(rb.messages, msg)
 }
 
-func (rb *ResponseBuffer) setNestedBatchTag(msg *ircmsg.IRCMessage) {
+func (rb *ResponseBuffer) setNestedBatchTag(msg *ircmsg.Message) {
 	if 0 < len(rb.nestedBatches) {
 		msg.SetTag("batch", rb.nestedBatches[len(rb.nestedBatches)-1])
 	}
 // Broadcast adds a standard new message to our queue, then sends an unlabeled copy
 // to all other sessions.
 func (rb *ResponseBuffer) Broadcast(tags map[string]string, prefix string, command string, params ...string) {
-	// can't reuse the IRCMessage object because of tag pollution :-\
+	// can't reuse the Message object because of tag pollution :-\
 	rb.Add(tags, prefix, command, params...)
 	for _, session := range rb.session.client.Sessions() {
 		if session != rb.session {

irc/services.go

 }
 
 // generic handler for IRC commands like `/NICKSERV INFO`
-func serviceCmdHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func serviceCmdHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	service, ok := oragonoServicesByCommandAlias[msg.Command]
 	if !ok {
 		server.logger.Warning("internal", "can't handle unrecognized service", msg.Command)

irc/uban.go

 }
 
 // UBAN <subcommand> [target] [DURATION <duration>] [reason...]
-func ubanHandler(server *Server, client *Client, msg ircmsg.IRCMessage, rb *ResponseBuffer) bool {
+func ubanHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	subcommand := strings.ToLower(msg.Params[0])
 	params := msg.Params[1:]
 	var target ubanTarget

vendor/github.com/goshuirc/irc-go/ircmsg/message.go

 	ErrorBadParam = errors.New("Cannot have an empty param, a param with spaces, or a param that starts with ':' before the last parameter")
 )
 
-// IRCMessage represents an IRC message, as defined by the RFCs and as
+// Message represents an IRC message, as defined by the RFCs and as
 // extended by the IRCv3 Message Tags specification with the introduction
 // of message tags.
-type IRCMessage struct {
+type Message struct {
 	Prefix         string
 	Command        string
 	Params         []string
 // will be encoded as a "trailing parameter" (preceded by a colon). This is
 // almost never necessary and should not be used except when having to interact
 // with broken implementations that don't correctly interpret IRC messages.
-func (msg *IRCMessage) ForceTrailing() {
+func (msg *Message) ForceTrailing() {
 	msg.forceTrailing = true
 }
 
 // GetTag returns whether a tag is present, and if so, what its value is.
-func (msg *IRCMessage) GetTag(tagName string) (present bool, value string) {
+func (msg *Message) GetTag(tagName string) (present bool, value string) {
 	if len(tagName) == 0 {
 		return
 	} else if tagName[0] == '+' {
 }
 
 // HasTag returns whether a tag is present.
-func (msg *IRCMessage) HasTag(tagName string) (present bool) {
+func (msg *Message) HasTag(tagName string) (present bool) {
 	present, _ = msg.GetTag(tagName)
 	return
 }
 
 // SetTag sets a tag.
-func (msg *IRCMessage) SetTag(tagName, tagValue string) {
+func (msg *Message) SetTag(tagName, tagValue string) {
 	if len(tagName) == 0 {
 		return
 	} else if tagName[0] == '+' {
 }
 
 // DeleteTag deletes a tag.
-func (msg *IRCMessage) DeleteTag(tagName string) {
+func (msg *Message) DeleteTag(tagName string) {
 	if len(tagName) == 0 {
 		return
 	} else if tagName[0] == '+' {
 }
 
 // UpdateTags is a convenience to set multiple tags at once.
-func (msg *IRCMessage) UpdateTags(tags map[string]string) {
+func (msg *Message) UpdateTags(tags map[string]string) {
 	for name, value := range tags {
 		msg.SetTag(name, value)
 	}
 }
 
 // AllTags returns all tags as a single map.
-func (msg *IRCMessage) AllTags() (result map[string]string) {
+func (msg *Message) AllTags() (result map[string]string) {
 	result = make(map[string]string, len(msg.tags)+len(msg.clientOnlyTags))
 	for name, value := range msg.tags {
 		result[name] = value
 }
 
 // ClientOnlyTags returns the client-only tags (the tags with the + prefix).
-// The returned map may be internal storage of the IRCMessage object and
+// The returned map may be internal storage of the Message object and
 // should not be modified.
-func (msg *IRCMessage) ClientOnlyTags() map[string]string {
+func (msg *Message) ClientOnlyTags() map[string]string {
 	return msg.clientOnlyTags
 }
 
 // ParseLine creates and returns a message from the given IRC line.
-func ParseLine(line string) (ircmsg IRCMessage, err error) {
+func ParseLine(line string) (ircmsg Message, err error) {
 	return parseLine(line, 0, 0)
 }
 
-// ParseLineStrict creates and returns an IRCMessage from the given IRC line,
+// ParseLineStrict creates and returns an Message from the given IRC line,
 // taking the maximum length into account and truncating the message as appropriate.
 // If fromClient is true, it enforces the client limit on tag data length (4094 bytes),
 // allowing the server to return ERR_INPUTTOOLONG as appropriate. If truncateLen is
 // nonzero, it is the length at which the non-tag portion of the message is truncated.
-func ParseLineStrict(line string, fromClient bool, truncateLen int) (ircmsg IRCMessage, err error) {
+func ParseLineStrict(line string, fromClient bool, truncateLen int) (ircmsg Message, err error) {
 	maxTagDataLength := MaxlenTagData
 	if fromClient {
 		maxTagDataLength = MaxlenClientTagData
 	return str[i:]
 }
 
-func parseLine(line string, maxTagDataLength int, truncateLen int) (ircmsg IRCMessage, err error) {
+func parseLine(line string, maxTagDataLength int, truncateLen int) (ircmsg Message, err error) {
 	// remove either \n or \r\n from the end of the line:
 	line = strings.TrimSuffix(line, "\n")
 	line = strings.TrimSuffix(line, "\r")
 }
 
 // helper to parse tags
-func (ircmsg *IRCMessage) parseTags(tags string) (err error) {
+func (ircmsg *Message) parseTags(tags string) (err error) {
 	for 0 < len(tags) {
 		tagEnd := strings.IndexByte(tags, ';')
 		endPos := tagEnd
 	return nil
 }
 
-// MakeMessage provides a simple way to create a new IRCMessage.
-func MakeMessage(tags map[string]string, prefix string, command string, params ...string) (ircmsg IRCMessage) {
+// MakeMessage provides a simple way to create a new Message.
+func MakeMessage(tags map[string]string, prefix string, command string, params ...string) (ircmsg Message) {
 	ircmsg.Prefix = prefix
 	ircmsg.Command = command
 	ircmsg.Params = params
 	return ircmsg
 }
 
-// Line returns a sendable line created from an IRCMessage.
-func (ircmsg *IRCMessage) Line() (result string, err error) {
+// Line returns a sendable line created from an Message.
+func (ircmsg *Message) Line() (result string, err error) {
 	bytes, err := ircmsg.line(0, 0, 0, 0)
 	if err == nil {
 		result = string(bytes)
 	return
 }
 
-// LineBytes returns a sendable line created from an IRCMessage.
-func (ircmsg *IRCMessage) LineBytes() (result []byte, err error) {
+// LineBytes returns a sendable line created from an Message.
+func (ircmsg *Message) LineBytes() (result []byte, err error) {
 	result, err = ircmsg.line(0, 0, 0, 0)
 	return
 }
 
-// LineBytesStrict returns a sendable line, as a []byte, created from an IRCMessage.
+// LineBytesStrict returns a sendable line, as a []byte, created from an Message.
 // fromClient controls whether the server-side or client-side tag length limit
 // is enforced. If truncateLen is nonzero, it is the length at which the
 // non-tag portion of the message is truncated.
-func (ircmsg *IRCMessage) LineBytesStrict(fromClient bool, truncateLen int) ([]byte, error) {
+func (ircmsg *Message) LineBytesStrict(fromClient bool, truncateLen int) ([]byte, error) {
 	var tagLimit, clientOnlyTagDataLimit, serverAddedTagDataLimit int
 	if fromClient {
 		// enforce client max tags:
 	return len(param) == 0 || strings.IndexByte(param, ' ') != -1 || param[0] == ':'
 }
 
-// line returns a sendable line created from an IRCMessage.
-func (ircmsg *IRCMessage) line(tagLimit, clientOnlyTagDataLimit, serverAddedTagDataLimit, truncateLen int) (result []byte, err error) {
+// line returns a sendable line created from an Message.
+func (ircmsg *Message) line(tagLimit, clientOnlyTagDataLimit, serverAddedTagDataLimit, truncateLen int) (result []byte, err error) {
 	if len(ircmsg.Command) == 0 {
 		return nil, ErrorCommandMissing
 	}

vendor/github.com/goshuirc/irc-go/ircmsg/tags.go

 // EscapeTagValue takes a value, and returns an escaped message tag value.
 //
 // This function is automatically used when lines are created from an
-// IRCMessage, so you don't need to call it yourself before creating a line.
+// Message, so you don't need to call it yourself before creating a line.
 func EscapeTagValue(inString string) string {
 	return valtoescape.Replace(inString)
 }

vendor/github.com/goshuirc/irc-go/ircreader/ircreader.go

 )
 
 /*
-IRCReader is an optimized line reader for IRC lines containing tags;
+Reader is an optimized line reader for IRC lines containing tags;
 most IRC lines will not approach the maximum line length (8191 bytes
 of tag data, plus 512 bytes of message data), so we want a buffered
 reader that can start with a smaller buffer and expand if necessary,
 	ErrReadQ = errors.New("readQ exceeded (read too many bytes without terminating newline)")
 )
 
-type IRCReader struct {
+type Reader struct {
 	conn io.Reader
 
 	initialSize int
 	eof        bool
 }
 
-// Returns a new *IRCReader with sane buffer size limits.
-func NewIRCReader(conn io.Reader) *IRCReader {
-	var reader IRCReader
+// Returns a new *Reader with sane buffer size limits.
+func NewIRCReader(conn io.Reader) *Reader {
+	var reader Reader
 	reader.Initialize(conn, 512, 8192+1024)
 	return &reader
 }
 
-// "Placement new" for an IRCReader; initializes it with custom buffer size
+// "Placement new" for a Reader; initializes it with custom buffer size
 // limits.
-func (cc *IRCReader) Initialize(conn io.Reader, initialSize, maxSize int) {
-	*cc = IRCReader{}
+func (cc *Reader) Initialize(conn io.Reader, initialSize, maxSize int) {
+	*cc = Reader{}
 	cc.conn = conn
 	cc.initialSize = initialSize
 	cc.maxSize = maxSize
 // or \r\n as the line terminator (but not \r in isolation). Passes through
 // errors from the underlying connection. Returns ErrReadQ if the buffer limit
 // was exceeded without a terminating \n.
-func (cc *IRCReader) ReadLine() ([]byte, error) {
+func (cc *Reader) ReadLine() ([]byte, error) {
 	for {
 		// try to find a terminated line in the buffered data already read
 		nlidx := bytes.IndexByte(cc.buf[cc.searchFrom:cc.end], '\n')

vendor/modules.txt

 # github.com/gorilla/websocket v1.4.2 => github.com/oragono/websocket v1.4.2-oragono1
 ## explicit
 github.com/gorilla/websocket
-# github.com/goshuirc/irc-go v0.0.0-20210304031553-cf78e9176f96
+# github.com/goshuirc/irc-go v0.0.0-20210311004346-ea7a188a73fe
 ## explicit
 github.com/goshuirc/irc-go/ircfmt
 github.com/goshuirc/irc-go/ircmsg