// Construct a names message for the channel.
func (c *Channel) NamesMessage(destIDs ...string) *parser.Message {
c.mutex.Lock()
defer c.mutex.Unlock()
buf := bytes.NewBuffer(nil)
for id := range c.users {
nick, _, _, _, ok := user.GetInfo(id)
if !ok {
log.Printf("Warning: Unknown id %q in %s", id, c.name)
continue
}
buf.WriteByte(' ')
buf.WriteString(nick)
}
buf.ReadByte()
return &parser.Message{
Command: parser.RPL_NAMREPLY,
Args: []string{
// =public *private @secret
"*",
"@",
c.name,
buf.String(),
},
DestIDs: destIDs,
}
}
// TODO(kevlar): Add channel to send messages back on
func DispatchClient(message *parser.Message, ircd *IRCd) {
hookName := message.Command
_, _, _, reg, ok := user.GetInfo(message.SenderID)
if !ok {
panic("Unknown user: " + message.SenderID)
}
var mask ExecutionMask
switch reg {
case user.Unregistered:
mask |= Registration
case user.RegisteredAsUser:
mask |= User
}
for _, hook := range registeredHooks[hookName] {
if hook.When&mask == mask {
// TODO(kevlar): Check callconstraints
go hook.Func(hookName, message, ircd)
hook.Calls++
}
}
}
func (s *IRCd) manageClients() {
defer s.running.Done()
uid2conn := make(map[string]*conn.Conn)
var open bool = true
var msg *parser.Message
for open {
// anything to do here?
select {
//// Incoming and outgoing messages to and from clients
// Messages directly from connections
// TODO(kevlar): Collapse into one case (I don't like that server gets split)
case msg = <-s.fromClient:
u := user.Get(msg.SenderID)
uid := u.ID()
if msg.Command == parser.CMD_ERROR {
user.Delete(uid)
conn := uid2conn[uid]
if conn != nil {
log.Debug.Printf("[%s] ** Connection terminated remotely", uid)
user.Delete(uid)
uid2conn[uid] = nil, false
conn.UnsubscribeClose(s.clientClosing)
conn.Close()
}
continue
}
log.Debug.Printf("[%s] >> %s", uid, msg)
DispatchClient(msg, s)
// Messages from hooks
case msg, open = <-s.ToClient:
// Handle internal messages
switch msg.Command {
case parser.INT_DELUSER:
// This is sent over the channel to ensure that all user messages
// which may need to query these UIDs are sent before they are
// removed.
for _, uid := range msg.DestIDs {
log.Debug.Printf("[%s] Netsplit", uid)
user.Delete(uid)
}
continue
}
// Count the number of messages sent
sentcount := 0
// For simplicity, * in the prefix or as the first argument
// is replaced by the nick of the user the message is sent to
setnick := len(msg.Args) > 0 && msg.Args[0] == "*"
setprefix := msg.Prefix == "*"
closeafter := false
if msg.Command == parser.CMD_ERROR {
// Close the connection and remove the prefix if we are sending an ERROR
closeafter = true
msg.Prefix = ""
} else if len(msg.Prefix) == 0 {
// Make sure a prefix is specified (use the server name)
msg.Prefix = Config.Name
}
local := make([]string, 0, len(msg.DestIDs))
remote := make([]string, 0, len(msg.DestIDs))
for _, id := range msg.DestIDs {
if id[:3] != Config.SID {
remote = append(remote, id)
continue
}
local = append(local, id)
}
// Pass the message to the server goroutine
if len(remote) > 0 {
if closeafter {
for _, id := range remote {
user.Delete(id)
}
} else {
log.Warn.Printf("Dropping non-local: %s", len(remote), msg)
}
// Short circuit if there are no local recipients
if len(local) == 0 {
continue
}
}
// Examine all arguments for UIDs and replace them
if isuid(msg.Prefix) {
nick, user, _, _, ok := user.GetInfo(msg.Prefix)
if !ok {
log.Warn.Printf("Nonexistent ID %s as prefix", msg.Prefix)
} else {
msg.Prefix = nick + "!" + user + "@host" // TODO(kevlar): hostname
}
}
for i := range msg.Args {
if isuid(msg.Args[i]) {
nick, _, _, _, ok := user.GetInfo(msg.Args[i])
if !ok {
log.Warn.Printf("Nonexistent ID %s as argument", msg.Args[i])
continue
}
msg.Args[i] = nick
}
}
for _, id := range msg.DestIDs {
conn, ok := uid2conn[id]
if !ok {
log.Warn.Printf("Nonexistent ID %s in send", id)
continue
}
if setnick || setprefix {
nick, _, _, _, _ := user.GetInfo(id)
if setnick {
msg.Args[0] = nick
}
if setprefix {
msg.Prefix = nick
}
}
conn.WriteMessage(msg)
log.Debug.Printf("[%s] << %s\n", id, msg)
sentcount++
if closeafter {
log.Debug.Printf("[%s] ** Connection terminated", id)
user.Delete(id)
uid2conn[id] = nil, false
conn.UnsubscribeClose(s.clientClosing)
conn.Close()
}
}
if sentcount == 0 {
log.Warn.Printf("Dropped outgoing client message: %s", msg)
}
// Connecting clients
case conn := <-s.newClient:
id := conn.ID()
uid2conn[id] = conn
user.Get(id)
conn.Subscribe(s.fromClient)
conn.SubscribeClose(s.clientClosing)
// Disconnecting clients
case closeid := <-s.clientClosing:
log.Debug.Printf("[%s] ** Connection closed", closeid)
user.Delete(closeid)
uid2conn[closeid] = nil, false
}
}
}