Merge pull request #8 from jlatt/cap-protocol

basic capability negotiation

irc/channel.go

 	return client.flags[Operator] || channel.members.HasMode(client, ChannelOperator)
 }
 
-func (channel *Channel) Nicks() []string {
+func (channel *Channel) Nicks(target *Client) []string {
+	isMultiPrefix := (target != nil) && target.capabilities[MultiPrefix]
 	nicks := make([]string, len(channel.members))
 	i := 0
 	for client, modes := range channel.members {
-		switch {
-		case modes[ChannelOperator]:
-			nicks[i] = "@" + client.Nick()
-		case modes[Voice]:
-			nicks[i] = "+" + client.Nick()
-		default:
-			nicks[i] = client.Nick()
+		if isMultiPrefix {
+			if modes[ChannelOperator] {
+				nicks[i] += "@"
+			}
+			if modes[Voice] {
+				nicks[i] += "+"
+			}
+		} else {
+			if modes[ChannelOperator] {
+				nicks[i] += "@"
+			} else if modes[Voice] {
+				nicks[i] += "+"
+			}
 		}
+		nicks[i] += client.Nick()
 		i += 1
 	}
 	return nicks

irc/client.go

 }
 
 type Client struct {
-	atime       time.Time
-	awayMessage string
-	channels    ChannelSet
-	commands    chan editableCommand
-	ctime       time.Time
-	flags       map[UserMode]bool
-	hasQuit     bool
-	hops        uint
-	hostname    string
-	idleTimer   *time.Timer
-	loginTimer  *time.Timer
-	nick        string
-	phase       Phase
-	quitTimer   *time.Timer
-	realname    string
-	server      *Server
-	socket      *Socket
-	username    string
+	atime        time.Time
+	authorized   bool
+	awayMessage  string
+	capabilities CapabilitySet
+	capState     CapState
+	channels     ChannelSet
+	commands     chan editableCommand
+	ctime        time.Time
+	flags        map[UserMode]bool
+	hasQuit      bool
+	hops         uint
+	hostname     string
+	idleTimer    *time.Timer
+	loginTimer   *time.Timer
+	nick         string
+	phase        Phase
+	quitTimer    *time.Timer
+	realname     string
+	server       *Server
+	socket       *Socket
+	username     string
 }
 
 func NewClient(server *Server, conn net.Conn) *Client {
 	now := time.Now()
 	client := &Client{
-		atime:    now,
-		channels: make(ChannelSet),
-		commands: make(chan editableCommand),
-		ctime:    now,
-		flags:    make(map[UserMode]bool),
-		phase:    server.InitPhase(),
-		server:   server,
+		atime:        now,
+		capState:     CapNone,
+		capabilities: make(CapabilitySet),
+		channels:     make(ChannelSet),
+		commands:     make(chan editableCommand),
+		ctime:        now,
+		flags:        make(map[UserMode]bool),
+		phase:        Registration,
+		server:       server,
 	}
 	client.socket = NewSocket(conn, client.commands)
 	client.loginTimer = time.AfterFunc(LOGIN_TIMEOUT, client.connectionTimeout)
 	}
 }
 
+func (client *Client) connectionTimeout() {
+	client.commands <- &QuitCommand{
+		message: "connection timeout",
+	}
+}
+
 //
 // idle timer goroutine
 //
 	client.server.idle <- client
 }
 
-//
-// quit timer goroutine
-//
-
-func (client *Client) connectionTimeout() {
-	client.server.timeout <- client
-}
-
 //
 // server goroutine
 //
 	}
 }
 
-func (client *Client) Reply(reply string) {
+func (client *Client) Reply(reply string, args ...interface{}) {
+	if len(args) > 0 {
+		reply = fmt.Sprintf(reply, args...)
+	}
 	client.socket.Write(reply)
 }
 

irc/commands.go

 	return cmd, nil
 }
 
-// TODO
 type CapCommand struct {
 	BaseCommand
-	args []string
+	subCommand   CapSubCommand
+	capabilities CapabilitySet
 }
 
 func (msg *CapCommand) String() string {
-	return fmt.Sprintf("CAP(args=%s)", msg.args)
+	return fmt.Sprintf("CAP(subCommand=%s, capabilities=%s)",
+		msg.subCommand, msg.capabilities)
 }
 
 func NewCapCommand(args []string) (editableCommand, error) {
-	return &CapCommand{
-		args: args,
-	}, nil
+	if len(args) < 1 {
+		return nil, NotEnoughArgsError
+	}
+
+	cmd := &CapCommand{
+		subCommand:   CapSubCommand(strings.ToUpper(args[0])),
+		capabilities: make(CapabilitySet),
+	}
+
+	if len(args) > 1 {
+		strs := spacesExpr.Split(args[1], -1)
+		for _, str := range strs {
+			cmd.capabilities[Capability(str)] = true
+		}
+	}
+	return cmd, nil
 }
 
 // HAPROXY support

irc/constants.go

 	ERR_TOOMANYTARGETS    NumericCode = 407
 	ERR_NOSUCHSERVICE     NumericCode = 408
 	ERR_NOORIGIN          NumericCode = 409
+	ERR_INVALIDCAPCMD     NumericCode = 410
 	ERR_NORECIPIENT       NumericCode = 411
 	ERR_NOTEXTTOSEND      NumericCode = 412
 	ERR_NOTOPLEVEL        NumericCode = 413
 	ERR_UMODEUNKNOWNFLAG  NumericCode = 501
 	ERR_USERSDONTMATCH    NumericCode = 502
 
+	CAP_LS    CapSubCommand = "LS"
+	CAP_LIST  CapSubCommand = "LIST"
+	CAP_REQ   CapSubCommand = "REQ"
+	CAP_ACK   CapSubCommand = "ACK"
+	CAP_NAK   CapSubCommand = "NAK"
+	CAP_CLEAR CapSubCommand = "CLEAR"
+	CAP_END   CapSubCommand = "END"
+
 	Add    ModeOp = '+'
 	List   ModeOp = '='
 	Remove ModeOp = '-'
 	Secret          ChannelMode = 's' // flag, deprecated
 	UserLimit       ChannelMode = 'l' // flag arg
 	Voice           ChannelMode = 'v' // arg
+
+	MultiPrefix Capability = "multi-prefix"
+	SASL        Capability = "sasl"
+
+	Disable CapModifier = '-'
+	Ack     CapModifier = '~'
+	Sticky  CapModifier = '='
+)
+
+var (
+	SupportedCapabilities = CapabilitySet{
+		MultiPrefix: true,
+	}
+)
+
+const (
+	Registration Phase = iota
+	Normal       Phase = iota
 )
 
 const (
-	Authorization Phase = iota
-	Registration  Phase = iota
-	Normal        Phase = iota
+	CapNone        CapState = iota
+	CapNegotiating CapState = iota
+	CapNegotiated  CapState = iota
 )

irc/reply.go

 
 	if channel != nil {
 		channelName = channel.name
-
-		if channel.members[client][ChannelOperator] {
-			flags += "@"
-		} else if channel.members[client][Voice] {
-			flags += "+"
+		if target.capabilities[MultiPrefix] {
+			if channel.members[client][ChannelOperator] {
+				flags += "@"
+			}
+			if channel.members[client][Voice] {
+				flags += "+"
+			}
+		} else {
+			if channel.members[client][ChannelOperator] {
+				flags += "@"
+			} else if channel.members[client][Voice] {
+				flags += "+"
+			}
 		}
 	}
 	target.NumericReply(RPL_WHOREPLY,
 }
 
 func (target *Client) RplNamReply(channel *Channel) {
-	target.MultilineReply(channel.Nicks(), RPL_NAMREPLY,
+	target.MultilineReply(channel.Nicks(target), RPL_NAMREPLY,
 		"= %s :%s", channel)
 }
 
 	target.NumericReply(ERR_CHANNELISFULL,
 		"%s :Cannot join channel (+l)", channel)
 }
+
+func (target *Client) ErrInvalidCapCmd(subCommand CapSubCommand) {
+	target.NumericReply(ERR_INVALIDCAPCMD,
+		"%s :Invalid CAP subcommand", subCommand)
+}

irc/server.go

 	operators map[string][]byte
 	password  []byte
 	signals   chan os.Signal
-	timeout   chan *Client
 }
 
 func NewServer(config *Config) *Server {
 		newConns:  make(chan net.Conn, 16),
 		operators: config.Operators(),
 		signals:   make(chan os.Signal, 1),
-		timeout:   make(chan *Client, 16),
 	}
 
 	if config.Server.Password != "" {
 	}
 
 	switch client.phase {
-	case Authorization:
-		authCmd, ok := cmd.(AuthServerCommand)
-		if !ok {
-			client.Quit("unexpected command")
-			return
-		}
-		authCmd.HandleAuthServer(server)
-
 	case Registration:
 		regCmd, ok := cmd.(RegServerCommand)
 		if !ok {
 		}
 		regCmd.HandleRegServer(server)
 
-	default:
+	case Normal:
 		srvCmd, ok := cmd.(ServerCommand)
 		if !ok {
 			client.ErrUnknownCommand(cmd.Code())
 
 		case client := <-server.idle:
 			client.Idle()
-
-		case client := <-server.timeout:
-			client.Quit("connection timeout")
 		}
 	}
 }
 
-func (server *Server) InitPhase() Phase {
-	if server.password == nil {
-		return Registration
-	}
-	return Authorization
-}
-
 //
 // listen goroutine
 //
 //
 
 func (s *Server) tryRegister(c *Client) {
-	if c.HasNick() && c.HasUsername() {
+	if c.HasNick() && c.HasUsername() && (c.capState != CapNegotiating) {
 		c.Register()
 		c.RplWelcome()
 		c.RplYourHost()
 }
 
 //
-// authorization commands
+// registration commands
 //
 
-func (msg *ProxyCommand) HandleAuthServer(server *Server) {
-	msg.Client().hostname = msg.hostname
-}
-
-func (msg *CapCommand) HandleAuthServer(server *Server) {
-	// TODO
-}
-
-func (msg *PassCommand) HandleAuthServer(server *Server) {
+func (msg *PassCommand) HandleRegServer(server *Server) {
 	client := msg.Client()
 	if msg.err != nil {
 		client.ErrPasswdMismatch()
 		return
 	}
 
-	client.phase = Registration
+	client.authorized = true
 }
 
-func (msg *QuitCommand) HandleAuthServer(server *Server) {
-	msg.Client().Quit(msg.message)
-}
-
-//
-// registration commands
-//
-
 func (msg *ProxyCommand) HandleRegServer(server *Server) {
 	msg.Client().hostname = msg.hostname
 }
 
 func (msg *CapCommand) HandleRegServer(server *Server) {
-	// TODO
+	client := msg.Client()
+
+	switch msg.subCommand {
+	case CAP_LS:
+		client.capState = CapNegotiating
+		client.Reply("CAP LS * :%s", SupportedCapabilities)
+
+	case CAP_LIST:
+		client.Reply("CAP LIST * :%s", client.capabilities)
+
+	case CAP_REQ:
+		client.capState = CapNegotiating
+		for capability := range msg.capabilities {
+			if !SupportedCapabilities[capability] {
+				client.Reply("CAP NAK * :%s", msg.capabilities)
+				return
+			}
+		}
+		for capability := range msg.capabilities {
+			client.capabilities[capability] = true
+		}
+		client.Reply("CAP ACK * :%s", msg.capabilities)
+
+	case CAP_CLEAR:
+		format := strings.TrimRight(
+			strings.Repeat("%s%s ", len(client.capabilities)), " ")
+		args := make([]interface{}, len(client.capabilities))
+		index := 0
+		for capability := range client.capabilities {
+			args[index] = Disable
+			args[index+1] = capability
+			index += 2
+			delete(client.capabilities, capability)
+		}
+		client.Reply("CAP ACK * :"+format, args...)
+
+	case CAP_END:
+		client.capState = CapNegotiated
+		server.tryRegister(client)
+
+	default:
+		client.ErrInvalidCapCmd(msg.subCommand)
+	}
 }
 
 func (m *NickCommand) HandleRegServer(s *Server) {
 	client := m.Client()
+	if !client.authorized {
+		client.ErrPasswdMismatch()
+		client.Quit("bad password")
+		return
+	}
+
+	if client.capState == CapNegotiating {
+		client.capState = CapNegotiated
+	}
 
 	if m.nickname == "" {
 		client.ErrNoNicknameGiven()
 }
 
 func (msg *RFC1459UserCommand) HandleRegServer(server *Server) {
+	client := msg.Client()
+	if !client.authorized {
+		client.ErrPasswdMismatch()
+		client.Quit("bad password")
+		return
+	}
 	msg.HandleRegServer2(server)
 }
 
 func (msg *RFC2812UserCommand) HandleRegServer(server *Server) {
 	client := msg.Client()
+	if !client.authorized {
+		client.ErrPasswdMismatch()
+		client.Quit("bad password")
+		return
+	}
 	flags := msg.Flags()
 	if len(flags) > 0 {
 		for _, mode := range msg.Flags() {
 
 func (msg *UserCommand) HandleRegServer2(server *Server) {
 	client := msg.Client()
+	if client.capState == CapNegotiating {
+		client.capState = CapNegotiated
+	}
 	client.username, client.realname = msg.username, msg.realname
 	server.tryRegister(client)
 }

irc/types.go

 // simple types
 //
 
+type CapSubCommand string
+
+type Capability string
+
+type CapModifier rune
+
+func (mod CapModifier) String() string {
+	return string(mod)
+}
+
+type CapState uint
+
+type CapabilitySet map[Capability]bool
+
+func (set CapabilitySet) String() string {
+	strs := make([]string, len(set))
+	index := 0
+	for capability := range set {
+		strs[index] = string(capability)
+		index += 1
+	}
+	return strings.Join(strs, " ")
+}
+
 // a string with wildcards
 type Mask string
 
 type UserMode rune
 
 func (mode UserMode) String() string {
-	return fmt.Sprintf("%c", mode)
+	return string(mode)
 }
 
 type Phase uint
 type ChannelMode rune
 
 func (mode ChannelMode) String() string {
-	return fmt.Sprintf("%c", mode)
+	return string(mode)
 }
 
 type ChannelNameMap map[string]*Channel