2
0
mirror of https://github.com/42wim/matterbridge synced 2024-11-03 15:40:24 +00:00
matterbridge/vendor/github.com/lrstanley/girc/state.go

551 lines
14 KiB
Go
Raw Normal View History

2017-11-08 21:47:18 +00:00
// Copyright (c) Liam Stanley <me@liamstanley.io>. All rights reserved. Use
// of this source code is governed by the MIT license that can be found in
// the LICENSE file.
package girc
import (
2019-09-07 19:35:45 +00:00
"fmt"
2017-11-08 21:47:18 +00:00
"sort"
"sync"
"time"
)
// state represents the actively-changing variables within the client
// runtime. Note that everything within the state should be guarded by the
// embedded sync.RWMutex.
type state struct {
sync.RWMutex
// nick, ident, and host are the internal trackers for our user.
nick, ident, host string
// channels represents all channels we're active in.
channels map[string]*Channel
// users represents all of users that we're tracking.
users map[string]*User
// enabledCap are the capabilities which are enabled for this connection.
2019-09-07 19:35:45 +00:00
enabledCap map[string]map[string]string
2017-11-08 21:47:18 +00:00
// tmpCap are the capabilties which we share with the server during the
// last capability check. These will get sent once we have received the
// last capability list command from the server.
2019-09-07 19:35:45 +00:00
tmpCap map[string]map[string]string
2017-11-08 21:47:18 +00:00
// serverOptions are the standard capabilities and configurations
// supported by the server at connection time. This also includes
// RPL_ISUPPORT entries.
serverOptions map[string]string
// motd is the servers message of the day.
motd string
2019-09-07 19:35:45 +00:00
// sts are strict transport security configurations, if specified by the
// server.
//
// TODO: ideally, this would be a configurable policy store that the user could
// optionally override (to store STS information on disk, memory, etc).
sts strictTransport
2017-11-08 21:47:18 +00:00
}
// reset resets the state back to it's original form.
2019-09-07 19:35:45 +00:00
func (s *state) reset(initial bool) {
2017-11-08 21:47:18 +00:00
s.Lock()
s.nick = ""
s.ident = ""
s.host = ""
s.channels = make(map[string]*Channel)
s.users = make(map[string]*User)
s.serverOptions = make(map[string]string)
2019-09-07 19:35:45 +00:00
s.enabledCap = make(map[string]map[string]string)
s.tmpCap = make(map[string]map[string]string)
2017-11-08 21:47:18 +00:00
s.motd = ""
2019-09-07 19:35:45 +00:00
if initial {
s.sts.reset()
}
2017-11-08 21:47:18 +00:00
s.Unlock()
}
// User represents an IRC user and the state attached to them.
type User struct {
// Nick is the users current nickname. rfc1459 compliant.
Nick string `json:"nick"`
// Ident is the users username/ident. Ident is commonly prefixed with a
// "~", which indicates that they do not have a identd server setup for
// authentication.
Ident string `json:"ident"`
// Host is the visible host of the users connection that the server has
// provided to us for their connection. May not always be accurate due to
// many networks spoofing/hiding parts of the hostname for privacy
// reasons.
Host string `json:"host"`
// ChannelList is a sorted list of all channels that we are currently
// tracking the user in. Each channel name is rfc1459 compliant. See
// User.Channels() for a shorthand if you're looking for the *Channel
// version of the channel list.
ChannelList []string `json:"channels"`
// FirstSeen represents the first time that the user was seen by the
// client for the given channel. Only usable if from state, not in past.
FirstSeen time.Time `json:"first_seen"`
// LastActive represents the last time that we saw the user active,
// which could be during nickname change, message, channel join, etc.
// Only usable if from state, not in past.
LastActive time.Time `json:"last_active"`
// Perms are the user permissions applied to this user that affect the given
// channel. This supports non-rfc style modes like Admin, Owner, and HalfOp.
Perms *UserPerms `json:"perms"`
// Extras are things added on by additional tracking methods, which may
// or may not work on the IRC server in mention.
Extras struct {
// Name is the users "realname" or full name. Commonly contains links
// to the IRC client being used, or something of non-importance. May
// also be empty if unsupported by the server/tracking is disabled.
Name string `json:"name"`
// Account refers to the account which the user is authenticated as.
// This differs between each network (e.g. usually Nickserv, but
// could also be something like Undernet). May also be empty if
// unsupported by the server/tracking is disabled.
Account string `json:"account"`
// Away refers to the away status of the user. An empty string
// indicates that they are active, otherwise the string is what they
// set as their away message. May also be empty if unsupported by the
// server/tracking is disabled.
Away string `json:"away"`
} `json:"extras"`
}
// Channels returns a reference of *Channels that the client knows the user
// is in. If you're just looking for the namme of the channels, use
// User.ChannelList.
func (u User) Channels(c *Client) []*Channel {
if c == nil {
panic("nil Client provided")
}
channels := []*Channel{}
c.state.RLock()
for i := 0; i < len(u.ChannelList); i++ {
ch := c.state.lookupChannel(u.ChannelList[i])
if ch != nil {
channels = append(channels, ch)
}
}
c.state.RUnlock()
return channels
}
// Copy returns a deep copy of the user which can be modified without making
// changes to the actual state.
func (u *User) Copy() *User {
2018-05-09 20:48:39 +00:00
if u == nil {
return nil
}
2017-11-08 21:47:18 +00:00
nu := &User{}
*nu = *u
nu.Perms = u.Perms.Copy()
_ = copy(nu.ChannelList, u.ChannelList)
return nu
}
// addChannel adds the channel to the users channel list.
func (u *User) addChannel(name string) {
if u.InChannel(name) {
return
}
u.ChannelList = append(u.ChannelList, ToRFC1459(name))
2018-05-09 20:48:39 +00:00
sort.Strings(u.ChannelList)
2017-11-08 21:47:18 +00:00
u.Perms.set(name, Perms{})
}
// deleteChannel removes an existing channel from the users channel list.
func (u *User) deleteChannel(name string) {
name = ToRFC1459(name)
j := -1
for i := 0; i < len(u.ChannelList); i++ {
if u.ChannelList[i] == name {
j = i
break
}
}
if j != -1 {
u.ChannelList = append(u.ChannelList[:j], u.ChannelList[j+1:]...)
}
u.Perms.remove(name)
}
// InChannel checks to see if a user is in the given channel.
func (u *User) InChannel(name string) bool {
name = ToRFC1459(name)
for i := 0; i < len(u.ChannelList); i++ {
if u.ChannelList[i] == name {
return true
}
}
return false
}
// Lifetime represents the amount of time that has passed since we have first
// seen the user.
func (u *User) Lifetime() time.Duration {
return time.Since(u.FirstSeen)
}
// Active represents the the amount of time that has passed since we have
// last seen the user.
func (u *User) Active() time.Duration {
return time.Since(u.LastActive)
}
// IsActive returns true if they were active within the last 30 minutes.
func (u *User) IsActive() bool {
return u.Active() < (time.Minute * 30)
}
// Channel represents an IRC channel and the state attached to it.
type Channel struct {
// Name of the channel. Must be rfc1459 compliant.
Name string `json:"name"`
// Topic of the channel.
Topic string `json:"topic"`
// UserList is a sorted list of all users we are currently tracking within
// the channel. Each is the nickname, and is rfc1459 compliant.
UserList []string `json:"user_list"`
// Joined represents the first time that the client joined the channel.
Joined time.Time `json:"joined"`
// Modes are the known channel modes that the bot has captured.
Modes CModes `json:"modes"`
}
// Users returns a reference of *Users that the client knows the channel has
// If you're just looking for just the name of the users, use Channnel.UserList.
func (ch Channel) Users(c *Client) []*User {
if c == nil {
panic("nil Client provided")
}
users := []*User{}
c.state.RLock()
for i := 0; i < len(ch.UserList); i++ {
user := c.state.lookupUser(ch.UserList[i])
if user != nil {
users = append(users, user)
}
}
c.state.RUnlock()
return users
}
// Trusted returns a list of users which have voice or greater in the given
// channel. See Perms.IsTrusted() for more information.
func (ch Channel) Trusted(c *Client) []*User {
if c == nil {
panic("nil Client provided")
}
users := []*User{}
c.state.RLock()
for i := 0; i < len(ch.UserList); i++ {
user := c.state.lookupUser(ch.UserList[i])
if user == nil {
continue
}
perms, ok := user.Perms.Lookup(ch.Name)
if ok && perms.IsTrusted() {
users = append(users, user)
}
}
c.state.RUnlock()
return users
}
// Admins returns a list of users which have half-op (if supported), or
// greater permissions (op, admin, owner, etc) in the given channel. See
// Perms.IsAdmin() for more information.
func (ch Channel) Admins(c *Client) []*User {
if c == nil {
panic("nil Client provided")
}
users := []*User{}
c.state.RLock()
for i := 0; i < len(ch.UserList); i++ {
user := c.state.lookupUser(ch.UserList[i])
if user == nil {
continue
}
perms, ok := user.Perms.Lookup(ch.Name)
if ok && perms.IsAdmin() {
users = append(users, user)
}
}
c.state.RUnlock()
return users
}
// addUser adds a user to the users list.
func (ch *Channel) addUser(nick string) {
if ch.UserIn(nick) {
return
}
ch.UserList = append(ch.UserList, ToRFC1459(nick))
sort.Strings(ch.UserList)
}
// deleteUser removes an existing user from the users list.
func (ch *Channel) deleteUser(nick string) {
nick = ToRFC1459(nick)
j := -1
for i := 0; i < len(ch.UserList); i++ {
if ch.UserList[i] == nick {
j = i
break
}
}
if j != -1 {
ch.UserList = append(ch.UserList[:j], ch.UserList[j+1:]...)
}
}
// Copy returns a deep copy of a given channel.
func (ch *Channel) Copy() *Channel {
2018-05-09 20:48:39 +00:00
if ch == nil {
return nil
}
2017-11-08 21:47:18 +00:00
nc := &Channel{}
*nc = *ch
_ = copy(nc.UserList, ch.UserList)
// And modes.
nc.Modes = ch.Modes.Copy()
return nc
}
// Len returns the count of users in a given channel.
func (ch *Channel) Len() int {
return len(ch.UserList)
}
// UserIn checks to see if a given user is in a channel.
func (ch *Channel) UserIn(name string) bool {
name = ToRFC1459(name)
for i := 0; i < len(ch.UserList); i++ {
if ch.UserList[i] == name {
return true
}
}
return false
}
// Lifetime represents the amount of time that has passed since we have first
// joined the channel.
func (ch *Channel) Lifetime() time.Duration {
return time.Since(ch.Joined)
}
// createChannel creates the channel in state, if not already done.
func (s *state) createChannel(name string) (ok bool) {
supported := s.chanModes()
prefixes, _ := parsePrefixes(s.userPrefixes())
if _, ok := s.channels[ToRFC1459(name)]; ok {
return false
}
s.channels[ToRFC1459(name)] = &Channel{
Name: name,
UserList: []string{},
Joined: time.Now(),
Modes: NewCModes(supported, prefixes),
}
return true
}
// deleteChannel removes the channel from state, if not already done.
func (s *state) deleteChannel(name string) {
name = ToRFC1459(name)
_, ok := s.channels[name]
if !ok {
return
}
for _, user := range s.channels[name].UserList {
s.users[user].deleteChannel(name)
if len(s.users[user].ChannelList) == 0 {
// Assume we were only tracking them in this channel, and they
// should be removed from state.
delete(s.users, user)
}
}
delete(s.channels, name)
}
// lookupChannel returns a reference to a channel, nil returned if no results
// found.
func (s *state) lookupChannel(name string) *Channel {
return s.channels[ToRFC1459(name)]
}
// lookupUser returns a reference to a user, nil returned if no results
// found.
func (s *state) lookupUser(name string) *User {
return s.users[ToRFC1459(name)]
}
// createUser creates the user in state, if not already done.
func (s *state) createUser(src *Source) (ok bool) {
if _, ok := s.users[src.ID()]; ok {
2017-11-08 21:47:18 +00:00
// User already exists.
return false
}
s.users[src.ID()] = &User{
Nick: src.Name,
Host: src.Host,
Ident: src.Ident,
2017-11-08 21:47:18 +00:00
FirstSeen: time.Now(),
LastActive: time.Now(),
Perms: &UserPerms{channels: make(map[string]Perms)},
}
return true
}
// deleteUser removes the user from channel state.
func (s *state) deleteUser(channelName, nick string) {
user := s.lookupUser(nick)
if user == nil {
return
}
if channelName == "" {
for i := 0; i < len(user.ChannelList); i++ {
s.channels[user.ChannelList[i]].deleteUser(nick)
}
delete(s.users, ToRFC1459(nick))
return
}
channel := s.lookupChannel(channelName)
if channel == nil {
return
}
user.deleteChannel(channelName)
channel.deleteUser(nick)
if len(user.ChannelList) == 0 {
// This means they are no longer in any channels we track, delete
// them from state.
delete(s.users, ToRFC1459(nick))
}
}
// renameUser renames the user in state, in all locations where relevant.
func (s *state) renameUser(from, to string) {
from = ToRFC1459(from)
// Update our nickname.
if from == ToRFC1459(s.nick) {
s.nick = to
}
user := s.lookupUser(from)
if user == nil {
return
}
delete(s.users, from)
user.Nick = to
user.LastActive = time.Now()
s.users[ToRFC1459(to)] = user
for i := 0; i < len(user.ChannelList); i++ {
for j := 0; j < len(s.channels[user.ChannelList[i]].UserList); j++ {
if s.channels[user.ChannelList[i]].UserList[j] == from {
s.channels[user.ChannelList[i]].UserList[j] = ToRFC1459(to)
2018-05-09 20:48:39 +00:00
sort.Strings(s.channels[user.ChannelList[i]].UserList)
break
2017-11-08 21:47:18 +00:00
}
}
}
}
2019-09-07 19:35:45 +00:00
type strictTransport struct {
beginUpgrade bool
upgradePort int
persistenceDuration int
persistenceReceived time.Time
preload bool
lastFailed time.Time
}
func (s *strictTransport) reset() {
s.upgradePort = -1
s.persistenceDuration = -1
s.preload = false
}
func (s *strictTransport) expired() bool {
return int(time.Since(s.persistenceReceived).Seconds()) > s.persistenceDuration
}
func (s *strictTransport) enabled() bool {
return s.upgradePort > 0
}
// ErrSTSUpgradeFailed is an error that occurs when a connection that was attempted
// to be upgraded via a strict transport policy, failed. This does not necessarily
// indicate that STS was to blame, but the underlying connection failed for some
// reason.
type ErrSTSUpgradeFailed struct {
Err error
}
func (e ErrSTSUpgradeFailed) Error() string {
return fmt.Sprintf("fail to upgrade to secure (sts) connection: %v", e.Err)
}
// notify sends state change notifications so users can update their refs
// when state changes.
func (s *state) notify(c *Client, ntype string) {
c.RunHandlers(&Event{Command: ntype})
}