3
0
mirror of https://github.com/ergochat/ergo.git synced 2024-12-23 11:12:44 +01:00
ergo/irc/getters.go

260 lines
6.2 KiB
Go
Raw Normal View History

// Copyright (c) 2017 Shivaram Lingamneni <slingamn@cs.stanford.edu>
// released under the MIT license
package irc
import (
"github.com/oragono/oragono/irc/isupport"
"github.com/oragono/oragono/irc/modes"
)
2017-10-05 15:39:57 +02:00
func (server *Server) Config() *Config {
server.configurableStateMutex.RLock()
defer server.configurableStateMutex.RUnlock()
return server.config
2018-03-18 02:32:12 +01:00
}
func (server *Server) ISupport() *isupport.List {
server.configurableStateMutex.RLock()
defer server.configurableStateMutex.RUnlock()
return server.isupport
}
func (server *Server) Limits() Limits {
return server.Config().Limits
}
func (server *Server) Password() []byte {
return server.Config().Server.passwordBytes
}
2017-10-26 10:19:01 +02:00
func (server *Server) RecoverFromErrors() bool {
return *server.Config().Debug.RecoverFromErrors
2017-10-26 10:19:01 +02:00
}
func (server *Server) DefaultChannelModes() modes.Modes {
return server.Config().Channels.defaultModes
2017-10-30 10:21:47 +01:00
}
func (server *Server) ChannelRegistrationEnabled() bool {
return server.Config().Channels.Registration.Enabled
}
func (server *Server) AccountConfig() *AccountConfig {
return &server.Config().Accounts
2018-03-22 16:04:21 +01:00
}
func (server *Server) FakelagConfig() *FakelagConfig {
return &server.Config().Fakelag
}
2018-04-19 08:48:19 +02:00
func (server *Server) GetOperator(name string) (oper *Oper) {
name, err := CasefoldName(name)
if err != nil {
return
}
server.configurableStateMutex.RLock()
defer server.configurableStateMutex.RUnlock()
return server.config.operators[name]
2018-04-19 08:48:19 +02:00
}
func (client *Client) Nick() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.nick
}
func (client *Client) NickMaskString() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.nickMaskString
}
func (client *Client) NickCasefolded() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.nickCasefolded
}
2017-10-15 18:24:28 +02:00
2018-12-23 19:25:02 +01:00
func (client *Client) NickMaskCasefolded() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.nickMaskCasefolded
}
2017-10-23 01:50:16 +02:00
func (client *Client) Username() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.username
}
func (client *Client) Hostname() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.hostname
}
func (client *Client) Realname() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.realname
}
// uniqueIdentifiers returns the strings for which the server enforces per-client
// uniqueness/ownership; no two clients can have colliding casefolded nicks or
// skeletons.
func (client *Client) uniqueIdentifiers() (nickCasefolded string, skeleton string) {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.nickCasefolded, client.skeleton
}
func (client *Client) ResumeToken() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.resumeToken
}
2018-04-19 08:48:19 +02:00
func (client *Client) Oper() *Oper {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.oper
}
2017-10-15 18:24:28 +02:00
func (client *Client) Registered() bool {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.registered
}
func (client *Client) Destroyed() bool {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.isDestroyed
}
2017-10-23 01:50:16 +02:00
func (client *Client) Account() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.account
}
func (client *Client) AccountName() string {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
return client.accountName
}
func (client *Client) SetAccountName(account string) (changed bool) {
var casefoldedAccount string
var err error
if account != "" {
if casefoldedAccount, err = CasefoldName(account); err != nil {
return
}
}
client.stateMutex.Lock()
defer client.stateMutex.Unlock()
changed = client.account != casefoldedAccount
client.account = casefoldedAccount
client.accountName = account
return
}
func (client *Client) HasMode(mode modes.Mode) bool {
2018-04-23 00:47:10 +02:00
// client.flags has its own synch
return client.flags.HasMode(mode)
}
func (client *Client) SetMode(mode modes.Mode, on bool) bool {
return client.flags.SetMode(mode, on)
2017-10-23 01:50:16 +02:00
}
func (client *Client) Channels() (result []*Channel) {
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
length := len(client.channels)
result = make([]*Channel, length)
i := 0
for channel := range client.channels {
result[i] = channel
i++
}
return
}
2018-05-04 06:24:54 +02:00
func (client *Client) WhoWas() (result WhoWas) {
return client.Details().WhoWas
}
func (client *Client) Details() (result ClientDetails) {
2018-05-04 06:24:54 +02:00
client.stateMutex.RLock()
defer client.stateMutex.RUnlock()
result.nick = client.nick
result.nickCasefolded = client.nickCasefolded
2018-05-04 06:24:54 +02:00
result.username = client.username
result.hostname = client.username
2018-05-04 06:24:54 +02:00
result.realname = client.realname
result.nickMask = client.nickMaskString
result.nickMaskCasefolded = client.nickMaskCasefolded
result.account = client.account
result.accountName = client.accountName
2018-05-04 06:24:54 +02:00
return
}
2017-10-23 01:50:16 +02:00
func (channel *Channel) Name() string {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return channel.name
}
2017-10-30 10:21:47 +01:00
func (channel *Channel) setName(name string) {
channel.stateMutex.Lock()
defer channel.stateMutex.Unlock()
channel.name = name
}
func (channel *Channel) NameCasefolded() string {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return channel.nameCasefolded
}
func (channel *Channel) setNameCasefolded(nameCasefolded string) {
channel.stateMutex.Lock()
defer channel.stateMutex.Unlock()
channel.nameCasefolded = nameCasefolded
}
2017-10-23 01:50:16 +02:00
func (channel *Channel) Members() (result []*Client) {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return channel.membersCache
}
2018-12-28 19:45:55 +01:00
func (channel *Channel) setUserLimit(limit int) {
2017-10-23 01:50:16 +02:00
channel.stateMutex.Lock()
channel.userLimit = limit
channel.stateMutex.Unlock()
}
func (channel *Channel) Key() string {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return channel.key
}
func (channel *Channel) setKey(key string) {
channel.stateMutex.Lock()
defer channel.stateMutex.Unlock()
2017-10-23 01:50:16 +02:00
channel.key = key
}
func (channel *Channel) Founder() string {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return channel.registeredFounder
}