Split modes into a subpackage (this is painful, but will force us to simplify and improve the API for interacting with modes)

irc/channel.go

 
 	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/caps"
+	"github.com/oragono/oragono/irc/modes"
 )
 
 var (
 
 // Channel represents a channel that clients can join.
 type Channel struct {
-	flags             ModeSet
-	lists             map[Mode]*UserMaskSet
+	flags             modes.ModeSet
+	lists             map[modes.Mode]*UserMaskSet
 	key               string
 	members           MemberSet
 	membersCache      []*Client  // allow iteration over channel members without holding the lock
 
 	channel := &Channel{
 		createdTime: time.Now(), // may be overwritten by applyRegInfo
-		flags:       make(ModeSet),
-		lists: map[Mode]*UserMaskSet{
-			BanMask:    NewUserMaskSet(),
-			ExceptMask: NewUserMaskSet(),
-			InviteMask: NewUserMaskSet(),
+		flags:       make(modes.ModeSet),
+		lists: map[modes.Mode]*UserMaskSet{
+			modes.BanMask:    NewUserMaskSet(),
+			modes.ExceptMask: NewUserMaskSet(),
+			modes.InviteMask: NewUserMaskSet(),
 		},
 		members:        make(MemberSet),
 		name:           name,
 	channel.name = chanReg.Name
 	channel.createdTime = chanReg.RegisteredAt
 	for _, mask := range chanReg.Banlist {
-		channel.lists[BanMask].Add(mask)
+		channel.lists[modes.BanMask].Add(mask)
 	}
 	for _, mask := range chanReg.Exceptlist {
-		channel.lists[ExceptMask].Add(mask)
+		channel.lists[modes.ExceptMask].Add(mask)
 	}
 	for _, mask := range chanReg.Invitelist {
-		channel.lists[InviteMask].Add(mask)
+		channel.lists[modes.InviteMask].Add(mask)
 	}
 }
 
 	info.RegisteredAt = channel.registeredTime
 
 	if includeLists {
-		for mask := range channel.lists[BanMask].masks {
+		for mask := range channel.lists[modes.BanMask].masks {
 			info.Banlist = append(info.Banlist, mask)
 		}
-		for mask := range channel.lists[ExceptMask].masks {
+		for mask := range channel.lists[modes.ExceptMask].masks {
 			info.Exceptlist = append(info.Exceptlist, mask)
 		}
-		for mask := range channel.lists[InviteMask].masks {
+		for mask := range channel.lists[modes.InviteMask].masks {
 			info.Invitelist = append(info.Invitelist, mask)
 		}
 	}
 }
 
 // ClientIsAtLeast returns whether the client has at least the given channel privilege.
-func (channel *Channel) ClientIsAtLeast(client *Client, permission Mode) bool {
+func (channel *Channel) ClientIsAtLeast(client *Client, permission modes.Mode) bool {
 	channel.stateMutex.RLock()
 	defer channel.stateMutex.RUnlock()
 
 	}
 
 	// check regular modes
-	for _, mode := range ChannelPrivModes {
+	for _, mode := range modes.ChannelPrivModes {
 		if channel.members.HasMode(client, mode) {
 			return true
 		}
 	return false
 }
 
-// Prefixes returns a list of prefixes for the given set of channel modes.
-func (modes ModeSet) Prefixes(isMultiPrefix bool) string {
-	var prefixes string
-
-	// add prefixes in order from highest to lowest privs
-	for _, mode := range ChannelPrivModes {
-		if modes[mode] {
-			prefixes += ChannelModePrefixes[mode]
-		}
-	}
-	if modes[Voice] {
-		prefixes += ChannelModePrefixes[Voice]
-	}
-
-	if !isMultiPrefix && len(prefixes) > 1 {
-		prefixes = string(prefixes[0])
-	}
-
-	return prefixes
-}
-
 func (channel *Channel) ClientPrefixes(client *Client, isMultiPrefix bool) string {
 	channel.stateMutex.RLock()
 	defer channel.stateMutex.RUnlock()
 	clientModes := channel.members[client]
 	targetModes := channel.members[target]
 	result := false
-	for _, mode := range ChannelPrivModes {
+	for _, mode := range modes.ChannelPrivModes {
 		if clientModes[mode] {
 			result = true
 			// admins cannot kick other admins
-			if mode == ChannelAdmin && targetModes[ChannelAdmin] {
+			if mode == modes.ChannelAdmin && targetModes[modes.ChannelAdmin] {
 				result = false
 			}
 			break
 
 // <mode> <mode params>
 func (channel *Channel) modeStrings(client *Client) (result []string) {
-	isMember := client.HasMode(Operator) || channel.hasClient(client)
+	isMember := client.HasMode(modes.Operator) || channel.hasClient(client)
 	showKey := isMember && (channel.key != "")
 	showUserLimit := channel.userLimit > 0
 
-	modes := "+"
+	mods := "+"
 
 	// flags with args
 	if showKey {
-		modes += Key.String()
+		mods += modes.Key.String()
 	}
 	if showUserLimit {
-		modes += UserLimit.String()
+		mods += modes.UserLimit.String()
 	}
 
 	channel.stateMutex.RLock()
 
 	// flags
 	for mode := range channel.flags {
-		modes += mode.String()
+		mods += mode.String()
 	}
 
-	result = []string{modes}
+	result = []string{mods}
 
 	// args for flags with args: The order must match above to keep
 	// positional arguments in place.
 		return
 	}
 
-	isInvited := channel.lists[InviteMask].Match(client.nickMaskCasefolded)
-	if channel.flags[InviteOnly] && !isInvited {
+	isInvited := channel.lists[modes.InviteMask].Match(client.nickMaskCasefolded)
+	if channel.flags[modes.InviteOnly] && !isInvited {
 		client.Send(nil, client.server.name, ERR_INVITEONLYCHAN, channel.name, fmt.Sprintf(client.t("Cannot join channel (+%s)"), "i"))
 		return
 	}
 
-	if channel.lists[BanMask].Match(client.nickMaskCasefolded) &&
+	if channel.lists[modes.BanMask].Match(client.nickMaskCasefolded) &&
 		!isInvited &&
-		!channel.lists[ExceptMask].Match(client.nickMaskCasefolded) {
+		!channel.lists[modes.ExceptMask].Match(client.nickMaskCasefolded) {
 		client.Send(nil, client.server.name, ERR_BANNEDFROMCHAN, channel.name, fmt.Sprintf(client.t("Cannot join channel (+%s)"), "b"))
 		return
 	}
 
 	// give channel mode if necessary
 	newChannel := firstJoin && !channel.IsRegistered()
-	var givenMode *Mode
+	var givenMode *modes.Mode
 	if client.AccountName() == channel.registeredFounder {
-		givenMode = &ChannelFounder
+		givenMode = &modes.ChannelFounder
 	} else if newChannel {
-		givenMode = &ChannelOperator
+		givenMode = &modes.ChannelOperator
 	}
 	if givenMode != nil {
 		channel.stateMutex.Lock()
 
 // SetTopic sets the topic of this channel, if the client is allowed to do so.
 func (channel *Channel) SetTopic(client *Client, topic string) {
-	if !(client.flags[Operator] || channel.hasClient(client)) {
+	if !(client.flags[modes.Operator] || channel.hasClient(client)) {
 		client.Send(nil, client.server.name, ERR_NOTONCHANNEL, channel.name, client.t("You're not on that channel"))
 		return
 	}
 
-	if channel.HasMode(OpOnlyTopic) && !channel.ClientIsAtLeast(client, ChannelOperator) {
+	if channel.HasMode(modes.OpOnlyTopic) && !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
 		client.Send(nil, client.server.name, ERR_CHANOPRIVSNEEDED, channel.name, client.t("You're not a channel operator"))
 		return
 	}
 	defer channel.stateMutex.RUnlock()
 
 	_, hasClient := channel.members[client]
-	if channel.flags[NoOutside] && !hasClient {
+	if channel.flags[modes.NoOutside] && !hasClient {
 		return false
 	}
-	if channel.flags[Moderated] && !channel.ClientIsAtLeast(client, Voice) {
+	if channel.flags[modes.Moderated] && !channel.ClientIsAtLeast(client, modes.Voice) {
 		return false
 	}
-	if channel.flags[RegisteredOnly] && client.account == &NoAccount {
+	if channel.flags[modes.RegisteredOnly] && client.account == &NoAccount {
 		return false
 	}
 	return true
 }
 
 // TagMsg sends a tag message to everyone in this channel who can accept them.
-func (channel *Channel) TagMsg(msgid string, minPrefix *Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client) {
+func (channel *Channel) TagMsg(msgid string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client) {
 	channel.sendMessage(msgid, "TAGMSG", []caps.Capability{caps.MessageTags}, minPrefix, clientOnlyTags, client, nil)
 }
 
 // sendMessage sends a given message to everyone on this channel.
-func (channel *Channel) sendMessage(msgid, cmd string, requiredCaps []caps.Capability, minPrefix *Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message *string) {
+func (channel *Channel) sendMessage(msgid, cmd string, requiredCaps []caps.Capability, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message *string) {
 	if !channel.CanSpeak(client) {
 		client.Send(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, client.t("Cannot send to channel"))
 		return
 	}
 
 	// for STATUSMSG
-	var minPrefixMode Mode
+	var minPrefixMode modes.Mode
 	if minPrefix != nil {
 		minPrefixMode = *minPrefix
 	}
 }
 
 // SplitPrivMsg sends a private message to everyone in this channel.
-func (channel *Channel) SplitPrivMsg(msgid string, minPrefix *Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message SplitMessage) {
+func (channel *Channel) SplitPrivMsg(msgid string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message SplitMessage) {
 	channel.sendSplitMessage(msgid, "PRIVMSG", minPrefix, clientOnlyTags, client, &message)
 }
 
 // SplitNotice sends a private message to everyone in this channel.
-func (channel *Channel) SplitNotice(msgid string, minPrefix *Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message SplitMessage) {
+func (channel *Channel) SplitNotice(msgid string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message SplitMessage) {
 	channel.sendSplitMessage(msgid, "NOTICE", minPrefix, clientOnlyTags, client, &message)
 }
 
-func (channel *Channel) sendSplitMessage(msgid, cmd string, minPrefix *Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message *SplitMessage) {
+func (channel *Channel) sendSplitMessage(msgid, cmd string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message *SplitMessage) {
 	if !channel.CanSpeak(client) {
 		client.Send(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, client.t("Cannot send to channel"))
 		return
 	}
 
 	// for STATUSMSG
-	var minPrefixMode Mode
+	var minPrefixMode modes.Mode
 	if minPrefix != nil {
 		minPrefixMode = *minPrefix
 	}
 	}
 }
 
-func (channel *Channel) applyModeMemberNoMutex(client *Client, mode Mode,
-	op ModeOp, nick string) *ModeChange {
+func (channel *Channel) applyModeMemberNoMutex(client *Client, mode modes.Mode, op modes.ModeOp, nick string) *modes.ModeChange {
 	if nick == "" {
 		//TODO(dan): shouldn't this be handled before it reaches this function?
 		client.Send(nil, client.server.name, ERR_NEEDMOREPARAMS, "MODE", client.t("Not enough parameters"))
 	modeset, exists := channel.members[target]
 	var already bool
 	if exists {
-		enable := op == Add
+		enable := op == modes.Add
 		already = modeset[mode] == enable
 		modeset[mode] = enable
 	}
 	} else if already {
 		return nil
 	} else {
-		return &ModeChange{
-			op:   op,
-			mode: mode,
-			arg:  nick,
+		return &modes.ModeChange{
+			Op:   op,
+			Mode: mode,
+			Arg:  nick,
 		}
 	}
 }
 
 // ShowMaskList shows the given list to the client.
-func (channel *Channel) ShowMaskList(client *Client, mode Mode) {
+func (channel *Channel) ShowMaskList(client *Client, mode modes.Mode) {
 	// choose appropriate modes
 	var rpllist, rplendoflist string
-	if mode == BanMask {
+	if mode == modes.BanMask {
 		rpllist = RPL_BANLIST
 		rplendoflist = RPL_ENDOFBANLIST
-	} else if mode == ExceptMask {
+	} else if mode == modes.ExceptMask {
 		rpllist = RPL_EXCEPTLIST
 		rplendoflist = RPL_ENDOFEXCEPTLIST
-	} else if mode == InviteMask {
+	} else if mode == modes.InviteMask {
 		rpllist = RPL_INVITELIST
 		rplendoflist = RPL_ENDOFINVITELIST
 	}
 	client.Send(nil, client.server.name, rplendoflist, nick, channel.name, client.t("End of list"))
 }
 
-func (channel *Channel) applyModeMask(client *Client, mode Mode, op ModeOp, mask string) bool {
+func (channel *Channel) applyModeMask(client *Client, mode modes.Mode, op modes.ModeOp, mask string) bool {
 	list := channel.lists[mode]
 	if list == nil {
 		// This should never happen, but better safe than panicky.
 		return false
 	}
 
-	if (op == List) || (mask == "") {
+	if (op == modes.List) || (mask == "") {
 		channel.ShowMaskList(client, mode)
 		return false
 	}
 
-	if !channel.ClientIsAtLeast(client, ChannelOperator) {
+	if !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
 		client.Send(nil, client.server.name, ERR_CHANOPRIVSNEEDED, channel.name, client.t("You're not a channel operator"))
 		return false
 	}
 
-	if op == Add {
+	if op == modes.Add {
 		return list.Add(mask)
 	}
 
-	if op == Remove {
+	if op == modes.Remove {
 		return list.Remove(mask)
 	}
 
 }
 
 func (channel *Channel) Kick(client *Client, target *Client, comment string) {
-	if !(client.flags[Operator] || channel.hasClient(client)) {
+	if !(client.flags[modes.Operator] || channel.hasClient(client)) {
 		client.Send(nil, client.server.name, ERR_NOTONCHANNEL, channel.name, client.t("You're not on that channel"))
 		return
 	}
-	if !channel.ClientIsAtLeast(client, ChannelOperator) {
+	if !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
 		client.Send(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, client.t("Cannot send to channel"))
 		return
 	}
 
 // Invite invites the given client to the channel, if the inviter can do so.
 func (channel *Channel) Invite(invitee *Client, inviter *Client) {
-	if channel.flags[InviteOnly] && !channel.ClientIsAtLeast(inviter, ChannelOperator) {
+	if channel.flags[modes.InviteOnly] && !channel.ClientIsAtLeast(inviter, modes.ChannelOperator) {
 		inviter.Send(nil, inviter.server.name, ERR_CHANOPRIVSNEEDED, channel.name, inviter.t("You're not a channel operator"))
 		return
 	}
 	}
 
 	//TODO(dan): handle this more nicely, keep a list of last X invited channels on invitee rather than explicitly modifying the invite list?
-	if channel.flags[InviteOnly] {
+	if channel.flags[modes.InviteOnly] {
 		nmc := invitee.NickCasefolded()
 		channel.stateMutex.Lock()
-		channel.lists[InviteMask].Add(nmc)
+		channel.lists[modes.InviteMask].Add(nmc)
 		channel.stateMutex.Unlock()
 	}
 
 	for _, member := range channel.Members() {
-		if member.capabilities.Has(caps.InviteNotify) && member != inviter && member != invitee && channel.ClientIsAtLeast(member, Halfop) {
+		if member.capabilities.Has(caps.InviteNotify) && member != inviter && member != invitee && channel.ClientIsAtLeast(member, modes.Halfop) {
 			member.Send(nil, inviter.NickMaskString(), "INVITE", invitee.Nick(), channel.name)
 		}
 	}
 	//TODO(dan): should inviter.server.name here be inviter.nickMaskString ?
 	inviter.Send(nil, inviter.server.name, RPL_INVITING, invitee.nick, channel.name)
 	invitee.Send(nil, inviter.nickMaskString, "INVITE", invitee.nick, channel.name)
-	if invitee.flags[Away] {
+	if invitee.flags[modes.Away] {
 		inviter.Send(nil, inviter.server.name, RPL_AWAY, invitee.nick, invitee.awayMessage)
 	}
 }

irc/chanserv.go

 	"strings"
 
 	"github.com/goshuirc/irc-go/ircfmt"
+	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/sno"
 )
 
 		}
 
 		channelInfo := server.channels.Get(channelKey)
-		if channelInfo == nil || !channelInfo.ClientIsAtLeast(client, ChannelOperator) {
+		if channelInfo == nil || !channelInfo.ClientIsAtLeast(client, modes.ChannelOperator) {
 			client.ChanServNotice(client.t("You must be an oper on the channel to register it"))
 			return
 		}
 		server.snomasks.Send(sno.LocalChannels, fmt.Sprintf(ircfmt.Unescape("Channel registered $c[grey][$r%s$c[grey]] by $c[grey][$r%s$c[grey]]"), channelName, client.nickMaskString))
 
 		// give them founder privs
-		change := channelInfo.applyModeMemberNoMutex(client, ChannelFounder, Add, client.NickCasefolded())
+		change := channelInfo.applyModeMemberNoMutex(client, modes.ChannelFounder, modes.Add, client.NickCasefolded())
 		if change != nil {
 			//TODO(dan): we should change the name of String and make it return a slice here
 			//TODO(dan): unify this code with code in modes.go

irc/client.go

 	"github.com/goshuirc/irc-go/ircmsg"
 	ident "github.com/oragono/go-ident"
 	"github.com/oragono/oragono/irc/caps"
+	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/sno"
 	"github.com/oragono/oragono/irc/utils"
 )
 	class              *OperClass
 	ctime              time.Time
 	exitedSnomaskSent  bool
-	flags              map[Mode]bool
+	flags              map[modes.Mode]bool
 	hasQuit            bool
 	hops               int
 	hostname           string
 		capVersion:     caps.Cap301,
 		channels:       make(ChannelSet),
 		ctime:          now,
-		flags:          make(map[Mode]bool),
+		flags:          make(map[modes.Mode]bool),
 		server:         server,
 		socket:         &socket,
 		account:        &NoAccount,
 
 	client.recomputeMaxlens()
 	if isTLS {
-		client.flags[TLS] = true
+		client.flags[modes.TLS] = true
 
 		// error is not useful to us here anyways so we can ignore it
 		client.certfp, _ = client.socket.CertFP()
 		return
 	}
 
-	if !oldClient.HasMode(TLS) || !client.HasMode(TLS) {
+	if !oldClient.HasMode(modes.TLS) || !client.HasMode(modes.TLS) {
 		client.Send(nil, server.name, ERR_CANNOT_RESUME, oldnick, client.t("Cannot resume connection, old and new clients must have TLS"))
 		return
 	}

irc/commands.go

 
 package irc
 
-import "github.com/goshuirc/irc-go/ircmsg"
+import (
+	"github.com/goshuirc/irc-go/ircmsg"
+	"github.com/oragono/oragono/irc/modes"
+)
 
 // Command represents a command accepted from a client.
 type Command struct {
 		client.Send(nil, server.name, ERR_NOTREGISTERED, client.nick, client.t("You need to register before you can use that command"))
 		return false
 	}
-	if cmd.oper && !client.flags[Operator] {
+	if cmd.oper && !client.flags[modes.Operator] {
 		client.Send(nil, server.name, ERR_NOPRIVILEGES, client.nick, client.t("Permission Denied - You're not an IRC operator"))
 		return false
 	}

irc/gateways.go

 	"fmt"
 	"net"
 
+	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/passwd"
 	"github.com/oragono/oragono/irc/utils"
 )
 	// set tls info
 	client.certfp = ""
 	if tls {
-		client.flags[TLS] = true
+		client.flags[modes.TLS] = true
 	} else {
-		delete(client.flags, TLS)
+		delete(client.flags, modes.TLS)
 	}
 
 	return false

irc/getters.go

 
 package irc
 
-import "github.com/oragono/oragono/irc/isupport"
+import (
+	"github.com/oragono/oragono/irc/isupport"
+	"github.com/oragono/oragono/irc/modes"
+)
 
 func (server *Server) ISupport() *isupport.List {
 	server.configurableStateMutex.RLock()
 	return server.webirc
 }
 
-func (server *Server) DefaultChannelModes() Modes {
+func (server *Server) DefaultChannelModes() modes.Modes {
 	server.configurableStateMutex.RLock()
 	defer server.configurableStateMutex.RUnlock()
 	return server.defaultChannelModes
 	return client.account.Name
 }
 
-func (client *Client) HasMode(mode Mode) bool {
+func (client *Client) HasMode(mode modes.Mode) bool {
 	client.stateMutex.RLock()
 	defer client.stateMutex.RUnlock()
 	return client.flags[mode]
 	channel.stateMutex.Unlock()
 }
 
-func (channel *Channel) HasMode(mode Mode) bool {
+func (channel *Channel) HasMode(mode modes.Mode) bool {
 	channel.stateMutex.RLock()
 	defer channel.stateMutex.RUnlock()
 	return channel.flags[mode]
 }
 
 // set a channel mode, return whether it was already set
-func (channel *Channel) setMode(mode Mode, enable bool) (already bool) {
+func (channel *Channel) setMode(mode modes.Mode, enable bool) (already bool) {
 	channel.stateMutex.Lock()
 	already = (channel.flags[mode] == enable)
 	if !already {

irc/handlers.go

 	"github.com/goshuirc/irc-go/ircmsg"
 	"github.com/oragono/oragono/irc/caps"
 	"github.com/oragono/oragono/irc/custime"
+	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/passwd"
 	"github.com/oragono/oragono/irc/sno"
 	"github.com/oragono/oragono/irc/utils"
 	}
 
 	if isAway {
-		client.flags[Away] = true
+		client.flags[modes.Away] = true
 	} else {
-		delete(client.flags, Away)
+		delete(client.flags, modes.Away)
 	}
 	client.awayMessage = text
 
-	var op ModeOp
-	if client.flags[Away] {
-		op = Add
+	var op modes.ModeOp
+	if client.flags[modes.Away] {
+		op = modes.Add
 		client.Send(nil, server.name, RPL_NOWAWAY, client.nick, client.t("You have been marked as being away"))
 	} else {
-		op = Remove
+		op = modes.Remove
 		client.Send(nil, server.name, RPL_UNAWAY, client.nick, client.t("You are no longer marked as being away"))
 	}
 	//TODO(dan): Should this be sent automagically as part of setting the flag/mode?
-	modech := ModeChanges{ModeChange{
-		mode: Away,
-		op:   op,
+	modech := modes.ModeChanges{modes.ModeChange{
+		Mode: modes.Away,
+		Op:   op,
 	}}
 	client.Send(nil, server.name, "MODE", client.nick, modech.String())
 
 	// dispatch away-notify
 	for friend := range client.Friends(caps.AwayNotify) {
-		if client.flags[Away] {
+		if client.flags[modes.Away] {
 			friend.SendFromClient("", client, nil, "AWAY", client.awayMessage)
 		} else {
 			friend.SendFromClient("", client, nil, "AWAY")
 
 // DEBUG GCSTATS/NUMGOROUTINE/etc
 func debugHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	if !client.flags[Operator] {
+	if !client.flags[modes.Operator] {
 		return false
 	}
 
 
 	// handle index
 	if argument == "index" {
-		if client.flags[Operator] {
+		if client.flags[modes.Operator] {
 			client.sendHelp("HELP", GetHelpIndex(client.languages, HelpIndexOpers))
 		} else {
 			client.sendHelp("HELP", GetHelpIndex(client.languages, HelpIndex))
 
 	helpHandler, exists := Help[argument]
 
-	if exists && (!helpHandler.oper || (helpHandler.oper && client.flags[Operator])) {
+	if exists && (!helpHandler.oper || (helpHandler.oper && client.flags[modes.Operator])) {
 		if helpHandler.textGenerator != nil {
 			client.sendHelp(strings.ToUpper(argument), client.t(helpHandler.textGenerator(client)))
 		} else {
 
 	if len(channels) == 0 {
 		for _, channel := range server.channels.Channels() {
-			if !client.flags[Operator] && channel.flags[Secret] {
+			if !client.flags[modes.Operator] && channel.flags[modes.Secret] {
 				continue
 			}
 			if matcher.Matches(channel) {
 		}
 	} else {
 		// limit regular users to only listing one channel
-		if !client.flags[Operator] {
+		if !client.flags[modes.Operator] {
 			channels = channels[:1]
 		}
 
 		for _, chname := range channels {
 			casefoldedChname, err := CasefoldChannel(chname)
 			channel := server.channels.Get(casefoldedChname)
-			if err != nil || channel == nil || (!client.flags[Operator] && channel.flags[Secret]) {
+			if err != nil || channel == nil || (!client.flags[modes.Operator] && channel.flags[modes.Secret]) {
 				if len(chname) > 0 {
 					client.Send(nil, server.name, ERR_NOSUCHCHANNEL, client.nick, chname, client.t("No such channel"))
 				}
 
 	for _, onlineusers := range server.clients.AllClients() {
 		totalcount++
-		if onlineusers.flags[Invisible] {
+		if onlineusers.flags[modes.Invisible] {
 			invisiblecount++
 		}
-		if onlineusers.flags[Operator] {
+		if onlineusers.flags[modes.Operator] {
 			opercount++
 		}
 	}
 	}
 
 	// applied mode changes
-	applied := make(ModeChanges, 0)
+	applied := make(modes.ModeChanges, 0)
 
 	if 1 < len(msg.Params) {
 		// parse out real mode changes
 	// save changes to banlist/exceptlist/invexlist
 	var banlistUpdated, exceptlistUpdated, invexlistUpdated bool
 	for _, change := range applied {
-		if change.mode == BanMask {
+		if change.Mode == modes.BanMask {
 			banlistUpdated = true
-		} else if change.mode == ExceptMask {
+		} else if change.Mode == modes.ExceptMask {
 			exceptlistUpdated = true
-		} else if change.mode == InviteMask {
+		} else if change.Mode == modes.InviteMask {
 			invexlistUpdated = true
 		}
 	}
 	}
 
 	// applied mode changes
-	applied := make(ModeChanges, 0)
+	applied := make(modes.ModeChanges, 0)
 
 	if 1 < len(msg.Params) {
 		// parse out real mode changes
 		params := msg.Params[1:]
-		changes, unknown := ParseUserModeChanges(params...)
+		changes, unknown := modes.ParseUserModeChanges(params...)
 
 		// alert for unknown mode changes
 		for char := range unknown {
 		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] {
+		if client.flags[modes.LocalOperator] || client.flags[modes.Operator] {
 			masks := server.snomasks.String(client)
 			if 0 < len(masks) {
 				client.Send(nil, target.nickMaskString, RPL_SNOMASKIS, targetNick, masks, client.t("Server notice masks"))
 		if i > maxTargets-1 {
 			break
 		}
-		prefixes, targetString := SplitChannelMembershipPrefixes(targetString)
-		lowestPrefix := GetLowestChannelModePrefix(prefixes)
+		prefixes, targetString := modes.SplitChannelMembershipPrefixes(targetString)
+		lowestPrefix := modes.GetLowestChannelModePrefix(prefixes)
 
 		target, cerr := CasefoldChannel(targetString)
 		if cerr == nil {
 			msgid := server.generateMessageID()
 			// restrict messages appropriately when +R is set
 			// intentionally make the sending user think the message went through fine
-			if !user.flags[RegisteredOnly] || client.registered {
+			if !user.flags[modes.RegisteredOnly] || client.registered {
 				user.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "NOTICE", user.nick, splitMsg)
 			}
 			if client.capabilities.Has(caps.EchoMessage) {
 		client.Send(nil, server.name, ERR_PASSWDMISMATCH, client.nick, client.t("Password incorrect"))
 		return true
 	}
-	if client.flags[Operator] == true {
+	if client.flags[modes.Operator] == true {
 		client.Send(nil, server.name, ERR_UNKNOWNERROR, "OPER", client.t("You're already opered-up!"))
 		return false
 	}
 		return true
 	}
 
-	client.flags[Operator] = true
+	client.flags[modes.Operator] = true
 	client.operName = name
 	client.class = oper.Class
 	client.whoisLine = oper.WhoisLine
 	}
 
 	// set new modes
-	var applied ModeChanges
+	var applied modes.ModeChanges
 	if 0 < len(oper.Modes) {
-		modeChanges, unknownChanges := ParseUserModeChanges(strings.Split(oper.Modes, " ")...)
+		modeChanges, unknownChanges := modes.ParseUserModeChanges(strings.Split(oper.Modes, " ")...)
 		applied = client.applyUserModeChanges(true, modeChanges)
 		if 0 < len(unknownChanges) {
 			var runes string
 
 	client.Send(nil, server.name, RPL_YOUREOPER, client.nick, client.t("You are now an IRC operator"))
 
-	applied = append(applied, ModeChange{
-		mode: Operator,
-		op:   Add,
+	applied = append(applied, modes.ModeChange{
+		Mode: modes.Operator,
+		Op:   modes.Add,
 	})
 	client.Send(nil, server.name, "MODE", client.nick, applied.String())
 
 		if i > maxTargets-1 {
 			break
 		}
-		prefixes, targetString := SplitChannelMembershipPrefixes(targetString)
-		lowestPrefix := GetLowestChannelModePrefix(prefixes)
+		prefixes, targetString := modes.SplitChannelMembershipPrefixes(targetString)
+		lowestPrefix := modes.GetLowestChannelModePrefix(prefixes)
 
 		// eh, no need to notify them
 		if len(targetString) < 1 {
 			msgid := server.generateMessageID()
 			// restrict messages appropriately when +R is set
 			// intentionally make the sending user think the message went through fine
-			if !user.flags[RegisteredOnly] || client.registered {
+			if !user.flags[modes.RegisteredOnly] || client.registered {
 				user.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "PRIVMSG", user.nick, splitMsg)
 			}
 			if client.capabilities.Has(caps.EchoMessage) {
 				client.SendSplitMsgFromClient(msgid, client, clientOnlyTags, "PRIVMSG", user.nick, splitMsg)
 			}
-			if user.flags[Away] {
+			if user.flags[modes.Away] {
 				//TODO(dan): possibly implement cooldown of away notifications to users
 				client.Send(nil, server.name, RPL_AWAY, user.nick, user.awayMessage)
 			}
 		return
 	}
 	//TODO(dan): allow IRCops to do this?
-	if !channel.ClientIsAtLeast(client, Operator) {
+	if !channel.ClientIsAtLeast(client, modes.Operator) {
 		errorResponse(RenamePrivsNeeded, oldName)
 		return
 	}
 		if i > maxTargets-1 {
 			break
 		}
-		prefixes, targetString := SplitChannelMembershipPrefixes(targetString)
-		lowestPrefix := GetLowestChannelModePrefix(prefixes)
+		prefixes, targetString := modes.SplitChannelMembershipPrefixes(targetString)
+		lowestPrefix := modes.GetLowestChannelModePrefix(prefixes)
 
 		// eh, no need to notify them
 		if len(targetString) < 1 {
 			if client.capabilities.Has(caps.EchoMessage) {
 				client.SendFromClient(msgid, client, clientOnlyTags, "TAGMSG", user.nick)
 			}
-			if user.flags[Away] {
+			if user.flags[modes.Away] {
 				//TODO(dan): possibly implement cooldown of away notifications to users
 				client.Send(nil, server.name, RPL_AWAY, user.nick, user.awayMessage)
 			}
 
 		var isOper, isAway string
 
-		if target.flags[Operator] {
+		if target.flags[modes.Operator] {
 			isOper = "*"
 		}
-		if target.flags[Away] {
+		if target.flags[modes.Away] {
 			isAway = "-"
 		} else {
 			isAway = "+"
 			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()) {
+				if client.flags[modes.TLS] || utils.AddrIsLocal(client.socket.conn.RemoteAddr()) {
 					secure = true
 				}
 			}
 		return false
 	}
 
-	if client.flags[Operator] {
+	if client.flags[modes.Operator] {
 		masks := strings.Split(masksString, ",")
 		for _, mask := range masks {
 			casefoldedMask, err := Casefold(mask)

irc/modes.go

 	"strconv"
 	"strings"
 
+	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/sno"
 )
 
-// ModeOp is an operation performed with modes
-type ModeOp rune
-
-func (op ModeOp) String() string {
-	return string(op)
-}
-
-const (
-	// Add is used when adding the given key.
-	Add ModeOp = '+'
-	// List is used when listing modes (for instance, listing the current bans on a channel).
-	List ModeOp = '='
-	// Remove is used when taking away the given key.
-	Remove ModeOp = '-'
-)
-
-// Mode represents a user/channel/server mode
-type Mode rune
-
-func (mode Mode) String() string {
-	return string(mode)
-}
-
-// ModeChange is a single mode changing
-type ModeChange struct {
-	mode Mode
-	op   ModeOp
-	arg  string
-}
-
-func (change *ModeChange) String() (str string) {
-	if (change.op == Add) || (change.op == Remove) {
-		str = change.op.String()
-	}
-	str += change.mode.String()
-	if change.arg != "" {
-		str += " " + change.arg
-	}
-	return
-}
-
-// ModeChanges are a collection of 'ModeChange's
-type ModeChanges []ModeChange
-
-func (changes ModeChanges) String() string {
-	if len(changes) == 0 {
-		return ""
-	}
-
-	op := changes[0].op
-	str := changes[0].op.String()
-
-	for _, change := range changes {
-		if change.op != op {
-			op = change.op
-			str += change.op.String()
-		}
-		str += change.mode.String()
-	}
-
-	for _, change := range changes {
-		if change.arg == "" {
-			continue
-		}
-		str += " " + change.arg
-	}
-	return str
-}
-
-// Modes is just a raw list of modes
-type Modes []Mode
-
-func (modes Modes) String() string {
-	strs := make([]string, len(modes))
-	for index, mode := range modes {
-		strs[index] = mode.String()
-	}
-	return strings.Join(strs, "")
-}
-
-// User Modes
-const (
-	Away            Mode = 'a'
-	Bot             Mode = 'B'
-	Invisible       Mode = 'i'
-	LocalOperator   Mode = 'O'
-	Operator        Mode = 'o'
-	Restricted      Mode = 'r'
-	RegisteredOnly  Mode = 'R'
-	ServerNotice    Mode = 's'
-	TLS             Mode = 'Z'
-	UserRoleplaying Mode = 'E'
-	WallOps         Mode = 'w'
-)
-
-var (
-	// SupportedUserModes are the user modes that we actually support (modifying).
-	SupportedUserModes = Modes{
-		Away, Bot, Invisible, Operator, RegisteredOnly, ServerNotice, UserRoleplaying,
-	}
-	// supportedUserModesString acts as a cache for when we introduce users
-	supportedUserModesString = SupportedUserModes.String()
-)
-
-// Channel Modes
-const (
-	BanMask         Mode = 'b' // arg
-	ChanRoleplaying Mode = 'E' // flag
-	ExceptMask      Mode = 'e' // arg
-	InviteMask      Mode = 'I' // arg
-	InviteOnly      Mode = 'i' // flag
-	Key             Mode = 'k' // flag arg
-	Moderated       Mode = 'm' // flag
-	NoOutside       Mode = 'n' // flag
-	OpOnlyTopic     Mode = 't' // flag
-	// RegisteredOnly mode is reused here from umode definition
-	Secret    Mode = 's' // flag
-	UserLimit Mode = 'l' // flag arg
-)
-
 var (
-	ChannelFounder  Mode = 'q' // arg
-	ChannelAdmin    Mode = 'a' // arg
-	ChannelOperator Mode = 'o' // arg
-	Halfop          Mode = 'h' // arg
-	Voice           Mode = 'v' // arg
-
-	// SupportedChannelModes are the channel modes that we support.
-	SupportedChannelModes = Modes{
-		BanMask, ChanRoleplaying, ExceptMask, InviteMask, InviteOnly, Key,
-		Moderated, NoOutside, OpOnlyTopic, RegisteredOnly, Secret, UserLimit,
-	}
-	// supportedChannelModesString acts as a cache for when we introduce users
-	supportedChannelModesString = SupportedChannelModes.String()
-
 	// DefaultChannelModes are enabled on brand new channels when they're created.
 	// this can be overridden in the `channels` config, with the `default-modes` key
-	DefaultChannelModes = Modes{
-		NoOutside, OpOnlyTopic,
-	}
-
-	// ChannelPrivModes holds the list of modes that are privileged, ie founder/op/halfop, in order.
-	// voice is not in this list because it cannot perform channel operator actions.
-	ChannelPrivModes = Modes{
-		ChannelFounder, ChannelAdmin, ChannelOperator, Halfop,
-	}
-
-	ChannelModePrefixes = map[Mode]string{
-		ChannelFounder:  "~",
-		ChannelAdmin:    "&",
-		ChannelOperator: "@",
-		Halfop:          "%",
-		Voice:           "+",
+	DefaultChannelModes = modes.Modes{
+		modes.NoOutside, modes.OpOnlyTopic,
 	}
 )
 
-//
-// channel membership prefixes
-//
-
-// SplitChannelMembershipPrefixes takes a target and returns the prefixes on it, then the name.
-func SplitChannelMembershipPrefixes(target string) (prefixes string, name string) {
-	name = target
-	for {
-		if len(name) > 0 && strings.Contains("~&@%+", string(name[0])) {
-			prefixes += string(name[0])
-			name = name[1:]
-		} else {
-			break
-		}
-	}
-
-	return prefixes, name
-}
-
-// GetLowestChannelModePrefix returns the lowest channel prefix mode out of the given prefixes.
-func GetLowestChannelModePrefix(prefixes string) *Mode {
-	var lowest *Mode
-
-	if strings.Contains(prefixes, "+") {
-		lowest = &Voice
-	} else {
-		for i, mode := range ChannelPrivModes {
-			if strings.Contains(prefixes, ChannelModePrefixes[mode]) {
-				lowest = &ChannelPrivModes[i]
-			}
-		}
-	}
-
-	return lowest
-}
-
-//
-// commands
-//
-
-// ParseUserModeChanges returns the valid changes, and the list of unknown chars.
-func ParseUserModeChanges(params ...string) (ModeChanges, map[rune]bool) {
-	changes := make(ModeChanges, 0)
-	unknown := make(map[rune]bool)
-
-	op := List
-
-	if 0 < len(params) {
-		modeArg := params[0]
-		skipArgs := 1
-
-		for _, mode := range modeArg {
-			if mode == '-' || mode == '+' {
-				op = ModeOp(mode)
-				continue
-			}
-			change := ModeChange{
-				mode: Mode(mode),
-				op:   op,
-			}
-
-			// put arg into modechange if needed
-			switch Mode(mode) {
-			case ServerNotice:
-				// always require arg
-				if len(params) > skipArgs {
-					change.arg = params[skipArgs]
-					skipArgs++
-				} else {
-					continue
-				}
-			}
-
-			var isKnown bool
-			for _, supportedMode := range SupportedUserModes {
-				if rune(supportedMode) == mode {
-					isKnown = true
-					break
-				}
-			}
-			if !isKnown {
-				unknown[mode] = true
-				continue
-			}
-
-			changes = append(changes, change)
-		}
-	}
-
-	return changes, unknown
-}
-
 // applyUserModeChanges applies the given changes, and returns the applied changes.
-func (client *Client) applyUserModeChanges(force bool, changes ModeChanges) ModeChanges {
-	applied := make(ModeChanges, 0)
+func (client *Client) applyUserModeChanges(force bool, changes modes.ModeChanges) modes.ModeChanges {
+	applied := make(modes.ModeChanges, 0)
 
 	for _, change := range changes {
-		switch change.mode {
-		case Bot, Invisible, WallOps, UserRoleplaying, Operator, LocalOperator, RegisteredOnly:
-			switch change.op {
-			case Add:
-				if !force && (change.mode == Operator || change.mode == LocalOperator) {
+		switch change.Mode {
+		case modes.Bot, modes.Invisible, modes.WallOps, modes.UserRoleplaying, modes.Operator, modes.LocalOperator, modes.RegisteredOnly:
+			switch change.Op {
+			case modes.Add:
+				if !force && (change.Mode == modes.Operator || change.Mode == modes.LocalOperator) {
 					continue
 				}
 
-				if client.flags[change.mode] {
+				if client.flags[change.Mode] {
 					continue
 				}
-				client.flags[change.mode] = true
+				client.flags[change.Mode] = true
 				applied = append(applied, change)
 
-			case Remove:
-				if !client.flags[change.mode] {
+			case modes.Remove:
+				if !client.flags[change.Mode] {
 					continue
 				}
-				delete(client.flags, change.mode)
+				delete(client.flags, change.Mode)
 				applied = append(applied, change)
 			}
 
-		case ServerNotice:
-			if !client.flags[Operator] {
+		case modes.ServerNotice:
+			if !client.flags[modes.Operator] {
 				continue
 			}
 			var masks []sno.Mask
-			if change.op == Add || change.op == Remove {
-				for _, char := range change.arg {
+			if change.Op == modes.Add || change.Op == modes.Remove {
+				for _, char := range change.Arg {
 					masks = append(masks, sno.Mask(char))
 				}
 			}
-			if change.op == Add {
+			if change.Op == modes.Add {
 				client.server.snomasks.AddMasks(client, masks...)
 				applied = append(applied, change)
-			} else if change.op == Remove {
+			} else if change.Op == modes.Remove {
 				client.server.snomasks.RemoveMasks(client, masks...)
 				applied = append(applied, change)
 			}
 }
 
 // ParseDefaultChannelModes parses the `default-modes` line of the config
-func ParseDefaultChannelModes(config *Config) Modes {
+func ParseDefaultChannelModes(config *Config) modes.Modes {
 	if config.Channels.DefaultModes == nil {
 		// not present in config, fall back to compile-time default
 		return DefaultChannelModes
 	}
 	modeChangeStrings := strings.Split(strings.TrimSpace(*config.Channels.DefaultModes), " ")
 	modeChanges, _ := ParseChannelModeChanges(modeChangeStrings...)
-	defaultChannelModes := make(Modes, 0)
+	defaultChannelModes := make(modes.Modes, 0)
 	for _, modeChange := range modeChanges {
-		if modeChange.op == Add {
-			defaultChannelModes = append(defaultChannelModes, modeChange.mode)
+		if modeChange.Op == modes.Add {
+			defaultChannelModes = append(defaultChannelModes, modeChange.Mode)
 		}
 	}
 	return defaultChannelModes
 }
 
 // ParseChannelModeChanges returns the valid changes, and the list of unknown chars.
-func ParseChannelModeChanges(params ...string) (ModeChanges, map[rune]bool) {
-	changes := make(ModeChanges, 0)
+func ParseChannelModeChanges(params ...string) (modes.ModeChanges, map[rune]bool) {
+	changes := make(modes.ModeChanges, 0)
 	unknown := make(map[rune]bool)
 
-	op := List
+	op := modes.List
 
 	if 0 < len(params) {
 		modeArg := params[0]
 
 		for _, mode := range modeArg {
 			if mode == '-' || mode == '+' {
-				op = ModeOp(mode)
+				op = modes.ModeOp(mode)
 				continue
 			}
-			change := ModeChange{
-				mode: Mode(mode),
-				op:   op,
+			change := modes.ModeChange{
+				Mode: modes.Mode(mode),
+				Op:   op,
 			}
 
 			// put arg into modechange if needed
-			switch Mode(mode) {
-			case BanMask, ExceptMask, InviteMask:
+			switch modes.Mode(mode) {
+			case modes.BanMask, modes.ExceptMask, modes.InviteMask:
 				if len(params) > skipArgs {
-					change.arg = params[skipArgs]
+					change.Arg = params[skipArgs]
 					skipArgs++
 				} else {
-					change.op = List
+					change.Op = modes.List
 				}
-			case ChannelFounder, ChannelAdmin, ChannelOperator, Halfop, Voice:
+			case modes.ChannelFounder, modes.ChannelAdmin, modes.ChannelOperator, modes.Halfop, modes.Voice:
 				if len(params) > skipArgs {
-					change.arg = params[skipArgs]
+					change.Arg = params[skipArgs]
 					skipArgs++
 				} else {
 					continue
 				}
-			case Key, UserLimit:
+			case modes.Key, modes.UserLimit:
 				// don't require value when removing
-				if change.op == Add {
+				if change.Op == modes.Add {
 					if len(params) > skipArgs {
-						change.arg = params[skipArgs]
+						change.Arg = params[skipArgs]
 						skipArgs++
 					} else {
 						continue
 			}
 
 			var isKnown bool
-			for _, supportedMode := range SupportedChannelModes {
+			for _, supportedMode := range modes.SupportedChannelModes {
 				if rune(supportedMode) == mode {
 					isKnown = true
 					break
 				}
 			}
-			for _, supportedMode := range ChannelPrivModes {
+			for _, supportedMode := range modes.ChannelPrivModes {
 				if rune(supportedMode) == mode {
 					isKnown = true
 					break
 				}
 			}
-			if mode == rune(Voice) {
+			if mode == rune(modes.Voice) {
 				isKnown = true
 			}
 			if !isKnown {
 }
 
 // ApplyChannelModeChanges applies a given set of mode changes.
-func (channel *Channel) ApplyChannelModeChanges(client *Client, isSamode bool, changes ModeChanges) ModeChanges {
+func (channel *Channel) ApplyChannelModeChanges(client *Client, isSamode bool, changes modes.ModeChanges) modes.ModeChanges {
 	// so we only output one warning for each list type when full
-	listFullWarned := make(map[Mode]bool)
+	listFullWarned := make(map[modes.Mode]bool)
 
-	clientIsOp := channel.ClientIsAtLeast(client, ChannelOperator)
+	clientIsOp := channel.ClientIsAtLeast(client, modes.ChannelOperator)
 	var alreadySentPrivError bool
 
-	applied := make(ModeChanges, 0)
+	applied := make(modes.ModeChanges, 0)
 
-	isListOp := func(change ModeChange) bool {
-		return (change.op == List) || (change.arg == "")
+	isListOp := func(change modes.ModeChange) bool {
+		return (change.Op == modes.List) || (change.Arg == "")
 	}
 
-	hasPrivs := func(change ModeChange) bool {
+	hasPrivs := func(change modes.ModeChange) bool {
 		if isSamode {
 			return true
 		}
-		switch change.mode {
-		case ChannelFounder, ChannelAdmin, ChannelOperator, Halfop, Voice:
+		switch change.Mode {
+		case modes.ChannelFounder, modes.ChannelAdmin, modes.ChannelOperator, modes.Halfop, modes.Voice:
 			// Admins can't give other people Admin or remove it from others
-			if change.mode == ChannelAdmin {
+			if change.Mode == modes.ChannelAdmin {
 				return false
 			}
-			if change.op == List {
+			if change.Op == modes.List {
 				return true
 			}
-			cfarg, _ := CasefoldName(change.arg)
-			if change.op == Remove && cfarg == client.nickCasefolded {
+			cfarg, _ := CasefoldName(change.Arg)
+			if change.Op == modes.Remove && cfarg == client.nickCasefolded {
 				// "There is no restriction, however, on anyone `deopping' themselves"
 				// <https://tools.ietf.org/html/rfc2812#section-3.1.5>
 				return true
 			}
-			return channel.ClientIsAtLeast(client, change.mode)
-		case BanMask:
+			return channel.ClientIsAtLeast(client, change.Mode)
+		case modes.BanMask:
 			// #163: allow unprivileged users to list ban masks
 			return clientIsOp || isListOp(change)
 		default:
 			continue
 		}
 
-		switch change.mode {
-		case BanMask, ExceptMask, InviteMask:
+		switch change.Mode {
+		case modes.BanMask, modes.ExceptMask, modes.InviteMask:
 			if isListOp(change) {
-				channel.ShowMaskList(client, change.mode)
+				channel.ShowMaskList(client, change.Mode)
 				continue
 			}
 
 			// confirm mask looks valid
-			mask, err := Casefold(change.arg)
+			mask, err := Casefold(change.Arg)
 			if err != nil {
 				continue
 			}
 
-			switch change.op {
-			case Add:
-				if channel.lists[change.mode].Length() >= client.server.Limits().ChanListModes {
-					if !listFullWarned[change.mode] {
-						client.Send(nil, client.server.name, ERR_BANLISTFULL, client.Nick(), channel.Name(), change.mode.String(), client.t("Channel list is full"))
-						listFullWarned[change.mode] = true
+			switch change.Op {
+			case modes.Add:
+				if channel.lists[change.Mode].Length() >= client.server.Limits().ChanListModes {
+					if !listFullWarned[change.Mode] {
+						client.Send(nil, client.server.name, ERR_BANLISTFULL, client.Nick(), channel.Name(), change.Mode.String(), client.t("Channel list is full"))
+						listFullWarned[change.Mode] = true
 					}
 					continue
 				}
 
-				channel.lists[change.mode].Add(mask)
+				channel.lists[change.Mode].Add(mask)
 				applied = append(applied, change)
 
-			case Remove:
-				channel.lists[change.mode].Remove(mask)
+			case modes.Remove:
+				channel.lists[change.Mode].Remove(mask)
 				applied = append(applied, change)
 			}
 
-		case UserLimit:
-			switch change.op {
-			case Add:
-				val, err := strconv.ParseUint(change.arg, 10, 64)
+		case modes.UserLimit:
+			switch change.Op {
+			case modes.Add:
+				val, err := strconv.ParseUint(change.Arg, 10, 64)
 				if err == nil {
 					channel.setUserLimit(val)
 					applied = append(applied, change)
 				}
 
-			case Remove:
+			case modes.Remove:
 				channel.setUserLimit(0)
 				applied = append(applied, change)
 			}
 
-		case Key:
-			switch change.op {
-			case Add:
-				channel.setKey(change.arg)
+		case modes.Key:
+			switch change.Op {
+			case modes.Add:
+				channel.setKey(change.Arg)
 
-			case Remove:
+			case modes.Remove:
 				channel.setKey("")
 			}
 			applied = append(applied, change)
 
-		case InviteOnly, Moderated, NoOutside, OpOnlyTopic, RegisteredOnly, Secret, ChanRoleplaying:
-			if change.op == List {
+		case modes.InviteOnly, modes.Moderated, modes.NoOutside, modes.OpOnlyTopic, modes.RegisteredOnly, modes.Secret, modes.ChanRoleplaying:
+			if change.Op == modes.List {
 				continue
 			}
 
-			already := channel.setMode(change.mode, change.op == Add)
+			already := channel.setMode(change.Mode, change.Op == modes.Add)
 			if !already {
 				applied = append(applied, change)
 			}
 
-		case ChannelFounder, ChannelAdmin, ChannelOperator, Halfop, Voice:
-			if change.op == List {
+		case modes.ChannelFounder, modes.ChannelAdmin, modes.ChannelOperator, modes.Halfop, modes.Voice:
+			if change.Op == modes.List {
 				continue
 			}
 
-			change := channel.applyModeMemberNoMutex(client, change.mode, change.op, change.arg)
+			change := channel.applyModeMemberNoMutex(client, change.Mode, change.Op, change.Arg)
 			if change != nil {
 				applied = append(applied, *change)
 			}

irc/modes/modes.go

+// Copyright (c) 2012-2014 Jeremy Latt
+// Copyright (c) 2014-2015 Edmund Huber
+// Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
+// released under the MIT license
+
+package modes
+
+import (
+	"strings"
+)
+
+var (
+	// SupportedUserModes are the user modes that we actually support (modifying).
+	SupportedUserModes = Modes{
+		Away, Bot, Invisible, Operator, RegisteredOnly, ServerNotice, UserRoleplaying,
+	}
+
+	// SupportedChannelModes are the channel modes that we support.
+	SupportedChannelModes = Modes{
+		BanMask, ChanRoleplaying, ExceptMask, InviteMask, InviteOnly, Key,
+		Moderated, NoOutside, OpOnlyTopic, RegisteredOnly, Secret, UserLimit,
+	}
+)
+
+// ModeOp is an operation performed with modes
+type ModeOp rune
+
+func (op ModeOp) String() string {
+	return string(op)
+}
+
+const (
+	// Add is used when adding the given key.
+	Add ModeOp = '+'
+	// List is used when listing modes (for instance, listing the current bans on a channel).
+	List ModeOp = '='
+	// Remove is used when taking away the given key.
+	Remove ModeOp = '-'
+)
+
+// Mode represents a user/channel/server mode
+type Mode rune
+
+func (mode Mode) String() string {
+	return string(mode)
+}
+
+// ModeChange is a single mode changing
+type ModeChange struct {
+	Mode Mode
+	Op   ModeOp
+	Arg  string
+}
+
+func (change *ModeChange) String() (str string) {
+	if (change.Op == Add) || (change.Op == Remove) {
+		str = change.Op.String()
+	}
+	str += change.Mode.String()
+	if change.Arg != "" {
+		str += " " + change.Arg
+	}
+	return
+}
+
+// ModeChanges are a collection of 'ModeChange's
+type ModeChanges []ModeChange
+
+func (changes ModeChanges) String() string {
+	if len(changes) == 0 {
+		return ""
+	}
+
+	op := changes[0].Op
+	str := changes[0].Op.String()
+
+	for _, change := range changes {
+		if change.Op != op {
+			op = change.Op
+			str += change.Op.String()
+		}
+		str += change.Mode.String()
+	}
+
+	for _, change := range changes {
+		if change.Arg == "" {
+			continue
+		}
+		str += " " + change.Arg
+	}
+	return str
+}
+
+// Modes is just a raw list of modes
+type Modes []Mode
+
+func (modes Modes) String() string {
+	strs := make([]string, len(modes))
+	for index, mode := range modes {
+		strs[index] = mode.String()
+	}
+	return strings.Join(strs, "")
+}
+
+// User Modes
+const (
+	Away            Mode = 'a'
+	Bot             Mode = 'B'
+	Invisible       Mode = 'i'
+	LocalOperator   Mode = 'O'
+	Operator        Mode = 'o'
+	Restricted      Mode = 'r'
+	RegisteredOnly  Mode = 'R'
+	ServerNotice    Mode = 's'
+	TLS             Mode = 'Z'
+	UserRoleplaying Mode = 'E'
+	WallOps         Mode = 'w'
+)
+
+// Channel Modes
+const (
+	BanMask         Mode = 'b' // arg
+	ChanRoleplaying Mode = 'E' // flag
+	ExceptMask      Mode = 'e' // arg
+	InviteMask      Mode = 'I' // arg
+	InviteOnly      Mode = 'i' // flag
+	Key             Mode = 'k' // flag arg
+	Moderated       Mode = 'm' // flag
+	NoOutside       Mode = 'n' // flag
+	OpOnlyTopic     Mode = 't' // flag
+	// RegisteredOnly mode is reused here from umode definition
+	Secret    Mode = 's' // flag
+	UserLimit Mode = 'l' // flag arg
+)
+
+var (
+	ChannelFounder  Mode = 'q' // arg
+	ChannelAdmin    Mode = 'a' // arg
+	ChannelOperator Mode = 'o' // arg
+	Halfop          Mode = 'h' // arg
+	Voice           Mode = 'v' // arg
+
+	// ChannelPrivModes holds the list of modes that are privileged, ie founder/op/halfop, in order.
+	// voice is not in this list because it cannot perform channel operator actions.
+	ChannelPrivModes = Modes{
+		ChannelFounder, ChannelAdmin, ChannelOperator, Halfop,
+	}
+
+	ChannelModePrefixes = map[Mode]string{
+		ChannelFounder:  "~",
+		ChannelAdmin:    "&",
+		ChannelOperator: "@",
+		Halfop:          "%",
+		Voice:           "+",
+	}
+)
+
+//
+// channel membership prefixes
+//
+
+// SplitChannelMembershipPrefixes takes a target and returns the prefixes on it, then the name.
+func SplitChannelMembershipPrefixes(target string) (prefixes string, name string) {
+	name = target
+	for {
+		if len(name) > 0 && strings.Contains("~&@%+", string(name[0])) {
+			prefixes += string(name[0])
+			name = name[1:]
+		} else {
+			break
+		}
+	}
+
+	return prefixes, name
+}
+
+// GetLowestChannelModePrefix returns the lowest channel prefix mode out of the given prefixes.
+func GetLowestChannelModePrefix(prefixes string) *Mode {
+	var lowest *Mode
+
+	if strings.Contains(prefixes, "+") {
+		lowest = &Voice
+	} else {
+		for i, mode := range ChannelPrivModes {
+			if strings.Contains(prefixes, ChannelModePrefixes[mode]) {
+				lowest = &ChannelPrivModes[i]
+			}
+		}
+	}
+
+	return lowest
+}
+
+//
+// commands
+//
+
+// ParseUserModeChanges returns the valid changes, and the list of unknown chars.
+func ParseUserModeChanges(params ...string) (ModeChanges, map[rune]bool) {
+	changes := make(ModeChanges, 0)
+	unknown := make(map[rune]bool)
+
+	op := List
+
+	if 0 < len(params) {
+		modeArg := params[0]
+		skipArgs := 1
+
+		for _, mode := range modeArg {
+			if mode == '-' || mode == '+' {
+				op = ModeOp(mode)
+				continue
+			}
+			change := ModeChange{
+				Mode: Mode(mode),
+				Op:   op,
+			}
+
+			// put arg into modechange if needed
+			switch Mode(mode) {
+			case ServerNotice:
+				// always require arg
+				if len(params) > skipArgs {
+					change.Arg = params[skipArgs]
+					skipArgs++
+				} else {
+					continue
+				}
+			}
+
+			var isKnown bool
+			for _, supportedMode := range SupportedUserModes {
+				if rune(supportedMode) == mode {
+					isKnown = true
+					break
+				}
+			}
+			if !isKnown {
+				unknown[mode] = true
+				continue
+			}
+
+			changes = append(changes, change)
+		}
+	}
+
+	return changes, unknown
+}
+
+// ModeSet holds a set of modes.
+type ModeSet map[Mode]bool
+
+// String returns the modes in this set.
+func (set ModeSet) String() string {
+	if len(set) == 0 {
+		return ""
+	}
+	strs := make([]string, len(set))
+	index := 0
+	for mode := range set {
+		strs[index] = mode.String()
+		index++
+	}
+	return strings.Join(strs, "")
+}
+
+// Prefixes returns a list of prefixes for the given set of channel modes.
+func (set ModeSet) Prefixes(isMultiPrefix bool) string {
+	var prefixes string
+
+	// add prefixes in order from highest to lowest privs
+	for _, mode := range ChannelPrivModes {
+		if set[mode] {
+			prefixes += ChannelModePrefixes[mode]
+		}
+	}
+	if set[Voice] {
+		prefixes += ChannelModePrefixes[Voice]
+	}
+
+	if !isMultiPrefix && len(prefixes) > 1 {
+		prefixes = string(prefixes[0])
+	}
+
+	return prefixes
+}

irc/roleplay.go

 	"fmt"
 
 	"github.com/oragono/oragono/irc/caps"
+	"github.com/oragono/oragono/irc/modes"
 )
 
 const (
 			return
 		}
 
-		if !channel.flags[ChanRoleplaying] {
+		if !channel.flags[modes.ChanRoleplaying] {
 			client.Send(nil, client.server.name, ERR_CANNOTSENDRP, channel.name, client.t("Channel doesn't have roleplaying mode available"))
 			return
 		}
 			return
 		}
 
-		if !user.flags[UserRoleplaying] {
+		if !user.flags[modes.UserRoleplaying] {
 			client.Send(nil, client.server.name, ERR_CANNOTSENDRP, user.nick, client.t("User doesn't have roleplaying mode enabled"))
 			return
 		}
 		if client.capabilities.Has(caps.EchoMessage) {
 			client.Send(nil, source, "PRIVMSG", user.nick, message)
 		}
-		if user.flags[Away] {
+		if user.flags[modes.Away] {
 			//TODO(dan): possibly implement cooldown of away notifications to users
 			client.Send(nil, server.name, RPL_AWAY, user.nick, user.awayMessage)
 		}

irc/server.go

 	"github.com/oragono/oragono/irc/isupport"
 	"github.com/oragono/oragono/irc/languages"
 	"github.com/oragono/oragono/irc/logger"
+	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/passwd"
 	"github.com/oragono/oragono/irc/sno"
 	"github.com/oragono/oragono/irc/utils"
 	couldNotParseIPMsg, _ = (&[]ircmsg.IrcMessage{ircmsg.MakeMessage(nil, "", "ERROR", "Unable to parse your IP address")}[0]).Line()
 
 	RenamePrivsNeeded = errors.New("Only chanops can rename channels")
+
+	// supportedUserModesString acts as a cache for when we introduce users
+	supportedUserModesString = modes.SupportedUserModes.String()
+	// supportedChannelModesString acts as a cache for when we introduce users
+	supportedChannelModesString = modes.SupportedChannelModes.String()
 )
 
 // Limits holds the maximum limits for various things such as topic lengths.
 	connectionLimiter            *connection_limits.Limiter
 	connectionThrottler          *connection_limits.Throttler
 	ctime                        time.Time
-	defaultChannelModes          Modes
+	defaultChannelModes          modes.Modes
 	dlines                       *DLineManager
 	loggingRawIO                 bool
 	isupport                     *isupport.List
 	isupport := isupport.NewList()
 	isupport.Add("AWAYLEN", strconv.Itoa(server.limits.AwayLen))
 	isupport.Add("CASEMAPPING", "ascii")
-	isupport.Add("CHANMODES", strings.Join([]string{Modes{BanMask, ExceptMask, InviteMask}.String(), "", Modes{UserLimit, Key}.String(), Modes{InviteOnly, Moderated, NoOutside, OpOnlyTopic, ChanRoleplaying, Secret}.String()}, ","))
+	isupport.Add("CHANMODES", strings.Join([]string{modes.Modes{modes.BanMask, modes.ExceptMask, modes.InviteMask}.String(), "", modes.Modes{modes.UserLimit, modes.Key}.String(), modes.Modes{modes.InviteOnly, modes.Moderated, modes.NoOutside, modes.OpOnlyTopic, modes.ChanRoleplaying, modes.Secret}.String()}, ","))
 	isupport.Add("CHANNELLEN", strconv.Itoa(server.limits.ChannelLen))
 	isupport.Add("CHANTYPES", "#")
 	isupport.Add("ELIST", "U")
 	server.configurableStateMutex.Unlock()
 }
 
-func loadChannelList(channel *Channel, list string, maskMode Mode) {
+func loadChannelList(channel *Channel, list string, maskMode modes.Mode) {
 	if list == "" {
 		return
 	}
 	var chstrs []string
 	for _, channel := range client.Channels() {
 		// channel is secret and the target can't see it
-		if !target.flags[Operator] && channel.HasMode(Secret) && !channel.hasClient(target) {
+		if !target.flags[modes.Operator] && channel.HasMode(modes.Secret) && !channel.hasClient(target) {
 			continue
 		}
 		chstrs = append(chstrs, channel.ClientPrefixes(client, isMultiPrefix)+channel.name)
 	if target.class != nil {
 		client.Send(nil, client.server.name, RPL_WHOISOPERATOR, client.nick, target.nick, target.whoisLine)
 	}
-	if client.flags[Operator] || client == target {
+	if client.flags[modes.Operator] || client == target {
 		client.Send(nil, client.server.name, RPL_WHOISACTUALLY, client.nick, target.nick, fmt.Sprintf("%s@%s", target.username, utils.LookupHostname(target.IPString())), target.IPString(), client.t("Actual user@host, Actual IP"))
 	}
-	if target.flags[TLS] {
+	if target.flags[modes.TLS] {
 		client.Send(nil, client.server.name, RPL_WHOISSECURE, client.nick, target.nick, client.t("is using a secure connection"))
 	}
 	accountName := target.AccountName()
 	if accountName != "" {
 		client.Send(nil, client.server.name, RPL_WHOISACCOUNT, client.nick, accountName, client.t("is logged in as"))
 	}
-	if target.flags[Bot] {
+	if target.flags[modes.Bot] {
 		client.Send(nil, client.server.name, RPL_WHOISBOT, client.nick, target.nick, ircfmt.Unescape(fmt.Sprintf(client.t("is a $bBot$b on %s"), client.server.networkName)))
 	}
 
 		client.Send(nil, client.server.name, RPL_WHOISLANGUAGE, params...)
 	}
 
-	if target.certfp != "" && (client.flags[Operator] || client == target) {
+	if target.certfp != "" && (client.flags[modes.Operator] || client == target) {
 		client.Send(nil, client.server.name, RPL_WHOISCERTFP, client.nick, target.nick, fmt.Sprintf(client.t("has client certificate fingerprint %s"), target.certfp))
 	}
 	client.Send(nil, client.server.name, RPL_WHOISIDLE, client.nick, target.nick, strconv.FormatUint(target.IdleSeconds(), 10), strconv.FormatInt(target.SignonTime(), 10), client.t("seconds idle, signon time"))
 	channelName := "*"
 	flags := ""
 
-	if client.HasMode(Away) {
+	if client.HasMode(modes.Away) {
 		flags = "G"
 	} else {
 		flags = "H"
 	}
-	if client.HasMode(Operator) {
+	if client.HasMode(modes.Operator) {
 		flags += "*"
 	}
 
 
 func whoChannel(client *Client, channel *Channel, friends ClientSet) {
 	for _, member := range channel.Members() {
-		if !client.flags[Invisible] || friends[client] {
+		if !client.flags[modes.Invisible] || friends[client] {
 			client.rplWhoReply(channel, member)
 		}
 	}
 }
 
 // GetDefaultChannelModes returns our default channel modes.
-func (server *Server) GetDefaultChannelModes() Modes {
+func (server *Server) GetDefaultChannelModes() modes.Modes {
 	server.configurableStateMutex.RLock()
 	defer server.configurableStateMutex.RUnlock()
 	return server.defaultChannelModes
 func (target *Client) RplList(channel *Channel) {
 	// get the correct number of channel members
 	var memberCount int
-	if target.flags[Operator] || channel.hasClient(target) {
+	if target.flags[modes.Operator] || channel.hasClient(target) {
 		memberCount = len(channel.Members())
 	} else {
 		for _, member := range channel.Members() {
-			if !member.HasMode(Invisible) {
+			if !member.HasMode(modes.Invisible) {
 				memberCount++
 			}
 		}
 	}
 
 	// limit regular users to only listing one channel
-	if !client.flags[Operator] {
+	if !client.flags[modes.Operator] {
 		channels = channels[:1]
 	}
 

irc/types.go

 
 package irc
 
-import (
-	"strings"
-)
-
-// ModeSet holds a set of modes.
-type ModeSet map[Mode]bool
-
-// String returns the modes in this set.
-func (set ModeSet) String() string {
-	if len(set) == 0 {
-		return ""
-	}
-	strs := make([]string, len(set))
-	index := 0
-	for mode := range set {
-		strs[index] = mode.String()
-		index++
-	}
-	return strings.Join(strs, "")
-}
+import "github.com/oragono/oragono/irc/modes"
 
 // ClientSet is a set of clients.
 type ClientSet map[*Client]bool
 }
 
 // MemberSet is a set of members with modes.
-type MemberSet map[*Client]ModeSet
+type MemberSet map[*Client]modes.ModeSet
 
 // Add adds the given client to this set.
 func (members MemberSet) Add(member *Client) {
-	members[member] = make(ModeSet)
+	members[member] = make(modes.ModeSet)
 }
 
 // Remove removes the given client from this set.
 }
 
 // HasMode returns true if the given client is in this set with the given mode.
-func (members MemberSet) HasMode(member *Client, mode Mode) bool {
+func (members MemberSet) HasMode(member *Client, mode modes.Mode) bool {
 	modes, ok := members[member]
 	if !ok {
 		return false
 }
 
 // AnyHasMode returns true if any of our clients has the given mode.
-func (members MemberSet) AnyHasMode(mode Mode) bool {
+func (members MemberSet) AnyHasMode(mode modes.Mode) bool {
 	for _, modes := range members {
 		if modes[mode] {
 			return true