implement #199

irc/client.go

 	nickMaskString     string // cache for nickmask string since it's used with lots of replies
 	nickTimer          *NickTimer
 	operName           string
+	preregNick         string
 	proxiedIP          net.IP // actual remote IP if using the PROXY protocol
 	quitMessage        string
 	rawHostname        string

irc/config.go

 type AccountConfig struct {
 	Registration          AccountRegistrationConfig
 	AuthenticationEnabled bool                  `yaml:"authentication-enabled"`
+	SkipServerPassword    bool                  `yaml:"skip-server-password"`
 	NickReservation       NickReservationConfig `yaml:"nick-reservation"`
 }
 

irc/getters.go

 	return
 }
 
+func (client *Client) Authorized() bool {
+	client.stateMutex.RLock()
+	defer client.stateMutex.RUnlock()
+	return client.authorized
+}
+
+func (client *Client) SetAuthorized(authorized bool) {
+	client.stateMutex.Lock()
+	defer client.stateMutex.Unlock()
+	client.authorized = authorized
+}
+
+func (client *Client) PreregNick() string {
+	client.stateMutex.RLock()
+	defer client.stateMutex.RUnlock()
+	return client.preregNick
+}
+
+func (client *Client) SetPreregNick(preregNick string) {
+	client.stateMutex.Lock()
+	defer client.stateMutex.Unlock()
+	client.preregNick = preregNick
+}
+
 func (client *Client) HasMode(mode modes.Mode) bool {
 	client.stateMutex.RLock()
 	defer client.stateMutex.RUnlock()

irc/handlers.go

 	// let the SASL handler do its thing
 	exiting := handler(server, client, client.saslMechanism, data, rb)
 
+	if client.LoggedIntoAccount() && server.AccountConfig().SkipServerPassword {
+		client.SetAuthorized(true)
+	}
+
 	// wait 'til SASL is done before emptying the sasl vars
 	client.saslInProgress = false
 	client.saslMechanism = ""
 		rb.Add(nil, server.name, "CAP", client.nick, "ACK", capString)
 
 	case "END":
-		if !client.registered {
+		if !client.Registered() {
 			client.capState = caps.NegotiatedState
-			server.tryRegister(client)
 		}
 
 	default:
 
 // NICK <nickname>
 func nickHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
-	if !client.authorized {
-		client.Quit("Bad password")
-		return true
+	if client.Registered() {
+		performNickChange(server, client, client, msg.Params[0], rb)
+	} else {
+		client.SetPreregNick(msg.Params[0])
 	}
-
-	return performNickChange(server, client, client, msg.Params[0], rb)
+	return false
 }
 
 // NOTICE <target>{,<target>} <message>
 
 // PASS <password>
 func passHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
-	if client.registered {
+	if client.Registered() {
 		rb.Add(nil, server.name, ERR_ALREADYREGISTRED, client.nick, client.t("You may not reregister"))
 		return false
 	}
 
 	// if no password exists, skip checking
 	if len(server.password) == 0 {
-		client.authorized = true
+		client.SetAuthorized(true)
 		return false
 	}
 
 		return true
 	}
 
-	client.authorized = true
+	client.SetAuthorized(true)
 	return false
 }
 
 // http://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
 func proxyHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
 	// only allow unregistered clients to use this command
-	if client.registered || client.proxiedIP != nil {
+	if client.Registered() || client.proxiedIP != nil {
 		return false
 	}
 
 		rb.Add(nil, server.name, ERR_NOSUCHNICK, client.nick, msg.Params[0], client.t("No such nick"))
 		return false
 	}
-	return performNickChange(server, client, target, msg.Params[1], rb)
+	performNickChange(server, client, target, msg.Params[1], rb)
+	return false
 }
 
 // SCENE <target> <message>
 
 // USER <username> * 0 <realname>
 func userHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
-	if client.registered {
+	if client.Registered() {
 		rb.Add(nil, server.name, ERR_ALREADYREGISTRED, client.nick, client.t("You may not reregister"))
 		return false
 	}
 
-	if !client.authorized {
-		client.Quit("Bad password")
-		return true
-	}
-
 	if client.username != "" && client.realname != "" {
 		return false
 	}
 		client.realname = msg.Params[3]
 	}
 
-	server.tryRegister(client)
-
 	return false
 }
 
 // WEBIRC <password> <gateway> <hostname> <ip> [:flag1 flag2=x flag3]
 func webircHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
 	// only allow unregistered clients to use this command
-	if client.registered || client.proxiedIP != nil {
+	if client.Registered() || client.proxiedIP != nil {
 		return false
 	}
 

irc/nickname.go

 	}
 )
 
+// returns whether the change succeeded or failed
 func performNickChange(server *Server, client *Client, target *Client, newnick string, rb *ResponseBuffer) bool {
 	nickname := strings.TrimSpace(newnick)
 	cfnick, err := CasefoldName(nickname)
 	}
 
 	if target.Nick() == nickname {
-		return false
+		return true
 	}
 
 	hadNick := target.HasNick()
 		rb.Add(nil, server.name, ERR_NICKNAMEINUSE, client.nick, nickname, client.t("Nickname is already in use"))
 		return false
 	} else if err == errNicknameReserved {
-		client.Send(nil, server.name, ERR_NICKNAMEINUSE, client.nick, nickname, client.t("Nickname is reserved by a different account"))
+		rb.Add(nil, server.name, ERR_NICKNAMEINUSE, client.nick, nickname, client.t("Nickname is reserved by a different account"))
 		return false
 	} else if err != nil {
 		rb.Add(nil, server.name, ERR_UNKNOWNERROR, client.nick, "NICK", fmt.Sprintf(client.t("Could not set or change nickname: %s"), err.Error()))
 		}
 	}
 
-	if target.registered {
+	if target.Registered() {
 		client.server.monitorManager.AlertAbout(target, true)
-	} else {
-		server.tryRegister(target)
 	}
-	return false
+	// else: Run() will attempt registration immediately after this
+	return true
 }
 
 func (server *Server) RandomlyRename(client *Client) {

irc/server.go

 //
 
 func (server *Server) tryRegister(c *Client) {
-	if c.registered || !c.HasNick() || !c.HasUsername() ||
-		(c.capState == caps.NegotiatingState) {
+	if c.Registered() {
+		return
+	}
+
+	preregNick := c.PreregNick()
+	if preregNick == "" || !c.HasUsername() || c.capState == caps.NegotiatingState {
+		return
+	}
+
+	// client MUST send PASS (or AUTHENTICATE, if skip-server-password is set)
+	// before completing the other registration commands
+	if !c.Authorized() {
+		c.Quit(c.t("Bad password"))
+		c.destroy(false)
+		return
+	}
+
+	rb := NewResponseBuffer(c)
+	nickAssigned := performNickChange(server, c, c, preregNick, rb)
+	rb.Send()
+	if !nickAssigned {
 		return
 	}
 
 	//TODO(dan): Look at adding last optional [<channel modes with a parameter>] parameter
 	c.Send(nil, server.name, RPL_MYINFO, c.nick, server.name, Ver, supportedUserModesString, supportedChannelModesString)
 
-	rb := NewResponseBuffer(c)
+	rb = NewResponseBuffer(c)
 	c.RplISupport(rb)
 	server.MOTD(c, rb)
 	rb.Send()

oragono.yaml

     # is account authentication enabled?
     authentication-enabled: true
 
+    # some clients (notably Pidgin and Hexchat) offer only a single password field,
+    # which makes it impossible to specify a separate server password (for the PASS
+    # command) and SASL password. if this option is set to true, a client that
+    # successfully authenticates with SASL will not be required to send
+    # PASS as well, so it can be configured to authenticate with SASL only.
+    skip-server-password: false
+
     # nick-reservation controls how, and whether, nicknames are linked to accounts
     nick-reservation:
         # is there any enforcement of reserved nicknames?