示例#1
0
// 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,
	}
}
示例#2
0
// 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++
		}
	}
}
示例#3
0
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
		}
	}
}