Merge pull request #352 from slingamn/chanreglimit.1

track channel registrations per account

irc/accounts.go

 	keyAccountEnforcement      = "account.customenforcement %s"
 	keyAccountVHost            = "account.vhost %s"
 	keyCertToAccount           = "account.creds.certfp %s"
+	keyAccountChannels         = "account.channels %s"
 
 	keyVHostQueueAcctToId = "vhostQueue %s"
 	vhostRequestIdx       = "vhostQueue"
 	nicksKey := fmt.Sprintf(keyAccountAdditionalNicks, casefoldedAccount)
 	vhostKey := fmt.Sprintf(keyAccountVHost, casefoldedAccount)
 	vhostQueueKey := fmt.Sprintf(keyVHostQueueAcctToId, casefoldedAccount)
+	channelsKey := fmt.Sprintf(keyAccountChannels, casefoldedAccount)
 
 	var clients []*Client
 
+	var registeredChannels []string
+	// on our way out, unregister all the account's channels and delete them from the db
+	defer func() {
+		for _, channelName := range registeredChannels {
+			info := am.server.channelRegistry.LoadChannel(channelName)
+			if info != nil && info.Founder == casefoldedAccount {
+				am.server.channelRegistry.Delete(channelName, *info)
+			}
+			channel := am.server.channels.Get(channelName)
+			if channel != nil {
+				channel.SetUnregistered(casefoldedAccount)
+			}
+		}
+	}()
+
 	var credText string
 	var rawNicks string
 
 	defer am.serialCacheUpdateMutex.Unlock()
 
 	var accountName string
+	var channelsStr string
 	am.server.store.Update(func(tx *buntdb.Tx) error {
 		tx.Delete(accountKey)
 		accountName, _ = tx.Get(accountNameKey)
 		credText, err = tx.Get(credentialsKey)
 		tx.Delete(credentialsKey)
 		tx.Delete(vhostKey)
+		channelsStr, _ = tx.Get(channelsKey)
+		tx.Delete(channelsKey)
+
 		_, err := tx.Delete(vhostQueueKey)
 		am.decrementVHostQueueCount(casefoldedAccount, err)
 		return nil
 
 	skeleton, _ := Skeleton(accountName)
 	additionalNicks := unmarshalReservedNicks(rawNicks)
+	registeredChannels = unmarshalRegisteredChannels(channelsStr)
 
 	am.Lock()
 	defer am.Unlock()
 	if err != nil {
 		return errAccountDoesNotExist
 	}
+
 	return nil
 }
 
+func unmarshalRegisteredChannels(channelsStr string) (result []string) {
+	if channelsStr != "" {
+		result = strings.Split(channelsStr, ",")
+	}
+	return
+}
+
+func (am *AccountManager) ChannelsForAccount(account string) (channels []string) {
+	cfaccount, err := CasefoldName(account)
+	if err != nil {
+		return
+	}
+
+	var channelStr string
+	key := fmt.Sprintf(keyAccountChannels, cfaccount)
+	am.server.store.View(func(tx *buntdb.Tx) error {
+		channelStr, _ = tx.Get(key)
+		return nil
+	})
+	return unmarshalRegisteredChannels(channelStr)
+}
+
 func (am *AccountManager) AuthenticateByCertFP(client *Client) error {
 	if client.certfp == "" {
 		return errAccountInvalidCredentials

irc/channel.go

 }
 
 // SetUnregistered deletes the channel's registration information.
-func (channel *Channel) SetUnregistered() {
+func (channel *Channel) SetUnregistered(expectedFounder string) {
 	channel.stateMutex.Lock()
 	defer channel.stateMutex.Unlock()
 
+	if channel.registeredFounder != expectedFounder {
+		return
+	}
 	channel.registeredFounder = ""
 	var zeroTime time.Time
 	channel.registeredTime = zeroTime

irc/channelreg.go

 			for _, keyFmt := range channelKeyStrings {
 				tx.Delete(fmt.Sprintf(keyFmt, key))
 			}
+
+			// remove this channel from the client's list of registered channels
+			channelsKey := fmt.Sprintf(keyAccountChannels, info.Founder)
+			channelsStr, err := tx.Get(channelsKey)
+			if err == buntdb.ErrNotFound {
+				return
+			}
+			registeredChannels := unmarshalRegisteredChannels(channelsStr)
+			var nowRegisteredChannels []string
+			for _, channel := range registeredChannels {
+				if channel != key {
+					nowRegisteredChannels = append(nowRegisteredChannels, channel)
+				}
+			}
+			tx.Set(channelsKey, strings.Join(nowRegisteredChannels, ","), nil)
 		}
 	}
 }
 
 // saveChannel saves a channel to the store.
 func (reg *ChannelRegistry) saveChannel(tx *buntdb.Tx, channelKey string, channelInfo RegisteredChannel, includeFlags uint) {
+	// maintain the mapping of account -> registered channels
+	chanExistsKey := fmt.Sprintf(keyChannelExists, channelKey)
+	_, existsErr := tx.Get(chanExistsKey)
+	if existsErr == buntdb.ErrNotFound {
+		// this is a new registration, need to update account-to-channels
+		accountChannelsKey := fmt.Sprintf(keyAccountChannels, channelInfo.Founder)
+		alreadyChannels, _ := tx.Get(accountChannelsKey)
+		newChannels := channelKey // this is the casefolded channel name
+		if alreadyChannels != "" {
+			newChannels = fmt.Sprintf("%s,%s", alreadyChannels, newChannels)
+		}
+		tx.Set(accountChannelsKey, newChannels, nil)
+	}
+
 	if includeFlags&IncludeInitial != 0 {
-		tx.Set(fmt.Sprintf(keyChannelExists, channelKey), "1", nil)
+		tx.Set(chanExistsKey, "1", nil)
 		tx.Set(fmt.Sprintf(keyChannelName, channelKey), channelInfo.Name, nil)
 		tx.Set(fmt.Sprintf(keyChannelRegTime, channelKey), strconv.FormatInt(channelInfo.RegisteredAt.Unix(), 10), nil)
 		tx.Set(fmt.Sprintf(keyChannelFounder, channelKey), channelInfo.Founder, nil)

irc/chanserv.go

 		return
 	}
 
+	account := client.Account()
+	channelsAlreadyRegistered := server.accounts.ChannelsForAccount(account)
+	if server.Config().Channels.Registration.MaxChannelsPerAccount <= len(channelsAlreadyRegistered) {
+		csNotice(rb, client.t("You have already registered the maximum number of channels; try dropping some with /CS UNREGISTER"))
+		return
+	}
+
 	// this provides the synchronization that allows exactly one registration of the channel:
-	err = channelInfo.SetRegistered(client.Account())
+	err = channelInfo.SetRegistered(account)
 	if err != nil {
 		csNotice(rb, err.Error())
 		return
 		return
 	}
 
-	hasPrivs := client.HasRoleCapabs("chanreg")
-	if !hasPrivs {
-		founder := channel.Founder()
-		hasPrivs = founder != "" && founder == client.Account()
+	founder := channel.Founder()
+	if founder == "" {
+		csNotice(rb, client.t("That channel is not registered"))
+		return
 	}
+
+	hasPrivs := client.HasRoleCapabs("chanreg") || founder == client.Account()
 	if !hasPrivs {
 		csNotice(rb, client.t("Insufficient privileges"))
 		return
 		return
 	}
 
-	channel.SetUnregistered()
-	go server.channelRegistry.Delete(channelKey, info)
+	channel.SetUnregistered(founder)
+	server.channelRegistry.Delete(channelKey, info)
 	csNotice(rb, fmt.Sprintf(client.t("Channel %s is now unregistered"), channelKey))
 }
 

irc/config.go

 
 // ChannelRegistrationConfig controls channel registration.
 type ChannelRegistrationConfig struct {
-	Enabled bool
+	Enabled               bool
+	MaxChannelsPerAccount int `yaml:"max-channels-per-account"`
 }
 
 // OperClassConfig defines a specific operator class.
 	Accounts AccountConfig
 
 	Channels struct {
-		DefaultModes *string `yaml:"default-modes"`
-		defaultModes modes.Modes
-		Registration ChannelRegistrationConfig
+		DefaultModes         *string `yaml:"default-modes"`
+		defaultModes         modes.Modes
+		MaxChannelsPerClient int `yaml:"max-channels-per-client"`
+		Registration         ChannelRegistrationConfig
 	}
 
 	OperClasses map[string]*OperClassConfig `yaml:"oper-classes"`
 		config.Accounts.Registration.BcryptCost = passwd.DefaultCost
 	}
 
+	if config.Channels.MaxChannelsPerClient == 0 {
+		config.Channels.MaxChannelsPerClient = 100
+	}
+	if config.Channels.Registration.MaxChannelsPerAccount == 0 {
+		config.Channels.Registration.MaxChannelsPerAccount = 15
+	}
+
 	// in the current implementation, we disable history by creating a history buffer
 	// with zero capacity. but the `enabled` config option MUST be respected regardless
 	// of this detail

irc/database.go

 	// 'version' of the database schema
 	keySchemaVersion = "db.version"
 	// latest schema of the db
-	latestDbSchema = "4"
+	latestDbSchema = "5"
 )
 
 type SchemaChanger func(*Config, *buntdb.Tx) error
 	return nil
 }
 
+// create new key tracking channels that belong to an account
+func schemaChangeV4ToV5(config *Config, tx *buntdb.Tx) error {
+	founderToChannels := make(map[string][]string)
+	prefix := "channel.founder "
+	tx.AscendGreaterOrEqual("", prefix, func(key, value string) bool {
+		if !strings.HasPrefix(key, prefix) {
+			return false
+		}
+		channel := strings.TrimPrefix(key, prefix)
+		founderToChannels[value] = append(founderToChannels[value], channel)
+		return true
+	})
+
+	for founder, channels := range founderToChannels {
+		tx.Set(fmt.Sprintf("account.channels %s", founder), strings.Join(channels, ","), nil)
+	}
+	return nil
+}
+
 func init() {
 	allChanges := []SchemaChange{
 		{
 			TargetVersion:  "4",
 			Changer:        schemaChangeV3ToV4,
 		},
+		{
+			InitialVersion: "4",
+			TargetVersion:  "5",
+			Changer:        schemaChangeV4ToV5,
+		},
 	}
 
 	// build the index

irc/getters.go

 	return
 }
 
+func (client *Client) NumChannels() int {
+	client.stateMutex.RLock()
+	defer client.stateMutex.RUnlock()
+	return len(client.channels)
+}
+
 func (client *Client) WhoWas() (result WhoWas) {
 	return client.Details().WhoWas
 }

irc/handlers.go

 		keys = strings.Split(msg.Params[1], ",")
 	}
 
+	config := server.Config()
+	oper := client.Oper()
 	for i, name := range channels {
+		if config.Channels.MaxChannelsPerClient <= client.NumChannels() && oper == nil {
+			rb.Add(nil, server.name, ERR_TOOMANYCHANNELS, client.Nick(), name, client.t("You have joined too many channels"))
+			return false
+		}
 		var key string
 		if len(keys) > i {
 			key = keys[i]

irc/nickserv.go

 	for _, nick := range account.AdditionalNicks {
 		nsNotice(rb, fmt.Sprintf(client.t("Additional grouped nick: %s"), nick))
 	}
+	for _, channel := range server.accounts.ChannelsForAccount(accountName) {
+		nsNotice(rb, fmt.Sprintf(client.t("Registered channel: %s"), channel))
+	}
 }
 
 func nsRegisterHandler(server *Server, client *Client, command string, params []string, rb *ResponseBuffer) {

oragono.yaml

     # see  /QUOTE HELP cmodes  for more channel modes
     default-modes: +nt
 
+    # how many channels can a client be in at once?
+    max-channels-per-client: 100
+
     # channel registration - requires an account
     registration:
         # can users register new channels?
         enabled: true
 
+        # how many channels can each account register?
+        max-channels-per-account: 15
+
 # operator classes
 oper-classes:
     # local operator