initial implementation of bouncer functionality

gencapdefs.py

         url="https://ircv3.net/specs/extensions/userhost-in-names-3.2.html",
         standard="IRCv3",
     ),
+    CapDef(
+        identifier="Bouncer",
+        name="oragono.io/bnc",
+        url="https://oragono.io/bnc",
+        standard="Oragono-specific",
+    ),
+    CapDef(
+        identifier="ZNCSelfMessage",
+        name="znc.in/self-message",
+        url="https://wiki.znc.in/Query_buffers",
+        standard="ZNC vendor",
+    ),
 ]
 
 def validate_defs():

irc/accounts.go

 		nickMethod := finalEnforcementMethod(nickAccount)
 		skelMethod := finalEnforcementMethod(skelAccount)
 		switch {
-		case nickMethod == NickReservationNone && skelMethod == NickReservationNone:
-			return nickAccount, NickReservationNone
 		case skelMethod == NickReservationNone:
 			return nickAccount, nickMethod
 		case nickMethod == NickReservationNone:
 	}
 }
 
+func (am *AccountManager) BouncerAllowed(account string, session *Session) bool {
+	// TODO stub
+	config := am.server.Config()
+	if !config.Accounts.Bouncer.Enabled {
+		return false
+	}
+	return config.Accounts.Bouncer.AllowedByDefault || session.capabilities.Has(caps.Bouncer)
+}
+
 // Looks up the enforcement method stored in the database for an account
 // (typically you want EnforcementStatus instead, which respects the config)
 func (am *AccountManager) getStoredEnforcementStatus(account string) string {
 	}
 	for _, client := range clients {
 		if config.Accounts.RequireSasl.Enabled {
-			client.Quit(client.t("You are no longer authorized to be on this server"))
+			client.Quit(client.t("You are no longer authorized to be on this server"), nil)
 			// destroy acquires a semaphore so we can't call it while holding a lock
-			go client.destroy(false)
+			go client.destroy(false, nil)
 		} else {
 			am.logoutOfAccount(client)
 		}

irc/caps/defs.go

 
 const (
 	// number of recognized capabilities:
-	numCapabs = 22
+	numCapabs = 24
 	// length of the uint64 array that represents the bitset:
 	bitsetLen = 1
 )
 	// UserhostInNames is the IRCv3 capability named "userhost-in-names":
 	// https://ircv3.net/specs/extensions/userhost-in-names-3.2.html
 	UserhostInNames Capability = iota
+
+	// Bouncer is the Oragono-specific capability named "oragono.io/bnc":
+	// https://oragono.io/bnc
+	Bouncer Capability = iota
+
+	// ZNCSelfMessage is the ZNC vendor capability named "znc.in/self-message":
+	// https://wiki.znc.in/Query_buffers
+	ZNCSelfMessage Capability = iota
 )
 
 // `capabilityNames[capab]` is the string name of the capability `capab`
 		"draft/setname",
 		"sts",
 		"userhost-in-names",
+		"oragono.io/bnc",
+		"znc.in/self-message",
 	}
 )

irc/caps/set.go

 	return &newSet
 }
 
+// NewCompleteSet returns a new Set, with all defined capabilities enabled.
+func NewCompleteSet() *Set {
+	var newSet Set
+	asSlice := newSet[:]
+	for i := 0; i < numCapabs; i += 1 {
+		utils.BitsetSet(asSlice, uint(i), true)
+	}
+	return &newSet
+}
+
 // Enable enables the given capabilities.
 func (s *Set) Enable(capabs ...Capability) {
 	asSlice := s[:]
 	return utils.BitsetGet(s[:], uint(capab))
 }
 
+// HasAll returns true if the set has all the given capabilities.
+func (s *Set) HasAll(capabs ...Capability) bool {
+	for _, capab := range capabs {
+		if !s.Has(capab) {
+			return false
+		}
+	}
+	return true
+}
+
 // Union adds all the capabilities of another set to this set.
 func (s *Set) Union(other *Set) {
 	utils.BitsetUnion(s[:], other[:])
 
 	return strings.Join(strs, " ")
 }
+
+// returns whether we should send `znc.in/self-message`-style echo messages
+// to sessions other than that which originated the message
+func (capabs *Set) SelfMessagesEnabled() bool {
+	return capabs.Has(EchoMessage) || capabs.Has(ZNCSelfMessage)
+}

irc/channel.go

 
 // Names sends the list of users joined to the channel to the given client.
 func (channel *Channel) Names(client *Client, rb *ResponseBuffer) {
-	isMultiPrefix := client.capabilities.Has(caps.MultiPrefix)
-	isUserhostInNames := client.capabilities.Has(caps.UserhostInNames)
+	isMultiPrefix := rb.session.capabilities.Has(caps.MultiPrefix)
+	isUserhostInNames := rb.session.capabilities.Has(caps.UserhostInNames)
 
 	maxNamLen := 480 - len(client.server.name) - len(client.Nick())
 	var namesLines []string
 	}
 
 	for _, member := range channel.Members() {
-		if member == client {
-			continue
-		}
-		if member.capabilities.Has(caps.ExtendedJoin) {
-			member.Send(nil, details.nickMask, "JOIN", chname, details.accountName, details.realname)
-		} else {
-			member.Send(nil, details.nickMask, "JOIN", chname)
-		}
-		if givenMode != 0 {
-			member.Send(nil, client.server.name, "MODE", chname, modestr, details.nick)
+		for _, session := range member.Sessions() {
+			if session == rb.session {
+				continue
+			} else if client == session.client {
+				channel.playJoinForSession(session)
+				continue
+			}
+			if session.capabilities.Has(caps.ExtendedJoin) {
+				session.Send(nil, details.nickMask, "JOIN", chname, details.accountName, details.realname)
+			} else {
+				session.Send(nil, details.nickMask, "JOIN", chname)
+			}
+			if givenMode != 0 {
+				session.Send(nil, client.server.name, "MODE", chname, modestr, details.nick)
+			}
 		}
 	}
 
-	if client.capabilities.Has(caps.ExtendedJoin) {
+	if rb.session.capabilities.Has(caps.ExtendedJoin) {
 		rb.Add(nil, details.nickMask, "JOIN", chname, details.accountName, details.realname)
 	} else {
 		rb.Add(nil, details.nickMask, "JOIN", chname)
 	}
 
-	channel.SendTopic(client, rb, false)
-
-	channel.Names(client, rb)
+	if rb.session.client == client {
+		// don't send topic and names for a SAJOIN of a different client
+		channel.SendTopic(client, rb, false)
+		channel.Names(client, rb)
+	}
 
 	// TODO #259 can be implemented as Flush(false) (i.e., nonblocking) while holding joinPartMutex
 	rb.Flush(true)
 	}
 }
 
+// plays channel join messages (the JOIN line, topic, and names) to a session.
+// this is used when attaching a new session to an existing client that already has
+// channels, and also when one session of a client initiates a JOIN and the other
+// sessions need to receive the state change
+func (channel *Channel) playJoinForSession(session *Session) {
+	client := session.client
+	sessionRb := NewResponseBuffer(session)
+	if session.capabilities.Has(caps.ExtendedJoin) {
+		sessionRb.Add(nil, client.NickMaskString(), "JOIN", channel.Name(), client.AccountName(), client.Realname())
+	} else {
+		sessionRb.Add(nil, client.NickMaskString(), "JOIN", channel.Name())
+	}
+	channel.SendTopic(client, sessionRb, false)
+	channel.Names(client, sessionRb)
+	sessionRb.Send(false)
+}
+
 // Part parts the given client from this channel, with the given message.
 func (channel *Channel) Part(client *Client, message string, rb *ResponseBuffer) {
 	chname := channel.Name()
 		member.Send(nil, details.nickMask, "PART", chname, message)
 	}
 	rb.Add(nil, details.nickMask, "PART", chname, message)
+	for _, session := range client.Sessions() {
+		if session != rb.session {
+			session.Send(nil, details.nickMask, "PART", chname, message)
+		}
+	}
 
 	channel.history.Add(history.Item{
 		Type:        history.Part,
 	accountName := newClient.AccountName()
 	realName := newClient.Realname()
 	for _, member := range channel.Members() {
-		if member.capabilities.Has(caps.Resume) {
-			continue
-		}
+		for _, session := range member.Sessions() {
+			if session.capabilities.Has(caps.Resume) {
+				continue
+			}
 
-		if member.capabilities.Has(caps.ExtendedJoin) {
-			member.Send(nil, nickMask, "JOIN", channel.name, accountName, realName)
-		} else {
-			member.Send(nil, nickMask, "JOIN", channel.name)
-		}
+			if session.capabilities.Has(caps.ExtendedJoin) {
+				session.Send(nil, nickMask, "JOIN", channel.name, accountName, realName)
+			} else {
+				session.Send(nil, nickMask, "JOIN", channel.name)
+			}
 
-		if 0 < len(oldModes) {
-			member.Send(nil, channel.server.name, "MODE", channel.name, oldModes, nick)
+			if 0 < len(oldModes) {
+				session.Send(nil, channel.server.name, "MODE", channel.name, oldModes, nick)
+			}
 		}
 	}
 
-	rb := NewResponseBuffer(newClient)
+	rb := NewResponseBuffer(newClient.Sessions()[0])
 	// use blocking i/o to synchronize with the later history replay
-	if newClient.capabilities.Has(caps.ExtendedJoin) {
+	if rb.session.capabilities.Has(caps.ExtendedJoin) {
 		rb.Add(nil, nickMask, "JOIN", channel.name, accountName, realName)
 	} else {
 		rb.Add(nil, nickMask, "JOIN", channel.name)
 
 func (channel *Channel) replayHistoryForResume(newClient *Client, after time.Time, before time.Time) {
 	items, complete := channel.history.Between(after, before, false, 0)
-	rb := NewResponseBuffer(newClient)
+	rb := NewResponseBuffer(newClient.Sessions()[0])
 	channel.replayHistoryItems(rb, items)
 	if !complete && !newClient.resumeDetails.HistoryIncomplete {
 		// warn here if we didn't warn already
 func (channel *Channel) replayHistoryItems(rb *ResponseBuffer, items []history.Item) {
 	chname := channel.Name()
 	client := rb.target
-	serverTime := client.capabilities.Has(caps.ServerTime)
+	serverTime := rb.session.capabilities.Has(caps.ServerTime)
 
 	for _, item := range items {
 		var tags map[string]string
 // SendTopic sends the channel topic to the given client.
 // `sendNoTopic` controls whether RPL_NOTOPIC is sent when the topic is unset
 func (channel *Channel) SendTopic(client *Client, rb *ResponseBuffer, sendNoTopic bool) {
-	if !channel.hasClient(client) {
-		rb.Add(nil, client.server.name, ERR_NOTONCHANNEL, client.Nick(), channel.name, client.t("You're not on that channel"))
-		return
-	}
-
 	channel.stateMutex.RLock()
 	name := channel.name
 	topic := channel.topic
 	topicSetBy := channel.topicSetBy
 	topicSetTime := channel.topicSetTime
+	_, hasClient := channel.members[client]
 	channel.stateMutex.RUnlock()
 
+	if !hasClient {
+		rb.Add(nil, client.server.name, ERR_NOTONCHANNEL, client.Nick(), channel.name, client.t("You're not on that channel"))
+		return
+	}
+
 	if topic == "" {
 		if sendNoTopic {
 			rb.Add(nil, client.server.name, RPL_NOTOPIC, client.nick, name, client.t("No topic is set"))
 	channel.topicSetTime = time.Now()
 	channel.stateMutex.Unlock()
 
+	prefix := client.NickMaskString()
 	for _, member := range channel.Members() {
-		if member == client {
-			rb.Add(nil, client.nickMaskString, "TOPIC", channel.name, topic)
-		} else {
-			member.Send(nil, client.nickMaskString, "TOPIC", channel.name, topic)
+		for _, session := range member.Sessions() {
+			if session == rb.session {
+				rb.Add(nil, prefix, "TOPIC", channel.name, topic)
+			} else {
+				session.Send(nil, prefix, "TOPIC", channel.name, topic)
+			}
 		}
 	}
 
 		return
 	}
 
+	nickmask := client.NickMaskString()
+	account := client.AccountName()
+	chname := channel.Name()
+	now := time.Now().UTC()
+
 	// for STATUSMSG
 	var minPrefixMode modes.Mode
 	if minPrefix != nil {
 		minPrefixMode = *minPrefix
 	}
 	// send echo-message
-	if client.capabilities.Has(caps.EchoMessage) {
+	// TODO this should use `now` as the time for consistency
+	if rb.session.capabilities.Has(caps.EchoMessage) {
 		var tagsToUse map[string]string
-		if client.capabilities.Has(caps.MessageTags) {
+		if rb.session.capabilities.Has(caps.MessageTags) {
 			tagsToUse = clientOnlyTags
 		}
-		nickMaskString := client.NickMaskString()
-		accountName := client.AccountName()
-		if histType == history.Tagmsg && client.capabilities.Has(caps.MessageTags) {
-			rb.AddFromClient(message.Msgid, nickMaskString, accountName, tagsToUse, command, channel.name)
+		if histType == history.Tagmsg && rb.session.capabilities.Has(caps.MessageTags) {
+			rb.AddFromClient(message.Msgid, nickmask, account, tagsToUse, command, chname)
 		} else {
-			rb.AddSplitMessageFromClient(nickMaskString, accountName, tagsToUse, command, channel.name, message)
+			rb.AddSplitMessageFromClient(nickmask, account, tagsToUse, command, chname, message)
 		}
 	}
-
-	nickmask := client.NickMaskString()
-	account := client.AccountName()
-
-	now := time.Now().UTC()
-
-	for _, member := range channel.Members() {
-		if minPrefix != nil && !channel.ClientIsAtLeast(member, minPrefixMode) {
-			// STATUSMSG
+	// send echo-message to other connected sessions
+	for _, session := range client.Sessions() {
+		if session == rb.session || !session.capabilities.SelfMessagesEnabled() {
 			continue
 		}
+		var tagsToUse map[string]string
+		if session.capabilities.Has(caps.MessageTags) {
+			tagsToUse = clientOnlyTags
+		}
+		if histType == history.Tagmsg && session.capabilities.Has(caps.MessageTags) {
+			session.sendFromClientInternal(false, now, message.Msgid, nickmask, account, tagsToUse, command, chname)
+		} else {
+			session.sendSplitMsgFromClientInternal(false, now, nickmask, account, tagsToUse, command, chname, message)
+		}
+	}
+
+	for _, member := range channel.Members() {
 		// echo-message is handled above, so skip sending the msg to the user themselves as well
 		if member == client {
 			continue
 		}
-		var tagsToUse map[string]string
-		if member.capabilities.Has(caps.MessageTags) {
-			tagsToUse = clientOnlyTags
-		} else if histType == history.Tagmsg {
+		if minPrefix != nil && !channel.ClientIsAtLeast(member, minPrefixMode) {
+			// STATUSMSG
 			continue
 		}
 
-		if histType == history.Tagmsg {
-			member.sendFromClientInternal(false, now, message.Msgid, nickmask, account, tagsToUse, command, channel.name)
-		} else {
-			member.sendSplitMsgFromClientInternal(false, now, nickmask, account, tagsToUse, command, channel.name, message)
+		for _, session := range member.Sessions() {
+			var tagsToUse map[string]string
+			if session.capabilities.Has(caps.MessageTags) {
+				tagsToUse = clientOnlyTags
+			} else if histType == history.Tagmsg {
+				continue
+			}
+
+			if histType == history.Tagmsg {
+				session.sendFromClientInternal(false, now, message.Msgid, nickmask, account, tagsToUse, command, chname)
+			} else {
+				session.sendSplitMsgFromClientInternal(false, now, nickmask, account, tagsToUse, command, chname, message)
+			}
 		}
 	}
 
 
 	clientMask := client.NickMaskString()
 	targetNick := target.Nick()
+	chname := channel.Name()
 	for _, member := range channel.Members() {
-		member.Send(nil, clientMask, "KICK", channel.name, targetNick, comment)
+		for _, session := range member.Sessions() {
+			if session != rb.session {
+				session.Send(nil, clientMask, "KICK", chname, targetNick, comment)
+			}
+		}
 	}
+	rb.Add(nil, clientMask, "KICK", chname, targetNick, comment)
 
 	message := utils.SplitMessage{}
 	message.Message = comment
 	}
 
 	for _, member := range channel.Members() {
-		if member.capabilities.Has(caps.InviteNotify) && member != inviter && member != invitee && channel.ClientIsAtLeast(member, modes.Halfop) {
-			member.Send(nil, inviter.NickMaskString(), "INVITE", invitee.Nick(), chname)
+		if member == inviter || member == invitee || !channel.ClientIsAtLeast(member, modes.Halfop) {
+			continue
+		}
+		for _, session := range member.Sessions() {
+			if session.capabilities.Has(caps.InviteNotify) {
+				session.Send(nil, inviter.NickMaskString(), "INVITE", invitee.Nick(), chname)
+			}
 		}
 	}
 

irc/client.go

 	accountName        string // display name of the account: uncasefolded, '*' if not logged in
 	atime              time.Time
 	awayMessage        string
-	capabilities       caps.Set
-	capState           caps.State
-	capVersion         caps.Version
 	certfp             string
 	channels           ChannelSet
 	ctime              time.Time
 	exitedSnomaskSent  bool
-	fakelag            Fakelag
 	flags              modes.ModeSet
-	hasQuit            bool
-	hops               int
 	hostname           string
-	idletimer          IdleTimer
 	invitedTo          map[string]bool
-	isDestroyed        bool
 	isTor              bool
-	isQuitting         bool
 	languages          []string
 	loginThrottle      connection_limits.GenericThrottle
-	maxlenRest         uint32
 	nick               string
 	nickCasefolded     string
 	nickMaskCasefolded string
 	oper               *Oper
 	preregNick         string
 	proxiedIP          net.IP // actual remote IP if using the PROXY protocol
-	quitMessage        string
 	rawHostname        string
 	realname           string
 	realIP             net.IP
 	sentPassCommand    bool
 	server             *Server
 	skeleton           string
-	socket             *Socket
+	sessions           []*Session
 	stateMutex         sync.RWMutex // tier 1
 	username           string
 	vhost              string
 	history            *history.Buffer
 }
 
+// Session is an individual client connection to the server (TCP connection
+// and associated per-connection data, such as capabilities). There is a
+// many-one relationship between sessions and clients.
+type Session struct {
+	client *Client
+
+	socket    *Socket
+	idletimer IdleTimer
+	fakelag   Fakelag
+
+	quitMessage string
+
+	capabilities caps.Set
+	maxlenRest   uint32
+	capState     caps.State
+	capVersion   caps.Version
+
+	// TODO track per-connection real IP, proxied IP, and hostname here,
+	// so we can list attached sessions and their details
+}
+
+// sets the session quit message, if there isn't one already
+func (sd *Session) SetQuitMessage(message string) (set bool) {
+	if message == "" {
+		if sd.quitMessage == "" {
+			sd.quitMessage = "Connection closed"
+			return true
+		} else {
+			return false
+		}
+	} else {
+		sd.quitMessage = message
+		return true
+	}
+}
+
+// set the negotiated message length based on session capabilities
+func (session *Session) SetMaxlenRest() {
+	maxlenRest := 512
+	if session.capabilities.Has(caps.MaxLine) {
+		maxlenRest = session.client.server.Config().Limits.LineLen.Rest
+	}
+	atomic.StoreUint32(&session.maxlenRest, uint32(maxlenRest))
+}
+
+// allow the negotiated message length limit to be read without locks; this is a convenience
+// so that Session.SendRawMessage doesn't have to acquire any Client locks
+func (session *Session) MaxlenRest() int {
+	return int(atomic.LoadUint32(&session.maxlenRest))
+}
+
 // WhoWas is the subset of client details needed to answer a WHOWAS query
 type WhoWas struct {
 	nick           string
 	// give them 1k of grace over the limit:
 	socket := NewSocket(conn.Conn, fullLineLenLimit+1024, config.Server.MaxSendQBytes)
 	client := &Client{
-		atime:      now,
-		capState:   caps.NoneState,
-		capVersion: caps.Cap301,
-		channels:   make(ChannelSet),
-		ctime:      now,
-		isTor:      conn.IsTor,
-		languages:  server.Languages().Default(),
+		atime:     now,
+		channels:  make(ChannelSet),
+		ctime:     now,
+		isTor:     conn.IsTor,
+		languages: server.Languages().Default(),
 		loginThrottle: connection_limits.GenericThrottle{
 			Duration: config.Accounts.LoginThrottling.Duration,
 			Limit:    config.Accounts.LoginThrottling.MaxAttempts,
 		},
 		server:         server,
-		socket:         socket,
 		accountName:    "*",
 		nick:           "*", // * is used until actual nick is given
 		nickCasefolded: "*",
 		nickMaskString: "*", // * is used until actual nick is given
 		history:        history.NewHistoryBuffer(config.History.ClientLength),
 	}
-
-	client.recomputeMaxlens()
+	session := &Session{
+		client:     client,
+		socket:     socket,
+		capVersion: caps.Cap301,
+		capState:   caps.NoneState,
+	}
+	session.SetMaxlenRest()
+	client.sessions = []*Session{session}
 
 	if conn.IsTLS {
 		client.SetMode(modes.TLS, true)
 		// error is not useful to us here anyways so we can ignore it
-		client.certfp, _ = client.socket.CertFP()
+		client.certfp, _ = socket.CertFP()
 	}
 
 	if conn.IsTor {
 		}
 	}
 
-	client.run()
+	client.run(session)
 }
 
 func (client *Client) doIdentLookup(conn net.Conn) {
 	return !config.Accounts.RequireSasl.Enabled || saslSent || utils.IPInNets(client.IP(), config.Accounts.RequireSasl.exemptedNets)
 }
 
-func (client *Client) resetFakelag() {
-	var flc FakelagConfig = client.server.Config().Fakelag
-	flc.Enabled = flc.Enabled && !client.HasRoleCapabs("nofakelag")
-	client.fakelag.Initialize(flc)
+func (session *Session) resetFakelag() {
+	var flc FakelagConfig = session.client.server.Config().Fakelag
+	flc.Enabled = flc.Enabled && !session.client.HasRoleCapabs("nofakelag")
+	session.fakelag.Initialize(flc)
 }
 
 // IP returns the IP address of this client.
 // command goroutine
 //
 
-func (client *Client) recomputeMaxlens() int {
-	maxlenRest := 512
-	if client.capabilities.Has(caps.MaxLine) {
-		maxlenRest = client.server.Limits().LineLen.Rest
-	}
-
-	atomic.StoreUint32(&client.maxlenRest, uint32(maxlenRest))
-
-	return maxlenRest
-}
-
-// allow these negotiated length limits to be read without locks; this is a convenience
-// so that Client.Send doesn't have to acquire any Client locks
-func (client *Client) MaxlenRest() int {
-	return int(atomic.LoadUint32(&client.maxlenRest))
-}
-
-func (client *Client) run() {
-	var err error
-	var isExiting bool
-	var line string
-	var msg ircmsg.IrcMessage
+func (client *Client) run(session *Session) {
 
 	defer func() {
 		if r := recover(); r != nil {
 			}
 		}
 		// ensure client connection gets closed
-		client.destroy(false)
+		client.destroy(false, session)
 	}()
 
-	client.idletimer.Initialize(client)
+	session.idletimer.Initialize(session)
+	session.resetFakelag()
 
-	client.nickTimer.Initialize(client)
-
-	client.resetFakelag()
+	isReattach := client.Registered()
+	// don't reset the nick timer during a reattach
+	if !isReattach {
+		client.nickTimer.Initialize(client)
+	}
 
 	firstLine := true
 
 	for {
-		maxlenRest := client.recomputeMaxlens()
+		maxlenRest := session.MaxlenRest()
 
-		line, err = client.socket.Read()
+		line, err := session.socket.Read()
 		if err != nil {
 			quitMessage := "connection closed"
 			if err == errReadQ {
 				quitMessage = "readQ exceeded"
 			}
-			client.Quit(quitMessage)
+			client.Quit(quitMessage, session)
 			break
 		}
 
 		}
 
 		// special-cased handling of PROXY protocol, see `handleProxyCommand` for details:
-		if firstLine {
+		if !isReattach && firstLine {
 			firstLine = false
 			if strings.HasPrefix(line, "PROXY") {
-				err = handleProxyCommand(client.server, client, line)
+				err = handleProxyCommand(client.server, client, session, line)
 				if err != nil {
 					break
 				} else {
 			}
 		}
 
-		msg, err = ircmsg.ParseLineStrict(line, true, maxlenRest)
+		msg, err := ircmsg.ParseLineStrict(line, true, maxlenRest)
 		if err == ircmsg.ErrorLineIsEmpty {
 			continue
 		} else if err == ircmsg.ErrorLineTooLong {
 			client.Send(nil, client.server.name, ERR_INPUTTOOLONG, client.Nick(), client.t("Input line too long"))
 			continue
 		} else if err != nil {
-			client.Quit(client.t("Received malformed line"))
+			client.Quit(client.t("Received malformed line"), session)
 			break
 		}
 
 			continue
 		}
 
-		isExiting = cmd.Run(client.server, client, msg)
-		if isExiting || client.isQuitting {
+		isExiting := cmd.Run(client.server, client, session, msg)
+		if isExiting {
+			break
+		} else if session.client != client {
+			// bouncer reattach
+			session.playReattachMessages()
+			go session.client.run(session)
 			break
 		}
 	}
 }
 
+func (session *Session) playReattachMessages() {
+	for _, channel := range session.client.Channels() {
+		channel.playJoinForSession(session)
+	}
+}
+
 //
 // idle, quit, timers and timeouts
 //
 }
 
 // Ping sends the client a PING message.
-func (client *Client) Ping() {
-	client.Send(nil, "", "PING", client.nick)
-
+func (session *Session) Ping() {
+	session.Send(nil, "", "PING", session.client.Nick())
 }
 
 // tryResume tries to resume if the client asked us to.
 		return
 	}
 
+	if 1 < len(oldClient.Sessions()) {
+		client.Send(nil, server.name, "RESUME", "ERR", client.t("Cannot resume a client with multiple attached sessions"))
+		return
+	}
+
 	err := server.clients.Resume(client, oldClient)
 	if err != nil {
 		client.Send(nil, server.name, "RESUME", "ERR", client.t("Cannot resume connection"))
 
 	// send quit/resume messages to friends
 	for friend := range friends {
-		if friend.capabilities.Has(caps.Resume) {
-			if timestamp.IsZero() {
-				friend.Send(nil, oldNickmask, "RESUMED", username, hostname)
-			} else {
-				friend.Send(nil, oldNickmask, "RESUMED", username, hostname, timestampString)
-			}
-		} else {
-			if client.resumeDetails.HistoryIncomplete {
-				friend.Send(nil, oldNickmask, "QUIT", fmt.Sprintf(friend.t("Client reconnected (up to %d seconds of history lost)"), gapSeconds))
+		for _, session := range friend.Sessions() {
+			if session.capabilities.Has(caps.Resume) {
+				if timestamp.IsZero() {
+					session.Send(nil, oldNickmask, "RESUMED", username, hostname)
+				} else {
+					session.Send(nil, oldNickmask, "RESUMED", username, hostname, timestampString)
+				}
 			} else {
-				friend.Send(nil, oldNickmask, "QUIT", fmt.Sprintf(friend.t("Client reconnected")))
+				if client.resumeDetails.HistoryIncomplete {
+					session.Send(nil, oldNickmask, "QUIT", fmt.Sprintf(friend.t("Client reconnected (up to %d seconds of history lost)"), gapSeconds))
+				} else {
+					session.Send(nil, oldNickmask, "QUIT", fmt.Sprintf(friend.t("Client reconnected")))
+				}
 			}
 		}
 	}
 	if !details.Timestamp.IsZero() {
 		now := time.Now()
 		items, complete := client.history.Between(details.Timestamp, now, false, 0)
-		rb := NewResponseBuffer(client)
+		rb := NewResponseBuffer(client.Sessions()[0])
 		client.replayPrivmsgHistory(rb, items, complete)
 		rb.Send(true)
 	}
 
-	details.OldClient.destroy(true)
+	details.OldClient.destroy(true, nil)
 }
 
 func (client *Client) replayPrivmsgHistory(rb *ResponseBuffer, items []history.Item, complete bool) {
 	nick := client.Nick()
-	serverTime := client.capabilities.Has(caps.ServerTime)
+	serverTime := rb.session.capabilities.Has(caps.ServerTime)
 	for _, item := range items {
 		var command string
 		switch item.Type {
 }
 
 // Friends refers to clients that share a channel with this client.
-func (client *Client) Friends(capabs ...caps.Capability) ClientSet {
-	friends := make(ClientSet)
+func (client *Client) Friends(capabs ...caps.Capability) (result map[*Session]bool) {
+	result = make(map[*Session]bool)
 
-	// make sure that I have the right caps
-	hasCaps := true
-	for _, capab := range capabs {
-		if !client.capabilities.Has(capab) {
-			hasCaps = false
-			break
+	// look at the client's own sessions
+	for _, session := range client.Sessions() {
+		if session.capabilities.HasAll(capabs...) {
+			result[session] = true
 		}
 	}
-	if hasCaps {
-		friends.Add(client)
-	}
 
 	for _, channel := range client.Channels() {
 		for _, member := range channel.Members() {
-			// make sure they have all the required caps
-			hasCaps = true
-			for _, capab := range capabs {
-				if !member.capabilities.Has(capab) {
-					hasCaps = false
-					break
+			for _, session := range member.Sessions() {
+				if session.capabilities.HasAll(capabs...) {
+					result[session] = true
 				}
 			}
-			if hasCaps {
-				friends.Add(member)
-			}
 		}
 	}
-	return friends
+
+	return
 }
 
 func (client *Client) SetOper(oper *Oper) {
 // Quit sets the given quit message for the client.
 // (You must ensure separately that destroy() is called, e.g., by returning `true` from
 // the command handler or calling it yourself.)
-func (client *Client) Quit(message string) {
-	client.stateMutex.Lock()
-	alreadyQuit := client.isQuitting
-	if !alreadyQuit {
-		client.isQuitting = true
-		client.quitMessage = message
-	}
-	registered := client.registered
-	prefix := client.nickMaskString
-	client.stateMutex.Unlock()
+func (client *Client) Quit(message string, session *Session) {
+	setFinalData := func(sess *Session) {
+		message := sess.quitMessage
+		var finalData []byte
+		// #364: don't send QUIT lines to unregistered clients
+		if client.registered {
+			quitMsg := ircmsg.MakeMessage(nil, client.nickMaskString, "QUIT", message)
+			finalData, _ = quitMsg.LineBytesStrict(false, 512)
+		}
 
-	if alreadyQuit {
-		return
-	}
+		errorMsg := ircmsg.MakeMessage(nil, "", "ERROR", message)
+		errorMsgBytes, _ := errorMsg.LineBytesStrict(false, 512)
+		finalData = append(finalData, errorMsgBytes...)
 
-	var finalData []byte
-	// #364: don't send QUIT lines to unregistered clients
-	if registered {
-		quitMsg := ircmsg.MakeMessage(nil, prefix, "QUIT", message)
-		finalData, _ = quitMsg.LineBytesStrict(false, 512)
+		sess.socket.SetFinalData(finalData)
 	}
 
-	errorMsg := ircmsg.MakeMessage(nil, "", "ERROR", message)
-	errorMsgBytes, _ := errorMsg.LineBytesStrict(false, 512)
-	finalData = append(finalData, errorMsgBytes...)
+	client.stateMutex.Lock()
+	defer client.stateMutex.Unlock()
+
+	var sessions []*Session
+	if session != nil {
+		sessions = []*Session{session}
+	} else {
+		sessions = client.sessions
+	}
 
-	client.socket.SetFinalData(finalData)
+	for _, session := range sessions {
+		if session.SetQuitMessage(message) {
+			setFinalData(session)
+		}
+	}
 }
 
 // destroy gets rid of a client, removes them from server lists etc.
-func (client *Client) destroy(beingResumed bool) {
+// if `session` is nil, destroys the client unconditionally, removing all sessions;
+// otherwise, destroys one specific session, only destroying the client if it
+// has no more sessions.
+func (client *Client) destroy(beingResumed bool, session *Session) {
+	var sessionsToDestroy []*Session
+
 	// allow destroy() to execute at most once
 	client.stateMutex.Lock()
-	isDestroyed := client.isDestroyed
-	client.isDestroyed = true
-	quitMessage := client.quitMessage
 	nickMaskString := client.nickMaskString
 	accountName := client.accountName
+
+	alreadyDestroyed := len(client.sessions) == 0
+	sessionRemoved := false
+	var remainingSessions int
+	if session == nil {
+		sessionRemoved = !alreadyDestroyed
+		sessionsToDestroy = client.sessions
+		client.sessions = nil
+		remainingSessions = 0
+	} else {
+		sessionRemoved, remainingSessions = client.removeSession(session)
+		if sessionRemoved {
+			sessionsToDestroy = []*Session{session}
+		}
+	}
+	var quitMessage string
+	if 0 < len(sessionsToDestroy) {
+		quitMessage = sessionsToDestroy[0].quitMessage
+	}
 	client.stateMutex.Unlock()
 
-	if isDestroyed {
+	if alreadyDestroyed || !sessionRemoved {
+		return
+	}
+
+	for _, session := range sessionsToDestroy {
+		if session.client != client {
+			// session has been attached to a new client; do not destroy it
+			continue
+		}
+		session.idletimer.Stop()
+		session.socket.Close()
+		// send quit/error message to client if they haven't been sent already
+		client.Quit("", session)
+	}
+
+	if remainingSessions != 0 {
 		return
 	}
 
 		client.server.logger.Debug("quit", fmt.Sprintf("%s is no longer on the server", client.nick))
 	}
 
-	// send quit/error message to client if they haven't been sent already
-	client.Quit("Connection closed")
-
 	if !beingResumed {
 		client.server.whoWas.Append(client.WhoWas())
 	}
 	}
 
 	// clean up self
-	client.idletimer.Stop()
 	client.nickTimer.Stop()
 
 	client.server.accounts.Logout(client)
 
-	client.socket.Close()
-
 	// send quit messages to friends
 	if !beingResumed {
 		if client.Registered() {
 
 // SendSplitMsgFromClient sends an IRC PRIVMSG/NOTICE coming from a specific client.
 // Adds account-tag to the line as well.
-func (client *Client) SendSplitMsgFromClient(from *Client, tags map[string]string, command, target string, message utils.SplitMessage) {
-	client.sendSplitMsgFromClientInternal(false, time.Time{}, from.NickMaskString(), from.AccountName(), tags, command, target, message)
-}
-
-func (client *Client) sendSplitMsgFromClientInternal(blocking bool, serverTime time.Time, nickmask, accountName string, tags map[string]string, command, target string, message utils.SplitMessage) {
-	if client.capabilities.Has(caps.MaxLine) || message.Wrapped == nil {
-		client.sendFromClientInternal(blocking, serverTime, message.Msgid, nickmask, accountName, tags, command, target, message.Message)
+func (session *Session) sendSplitMsgFromClientInternal(blocking bool, serverTime time.Time, nickmask, accountName string, tags map[string]string, command, target string, message utils.SplitMessage) {
+	if session.capabilities.Has(caps.MaxLine) || message.Wrapped == nil {
+		session.sendFromClientInternal(blocking, serverTime, message.Msgid, nickmask, accountName, tags, command, target, message.Message)
 	} else {
 		for _, messagePair := range message.Wrapped {
-			client.sendFromClientInternal(blocking, serverTime, messagePair.Msgid, nickmask, accountName, tags, command, target, messagePair.Message)
+			session.sendFromClientInternal(blocking, serverTime, messagePair.Msgid, nickmask, accountName, tags, command, target, messagePair.Message)
 		}
 	}
 }
 // this is SendFromClient, but directly exposing nickmask and accountName,
 // for things like history replay and CHGHOST where they no longer (necessarily)
 // correspond to the current state of a client
-func (client *Client) sendFromClientInternal(blocking bool, serverTime time.Time, msgid string, nickmask, accountName string, tags map[string]string, command string, params ...string) error {
+func (client *Client) sendFromClientInternal(blocking bool, serverTime time.Time, msgid string, nickmask, accountName string, tags map[string]string, command string, params ...string) (err error) {
+	for _, session := range client.Sessions() {
+		err_ := session.sendFromClientInternal(blocking, serverTime, msgid, nickmask, accountName, tags, command, params...)
+		if err_ != nil {
+			err = err_
+		}
+	}
+	return
+}
+
+func (session *Session) sendFromClientInternal(blocking bool, serverTime time.Time, msgid string, nickmask, accountName string, tags map[string]string, command string, params ...string) (err error) {
 	msg := ircmsg.MakeMessage(tags, nickmask, command, params...)
 	// attach account-tag
-	if client.capabilities.Has(caps.AccountTag) && accountName != "*" {
+	if session.capabilities.Has(caps.AccountTag) && accountName != "*" {
 		msg.SetTag("account", accountName)
 	}
 	// attach message-id
-	if msgid != "" && client.capabilities.Has(caps.MessageTags) {
+	if msgid != "" && session.capabilities.Has(caps.MessageTags) {
 		msg.SetTag("draft/msgid", msgid)
 	}
 	// attach server-time
-	if client.capabilities.Has(caps.ServerTime) {
+	if session.capabilities.Has(caps.ServerTime) {
 		msg.SetTag("time", time.Now().UTC().Format(IRCv3TimestampFormat))
 	}
 
-	return client.SendRawMessage(msg, blocking)
+	return session.SendRawMessage(msg, blocking)
 }
 
 var (
 )
 
 // SendRawMessage sends a raw message to the client.
-func (client *Client) SendRawMessage(message ircmsg.IrcMessage, blocking bool) error {
+func (session *Session) SendRawMessage(message ircmsg.IrcMessage, blocking bool) error {
 	// use dumb hack to force the last param to be a trailing param if required
 	var usedTrailingHack bool
 	if commandsThatMustUseTrailing[message.Command] && len(message.Params) > 0 {
 	}
 
 	// assemble message
-	maxlenRest := client.MaxlenRest()
+	maxlenRest := session.MaxlenRest()
 	line, err := message.LineBytesStrict(false, maxlenRest)
 	if err != nil {
 		logline := fmt.Sprintf("Error assembling message for sending: %v\n%s", err, debug.Stack())
-		client.server.logger.Error("internal", logline)
+		session.client.server.logger.Error("internal", logline)
 
-		message = ircmsg.MakeMessage(nil, client.server.name, ERR_UNKNOWNERROR, "*", "Error assembling message for sending")
+		message = ircmsg.MakeMessage(nil, session.client.server.name, ERR_UNKNOWNERROR, "*", "Error assembling message for sending")
 		line, _ := message.LineBytesStrict(false, 0)
 
 		if blocking {
-			client.socket.BlockingWrite(line)
+			session.socket.BlockingWrite(line)
 		} else {
-			client.socket.Write(line)
+			session.socket.Write(line)
 		}
 		return err
 	}
 		line = line[:len(line)-1]
 	}
 
-	if client.server.logger.IsLoggingRawIO() {
+	if session.client.server.logger.IsLoggingRawIO() {
 		logline := string(line[:len(line)-2]) // strip "\r\n"
-		client.server.logger.Debug("useroutput", client.nick, " ->", logline)
+		session.client.server.logger.Debug("useroutput", session.client.Nick(), " ->", logline)
 	}
 
 	if blocking {
-		return client.socket.BlockingWrite(line)
+		return session.socket.BlockingWrite(line)
 	} else {
-		return client.socket.Write(line)
+		return session.socket.Write(line)
 	}
 }
 
 // Send sends an IRC line to the client.
-func (client *Client) Send(tags map[string]string, prefix string, command string, params ...string) error {
+func (client *Client) Send(tags map[string]string, prefix string, command string, params ...string) (err error) {
+	for _, session := range client.Sessions() {
+		err_ := session.Send(tags, prefix, command, params...)
+		if err_ != nil {
+			err = err_
+		}
+	}
+	return
+}
+
+func (session *Session) Send(tags map[string]string, prefix string, command string, params ...string) (err error) {
 	msg := ircmsg.MakeMessage(tags, prefix, command, params...)
-	if client.capabilities.Has(caps.ServerTime) && !msg.HasTag("time") {
+	if session.capabilities.Has(caps.ServerTime) && !msg.HasTag("time") {
 		msg.SetTag("time", time.Now().UTC().Format(IRCv3TimestampFormat))
 	}
-	return client.SendRawMessage(msg, false)
+	return session.SendRawMessage(msg, false)
 }
 
 // Notice sends the client a notice from the server.
 func (client *Client) Notice(text string) {
-	limit := 400
-	if client.capabilities.Has(caps.MaxLine) {
-		limit = client.server.Limits().LineLen.Rest - 110
-	}
-	lines := utils.WordWrap(text, limit)
-
-	// force blank lines to be sent if we receive them
-	if len(lines) == 0 {
-		lines = []string{""}
-	}
-
-	for _, line := range lines {
-		client.Send(nil, client.server.name, "NOTICE", client.nick, line)
-	}
+	client.Send(nil, client.server.name, "NOTICE", client.Nick(), text)
 }
 
 func (client *Client) addChannel(channel *Channel) {

irc/client_lookup_set.go

 	"strings"
 
 	"github.com/goshuirc/irc-go/ircmatch"
+
 	"github.com/oragono/oragono/irc/caps"
+	"github.com/oragono/oragono/irc/modes"
 
 	"sync"
 )
 }
 
 // SetNick sets a client's nickname, validating it against nicknames in use
-func (clients *ClientManager) SetNick(client *Client, newNick string) error {
+func (clients *ClientManager) SetNick(client *Client, session *Session, newNick string) error {
 	newcfnick, err := CasefoldName(newNick)
 	if err != nil {
 		return err
 	}
 
 	reservedAccount, method := client.server.accounts.EnforcementStatus(newcfnick, newSkeleton)
+	account := client.Account()
+	bouncerAllowed := client.server.accounts.BouncerAllowed(account, session)
 
 	clients.Lock()
 	defer clients.Unlock()
 
-	currentNewEntry := clients.byNick[newcfnick]
+	currentClient := clients.byNick[newcfnick]
 	// the client may just be changing case
-	if currentNewEntry != nil && currentNewEntry != client {
-		return errNicknameInUse
+	if currentClient != nil && currentClient != client {
+		// these conditions forbid reattaching to an existing session:
+		if client.Registered() || !bouncerAllowed || account == "" || account != currentClient.Account() || client.isTor != currentClient.isTor || client.HasMode(modes.TLS) != currentClient.HasMode(modes.TLS) {
+			return errNicknameInUse
+		}
+		if !currentClient.AddSession(session) {
+			return errNicknameInUse
+		}
+		// successful reattach:
+		return nil
 	}
 	// analogous checks for skeletons
 	skeletonHolder := clients.bySkeleton[newSkeleton]
 	if skeletonHolder != nil && skeletonHolder != client {
 		return errNicknameInUse
 	}
-	if method == NickReservationStrict && reservedAccount != "" && reservedAccount != client.Account() {
+	if method == NickReservationStrict && reservedAccount != "" && reservedAccount != account {
 		return errNicknameReserved
 	}
 	clients.removeInternal(client)
 }
 
 // AllWithCaps returns all clients with the given capabilities.
-func (clients *ClientManager) AllWithCaps(capabs ...caps.Capability) (set ClientSet) {
-	set = make(ClientSet)
-
+func (clients *ClientManager) AllWithCaps(capabs ...caps.Capability) (sessions []*Session) {
 	clients.RLock()
 	defer clients.RUnlock()
-	var client *Client
-	for _, client = range clients.byNick {
-		// make sure they have all the required caps
-		for _, capab := range capabs {
-			if !client.capabilities.Has(capab) {
-				continue
+	for _, client := range clients.byNick {
+		for _, session := range client.Sessions() {
+			if session.capabilities.HasAll(capabs...) {
+				sessions = append(sessions, session)
 			}
 		}
-
-		set.Add(client)
 	}
 
-	return set
+	return
 }
 
 // FindAll returns all clients that match the given userhost mask.

irc/commands.go

 }
 
 // Run runs this command with the given client/message.
-func (cmd *Command) Run(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
+func (cmd *Command) Run(server *Server, client *Client, session *Session, msg ircmsg.IrcMessage) bool {
 	if !client.registered && !cmd.usablePreReg {
 		client.Send(nil, server.name, ERR_NOTREGISTERED, "*", client.t("You need to register before you can use that command"))
 		return false
 	}
 
 	if client.registered {
-		client.fakelag.Touch()
+		session.fakelag.Touch()
 	}
 
-	rb := NewResponseBuffer(client)
+	rb := NewResponseBuffer(session)
 	rb.Label = GetLabel(msg)
 	exiting := cmd.handler(server, client, msg, rb)
 	rb.Send(true)
 
 	// after each command, see if we can send registration to the client
 	if !client.registered {
-		server.tryRegister(client)
+		server.tryRegister(client, session)
 	}
 
 	// most servers do this only for PING/PONG, but we'll do it for any command:
 	if client.registered {
-		client.idletimer.Touch()
+		session.idletimer.Touch()
 	}
 
 	if !cmd.leaveClientIdle {

irc/config.go

 	} `yaml:"login-throttling"`
 	SkipServerPassword bool                  `yaml:"skip-server-password"`
 	NickReservation    NickReservationConfig `yaml:"nick-reservation"`
-	VHosts             VHostConfig
+	Bouncer            struct {
+		Enabled          bool
+		AllowedByDefault bool `yaml:"allowed-by-default"`
+	}
+	VHosts VHostConfig
 }
 
 // AccountRegistrationConfig controls account registration.

irc/gateways.go

 }
 
 // ApplyProxiedIP applies the given IP to the client.
-func (client *Client) ApplyProxiedIP(proxiedIP string, tls bool) (success bool) {
+func (client *Client) ApplyProxiedIP(session *Session, proxiedIP string, tls bool) (success bool) {
 	// PROXY and WEBIRC are never accepted from a Tor listener, even if the address itself
 	// is whitelisted:
 	if client.isTor {
 	// ensure IP is sane
 	parsedProxiedIP := net.ParseIP(proxiedIP).To16()
 	if parsedProxiedIP == nil {
-		client.Quit(fmt.Sprintf(client.t("Proxied IP address is not valid: [%s]"), proxiedIP))
+		client.Quit(fmt.Sprintf(client.t("Proxied IP address is not valid: [%s]"), proxiedIP), session)
 		return false
 	}
 
 	isBanned, banMsg := client.server.checkBans(parsedProxiedIP)
 	if isBanned {
-		client.Quit(banMsg)
+		client.Quit(banMsg, session)
 		return false
 	}
 
 // PROXY TCP[46] SOURCEIP DESTIP SOURCEPORT DESTPORT\r\n
 // unfortunately, an ipv6 SOURCEIP can start with a double colon; in this case,
 // the message is invalid IRC and can't be parsed normally, hence the special handling.
-func handleProxyCommand(server *Server, client *Client, line string) (err error) {
+func handleProxyCommand(server *Server, client *Client, session *Session, line string) (err error) {
 	defer func() {
 		if err != nil {
-			client.Quit(client.t("Bad or unauthorized PROXY command"))
+			client.Quit(client.t("Bad or unauthorized PROXY command"), session)
 		}
 	}()
 
 
 	if utils.IPInNets(client.realIP, server.Config().Server.proxyAllowedFromNets) {
 		// assume PROXY connections are always secure
-		if client.ApplyProxiedIP(params[2], true) {
+		if client.ApplyProxiedIP(session, params[2], true) {
 			return nil
 		} else {
 			return errBadProxyLine

irc/getters.go

 	return server.Config().languageManager
 }
 
+func (client *Client) Sessions() (sessions []*Session) {
+	client.stateMutex.RLock()
+	sessions = make([]*Session, len(client.sessions))
+	copy(sessions, client.sessions)
+	client.stateMutex.RUnlock()
+	return
+}
+
+func (client *Client) AddSession(session *Session) (success bool) {
+	client.stateMutex.Lock()
+	defer client.stateMutex.Unlock()
+
+	if len(client.sessions) == 0 {
+		return false
+	}
+	session.client = client
+	client.sessions = append(client.sessions, session)
+	return true
+}
+
+func (client *Client) removeSession(session *Session) (success bool, length int) {
+	if len(client.sessions) == 0 {
+		return
+	}
+	sessions := make([]*Session, 0, len(client.sessions)-1)
+	for _, currentSession := range client.sessions {
+		if session == currentSession {
+			success = true
+		} else {
+			sessions = append(sessions, currentSession)
+		}
+	}
+	client.sessions = sessions
+	length = len(sessions)
+	return
+}
+
 func (client *Client) Nick() string {
 	client.stateMutex.RLock()
 	defer client.stateMutex.RUnlock()
 	client.stateMutex.Unlock()
 }
 
-func (client *Client) Destroyed() bool {
-	client.stateMutex.RLock()
-	defer client.stateMutex.RUnlock()
-	return client.isDestroyed
-}
-
 func (client *Client) Account() string {
 	client.stateMutex.RLock()
 	defer client.stateMutex.RUnlock()

irc/handlers.go

 		Mode: modes.Away,
 		Op:   op,
 	}}
-	rb.Add(nil, server.name, "MODE", client.nick, modech.String())
+
+	details := client.Details()
+	modeString := modech.String()
+	rb.Add(nil, server.name, "MODE", details.nick, modeString)
 
 	// dispatch away-notify
-	for friend := range client.Friends(caps.AwayNotify) {
+	for session := range client.Friends(caps.AwayNotify) {
+		if session != rb.session && rb.session.client == client {
+			session.Send(nil, server.name, "MODE", details.nick, modeString)
+		}
 		if isAway {
-			friend.SendFromClient("", client, nil, "AWAY", awayMessage)
+			session.sendFromClientInternal(false, time.Time{}, "", details.nickMask, details.account, nil, "AWAY", awayMessage)
 		} else {
-			friend.SendFromClient("", client, nil, "AWAY")
+			session.sendFromClientInternal(false, time.Time{}, "", details.nickMask, details.account, nil, "AWAY")
 		}
 	}
 
 	switch subCommand {
 	case "LS":
 		if !client.registered {
-			client.capState = caps.NegotiatingState
+			rb.session.capState = caps.NegotiatingState
 		}
 		if len(msg.Params) > 1 && msg.Params[1] == "302" {
-			client.capVersion = 302
+			rb.session.capVersion = 302
 		}
 		// weechat 1.4 has a bug here where it won't accept the CAP reply unless it contains
 		// the server.name source... otherwise it doesn't respond to the CAP message with
 		// anything and just hangs on connection.
 		//TODO(dan): limit number of caps and send it multiline in 3.2 style as appropriate.
-		rb.Add(nil, server.name, "CAP", client.nick, subCommand, SupportedCapabilities.String(client.capVersion, CapValues))
+		rb.Add(nil, server.name, "CAP", client.nick, subCommand, SupportedCapabilities.String(rb.session.capVersion, CapValues))
 
 	case "LIST":
-		rb.Add(nil, server.name, "CAP", client.nick, subCommand, client.capabilities.String(caps.Cap301, CapValues)) // values not sent on LIST so force 3.1
+		rb.Add(nil, server.name, "CAP", client.nick, subCommand, rb.session.capabilities.String(caps.Cap301, CapValues)) // values not sent on LIST so force 3.1
 
 	case "REQ":
 		if !client.registered {
-			client.capState = caps.NegotiatingState
+			rb.session.capState = caps.NegotiatingState
 		}
 
 		// make sure all capabilities actually exist
 			rb.Add(nil, server.name, "CAP", client.nick, "NAK", capString)
 			return false
 		}
-		client.capabilities.Union(toAdd)
-		client.capabilities.Subtract(toRemove)
+		rb.session.capabilities.Union(toAdd)
+		rb.session.capabilities.Subtract(toRemove)
 		rb.Add(nil, server.name, "CAP", client.nick, "ACK", capString)
 
 		// if this is the first time the client is requesting a resume token,
 			}
 		}
 
+		// update maxlenrest, just in case they altered the maxline cap
+		rb.session.SetMaxlenRest()
+
 	case "END":
 		if !client.registered {
-			client.capState = caps.NegotiatedState
+			rb.session.capState = caps.NegotiatedState
 		}
 
 	default:
 		if success && len(items) > 0 {
 			return
 		}
-		newRb := NewResponseBuffer(client)
+		newRb := NewResponseBuffer(rb.session)
 		newRb.Label = rb.Label // same label, new batch
 		// TODO: send `WARN CHATHISTORY MAX_MESSAGES_EXCEEDED` when appropriate
 		if hist == nil {
 
 		for _, mcl := range clientsToKill {
 			mcl.exitedSnomaskSent = true
-			mcl.Quit(fmt.Sprintf(mcl.t("You have been banned from this server (%s)"), reason))
+			mcl.Quit(fmt.Sprintf(mcl.t("You have been banned from this server (%s)"), reason), nil)
 			if mcl == client {
 				killClient = true
 			} else {
 				// if mcl == client, we kill them below
-				mcl.destroy(false)
+				mcl.destroy(false, nil)
 			}
 		}
 
 				return false
 			}
 			channelString = msg.Params[1]
-			rb = NewResponseBuffer(target)
 		}
 	}
 
 	for _, chname := range channels {
 		server.channels.Join(target, chname, "", true, rb)
 	}
-	if client != target {
-		rb.Send(false)
-	}
 	return false
 }
 
 	server.snomasks.Send(sno.LocalKills, fmt.Sprintf(ircfmt.Unescape("%s$r was killed by %s $c[grey][$r%s$c[grey]]"), target.nick, client.nick, comment))
 	target.exitedSnomaskSent = true
 
-	target.Quit(quitMsg)
-	target.destroy(false)
+	target.Quit(quitMsg, nil)
+	target.destroy(false, nil)
 	return false
 }
 
 
 		for _, mcl := range clientsToKill {
 			mcl.exitedSnomaskSent = true
-			mcl.Quit(fmt.Sprintf(mcl.t("You have been banned from this server (%s)"), reason))
+			mcl.Quit(fmt.Sprintf(mcl.t("You have been banned from this server (%s)"), reason), nil)
 			if mcl == client {
 				killClient = true
 			} else {
 				// if mcl == client, we kill them below
-				mcl.destroy(false)
+				mcl.destroy(false, nil)
 			}
 		}
 
 	}
 
 	// send out changes
+	prefix := client.NickMaskString()
 	if len(applied) > 0 {
 		//TODO(dan): we should change the name of String and make it return a slice here
 		args := append([]string{channel.name}, strings.Split(applied.String(), " ")...)
 		for _, member := range channel.Members() {
 			if member == client {
-				rb.Add(nil, client.nickMaskString, "MODE", args...)
+				rb.Add(nil, prefix, "MODE", args...)
+				for _, session := range client.Sessions() {
+					if session != rb.session {
+						session.Send(nil, prefix, "MODE", args...)
+					}
+				}
 			} else {
-				member.Send(nil, client.nickMaskString, "MODE", args...)
+				member.Send(nil, prefix, "MODE", args...)
 			}
 		}
 	} else {
 		args := append([]string{client.nick, channel.name}, channel.modeStrings(client)...)
-		rb.Add(nil, client.nickMaskString, RPL_CHANNELMODEIS, args...)
+		rb.Add(nil, prefix, RPL_CHANNELMODEIS, args...)
 		rb.Add(nil, client.nickMaskString, RPL_CHANNELCREATED, client.nick, channel.name, strconv.FormatInt(channel.createdTime.Unix(), 10))
 	}
 	return false
 // NICK <nickname>
 func nickHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
 	if client.registered {
-		performNickChange(server, client, client, msg.Params[0], rb)
+		performNickChange(server, client, client, nil, msg.Params[0], rb)
 	} else {
 		client.preregNick = msg.Params[0]
 	}
 
 	for i, targetString := range targets {
 		// each target gets distinct msgids
-		splitMsg := utils.MakeSplitMessage(message, !client.capabilities.Has(caps.MaxLine))
+		splitMsg := utils.MakeSplitMessage(message, !rb.session.capabilities.Has(caps.MaxLine))
 		now := time.Now().UTC()
 
 		// max of four targets per privmsg
 			}
 			tnick := user.Nick()
 
-			if histType == history.Tagmsg && !user.capabilities.Has(caps.MessageTags) {
-				continue // nothing to do
-			}
-
 			nickMaskString := client.NickMaskString()
 			accountName := client.AccountName()
 			// restrict messages appropriately when +R is set
 			allowedPlusR := !user.HasMode(modes.RegisteredOnly) || client.LoggedIntoAccount()
 			allowedTor := !user.isTor || !isRestrictedCTCPMessage(message)
 			if allowedPlusR && allowedTor {
-				if histType == history.Tagmsg {
-					user.sendFromClientInternal(false, now, splitMsg.Msgid, nickMaskString, accountName, clientOnlyTags, msg.Command, tnick)
-				} else {
-					user.SendSplitMsgFromClient(client, clientOnlyTags, msg.Command, tnick, splitMsg)
+				for _, session := range user.Sessions() {
+					if histType == history.Tagmsg {
+						// don't send TAGMSG at all if they don't have the tags cap
+						if session.capabilities.Has(caps.MessageTags) {
+							session.sendFromClientInternal(false, now, splitMsg.Msgid, nickMaskString, accountName, clientOnlyTags, msg.Command, tnick)
+						}
+					} else {
+						session.sendSplitMsgFromClientInternal(false, now, nickMaskString, accountName, clientOnlyTags, msg.Command, tnick, splitMsg)
+					}
 				}
 			}
-			if client.capabilities.Has(caps.EchoMessage) {
-				if histType == history.Tagmsg && client.capabilities.Has(caps.MessageTags) {
+			// an echo-message may need to be included in the response:
+			if rb.session.capabilities.Has(caps.EchoMessage) {
+				if histType == history.Tagmsg && rb.session.capabilities.Has(caps.MessageTags) {
 					rb.AddFromClient(splitMsg.Msgid, nickMaskString, accountName, clientOnlyTags, msg.Command, tnick)
 				} else {
 					rb.AddSplitMessageFromClient(nickMaskString, accountName, clientOnlyTags, msg.Command, tnick, splitMsg)
 				}
 			}
+			// an echo-message may need to go out to other client sessions:
+			for _, session := range client.Sessions() {
+				if session == rb.session || !rb.session.capabilities.SelfMessagesEnabled() {
+					continue
+				}
+				if histType == history.Tagmsg && rb.session.capabilities.Has(caps.MessageTags) {
+					session.sendFromClientInternal(false, now, splitMsg.Msgid, nickMaskString, accountName, clientOnlyTags, msg.Command, tnick)
+				} else {
+					session.sendSplitMsgFromClientInternal(false, now, nickMaskString, accountName, clientOnlyTags, msg.Command, tnick, splitMsg)
+				}
+			}
 			if histType != history.Notice && user.HasMode(modes.Away) {
 				//TODO(dan): possibly implement cooldown of away notifications to users
 				rb.Add(nil, server.name, RPL_AWAY, cnick, tnick, user.AwayMessage())
 	}
 	if !authorized {
 		rb.Add(nil, server.name, ERR_PASSWDMISMATCH, client.Nick(), client.t("Password incorrect"))
-		client.Quit(client.t("Password incorrect"))
+		client.Quit(client.t("Password incorrect"), rb.session)
 		return true
 	}
 
 	server.snomasks.Send(sno.LocalOpers, fmt.Sprintf(ircfmt.Unescape("Client opered up $c[grey][$r%s$c[grey], $r%s$c[grey]]"), client.nickMaskString, oper.Name))
 
 	// client may now be unthrottled by the fakelag system
-	client.resetFakelag()
+	for _, session := range client.Sessions() {
+		session.resetFakelag()
+	}
 
 	return false
 }
 	password := []byte(msg.Params[0])
 	if bcrypt.CompareHashAndPassword(serverPassword, password) != nil {
 		rb.Add(nil, server.name, ERR_PASSWDMISMATCH, client.nick, client.t("Password incorrect"))
-		client.Quit(client.t("Password incorrect"))
+		client.Quit(client.t("Password incorrect"), rb.session)
 		return true
 	}
 
 	if len(msg.Params) > 0 {
 		reason += ": " + msg.Params[0]
 	}
-	client.Quit(reason)
+	client.Quit(reason, rb.session)
 	return true
 }
 
 	// send RENAME messages
 	clientPrefix := client.NickMaskString()
 	for _, mcl := range channel.Members() {
-		targetRb := rb
-		targetPrefix := clientPrefix
-		if mcl != client {
-			targetRb = NewResponseBuffer(mcl)
-			targetPrefix = mcl.NickMaskString()
-		}
-		if mcl.capabilities.Has(caps.Rename) {
-			if reason != "" {
-				targetRb.Add(nil, clientPrefix, "RENAME", oldName, newName, reason)
-			} else {
-				targetRb.Add(nil, clientPrefix, "RENAME", oldName, newName)
+		for _, mSession := range mcl.Sessions() {
+			targetRb := rb
+			targetPrefix := clientPrefix
+			if mSession != rb.session {
+				targetRb = NewResponseBuffer(mSession)
+				targetPrefix = mcl.NickMaskString()
 			}
-		} else {
-			if reason != "" {
-				targetRb.Add(nil, targetPrefix, "PART", oldName, fmt.Sprintf(mcl.t("Channel renamed: %s"), reason))
+			if mSession.capabilities.Has(caps.Rename) {
+				if reason != "" {
+					targetRb.Add(nil, clientPrefix, "RENAME", oldName, newName, reason)
+				} else {
+					targetRb.Add(nil, clientPrefix, "RENAME", oldName, newName)
+				}
 			} else {
-				targetRb.Add(nil, targetPrefix, "PART", oldName, fmt.Sprintf(mcl.t("Channel renamed")))
+				if reason != "" {
+					targetRb.Add(nil, targetPrefix, "PART", oldName, fmt.Sprintf(mcl.t("Channel renamed: %s"), reason))
+				} else {
+					targetRb.Add(nil, targetPrefix, "PART", oldName, fmt.Sprintf(mcl.t("Channel renamed")))
+				}
+				if mSession.capabilities.Has(caps.ExtendedJoin) {
+					targetRb.Add(nil, targetPrefix, "JOIN", newName, mcl.AccountName(), mcl.Realname())
+				} else {
+					targetRb.Add(nil, targetPrefix, "JOIN", newName)
+				}
+				channel.SendTopic(mcl, targetRb, false)
+				channel.Names(mcl, targetRb)
 			}
-			if mcl.capabilities.Has(caps.ExtendedJoin) {
-				targetRb.Add(nil, targetPrefix, "JOIN", newName, mcl.AccountName(), mcl.Realname())
-			} else {
-				targetRb.Add(nil, targetPrefix, "JOIN", newName)
+			if mcl != client {
+				targetRb.Send(false)
 			}
-			channel.SendTopic(mcl, targetRb, false)
-			channel.Names(mcl, targetRb)
-		}
-		if mcl != client {
-			targetRb.Send(false)
 		}
 	}
 
 		rb.Add(nil, server.name, ERR_NOSUCHNICK, client.nick, msg.Params[0], client.t("No such nick"))
 		return false
 	}
-	performNickChange(server, client, target, msg.Params[1], rb)
+	performNickChange(server, client, target, nil, msg.Params[1], rb)
 	return false
 }
 
 	client.realname = realname
 	client.stateMutex.Unlock()
 
+	details := client.Details()
+
 	// alert friends
-	for friend := range client.Friends(caps.SetName) {
-		friend.SendFromClient("", client, nil, "SETNAME", realname)
+	now := time.Now().UTC()
+	for session := range client.Friends(caps.SetName) {
+		session.sendFromClientInternal(false, now, "", details.nickMask, details.account, nil, "SETNAME", details.realname)
 	}
 
 	return false
 			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.HasMode(modes.TLS) || utils.AddrIsLocal(client.socket.conn.RemoteAddr()) {
+				if client.HasMode(modes.TLS) || client.realIP.IsLoopback() {
 					secure = true
 				}
 			}
 			if strings.HasPrefix(proxiedIP, "[") && strings.HasSuffix(proxiedIP, "]") {
 				proxiedIP = proxiedIP[1 : len(proxiedIP)-1]
 			}
-			return !client.ApplyProxiedIP(proxiedIP, secure)
+			return !client.ApplyProxiedIP(rb.session, proxiedIP, secure)
 		}
 	}
 
-	client.Quit(client.t("WEBIRC command is not usable from your address or incorrect password given"))
+	client.Quit(client.t("WEBIRC command is not usable from your address or incorrect password given"), rb.session)
 	return true
 }
 
 		mask = casefoldedMask
 	}
 
-	friends := client.Friends()
-
 	//TODO(dan): is this used and would I put this param in the Modern doc?
 	// if not, can we remove it?
 	//var operatorOnly bool
 		// TODO implement wildcard matching
 		//TODO(dan): ^ only for opers
 		channel := server.channels.Get(mask)
-		if channel != nil {
-			whoChannel(client, channel, friends, rb)
+		if channel != nil && channel.hasClient(client) {
+			for _, member := range channel.Members() {
+				if !member.HasMode(modes.Invisible) {
+					client.rplWhoReply(channel, member, rb)
+				}
+			}
 		}
 	} else {
 		for mclient := range server.clients.FindAll(mask) {

irc/idletimer.go

 
 	// immutable after construction
 	registerTimeout time.Duration
-	client          *Client
+	session         *Session
 
 	// mutable
 	idleTimeout time.Duration
 
 // Initialize sets up an IdleTimer and starts counting idle time;
 // if there is no activity from the client, it will eventually be stopped.
-func (it *IdleTimer) Initialize(client *Client) {
-	it.client = client
+func (it *IdleTimer) Initialize(session *Session) {
+	it.session = session
 	it.registerTimeout = RegisterTimeout
 	it.idleTimeout, it.quitTimeout = it.recomputeDurations()
+	registered := session.client.Registered()
 
 	it.Lock()
 	defer it.Unlock()
-	it.state = TimerUnregistered
+	if registered {
+		it.state = TimerActive
+	} else {
+		it.state = TimerUnregistered
+	}
 	it.resetTimeout()
 }
 
 	totalTimeout := DefaultTotalTimeout
 	// if they have the resume cap, wait longer before pinging them out
 	// to give them a chance to resume their connection
-	if it.client.capabilities.Has(caps.Resume) {
+	if it.session.capabilities.Has(caps.Resume) {
 		totalTimeout = ResumeableTotalTimeout
 	}
 
 	idleTimeout = DefaultIdleTimeout
-	if it.client.isTor {
+	if it.session.client.isTor {
 		idleTimeout = TorIdleTimeout
 	}
 
 	}()
 
 	if previousState == TimerActive {
-		it.client.Ping()
+		it.session.Ping()
 	} else {
-		it.client.Quit(it.quitMessage(previousState))
-		it.client.destroy(false)
+		it.session.client.Quit(it.quitMessage(previousState), it.session)
+		it.session.client.destroy(false, it.session)
 	}
 }
 

irc/nickname.go

 )
 
 // returns whether the change succeeded or failed
-func performNickChange(server *Server, client *Client, target *Client, newnick string, rb *ResponseBuffer) bool {
+func performNickChange(server *Server, client *Client, target *Client, session *Session, newnick string, rb *ResponseBuffer) bool {
 	nickname := strings.TrimSpace(newnick)
 	cfnick, err := CasefoldName(nickname)
 	currentNick := client.Nick()
 
 	hadNick := target.HasNick()
 	origNickMask := target.NickMaskString()
-	whowas := client.WhoWas()
-	err = client.server.clients.SetNick(target, nickname)
+	whowas := target.WhoWas()
+	err = client.server.clients.SetNick(target, session, nickname)
 	if err == errNicknameInUse {
 		rb.Add(nil, server.name, ERR_NICKNAMEINUSE, currentNick, nickname, client.t("Nickname is already in use"))
 		return false
 		return false
 	}
 
-	client.nickTimer.Touch()
+	target.nickTimer.Touch()
 
 	client.server.logger.Debug("nick", fmt.Sprintf("%s changed nickname to %s [%s]", origNickMask, nickname, cfnick))
 	if hadNick {
 		target.server.snomasks.Send(sno.LocalNicks, fmt.Sprintf(ircfmt.Unescape("$%s$r changed nickname to %s"), whowas.nick, nickname))
 		target.server.whoWas.Append(whowas)
 		rb.Add(nil, origNickMask, "NICK", nickname)
-		for friend := range target.Friends() {
-			if friend != client {
-				friend.Send(nil, origNickMask, "NICK", nickname)
+		for session := range target.Friends() {
+			if session != rb.session {
+				session.Send(nil, origNickMask, "NICK", nickname)
 			}
 		}
 	}
 	buf := make([]byte, 8)
 	rand.Read(buf)
 	nick := fmt.Sprintf("%s%s", prefix, hex.EncodeToString(buf))
-	rb := NewResponseBuffer(client)
-	performNickChange(server, client, client, nick, rb)
+	sessions := client.Sessions()
+	if len(sessions) == 0 {
+		return
+	}
+	// XXX arbitrarily pick the first session to receive error messages;
+	// all other sessions receive a `NICK` line same as a friend would
+	rb := NewResponseBuffer(sessions[0])
+	performNickChange(server, client, client, nil, nick, rb)
 	rb.Send(false)
 	// technically performNickChange can fail to change the nick,
 	// but if they're still delinquent, the timer will get them later

irc/nickserv.go

 		return
 	}
 
-	ghost.Quit(fmt.Sprintf(ghost.t("GHOSTed by %s"), client.Nick()))
-	ghost.destroy(false)
+	ghost.Quit(fmt.Sprintf(ghost.t("GHOSTed by %s"), client.Nick()), nil)
+	ghost.destroy(false, nil)
 }
 
 func nsGroupHandler(server *Server, client *Client, command string, params []string, rb *ResponseBuffer) {

irc/responsebuffer.go

 type ResponseBuffer struct {
 	Label     string
 	batchID   string
-	target    *Client
 	messages  []ircmsg.IrcMessage
 	finalized bool
+	target    *Client
+	session   *Session
 }
 
 // GetLabel returns the label from the given message.
 }
 
 // NewResponseBuffer returns a new ResponseBuffer.
-func NewResponseBuffer(target *Client) *ResponseBuffer {
+func NewResponseBuffer(session *Session) *ResponseBuffer {
 	return &ResponseBuffer{
-		target: target,
+		session: session,
+		target:  session.client,
 	}
 }
 
 	msg.UpdateTags(tags)
 
 	// attach account-tag
-	if rb.target.capabilities.Has(caps.AccountTag) && fromAccount != "*" {
+	if rb.session.capabilities.Has(caps.AccountTag) && fromAccount != "*" {
 		msg.SetTag("account", fromAccount)
 	}
 	// attach message-id
-	if len(msgid) > 0 && rb.target.capabilities.Has(caps.MessageTags) {
+	if len(msgid) > 0 && rb.session.capabilities.Has(caps.MessageTags) {
 		msg.SetTag("draft/msgid", msgid)
 	}
 
 
 // AddSplitMessageFromClient adds a new split message from a specific client to our queue.
 func (rb *ResponseBuffer) AddSplitMessageFromClient(fromNickMask string, fromAccount string, tags map[string]string, command string, target string, message utils.SplitMessage) {
-	if rb.target.capabilities.Has(caps.MaxLine) || message.Wrapped == nil {
+	if rb.session.capabilities.Has(caps.MaxLine) || message.Wrapped == nil {
 		rb.AddFromClient(message.Msgid, fromNickMask, fromAccount, tags, command, target, message.Message)
 	} else {
 		for _, messagePair := range message.Wrapped {
 	if rb.Label != "" {
 		message.SetTag(caps.LabelTagName, rb.Label)
 	}
-	rb.target.SendRawMessage(message, blocking)
+	rb.session.SendRawMessage(message, blocking)
 }
 
 func (rb *ResponseBuffer) sendBatchEnd(blocking bool) {
 	}
 
 	message := ircmsg.MakeMessage(nil, rb.target.server.name, "BATCH", "-"+rb.batchID)
-	rb.target.SendRawMessage(message, blocking)
+	rb.session.SendRawMessage(message, blocking)
 }
 
 // Send sends all messages in the buffer to the client.
 		return nil
 	}
 
-	useLabel := rb.target.capabilities.Has(caps.LabeledResponse) && rb.Label != ""
+	useLabel := rb.session.capabilities.Has(caps.LabeledResponse) && rb.Label != ""
 	// use a batch if we have a label, and we either currently have 0 or 2+ messages,
 	// or we are doing a Flush() and we have to assume that there will be more messages
 	// in the future.
 	// send each message out
 	for _, message := range rb.messages {
 		// attach server-time if needed
-		if rb.target.capabilities.Has(caps.ServerTime) && !message.HasTag("time") {
+		if rb.session.capabilities.Has(caps.ServerTime) && !message.HasTag("time") {
 			message.SetTag("time", time.Now().UTC().Format(IRCv3TimestampFormat))
 		}
 
 		}
 
 		// send message out
-		rb.target.SendRawMessage(message, blocking)
+		rb.session.SendRawMessage(message, blocking)
 	}
 
 	// end batch if required

irc/roleplay.go

 		}
 
 		for _, member := range channel.Members() {
-			if member == client && !client.capabilities.Has(caps.EchoMessage) {
-				continue
-			}
-			if member == client {
-				rb.Add(nil, source, "PRIVMSG", channel.name, message)
-			} else {
-				member.Send(nil, source, "PRIVMSG", channel.name, message)
+			for _, session := range member.Sessions() {
+				if member == client && !session.capabilities.Has(caps.EchoMessage) {
+					continue
+				} else if rb.session == session {
+					rb.Add(nil, source, "PRIVMSG", channel.name, message)
+				} else if member == client || session.capabilities.Has(caps.EchoMessage) {
+					session.Send(nil, source, "PRIVMSG", channel.name, message)
+				}
 			}
 		}
 	} else {
 		cnick := client.Nick()
 		tnick := user.Nick()
 		user.Send(nil, source, "PRIVMSG", tnick, message)
-		if client.capabilities.Has(caps.EchoMessage) {
+		if rb.session.capabilities.Has(caps.EchoMessage) {
 			rb.Add(nil, source, "PRIVMSG", tnick, message)
 		}
 		if user.HasMode(modes.Away) {

irc/server.go

 	supportedChannelModesString = modes.SupportedChannelModes.String()
 
 	// SupportedCapabilities are the caps we advertise.
-	// MaxLine, SASL and STS are set during server startup.
-	SupportedCapabilities = caps.NewSet(caps.Acc, caps.AccountTag, caps.AccountNotify, caps.AwayNotify, caps.Batch, caps.CapNotify, caps.ChgHost, caps.EchoMessage, caps.ExtendedJoin, caps.InviteNotify, caps.LabeledResponse, caps.Languages, caps.MessageTags, caps.MultiPrefix, caps.Rename, caps.Resume, caps.ServerTime, caps.SetName, caps.UserhostInNames)
+	// MaxLine, SASL and STS may be unset during server startup / rehash.
+	SupportedCapabilities = caps.NewCompleteSet()
 
 	// CapValues are the actual values we advertise to v3.2 clients.
 	// actual values are set during server startup.
 // server functionality
 //
 
-func (server *Server) tryRegister(c *Client) {
+func (server *Server) tryRegister(c *Client, session *Session) {
 	resumed := false
 	// try to complete registration, either via RESUME token or normally
 	if c.resumeDetails != nil {
 		}
 		resumed = true
 	} else {
-		if c.preregNick == "" || !c.HasUsername() || c.capState == caps.NegotiatingState {
+		if c.preregNick == "" || !c.HasUsername() || session.capState == caps.NegotiatingState {
 			return
 		}
 
 		// before completing the other registration commands
 		config := server.Config()
 		if !c.isAuthorized(config) {
-			c.Quit(c.t("Bad password"))
-			c.destroy(false)
+			c.Quit(c.t("Bad password"), nil)
+			c.destroy(false, nil)
 			return
 		}
 
-		rb := NewResponseBuffer(c)
-		nickAssigned := performNickChange(server, c, c, c.preregNick, rb)
+		rb := NewResponseBuffer(session)
+		nickAssigned := performNickChange(server, c, c, session, c.preregNick, rb)
 		rb.Send(true)
 		if !nickAssigned {
 			c.preregNick = ""
 		// check KLINEs
 		isBanned, info := server.klines.CheckMasks(c.AllNickmasks()...)
 		if isBanned {
-			c.Quit(info.BanMessage(c.t("You are banned from this server (%s)")))
-			c.destroy(false)
+			c.Quit(info.BanMessage(c.t("You are banned from this server (%s)")), nil)
+			c.destroy(false, nil)
 			return
 		}
 	}
 
-	// registration has succeeded:
-	c.SetRegistered()
+	reattached := session.client != c
 
-	// count new user in statistics
-	server.stats.ChangeTotal(1)
+	if !reattached {
+		// registration has succeeded:
+		c.SetRegistered()
 
-	if !resumed {
-		server.monitorManager.AlertAbout(c, true)
+		// count new user in statistics
+		server.stats.ChangeTotal(1)
+
+		if !resumed {
+			server.monitorManager.AlertAbout(c, true)
+		}
 	}
 
 	// continue registration
 	//TODO(dan): Look at adding last optional [<channel modes with a parameter>] parameter
 	c.Send(nil, server.name, RPL_MYINFO, c.nick, server.name, Ver, supportedUserModesString, supportedChannelModesString)
 
-	rb := NewResponseBuffer(c)
+	rb := NewResponseBuffer(session)
 	c.RplISupport(rb)
 	server.MOTD(c, rb)
 	rb.Send(true)
 }
 
 // WhoisChannelsNames returns the common channel names between two users.
-func (client *Client) WhoisChannelsNames(target *Client) []string {
-	isMultiPrefix := client.capabilities.Has(caps.MultiPrefix)
+func (client *Client) WhoisChannelsNames(target *Client, multiPrefix bool) []string {
 	var chstrs []string
 	for _, channel := range target.Channels() {
 		// channel is secret and the target can't see it
 				continue
 			}
 		}
-		chstrs = append(chstrs, channel.ClientPrefixes(target, isMultiPrefix)+channel.name)
+		chstrs = append(chstrs, channel.ClientPrefixes(target, multiPrefix)+channel.name)
 	}
 	return chstrs
 }
 	rb.Add(nil, client.server.name, RPL_WHOISUSER, cnick, targetInfo.nick, targetInfo.username, targetInfo.hostname, "*", targetInfo.realname)
 	tnick := targetInfo.nick
 
-	whoischannels := client.WhoisChannelsNames(target)
+	whoischannels := client.WhoisChannelsNames(target, rb.session.capabilities.Has(caps.MultiPrefix))
 	if whoischannels != nil {
 		rb.Add(nil, client.server.name, RPL_WHOISCHANNELS, cnick, tnick, strings.Join(whoischannels, " "))
 	}
 	}
 
 	if channel != nil {
-		flags += channel.ClientPrefixes(client, target.capabilities.Has(caps.MultiPrefix))
+		// TODO is this right?
+		flags += channel.ClientPrefixes(client, rb.session.capabilities.Has(caps.MultiPrefix))
 		channelName = channel.name
 	}
-	rb.Add(nil, target.server.name, RPL_WHOREPLY, target.nick, channelName, client.Username(), client.Hostname(), client.server.name, client.Nick(), flags, strconv.Itoa(client.hops)+" "+client.Realname())
-}
-
-func whoChannel(client *Client, channel *Channel, friends ClientSet, rb *ResponseBuffer) {
-	for _, member := range channel.Members() {
-		if !client.HasMode(modes.Invisible) || friends[client] {
-			client.rplWhoReply(channel, member, rb)
-		}
-	}
+	// hardcode a hopcount of 0 for now
+	rb.Add(nil, target.server.name, RPL_WHOREPLY, target.nick, channelName, client.Username(), client.Hostname(), client.server.name, client.Nick(), flags, "0 "+client.Realname())
 }
 
 // rehash reloads the config and applies the changes from the config file.
 		SupportedCapabilities.Enable(caps.MaxLine)
 		value := fmt.Sprintf("%d", config.Limits.LineLen.Rest)
 		CapValues.Set(caps.MaxLine, value)
+	} else {
+		SupportedCapabilities.Disable(caps.MaxLine)
 	}
 
 	// STS
 	stsDisabledByRehash := false
 	stsCurrentCapValue, _ := CapValues.Get(caps.STS)
 	server.logger.Debug("server", "STS Vals", stsCurrentCapValue, stsValue, fmt.Sprintf("server[%v] config[%v]", stsPreviouslyEnabled, config.Server.STS.Enabled))
-	if config.Server.STS.Enabled && !stsPreviouslyEnabled {
+	if config.Server.STS.Enabled {
 		// enabling STS
 		SupportedCapabilities.Enable(caps.STS)
-		addedCaps.Add(caps.STS)
-		CapValues.Set(caps.STS, stsValue)
-	} else if !config.Server.STS.Enabled && stsPreviouslyEnabled {
+		if !stsPreviouslyEnabled {
+			addedCaps.Add(caps.STS)
+			CapValues.Set(caps.STS, stsValue)
+		} else if stsValue != stsCurrentCapValue {
+			// STS policy updated
+			CapValues.Set(caps.STS, stsValue)
+			updatedCaps.Add(caps.STS)
+		}
+	} else {
 		// disabling STS
 		SupportedCapabilities.Disable(caps.STS)
-		removedCaps.Add(caps.STS)
-		stsDisabledByRehash = true
-	} else if config.Server.STS.Enabled && stsPreviouslyEnabled && stsValue != stsCurrentCapValue {
-		// STS policy updated
-		CapValues.Set(caps.STS, stsValue)
-		updatedCaps.Add(caps.STS)
+		if stsPreviouslyEnabled {
+			removedCaps.Add(caps.STS)
+			stsDisabledByRehash = true
+		}
 	}
 
 	// resize history buffers as needed
 	}
 
 	// burst new and removed caps
-	var capBurstClients ClientSet
+	var capBurstSessions []*Session
 	added := make(map[caps.Version]string)
 	var removed string
 
 	removedCaps.Union(updatedCaps)
 
 	if !addedCaps.Empty() || !removedCaps.Empty() {
-		capBurstClients = server.clients.AllWithCaps(caps.CapNotify)
+		capBurstSessions = server.clients.AllWithCaps(caps.CapNotify)
 
 		added[caps.Cap301] = addedCaps.String(caps.Cap301, CapValues)
 		added[caps.Cap302] = addedCaps.String(caps.Cap302, CapValues)
 		removed = removedCaps.String(caps.Cap301, CapValues)
 	}
 
-	for sClient := range capBurstClients {
+	for _, sSession := range capBurstSessions {
 		if stsDisabledByRehash {
 			// remove STS policy
 			//TODO(dan): this is an ugly hack. we can write this better.
 		}
 		// DEL caps and then send NEW ones so that updated caps get removed/added correctly
 		if !removedCaps.Empty() {
-			sClient.Send(nil, server.name, "CAP", sClient.nick, "DEL", removed)
+			sSession.Send(nil, server.name, "CAP", sSession.client.Nick(), "DEL", removed)
 		}
 		if !addedCaps.Empty() {
-			sClient.Send(nil, server.name, "CAP", sClient.nick, "NEW", added[sClient.capVersion])
+			sSession.Send(nil, server.name, "CAP", sSession.client.Nick(), "NEW", added[sSession.capVersion])
 		}
 	}
 

oragono.yaml

         # rename-prefix - this is the prefix to use when renaming clients (e.g. Guest-AB54U31)
         rename-prefix: Guest-
 
+    # bouncer controls whether oragono can act as a bouncer, i.e., allowing
+    # multiple connections to attach to the same client/nickname identity
+    bouncer:
+        # when disabled, each connection must use a separate nickname (as is the
+        # typical behavior of IRC servers). when enabled, a new connection that
+        # has authenticated with SASL can associate itself with an existing
+        # client
+        enabled: true
+
+        # clients can opt in to bouncer functionality using the cap system, or
+        # via nickserv. if this is enabled, then they have to opt out instead
+        allowed-by-default: false
+
     # vhosts controls the assignment of vhosts (strings displayed in place of the user's
     # hostname/IP) by the HostServ service
     vhosts: