3
0
mirror of https://github.com/ergochat/ergo.git synced 2024-12-23 03:02:48 +01:00
ergo/irc/channel.go

841 lines
25 KiB
Go
Raw Normal View History

// Copyright (c) 2012-2014 Jeremy Latt
// Copyright (c) 2014-2015 Edmund Huber
2017-03-27 14:15:02 +02:00
// Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
// released under the MIT license
package irc
import (
"bytes"
"crypto/subtle"
"fmt"
"strconv"
"time"
2017-01-10 17:09:08 +01:00
"sync"
2017-06-15 18:14:19 +02:00
"github.com/goshuirc/irc-go/ircmsg"
"github.com/oragono/oragono/irc/caps"
"github.com/oragono/oragono/irc/modes"
)
2017-04-16 03:31:33 +02:00
// Channel represents a channel that clients can join.
type Channel struct {
2018-04-23 00:47:10 +02:00
flags *modes.ModeSet
lists map[modes.Mode]*UserMaskSet
key string
members MemberSet
membersCache []*Client // allow iteration over channel members without holding the lock
name string
nameCasefolded string
server *Server
createdTime time.Time
registeredFounder string
registeredTime time.Time
2017-11-22 10:41:11 +01:00
stateMutex sync.RWMutex // tier 1
2018-04-24 09:11:11 +02:00
joinPartMutex sync.Mutex // tier 3
topic string
topicSetBy string
topicSetTime time.Time
userLimit uint64
accountToUMode map[string]modes.Mode
}
2014-02-05 04:28:24 +01:00
// NewChannel creates a new channel from a `Server` and a `name`
// string, which must be unique on the server.
func NewChannel(s *Server, name string, regInfo *RegisteredChannel) *Channel {
casefoldedName, err := CasefoldChannel(name)
if err != nil {
2017-10-30 10:21:47 +01:00
s.logger.Error("internal", fmt.Sprintf("Bad channel name %s: %v", name, err))
return nil
}
channel := &Channel{
createdTime: time.Now(), // may be overwritten by applyRegInfo
2018-04-23 00:47:10 +02:00
flags: modes.NewModeSet(),
lists: map[modes.Mode]*UserMaskSet{
modes.BanMask: NewUserMaskSet(),
modes.ExceptMask: NewUserMaskSet(),
modes.InviteMask: NewUserMaskSet(),
2014-02-23 00:01:11 +01:00
},
members: make(MemberSet),
name: name,
nameCasefolded: casefoldedName,
server: s,
accountToUMode: make(map[string]modes.Mode),
2012-12-09 21:51:50 +01:00
}
if regInfo != nil {
channel.applyRegInfo(regInfo)
} else {
2017-10-30 10:21:47 +01:00
for _, mode := range s.DefaultChannelModes() {
2018-04-23 00:47:10 +02:00
channel.flags.SetMode(mode, true)
2016-04-21 11:29:50 +02:00
}
}
return channel
}
// read in channel state that was persisted in the DB
func (channel *Channel) applyRegInfo(chanReg *RegisteredChannel) {
channel.registeredFounder = chanReg.Founder
channel.registeredTime = chanReg.RegisteredAt
channel.topic = chanReg.Topic
channel.topicSetBy = chanReg.TopicSetBy
channel.topicSetTime = chanReg.TopicSetTime
channel.name = chanReg.Name
channel.createdTime = chanReg.RegisteredAt
channel.key = chanReg.Key
for _, mode := range chanReg.Modes {
2018-04-23 00:47:10 +02:00
channel.flags.SetMode(mode, true)
}
for _, mask := range chanReg.Banlist {
channel.lists[modes.BanMask].Add(mask)
}
for _, mask := range chanReg.Exceptlist {
channel.lists[modes.ExceptMask].Add(mask)
}
for _, mask := range chanReg.Invitelist {
channel.lists[modes.InviteMask].Add(mask)
}
for account, mode := range chanReg.AccountToUMode {
channel.accountToUMode[account] = mode
}
}
// obtain a consistent snapshot of the channel state that can be persisted to the DB
func (channel *Channel) ExportRegistration(includeFlags uint) (info RegisteredChannel) {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
info.Name = channel.name
info.Founder = channel.registeredFounder
info.RegisteredAt = channel.registeredTime
if includeFlags&IncludeTopic != 0 {
info.Topic = channel.topic
info.TopicSetBy = channel.topicSetBy
info.TopicSetTime = channel.topicSetTime
}
if includeFlags&IncludeModes != 0 {
info.Key = channel.key
2018-04-23 00:47:10 +02:00
info.Modes = channel.flags.AllModes()
}
if includeFlags&IncludeLists != 0 {
for mask := range channel.lists[modes.BanMask].masks {
info.Banlist = append(info.Banlist, mask)
}
for mask := range channel.lists[modes.ExceptMask].masks {
info.Exceptlist = append(info.Exceptlist, mask)
}
for mask := range channel.lists[modes.InviteMask].masks {
info.Invitelist = append(info.Invitelist, mask)
}
info.AccountToUMode = make(map[string]modes.Mode)
for account, mode := range channel.accountToUMode {
info.AccountToUMode[account] = mode
}
}
return
}
// SetRegistered registers the channel, returning an error if it was already registered.
func (channel *Channel) SetRegistered(founder string) error {
channel.stateMutex.Lock()
defer channel.stateMutex.Unlock()
if channel.registeredFounder != "" {
2018-02-03 13:03:36 +01:00
return errChannelAlreadyRegistered
}
channel.registeredFounder = founder
channel.registeredTime = time.Now()
channel.accountToUMode[founder] = modes.ChannelFounder
return nil
}
2018-06-04 11:02:22 +02:00
// SetUnregistered deletes the channel's registration information.
func (channel *Channel) SetUnregistered() {
channel.stateMutex.Lock()
defer channel.stateMutex.Unlock()
channel.registeredFounder = ""
var zeroTime time.Time
channel.registeredTime = zeroTime
channel.accountToUMode = make(map[string]modes.Mode)
}
// IsRegistered returns whether the channel is registered.
func (channel *Channel) IsRegistered() bool {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return channel.registeredFounder != ""
}
2018-04-24 09:11:11 +02:00
func (channel *Channel) regenerateMembersCache() {
channel.stateMutex.RLock()
2017-10-23 01:50:16 +02:00
result := make([]*Client, len(channel.members))
i := 0
for client := range channel.members {
result[i] = client
i++
}
2018-04-24 09:11:11 +02:00
channel.stateMutex.RUnlock()
channel.stateMutex.Lock()
2017-10-23 01:50:16 +02:00
channel.membersCache = result
2018-04-24 09:11:11 +02:00
channel.stateMutex.Unlock()
2012-12-10 06:46:22 +01:00
}
// Names sends the list of users joined to the channel to the given client.
2018-02-05 15:21:08 +01:00
func (channel *Channel) Names(client *Client, rb *ResponseBuffer) {
isMultiPrefix := client.capabilities.Has(caps.MultiPrefix)
isUserhostInNames := client.capabilities.Has(caps.UserhostInNames)
maxNamLen := 480 - len(client.server.name) - len(client.Nick())
var namesLines []string
var buffer bytes.Buffer
for _, target := range channel.Members() {
var nick string
if isUserhostInNames {
nick = target.NickMaskString()
} else {
nick = target.Nick()
2016-06-19 06:55:24 +02:00
}
channel.stateMutex.RLock()
modes := channel.members[target]
channel.stateMutex.RUnlock()
if modes == nil {
2016-06-19 06:55:24 +02:00
continue
}
prefix := modes.Prefixes(isMultiPrefix)
if buffer.Len()+len(nick)+len(prefix)+1 > maxNamLen {
namesLines = append(namesLines, buffer.String())
// memset(&buffer, 0, sizeof(bytes.Buffer));
var newBuffer bytes.Buffer
buffer = newBuffer
}
if buffer.Len() > 0 {
buffer.WriteString(" ")
}
buffer.WriteString(prefix)
buffer.WriteString(nick)
}
if buffer.Len() > 0 {
namesLines = append(namesLines, buffer.String())
2016-06-19 06:55:24 +02:00
}
for _, line := range namesLines {
if buffer.Len() > 0 {
rb.Add(nil, client.server.name, RPL_NAMREPLY, client.nick, "=", channel.name, line)
}
}
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, RPL_ENDOFNAMES, client.nick, channel.name, client.t("End of NAMES list"))
2013-06-03 07:07:50 +02:00
}
2016-10-22 16:45:51 +02:00
// ClientIsAtLeast returns whether the client has at least the given channel privilege.
func (channel *Channel) ClientIsAtLeast(client *Client, permission modes.Mode) bool {
2017-10-23 01:50:16 +02:00
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
2018-04-23 00:47:10 +02:00
clientModes := channel.members[client]
2018-05-23 21:35:50 +02:00
for _, mode := range modes.ChannelUserModes {
2018-04-23 00:47:10 +02:00
if clientModes.HasMode(mode) {
2016-10-22 16:45:51 +02:00
return true
}
if mode == permission {
break
}
}
return false
}
2017-10-23 01:50:16 +02:00
func (channel *Channel) ClientPrefixes(client *Client, isMultiPrefix bool) string {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
modes, present := channel.members[client]
if !present {
return ""
} else {
return modes.Prefixes(isMultiPrefix)
}
}
func (channel *Channel) ClientHasPrivsOver(client *Client, target *Client) bool {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
clientModes := channel.members[client]
targetModes := channel.members[target]
result := false
for _, mode := range modes.ChannelPrivModes {
2018-04-23 00:47:10 +02:00
if clientModes.HasMode(mode) {
2017-10-23 01:50:16 +02:00
result = true
// admins cannot kick other admins
2018-04-23 00:47:10 +02:00
if mode == modes.ChannelAdmin && targetModes.HasMode(modes.ChannelAdmin) {
2017-10-23 01:50:16 +02:00
result = false
}
break
2018-04-23 00:47:10 +02:00
} else if targetModes.HasMode(mode) {
2017-10-23 01:50:16 +02:00
break
}
}
return result
}
func (channel *Channel) hasClient(client *Client) bool {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
_, present := channel.members[client]
return present
2014-02-05 04:28:24 +01:00
}
2014-02-09 03:14:39 +01:00
// <mode> <mode params>
2017-10-23 01:50:16 +02:00
func (channel *Channel) modeStrings(client *Client) (result []string) {
isMember := client.HasMode(modes.Operator) || channel.hasClient(client)
showKey := isMember && (channel.key != "")
showUserLimit := channel.userLimit > 0
mods := "+"
2017-10-23 01:50:16 +02:00
// flags with args
if showKey {
mods += modes.Key.String()
2014-02-09 08:33:56 +01:00
}
if showUserLimit {
mods += modes.UserLimit.String()
}
2014-02-15 06:57:08 +01:00
2018-04-23 00:47:10 +02:00
mods += channel.flags.String()
2017-10-23 01:50:16 +02:00
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
result = []string{mods}
2014-02-15 06:57:08 +01:00
// args for flags with args: The order must match above to keep
// positional arguments in place.
if showKey {
2017-10-23 01:50:16 +02:00
result = append(result, channel.key)
2014-02-15 06:57:08 +01:00
}
if showUserLimit {
2017-10-23 01:50:16 +02:00
result = append(result, strconv.FormatUint(channel.userLimit, 10))
}
2014-02-15 06:57:08 +01:00
2017-10-23 01:50:16 +02:00
return
2014-02-09 03:14:39 +01:00
}
// IsFull returns true if this channel is at its' members limit.
func (channel *Channel) IsFull() bool {
2017-10-23 01:50:16 +02:00
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return (channel.userLimit > 0) && (uint64(len(channel.members)) >= channel.userLimit)
}
// CheckKey returns true if the key is not set or matches the given key.
2016-06-19 06:55:24 +02:00
func (channel *Channel) CheckKey(key string) bool {
chkey := channel.Key()
if chkey == "" {
return true
}
return subtle.ConstantTimeCompare([]byte(key), []byte(chkey)) == 1
}
2017-10-30 10:21:47 +01:00
func (channel *Channel) IsEmpty() bool {
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
return len(channel.members) == 0
}
// Join joins the given client to this channel (if they can be joined).
func (channel *Channel) Join(client *Client, key string, isSajoin bool, rb *ResponseBuffer) {
2017-10-23 01:50:16 +02:00
if channel.hasClient(client) {
// already joined, no message needs to be sent
return
}
channel.stateMutex.RLock()
chname := channel.name
founder := channel.registeredFounder
channel.stateMutex.RUnlock()
account := client.Account()
hasPrivs := isSajoin || (founder != "" && founder == account)
2018-04-24 09:11:11 +02:00
if !hasPrivs && channel.IsFull() {
2018-04-24 09:11:11 +02:00
rb.Add(nil, client.server.name, ERR_CHANNELISFULL, chname, fmt.Sprintf(client.t("Cannot join channel (+%s)"), "l"))
return
}
if !hasPrivs && !channel.CheckKey(key) {
2018-04-24 09:11:11 +02:00
rb.Add(nil, client.server.name, ERR_BADCHANNELKEY, chname, fmt.Sprintf(client.t("Cannot join channel (+%s)"), "k"))
2014-02-21 03:56:13 +01:00
return
}
isInvited := channel.lists[modes.InviteMask].Match(client.nickMaskCasefolded)
if !hasPrivs && channel.flags.HasMode(modes.InviteOnly) && !isInvited {
2018-04-24 09:11:11 +02:00
rb.Add(nil, client.server.name, ERR_INVITEONLYCHAN, chname, fmt.Sprintf(client.t("Cannot join channel (+%s)"), "i"))
2014-03-08 02:09:49 +01:00
return
}
if !hasPrivs && channel.lists[modes.BanMask].Match(client.nickMaskCasefolded) &&
2014-03-08 02:09:49 +01:00
!isInvited &&
!channel.lists[modes.ExceptMask].Match(client.nickMaskCasefolded) {
2018-04-24 09:11:11 +02:00
rb.Add(nil, client.server.name, ERR_BANNEDFROMCHAN, chname, fmt.Sprintf(client.t("Cannot join channel (+%s)"), "b"))
2014-03-08 02:09:49 +01:00
return
}
2018-04-24 09:11:11 +02:00
client.server.logger.Debug("join", fmt.Sprintf("%s joined channel %s", client.nick, chname))
2018-04-24 09:11:11 +02:00
newChannel, givenMode := func() (newChannel bool, givenMode modes.Mode) {
channel.joinPartMutex.Lock()
defer channel.joinPartMutex.Unlock()
func() {
channel.stateMutex.Lock()
defer channel.stateMutex.Unlock()
channel.members.Add(client)
firstJoin := len(channel.members) == 1
newChannel = firstJoin && channel.registeredFounder == ""
if newChannel {
givenMode = modes.ChannelOperator
2018-02-05 15:21:08 +01:00
} else {
2018-04-24 09:11:11 +02:00
givenMode = channel.accountToUMode[account]
2018-02-05 15:21:08 +01:00
}
2018-04-24 09:11:11 +02:00
if givenMode != 0 {
channel.members[client].SetMode(givenMode, true)
2018-02-05 15:21:08 +01:00
}
2018-04-24 09:11:11 +02:00
}()
2016-06-22 13:35:26 +02:00
2018-04-24 09:11:11 +02:00
channel.regenerateMembersCache()
return
}()
2017-10-23 01:50:16 +02:00
client.addChannel(channel)
2018-04-24 09:11:11 +02:00
nick := client.Nick()
nickmask := client.NickMaskString()
realname := client.Realname()
accountName := client.AccountName()
var modestr string
if givenMode != 0 {
modestr = fmt.Sprintf("+%v", givenMode)
}
2018-04-24 09:11:11 +02:00
for _, member := range channel.Members() {
if member == client {
continue
}
if member.capabilities.Has(caps.ExtendedJoin) {
member.Send(nil, nickmask, "JOIN", chname, accountName, realname)
} else {
member.Send(nil, nickmask, "JOIN", chname)
}
if givenMode != 0 {
member.Send(nil, client.server.name, "MODE", chname, modestr, nick)
}
}
if client.capabilities.Has(caps.ExtendedJoin) {
2018-04-24 09:11:11 +02:00
rb.Add(nil, nickmask, "JOIN", chname, accountName, realname)
} else {
2018-04-24 09:11:11 +02:00
rb.Add(nil, nickmask, "JOIN", chname)
}
2018-04-24 09:11:11 +02:00
// don't send topic when it's an entirely new channel
if !newChannel {
2018-02-05 15:21:08 +01:00
channel.SendTopic(client, rb)
}
2018-04-24 09:11:11 +02:00
2018-02-05 15:21:08 +01:00
channel.Names(client, rb)
2018-04-24 09:11:11 +02:00
if givenMode != 0 {
rb.Add(nil, client.server.name, "MODE", chname, modestr, nick)
}
}
// Part parts the given client from this channel, with the given message.
2018-02-05 15:21:08 +01:00
func (channel *Channel) Part(client *Client, message string, rb *ResponseBuffer) {
2018-04-24 09:11:11 +02:00
chname := channel.Name()
2017-10-23 01:50:16 +02:00
if !channel.hasClient(client) {
2018-04-24 09:11:11 +02:00
rb.Add(nil, client.server.name, ERR_NOTONCHANNEL, chname, client.t("You're not on that channel"))
return
}
2018-04-24 09:11:11 +02:00
channel.Quit(client)
nickmask := client.NickMaskString()
2017-10-23 01:50:16 +02:00
for _, member := range channel.Members() {
2018-04-24 09:11:11 +02:00
member.Send(nil, nickmask, "PART", chname, message)
}
2018-04-24 09:11:11 +02:00
rb.Add(nil, nickmask, "PART", chname, message)
2018-04-24 09:11:11 +02:00
client.server.logger.Debug("part", fmt.Sprintf("%s left channel %s", client.nick, chname))
}
2017-10-23 01:50:16 +02:00
// SendTopic sends the channel topic to the given client.
2018-02-05 15:21:08 +01:00
func (channel *Channel) SendTopic(client *Client, rb *ResponseBuffer) {
2017-10-23 01:50:16 +02:00
if !channel.hasClient(client) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_NOTONCHANNEL, client.nick, channel.name, client.t("You're not on that channel"))
return
}
2017-10-23 01:50:16 +02:00
channel.stateMutex.RLock()
name := channel.name
topic := channel.topic
topicSetBy := channel.topicSetBy
topicSetTime := channel.topicSetTime
channel.stateMutex.RUnlock()
if topic == "" {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, RPL_NOTOPIC, client.nick, name, client.t("No topic is set"))
return
}
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, RPL_TOPIC, client.nick, name, topic)
rb.Add(nil, client.server.name, RPL_TOPICTIME, client.nick, name, topicSetBy, strconv.FormatInt(topicSetTime.Unix(), 10))
}
// SetTopic sets the topic of this channel, if the client is allowed to do so.
2018-02-05 15:21:08 +01:00
func (channel *Channel) SetTopic(client *Client, topic string, rb *ResponseBuffer) {
2018-04-23 00:47:10 +02:00
if !(client.HasMode(modes.Operator) || channel.hasClient(client)) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_NOTONCHANNEL, channel.name, client.t("You're not on that channel"))
return
}
2018-04-23 00:47:10 +02:00
if channel.flags.HasMode(modes.OpOnlyTopic) && !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_CHANOPRIVSNEEDED, channel.name, client.t("You're not a channel operator"))
2014-02-16 04:56:38 +01:00
return
}
2016-09-12 04:40:09 +02:00
if len(topic) > client.server.limits.TopicLen {
topic = topic[:client.server.limits.TopicLen]
2016-09-12 04:22:50 +02:00
}
2017-10-23 01:50:16 +02:00
channel.stateMutex.Lock()
channel.topic = topic
channel.topicSetBy = client.nickMaskString
channel.topicSetTime = time.Now()
2017-10-23 01:50:16 +02:00
channel.stateMutex.Unlock()
2014-02-21 05:47:05 +01:00
2017-10-23 01:50:16 +02:00
for _, member := range channel.Members() {
2018-02-05 15:21:08 +01:00
if member == client {
rb.Add(nil, client.nickMaskString, "TOPIC", channel.name, topic)
} else {
member.Send(nil, client.nickMaskString, "TOPIC", channel.name, topic)
}
}
go channel.server.channelRegistry.StoreChannel(channel, IncludeTopic)
}
// CanSpeak returns true if the client can speak on this channel.
func (channel *Channel) CanSpeak(client *Client) bool {
2017-10-23 01:50:16 +02:00
channel.stateMutex.RLock()
defer channel.stateMutex.RUnlock()
2017-01-10 17:09:08 +01:00
2017-10-23 01:50:16 +02:00
_, hasClient := channel.members[client]
2018-04-23 00:47:10 +02:00
if channel.flags.HasMode(modes.NoOutside) && !hasClient {
return false
}
2018-04-23 00:47:10 +02:00
if channel.flags.HasMode(modes.Moderated) && !channel.ClientIsAtLeast(client, modes.Voice) {
return false
}
2018-04-23 00:47:10 +02:00
if channel.flags.HasMode(modes.RegisteredOnly) && client.Account() == "" {
return false
}
return true
}
2017-01-14 06:52:32 +01:00
// TagMsg sends a tag message to everyone in this channel who can accept them.
2018-02-05 15:21:08 +01:00
func (channel *Channel) TagMsg(msgid string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, rb *ResponseBuffer) {
channel.sendMessage(msgid, "TAGMSG", []caps.Capability{caps.MessageTags}, minPrefix, clientOnlyTags, client, nil, rb)
2017-01-14 06:52:32 +01:00
}
// sendMessage sends a given message to everyone on this channel.
2018-02-05 15:21:08 +01:00
func (channel *Channel) sendMessage(msgid, cmd string, requiredCaps []caps.Capability, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message *string, rb *ResponseBuffer) {
if !channel.CanSpeak(client) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, client.t("Cannot send to channel"))
2014-02-09 08:33:56 +01:00
return
}
2017-01-10 17:09:08 +01:00
2016-10-22 16:45:51 +02:00
// for STATUSMSG
var minPrefixMode modes.Mode
2016-10-22 16:45:51 +02:00
if minPrefix != nil {
minPrefixMode = *minPrefix
}
// send echo-message
if client.capabilities.Has(caps.EchoMessage) {
var messageTagsToUse *map[string]ircmsg.TagValue
if client.capabilities.Has(caps.MessageTags) {
messageTagsToUse = clientOnlyTags
}
if message == nil {
rb.AddFromClient(msgid, client, messageTagsToUse, cmd, channel.name)
} else {
rb.AddFromClient(msgid, client, messageTagsToUse, cmd, channel.name, *message)
}
}
2017-10-23 01:50:16 +02:00
for _, member := range channel.Members() {
2016-10-22 16:45:51 +02:00
if minPrefix != nil && !channel.ClientIsAtLeast(member, minPrefixMode) {
// STATUSMSG
continue
}
// echo-message is handled above, so skip sending the msg to the user themselves as well
if member == client {
continue
}
2017-01-14 06:52:32 +01:00
canReceive := true
for _, capName := range requiredCaps {
if !member.capabilities.Has(capName) {
2017-01-14 06:52:32 +01:00
canReceive = false
}
}
if !canReceive {
continue
}
2017-01-14 10:52:47 +01:00
var messageTagsToUse *map[string]ircmsg.TagValue
if member.capabilities.Has(caps.MessageTags) {
2017-01-14 10:52:47 +01:00
messageTagsToUse = clientOnlyTags
}
if message == nil {
member.SendFromClient(msgid, client, messageTagsToUse, cmd, channel.name)
} else {
member.SendFromClient(msgid, client, messageTagsToUse, cmd, channel.name, *message)
}
}
}
// SplitPrivMsg sends a private message to everyone in this channel.
2018-02-05 15:21:08 +01:00
func (channel *Channel) SplitPrivMsg(msgid string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message SplitMessage, rb *ResponseBuffer) {
channel.sendSplitMessage(msgid, "PRIVMSG", minPrefix, clientOnlyTags, client, &message, rb)
}
// SplitNotice sends a private message to everyone in this channel.
2018-02-05 15:21:08 +01:00
func (channel *Channel) SplitNotice(msgid string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message SplitMessage, rb *ResponseBuffer) {
channel.sendSplitMessage(msgid, "NOTICE", minPrefix, clientOnlyTags, client, &message, rb)
}
2018-02-05 15:21:08 +01:00
func (channel *Channel) sendSplitMessage(msgid, cmd string, minPrefix *modes.Mode, clientOnlyTags *map[string]ircmsg.TagValue, client *Client, message *SplitMessage, rb *ResponseBuffer) {
if !channel.CanSpeak(client) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, client.t("Cannot send to channel"))
return
}
// for STATUSMSG
var minPrefixMode modes.Mode
if minPrefix != nil {
minPrefixMode = *minPrefix
}
// send echo-message
if client.capabilities.Has(caps.EchoMessage) {
var tagsToUse *map[string]ircmsg.TagValue
if client.capabilities.Has(caps.MessageTags) {
tagsToUse = clientOnlyTags
}
if message == nil {
rb.AddFromClient(msgid, client, tagsToUse, cmd, channel.name)
} else {
rb.AddSplitMessageFromClient(msgid, client, tagsToUse, cmd, channel.name, *message)
}
}
2017-10-23 01:50:16 +02:00
for _, member := range channel.Members() {
if minPrefix != nil && !channel.ClientIsAtLeast(member, minPrefixMode) {
// STATUSMSG
continue
}
// echo-message is handled above, so skip sending the msg to the user themselves as well
if member == client {
continue
}
2017-01-14 12:48:57 +01:00
var tagsToUse *map[string]ircmsg.TagValue
if member.capabilities.Has(caps.MessageTags) {
2017-01-14 12:48:57 +01:00
tagsToUse = clientOnlyTags
}
if message == nil {
member.SendFromClient(msgid, client, tagsToUse, cmd, channel.name)
} else {
member.SendSplitMsgFromClient(msgid, client, tagsToUse, cmd, channel.name, *message)
}
}
}
2018-04-23 00:47:10 +02:00
func (channel *Channel) applyModeToMember(client *Client, mode modes.Mode, op modes.ModeOp, nick string, rb *ResponseBuffer) (result *modes.ModeChange) {
casefoldedName, err := CasefoldName(nick)
target := channel.server.clients.Get(casefoldedName)
if err != nil || target == nil {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_NOSUCHNICK, client.nick, nick, client.t("No such nick"))
2016-06-22 13:35:26 +02:00
return nil
2014-02-23 00:01:11 +01:00
}
2017-10-23 01:50:16 +02:00
channel.stateMutex.Lock()
modeset, exists := channel.members[target]
if exists {
2018-04-24 02:03:26 +02:00
if modeset.SetMode(mode, op == modes.Add) {
2018-04-23 00:47:10 +02:00
result = &modes.ModeChange{
Op: op,
Mode: mode,
Arg: nick,
}
}
2014-02-23 00:01:11 +01:00
}
2017-10-23 01:50:16 +02:00
channel.stateMutex.Unlock()
2014-02-23 00:01:11 +01:00
2017-10-23 01:50:16 +02:00
if !exists {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_USERNOTINCHANNEL, client.nick, channel.name, client.t("They aren't on that channel"))
2014-02-23 00:01:11 +01:00
}
2018-04-23 00:47:10 +02:00
return
2014-02-23 00:01:11 +01:00
}
// ShowMaskList shows the given list to the client.
2018-02-05 15:21:08 +01:00
func (channel *Channel) ShowMaskList(client *Client, mode modes.Mode, rb *ResponseBuffer) {
// choose appropriate modes
var rpllist, rplendoflist string
if mode == modes.BanMask {
rpllist = RPL_BANLIST
rplendoflist = RPL_ENDOFBANLIST
} else if mode == modes.ExceptMask {
rpllist = RPL_EXCEPTLIST
rplendoflist = RPL_ENDOFEXCEPTLIST
} else if mode == modes.InviteMask {
rpllist = RPL_INVITELIST
rplendoflist = RPL_ENDOFINVITELIST
}
nick := client.Nick()
2017-10-23 01:50:16 +02:00
channel.stateMutex.RLock()
// XXX don't acquire any new locks in this section, besides Socket.Write
for mask := range channel.lists[mode].masks {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, rpllist, nick, channel.name, mask)
}
2017-10-23 01:50:16 +02:00
channel.stateMutex.RUnlock()
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, rplendoflist, nick, channel.name, client.t("End of list"))
2014-03-08 02:35:58 +01:00
}
2014-03-08 02:09:49 +01:00
2018-02-05 15:21:08 +01:00
func (channel *Channel) applyModeMask(client *Client, mode modes.Mode, op modes.ModeOp, mask string, rb *ResponseBuffer) bool {
2014-03-08 02:09:49 +01:00
list := channel.lists[mode]
if list == nil {
// This should never happen, but better safe than panicky.
return false
}
if (op == modes.List) || (mask == "") {
2018-02-05 15:21:08 +01:00
channel.ShowMaskList(client, mode, rb)
2014-03-08 02:35:58 +01:00
return false
}
if !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_CHANOPRIVSNEEDED, channel.name, client.t("You're not a channel operator"))
2014-03-08 02:35:58 +01:00
return false
}
if op == modes.Add {
2014-03-08 02:35:58 +01:00
return list.Add(mask)
2014-03-08 02:09:49 +01:00
}
if op == modes.Remove {
2014-03-08 02:35:58 +01:00
return list.Remove(mask)
2014-03-08 02:09:49 +01:00
}
2014-03-08 02:35:58 +01:00
return false
2014-03-08 02:09:49 +01:00
}
2017-10-23 01:50:16 +02:00
// Quit removes the given client from the channel
func (channel *Channel) Quit(client *Client) {
2018-04-24 09:11:11 +02:00
channelEmpty := func() bool {
channel.joinPartMutex.Lock()
defer channel.joinPartMutex.Unlock()
2017-10-23 01:50:16 +02:00
2018-04-24 09:11:11 +02:00
channel.stateMutex.Lock()
channel.members.Remove(client)
channelEmpty := len(channel.members) == 0
channel.stateMutex.Unlock()
channel.regenerateMembersCache()
return channelEmpty
}()
2018-04-24 09:11:11 +02:00
if channelEmpty {
client.server.channels.Cleanup(channel)
}
2018-04-24 09:11:11 +02:00
client.removeChannel(channel)
2014-02-17 08:29:11 +01:00
}
2018-02-05 15:21:08 +01:00
func (channel *Channel) Kick(client *Client, target *Client, comment string, rb *ResponseBuffer) {
2018-04-23 00:47:10 +02:00
if !(client.HasMode(modes.Operator) || channel.hasClient(client)) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_NOTONCHANNEL, channel.name, client.t("You're not on that channel"))
2014-02-17 08:29:11 +01:00
return
}
if !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_CANNOTSENDTOCHAN, channel.name, client.t("Cannot send to channel"))
2014-02-17 08:29:11 +01:00
return
}
2017-10-23 01:50:16 +02:00
if !channel.hasClient(target) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, client.server.name, ERR_USERNOTINCHANNEL, client.nick, channel.name, client.t("They aren't on that channel"))
2014-02-17 08:29:11 +01:00
return
}
2017-10-23 01:50:16 +02:00
if !channel.ClientHasPrivsOver(client, target) {
rb.Add(nil, client.server.name, ERR_CHANOPRIVSNEEDED, channel.name, client.t("You don't have enough channel privileges"))
2017-10-23 01:50:16 +02:00
return
}
2014-02-17 08:29:11 +01:00
kicklimit := client.server.Limits().KickLen
2017-10-23 01:50:16 +02:00
if len(comment) > kicklimit {
comment = comment[:kicklimit]
2016-09-12 04:22:50 +02:00
}
clientMask := client.NickMaskString()
targetNick := target.Nick()
2017-10-23 01:50:16 +02:00
for _, member := range channel.Members() {
member.Send(nil, clientMask, "KICK", channel.name, targetNick, comment)
}
2017-10-23 01:50:16 +02:00
channel.Quit(target)
}
2014-02-25 16:28:09 +01:00
// Invite invites the given client to the channel, if the inviter can do so.
2018-02-05 15:21:08 +01:00
func (channel *Channel) Invite(invitee *Client, inviter *Client, rb *ResponseBuffer) {
2018-04-23 00:47:10 +02:00
if channel.flags.HasMode(modes.InviteOnly) && !channel.ClientIsAtLeast(inviter, modes.ChannelOperator) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, inviter.server.name, ERR_CHANOPRIVSNEEDED, channel.name, inviter.t("You're not a channel operator"))
2014-02-25 16:28:09 +01:00
return
}
2017-10-23 01:50:16 +02:00
if !channel.hasClient(inviter) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, inviter.server.name, ERR_NOTONCHANNEL, channel.name, inviter.t("You're not on that channel"))
2014-02-25 16:28:09 +01:00
return
}
2016-10-16 06:14:55 +02:00
//TODO(dan): handle this more nicely, keep a list of last X invited channels on invitee rather than explicitly modifying the invite list?
2018-04-23 00:47:10 +02:00
if channel.flags.HasMode(modes.InviteOnly) {
nmc := invitee.NickCasefolded()
2017-10-23 01:50:16 +02:00
channel.stateMutex.Lock()
channel.lists[modes.InviteMask].Add(nmc)
2017-10-23 01:50:16 +02:00
channel.stateMutex.Unlock()
2014-03-08 02:09:49 +01:00
}
2017-10-23 01:50:16 +02:00
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(), channel.name)
2016-10-16 06:14:55 +02:00
}
}
//TODO(dan): should inviter.server.name here be inviter.nickMaskString ?
2018-02-05 15:21:08 +01:00
rb.Add(nil, inviter.server.name, RPL_INVITING, invitee.nick, channel.name)
invitee.Send(nil, inviter.nickMaskString, "INVITE", invitee.nick, channel.name)
2018-04-23 00:47:10 +02:00
if invitee.HasMode(modes.Away) {
2018-02-05 15:21:08 +01:00
rb.Add(nil, inviter.server.name, RPL_AWAY, invitee.nick, invitee.awayMessage)
2014-02-25 16:28:09 +01:00
}
}