2016-06-15 13:50:56 +02:00
|
|
|
// Copyright (c) 2012-2014 Jeremy Latt
|
|
|
|
// Copyright (c) 2014-2015 Edmund Huber
|
|
|
|
// Copyright (c) 2016- Daniel Oaks <daniel@danieloaks.net>
|
|
|
|
// released under the MIT license
|
|
|
|
|
2012-12-09 07:54:58 +01:00
|
|
|
package irc
|
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
import (
|
2014-02-27 06:52:17 +01:00
|
|
|
"log"
|
2014-02-22 21:49:33 +01:00
|
|
|
"strconv"
|
|
|
|
)
|
|
|
|
|
2012-12-09 07:54:58 +01:00
|
|
|
type Channel struct {
|
2014-03-23 06:48:53 +01:00
|
|
|
flags ChannelModeSet
|
|
|
|
lists map[ChannelMode]*UserMaskSet
|
|
|
|
key Text
|
|
|
|
members MemberSet
|
|
|
|
name Name
|
|
|
|
server *Server
|
|
|
|
topic Text
|
|
|
|
userLimit uint64
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
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.
|
2016-04-21 11:29:50 +02:00
|
|
|
func NewChannel(s *Server, name Name, addDefaultModes bool) *Channel {
|
2012-12-15 23:34:20 +01:00
|
|
|
channel := &Channel{
|
2014-02-23 00:01:11 +01:00
|
|
|
flags: make(ChannelModeSet),
|
2014-03-08 02:09:49 +01:00
|
|
|
lists: map[ChannelMode]*UserMaskSet{
|
|
|
|
BanMask: NewUserMaskSet(),
|
|
|
|
ExceptMask: NewUserMaskSet(),
|
|
|
|
InviteMask: NewUserMaskSet(),
|
2014-02-23 00:01:11 +01:00
|
|
|
},
|
2014-02-17 07:20:42 +01:00
|
|
|
members: make(MemberSet),
|
2014-03-09 21:45:36 +01:00
|
|
|
name: name,
|
2014-02-17 07:20:42 +01:00
|
|
|
server: s,
|
2012-12-09 21:51:50 +01:00
|
|
|
}
|
2014-02-25 20:11:34 +01:00
|
|
|
|
2016-04-21 11:29:50 +02:00
|
|
|
if addDefaultModes {
|
|
|
|
for _, mode := range DefaultChannelModes {
|
|
|
|
channel.flags[mode] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-26 05:17:26 +01:00
|
|
|
s.channels.Add(channel)
|
2014-02-25 20:11:34 +01:00
|
|
|
|
2012-12-15 23:34:20 +01:00
|
|
|
return channel
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
2013-05-12 20:20:55 +02:00
|
|
|
func (channel *Channel) IsEmpty() bool {
|
|
|
|
return len(channel.members) == 0
|
2012-12-10 06:46:22 +01:00
|
|
|
}
|
|
|
|
|
2014-02-18 06:02:03 +01:00
|
|
|
func (channel *Channel) Names(client *Client) {
|
2014-02-22 22:15:31 +01:00
|
|
|
client.RplNamReply(channel)
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplEndOfNames(channel)
|
2013-06-03 07:07:50 +02:00
|
|
|
}
|
|
|
|
|
2014-02-10 04:59:59 +01:00
|
|
|
func (channel *Channel) ClientIsOperator(client *Client) bool {
|
2014-02-17 22:22:35 +01:00
|
|
|
return client.flags[Operator] || channel.members.HasMode(client, ChannelOperator)
|
2014-02-10 04:59:59 +01:00
|
|
|
}
|
|
|
|
|
2016-04-14 01:35:36 +02:00
|
|
|
// Prefixes returns a list of prefixes for the given set of channel modes.
|
|
|
|
func (modes ChannelModeSet) Prefixes(isMultiPrefix bool) string {
|
|
|
|
var prefixes string
|
|
|
|
|
|
|
|
// add prefixes in order from highest to lowest privs
|
|
|
|
for _, mode := range ChannelPrivModes {
|
|
|
|
if modes[mode] {
|
|
|
|
prefixes += ChannelModePrefixes[mode]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if modes[Voice] {
|
|
|
|
prefixes += ChannelModePrefixes[Voice]
|
|
|
|
}
|
|
|
|
|
|
|
|
if !isMultiPrefix && len(prefixes) > 1 {
|
|
|
|
prefixes = string(prefixes[0])
|
|
|
|
}
|
|
|
|
|
|
|
|
return prefixes
|
|
|
|
}
|
|
|
|
|
2014-03-01 04:21:33 +01:00
|
|
|
func (channel *Channel) Nicks(target *Client) []string {
|
|
|
|
isMultiPrefix := (target != nil) && target.capabilities[MultiPrefix]
|
2014-02-05 04:28:24 +01:00
|
|
|
nicks := make([]string, len(channel.members))
|
|
|
|
i := 0
|
2014-02-15 06:57:08 +01:00
|
|
|
for client, modes := range channel.members {
|
2016-04-14 01:35:36 +02:00
|
|
|
nicks[i] += modes.Prefixes(isMultiPrefix)
|
2014-03-09 21:45:36 +01:00
|
|
|
nicks[i] += client.Nick().String()
|
2014-02-05 04:28:24 +01:00
|
|
|
i += 1
|
|
|
|
}
|
|
|
|
return nicks
|
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) Id() Name {
|
2012-12-17 04:13:53 +01:00
|
|
|
return channel.name
|
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) Nick() Name {
|
2013-06-03 07:07:50 +02:00
|
|
|
return channel.name
|
|
|
|
}
|
|
|
|
|
2013-05-12 03:28:18 +02:00
|
|
|
func (channel *Channel) String() string {
|
2014-03-09 21:45:36 +01:00
|
|
|
return channel.Id().String()
|
2013-05-12 03:28:18 +02:00
|
|
|
}
|
|
|
|
|
2014-02-09 03:14:39 +01:00
|
|
|
// <mode> <mode params>
|
2014-02-22 21:49:33 +01:00
|
|
|
func (channel *Channel) ModeString(client *Client) (str string) {
|
|
|
|
isMember := client.flags[Operator] || channel.members.Has(client)
|
|
|
|
showKey := isMember && (channel.key != "")
|
|
|
|
showUserLimit := channel.userLimit > 0
|
|
|
|
|
|
|
|
// flags with args
|
|
|
|
if showKey {
|
2014-02-15 06:57:08 +01:00
|
|
|
str += Key.String()
|
2014-02-09 08:33:56 +01:00
|
|
|
}
|
2014-02-22 21:49:33 +01:00
|
|
|
if showUserLimit {
|
|
|
|
str += UserLimit.String()
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
// flags
|
2014-02-15 06:57:08 +01:00
|
|
|
for mode := range channel.flags {
|
|
|
|
str += mode.String()
|
|
|
|
}
|
|
|
|
|
2015-12-02 17:05:05 +01:00
|
|
|
str = "+" + str
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
// args for flags with args: The order must match above to keep
|
|
|
|
// positional arguments in place.
|
|
|
|
if showKey {
|
2014-03-09 21:45:36 +01:00
|
|
|
str += " " + channel.key.String()
|
2014-02-15 06:57:08 +01:00
|
|
|
}
|
2014-02-22 21:49:33 +01:00
|
|
|
if showUserLimit {
|
|
|
|
str += " " + strconv.FormatUint(channel.userLimit, 10)
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-09 08:33:56 +01:00
|
|
|
return
|
2014-02-09 03:14:39 +01:00
|
|
|
}
|
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
func (channel *Channel) IsFull() bool {
|
|
|
|
return (channel.userLimit > 0) &&
|
|
|
|
(uint64(len(channel.members)) >= channel.userLimit)
|
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) CheckKey(key Text) bool {
|
2014-02-22 21:49:33 +01:00
|
|
|
return (channel.key == "") || (channel.key == key)
|
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) Join(client *Client, key Text) {
|
2014-02-22 21:49:33 +01:00
|
|
|
if channel.members.Has(client) {
|
|
|
|
// already joined, no message?
|
2012-12-09 07:54:58 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
if channel.IsFull() {
|
|
|
|
client.ErrChannelIsFull(channel)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !channel.CheckKey(key) {
|
|
|
|
client.ErrBadChannelKey(channel)
|
2014-02-21 03:56:13 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-03-08 02:09:49 +01:00
|
|
|
isInvited := channel.lists[InviteMask].Match(client.UserHost())
|
|
|
|
if channel.flags[InviteOnly] && !isInvited {
|
|
|
|
client.ErrInviteOnlyChan(channel)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if channel.lists[BanMask].Match(client.UserHost()) &&
|
|
|
|
!isInvited &&
|
|
|
|
!channel.lists[ExceptMask].Match(client.UserHost()) {
|
|
|
|
client.ErrBannedFromChan(channel)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-19 04:31:59 +01:00
|
|
|
client.channels.Add(channel)
|
2014-02-17 02:23:47 +01:00
|
|
|
channel.members.Add(client)
|
2014-02-28 05:42:12 +01:00
|
|
|
if !channel.flags[Persistent] && (len(channel.members) == 1) {
|
2016-04-14 01:35:36 +02:00
|
|
|
channel.members[client][ChannelFounder] = true
|
2014-02-17 02:23:47 +01:00
|
|
|
channel.members[client][ChannelOperator] = true
|
|
|
|
}
|
|
|
|
|
2014-02-20 07:20:34 +01:00
|
|
|
reply := RplJoin(client, channel)
|
|
|
|
for member := range channel.members {
|
2014-02-22 20:40:32 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2014-02-17 02:23:47 +01:00
|
|
|
channel.GetTopic(client)
|
2014-02-18 06:02:03 +01:00
|
|
|
channel.Names(client)
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) Part(client *Client, message Text) {
|
2014-02-09 08:15:05 +01:00
|
|
|
if !channel.members.Has(client) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNotOnChannel(channel)
|
2012-12-09 07:54:58 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-21 03:20:07 +01:00
|
|
|
reply := RplPart(client, channel, message)
|
2014-02-20 07:20:34 +01:00
|
|
|
for member := range channel.members {
|
2014-02-22 20:40:32 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2014-02-17 08:29:11 +01:00
|
|
|
channel.Quit(client)
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
func (channel *Channel) GetTopic(client *Client) {
|
2014-02-09 08:15:05 +01:00
|
|
|
if !channel.members.Has(client) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNotOnChannel(channel)
|
2012-12-09 07:54:58 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
if channel.topic == "" {
|
|
|
|
// clients appear not to expect this
|
|
|
|
//replier.Reply(RplNoTopic(channel))
|
2012-12-09 07:54:58 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-20 07:20:34 +01:00
|
|
|
client.RplTopic(channel)
|
2014-02-17 07:20:42 +01:00
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) SetTopic(client *Client, topic Text) {
|
2014-02-22 21:49:33 +01:00
|
|
|
if !(client.flags[Operator] || channel.members.Has(client)) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNotOnChannel(channel)
|
2014-02-17 07:20:42 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-21 05:47:05 +01:00
|
|
|
if channel.flags[OpOnlyTopic] && !channel.ClientIsOperator(client) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
2014-02-16 04:56:38 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
channel.topic = topic
|
2014-02-21 05:47:05 +01:00
|
|
|
|
|
|
|
reply := RplTopicMsg(client, channel)
|
2014-02-20 07:20:34 +01:00
|
|
|
for member := range channel.members {
|
2014-02-22 20:40:32 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2014-02-26 00:57:35 +01:00
|
|
|
|
2014-02-27 06:52:17 +01:00
|
|
|
if err := channel.Persist(); err != nil {
|
2014-03-08 02:09:49 +01:00
|
|
|
log.Println("Channel.Persist:", channel, err)
|
2014-02-27 06:52:17 +01:00
|
|
|
}
|
2012-12-15 23:34:20 +01:00
|
|
|
}
|
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
func (channel *Channel) CanSpeak(client *Client) bool {
|
|
|
|
if client.flags[Operator] {
|
|
|
|
return true
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
if channel.flags[NoOutside] && !channel.members.Has(client) {
|
2014-02-22 21:49:33 +01:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
if channel.flags[Moderated] && !(channel.members.HasMode(client, Voice) ||
|
|
|
|
channel.members.HasMode(client, ChannelOperator)) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) PrivMsg(client *Client, message Text) {
|
2014-02-22 21:49:33 +01:00
|
|
|
if !channel.CanSpeak(client) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrCannotSendToChan(channel)
|
2014-02-09 08:33:56 +01:00
|
|
|
return
|
|
|
|
}
|
2014-03-28 03:04:34 +01:00
|
|
|
reply := RplPrivMsg(client, channel, message)
|
2014-02-20 07:20:34 +01:00
|
|
|
for member := range channel.members {
|
|
|
|
if member == client {
|
|
|
|
continue
|
|
|
|
}
|
2014-03-28 03:04:34 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2012-12-09 07:54:58 +01:00
|
|
|
}
|
2014-02-09 07:06:10 +01:00
|
|
|
|
2014-02-23 00:01:11 +01:00
|
|
|
func (channel *Channel) applyModeFlag(client *Client, mode ChannelMode,
|
|
|
|
op ModeOp) bool {
|
|
|
|
if !channel.ClientIsOperator(client) {
|
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
switch op {
|
|
|
|
case Add:
|
2014-02-26 07:16:23 +01:00
|
|
|
if channel.flags[mode] {
|
|
|
|
return false
|
|
|
|
}
|
2014-02-23 00:01:11 +01:00
|
|
|
channel.flags[mode] = true
|
|
|
|
return true
|
|
|
|
|
|
|
|
case Remove:
|
2014-02-26 07:16:23 +01:00
|
|
|
if !channel.flags[mode] {
|
|
|
|
return false
|
|
|
|
}
|
2014-02-23 00:01:11 +01:00
|
|
|
delete(channel.flags, mode)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (channel *Channel) applyModeMember(client *Client, mode ChannelMode,
|
2014-03-09 21:45:36 +01:00
|
|
|
op ModeOp, nick Name) bool {
|
2014-02-23 00:01:11 +01:00
|
|
|
if !channel.ClientIsOperator(client) {
|
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
if nick == "" {
|
|
|
|
client.ErrNeedMoreParams("MODE")
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
target := channel.server.clients.Get(nick)
|
|
|
|
if target == nil {
|
|
|
|
client.ErrNoSuchNick(nick)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
if !channel.members.Has(target) {
|
|
|
|
client.ErrUserNotInChannel(channel, target)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
switch op {
|
|
|
|
case Add:
|
2014-02-26 07:16:23 +01:00
|
|
|
if channel.members[target][mode] {
|
|
|
|
return false
|
|
|
|
}
|
2014-02-23 00:01:11 +01:00
|
|
|
channel.members[target][mode] = true
|
|
|
|
return true
|
|
|
|
|
|
|
|
case Remove:
|
2014-02-26 07:16:23 +01:00
|
|
|
if !channel.members[target][mode] {
|
|
|
|
return false
|
|
|
|
}
|
2014-02-23 00:01:11 +01:00
|
|
|
channel.members[target][mode] = false
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2014-03-08 02:35:58 +01:00
|
|
|
func (channel *Channel) ShowMaskList(client *Client, mode ChannelMode) {
|
|
|
|
for lmask := range channel.lists[mode].masks {
|
|
|
|
client.RplMaskList(mode, channel, lmask)
|
2014-03-08 02:09:49 +01:00
|
|
|
}
|
2014-03-08 02:35:58 +01:00
|
|
|
client.RplEndOfMaskList(mode, channel)
|
|
|
|
}
|
2014-03-08 02:09:49 +01:00
|
|
|
|
2014-03-08 02:35:58 +01:00
|
|
|
func (channel *Channel) applyModeMask(client *Client, mode ChannelMode, op ModeOp,
|
2014-03-09 21:45:36 +01:00
|
|
|
mask Name) 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
|
|
|
|
}
|
|
|
|
|
2014-03-08 02:35:58 +01:00
|
|
|
if (op == List) || (mask == "") {
|
|
|
|
channel.ShowMaskList(client, mode)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
if !channel.ClientIsOperator(client) {
|
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2014-03-08 02:09:49 +01:00
|
|
|
if op == Add {
|
2014-03-08 02:35:58 +01:00
|
|
|
return list.Add(mask)
|
2014-03-08 02:09:49 +01:00
|
|
|
}
|
|
|
|
|
2014-03-08 02:35:58 +01:00
|
|
|
if op == Remove {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2014-02-24 03:05:06 +01:00
|
|
|
func (channel *Channel) applyMode(client *Client, change *ChannelModeChange) bool {
|
2014-02-22 21:49:33 +01:00
|
|
|
switch change.mode {
|
2014-02-23 00:01:11 +01:00
|
|
|
case BanMask, ExceptMask, InviteMask:
|
2014-03-09 21:45:36 +01:00
|
|
|
return channel.applyModeMask(client, change.mode, change.op,
|
|
|
|
NewName(change.arg))
|
2014-02-16 04:49:20 +01:00
|
|
|
|
2016-04-14 14:33:38 +02:00
|
|
|
case InviteOnly, Moderated, NoOutside, OpOnlyTopic, Persistent, Secret:
|
2014-02-23 00:01:11 +01:00
|
|
|
return channel.applyModeFlag(client, change.mode, change.op)
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
case Key:
|
|
|
|
if !channel.ClientIsOperator(client) {
|
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
|
|
|
return false
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
switch change.op {
|
|
|
|
case Add:
|
|
|
|
if change.arg == "" {
|
|
|
|
client.ErrNeedMoreParams("MODE")
|
|
|
|
return false
|
2014-02-15 06:57:08 +01:00
|
|
|
}
|
2014-03-09 21:45:36 +01:00
|
|
|
key := NewText(change.arg)
|
|
|
|
if key == channel.key {
|
2014-02-26 07:16:23 +01:00
|
|
|
return false
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
channel.key = key
|
2014-02-22 21:49:33 +01:00
|
|
|
return true
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
case Remove:
|
|
|
|
channel.key = ""
|
|
|
|
return true
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
case UserLimit:
|
|
|
|
limit, err := strconv.ParseUint(change.arg, 10, 64)
|
|
|
|
if err != nil {
|
|
|
|
client.ErrNeedMoreParams("MODE")
|
|
|
|
return false
|
|
|
|
}
|
2014-02-26 07:16:23 +01:00
|
|
|
if (limit == 0) || (limit == channel.userLimit) {
|
2014-02-22 21:49:33 +01:00
|
|
|
return false
|
|
|
|
}
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
channel.userLimit = limit
|
|
|
|
return true
|
2014-02-15 06:57:08 +01:00
|
|
|
|
2016-04-14 01:35:36 +02:00
|
|
|
case ChannelFounder, ChannelAdmin, ChannelOperator, Halfop, Voice:
|
|
|
|
var hasPrivs bool
|
|
|
|
|
|
|
|
// make sure client has privs to edit the given prefix
|
|
|
|
for _, mode := range ChannelPrivModes {
|
|
|
|
if channel.members[client][mode] {
|
|
|
|
hasPrivs = true
|
|
|
|
|
|
|
|
// Admins can't give other people Admin or remove it from others,
|
|
|
|
// standard for that channel mode, we worry about this later
|
|
|
|
if mode == ChannelAdmin && change.mode == ChannelAdmin {
|
|
|
|
hasPrivs = false
|
|
|
|
}
|
|
|
|
|
|
|
|
break
|
|
|
|
} else if mode == change.mode {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
name := NewName(change.arg)
|
|
|
|
|
|
|
|
if !hasPrivs {
|
|
|
|
if change.op == Remove && name.ToLower() == client.nick.ToLower() {
|
|
|
|
// success!
|
|
|
|
} else {
|
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return channel.applyModeMember(client, change.mode, change.op, name)
|
2014-02-22 21:15:34 +01:00
|
|
|
|
2014-02-22 21:49:33 +01:00
|
|
|
default:
|
|
|
|
client.ErrUnknownMode(change.mode, channel)
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (channel *Channel) Mode(client *Client, changes ChannelModeChanges) {
|
|
|
|
if len(changes) == 0 {
|
|
|
|
client.RplChannelModeIs(channel)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
applied := make(ChannelModeChanges, 0)
|
|
|
|
for _, change := range changes {
|
|
|
|
if channel.applyMode(client, change) {
|
|
|
|
applied = append(applied, change)
|
2014-02-09 07:06:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
if len(applied) > 0 {
|
2014-02-22 21:49:33 +01:00
|
|
|
reply := RplChannelMode(client, channel, applied)
|
2014-02-20 07:20:34 +01:00
|
|
|
for member := range channel.members {
|
2014-02-22 21:49:33 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2014-02-25 20:11:34 +01:00
|
|
|
|
2014-02-27 06:52:17 +01:00
|
|
|
if err := channel.Persist(); err != nil {
|
2014-03-08 02:09:49 +01:00
|
|
|
log.Println("Channel.Persist:", channel, err)
|
2014-02-27 06:52:17 +01:00
|
|
|
}
|
2014-02-26 00:57:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-27 06:52:17 +01:00
|
|
|
func (channel *Channel) Persist() (err error) {
|
2014-02-26 00:57:35 +01:00
|
|
|
if channel.flags[Persistent] {
|
2014-02-27 06:52:17 +01:00
|
|
|
_, err = channel.server.db.Exec(`
|
2014-02-26 00:57:35 +01:00
|
|
|
INSERT OR REPLACE INTO channel
|
2014-03-08 03:14:02 +01:00
|
|
|
(name, flags, key, topic, user_limit, ban_list, except_list,
|
|
|
|
invite_list)
|
|
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
|
2014-03-13 21:18:40 +01:00
|
|
|
channel.name.String(), channel.flags.String(), channel.key.String(),
|
|
|
|
channel.topic.String(), channel.userLimit, channel.lists[BanMask].String(),
|
2014-03-08 03:14:02 +01:00
|
|
|
channel.lists[ExceptMask].String(), channel.lists[InviteMask].String())
|
2014-02-26 00:57:35 +01:00
|
|
|
} else {
|
2014-02-27 06:52:17 +01:00
|
|
|
_, err = channel.server.db.Exec(`
|
2014-03-16 03:18:57 +01:00
|
|
|
DELETE FROM channel WHERE name = ?`, channel.name.String())
|
2014-02-16 04:49:20 +01:00
|
|
|
}
|
2014-02-27 06:52:17 +01:00
|
|
|
return
|
2014-02-09 07:06:10 +01:00
|
|
|
}
|
2014-02-12 02:11:59 +01:00
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) Notice(client *Client, message Text) {
|
2014-02-22 21:49:33 +01:00
|
|
|
if !channel.CanSpeak(client) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrCannotSendToChan(channel)
|
2014-02-12 02:11:59 +01:00
|
|
|
return
|
|
|
|
}
|
2014-03-28 03:04:34 +01:00
|
|
|
reply := RplNotice(client, channel, message)
|
2014-02-20 07:20:34 +01:00
|
|
|
for member := range channel.members {
|
|
|
|
if member == client {
|
|
|
|
continue
|
|
|
|
}
|
2014-03-28 03:04:34 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2014-02-12 02:11:59 +01:00
|
|
|
}
|
2014-02-17 02:23:47 +01:00
|
|
|
|
2014-02-17 07:20:42 +01:00
|
|
|
func (channel *Channel) Quit(client *Client) {
|
|
|
|
channel.members.Remove(client)
|
2014-02-17 08:29:11 +01:00
|
|
|
client.channels.Remove(channel)
|
2014-02-28 03:33:03 +01:00
|
|
|
|
|
|
|
if !channel.flags[Persistent] && channel.IsEmpty() {
|
|
|
|
channel.server.channels.Remove(channel)
|
|
|
|
}
|
2014-02-17 08:29:11 +01:00
|
|
|
}
|
|
|
|
|
2014-03-09 21:45:36 +01:00
|
|
|
func (channel *Channel) Kick(client *Client, target *Client, comment Text) {
|
2014-02-22 21:49:33 +01:00
|
|
|
if !(client.flags[Operator] || channel.members.Has(client)) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrNotOnChannel(channel)
|
2014-02-17 08:29:11 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if !channel.ClientIsOperator(client) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrChanOPrivIsNeeded(channel)
|
2014-02-17 08:29:11 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if !channel.members.Has(target) {
|
2014-02-20 07:20:34 +01:00
|
|
|
client.ErrUserNotInChannel(channel, target)
|
2014-02-17 08:29:11 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-02-21 05:47:05 +01:00
|
|
|
reply := RplKick(channel, client, target, comment)
|
2014-02-20 07:20:34 +01:00
|
|
|
for member := range channel.members {
|
2014-02-22 20:40:32 +01:00
|
|
|
member.Reply(reply)
|
2014-02-20 07:20:34 +01:00
|
|
|
}
|
2014-02-17 08:29:11 +01:00
|
|
|
channel.Quit(target)
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
2014-02-25 16:28:09 +01:00
|
|
|
|
|
|
|
func (channel *Channel) Invite(invitee *Client, inviter *Client) {
|
|
|
|
if channel.flags[InviteOnly] && !channel.ClientIsOperator(inviter) {
|
|
|
|
inviter.ErrChanOPrivIsNeeded(channel)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !channel.members.Has(inviter) {
|
|
|
|
inviter.ErrNotOnChannel(channel)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-03-08 02:09:49 +01:00
|
|
|
if channel.flags[InviteOnly] {
|
|
|
|
channel.lists[InviteMask].Add(invitee.UserHost())
|
|
|
|
if err := channel.Persist(); err != nil {
|
|
|
|
log.Println("Channel.Persist:", channel, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-25 16:28:09 +01:00
|
|
|
inviter.RplInviting(invitee, channel.name)
|
2014-03-06 07:54:50 +01:00
|
|
|
invitee.Reply(RplInviteMsg(inviter, invitee, channel.name))
|
2014-02-25 16:28:09 +01:00
|
|
|
if invitee.flags[Away] {
|
|
|
|
inviter.RplAway(invitee)
|
|
|
|
}
|
|
|
|
}
|