fix #1850

Add WHO responses for services

irc/handlers.go

 
 // get the correct capitalization of a nick (if it's online), otherwise return ""
 func (server *Server) getCurrentNick(nick string) (result string) {
-	if service, isService := OragonoServices[strings.ToLower(nick)]; isService {
+	if service, isService := ErgoServices[strings.ToLower(nick)]; isService {
 		return service.Name
 	} else if iclient := server.clients.Get(nick); iclient != nil {
 		return iclient.Nick()
 		}
 	} else {
 		lowercaseTarget := strings.ToLower(target)
-		service, isService := OragonoServices[lowercaseTarget]
+		service, isService := ErgoServices[lowercaseTarget]
 		_, isZNC := zncHandlers[lowercaseTarget]
 
 		if isService || isZNC {
 	rb.Add(nil, client.server.name, numeric, params...)
 }
 
+func serviceWhoReply(client *Client, service *ircService, rb *ResponseBuffer, isWhox bool, fields whoxFields, whoType string) {
+	params := []string{client.Nick()}
+
+	if fields.Has('t') {
+		params = append(params, whoType)
+	}
+	if fields.Has('c') {
+		params = append(params, "*")
+	}
+	if fields.Has('u') {
+		params = append(params, service.Name)
+	}
+	if fields.Has('i') {
+		params = append(params, "127.0.0.1")
+	}
+	if fields.Has('h') {
+		params = append(params, "localhost")
+	}
+	if fields.Has('s') {
+		params = append(params, client.server.name)
+	}
+	if fields.Has('n') {
+		params = append(params, service.Name)
+	}
+	if fields.Has('f') { // "flags" (away + oper state + channel status prefix + bot)
+		params = append(params, "H")
+	}
+	if fields.Has('d') { // server hops from us to target
+		params = append(params, "0")
+	}
+	if fields.Has('l') { // idle seconds
+		params = append(params, "0")
+	}
+	if fields.Has('a') { // account, services are considered not to have one
+		params = append(params, "0")
+	}
+	if fields.Has('o') { // channel oplevel, not implemented
+		params = append(params, "*")
+	}
+	if fields.Has('r') {
+		params = append(params, service.Realname(client))
+	}
+
+	numeric := RPL_WHOSPCRPL
+	if !isWhox {
+		numeric = RPL_WHOREPLY
+		// if this isn't WHOX, stick hops + realname at the end
+		params = append(params, "0 "+service.Realname(client))
+	}
+
+	rb.Add(nil, client.server.name, numeric, params...)
+}
+
 // WHO <mask> [<filter>%<fields>,<type>]
 func whoHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
 	origMask := utils.SafeErrorParam(msg.Params[0])
 			}
 		}
 	} else if isBareNick {
-		mclient := server.clients.Get(mask)
-		if mclient != nil {
+		if mclient := server.clients.Get(mask); mclient != nil {
 			client.rplWhoReply(nil, mclient, rb, canSeeIPs, oper != nil, includeRFlag, isWhox, fields, whoType)
+		} else if service, ok := ErgoServices[strings.ToLower(mask)]; ok {
+			serviceWhoReply(client, service, rb, isWhox, fields, whoType)
 		}
 	} else {
 		// Construct set of channels the client is in.
 
 	handleService := func(nick string) bool {
 		cfnick, _ := CasefoldName(nick)
-		service, ok := OragonoServices[cfnick]
+		service, ok := ErgoServices[cfnick]
 		hostname := "localhost"
 		config := server.Config()
 		if config.Server.OverrideServicesHostname != "" {
 			return false
 		}
 		clientNick := client.Nick()
-		rb.Add(nil, client.server.name, RPL_WHOISUSER, clientNick, service.Name, service.Name, hostname, "*", fmt.Sprintf(client.t("Network service, for more info /msg %s HELP"), service.Name))
+		rb.Add(nil, client.server.name, RPL_WHOISUSER, clientNick, service.Name, service.Name, hostname, "*", service.Realname(client))
 		// #1080:
 		rb.Add(nil, client.server.name, RPL_WHOISOPERATOR, clientNick, service.Name, client.t("is a network service"))
 		// hehe

irc/services.go

 	HelpBanner     string
 }
 
+func (service *ircService) Realname(client *Client) string {
+	return fmt.Sprintf(client.t("Network service, for more info /msg %s HELP"), service.Name)
+}
+
 // defines a command associated with a service, e.g., NICKSERV IDENTIFY
 type serviceCommand struct {
 	aliasOf           string   // marks this command as an alias of another
 )
 
 // all services, by lowercase name
-var OragonoServices = map[string]*ircService{
+var ErgoServices = map[string]*ircService{
 	"nickserv": nickservService,
 	"chanserv": chanservService,
 	"hostserv": hostservService,
 
 // all service commands at the protocol level, by uppercase command name
 // e.g., NICKSERV, NS
-var oragonoServicesByCommandAlias map[string]*ircService
+var ergoServicesByCommandAlias map[string]*ircService
 
 // special-cased command shared by all services
 var servHelpCmd serviceCommand = serviceCommand{
 
 // generic handler for IRC commands like `/NICKSERV INFO`
 func serviceCmdHandler(server *Server, client *Client, msg ircmsg.Message, rb *ResponseBuffer) bool {
-	service, ok := oragonoServicesByCommandAlias[msg.Command]
+	service, ok := ergoServicesByCommandAlias[msg.Command]
 	if !ok {
 		server.logger.Warning("internal", "can't handle unrecognized service", msg.Command)
 		return false
 	if !utils.IsHostname(hostname) {
 		return fmt.Errorf("`%s` is an invalid services hostname", hostname)
 	}
-	for _, serv := range OragonoServices {
+	for _, serv := range ErgoServices {
 		serv.prefix = fmt.Sprintf("%s!%s@%s", serv.Name, serv.Name, hostname)
 	}
 	return nil
 func initializeServices() {
 	// this modifies the global Commands map,
 	// so it must be called from irc/commands.go's init()
-	oragonoServicesByCommandAlias = make(map[string]*ircService)
+	ergoServicesByCommandAlias = make(map[string]*ircService)
 
-	for serviceName, service := range OragonoServices {
+	for serviceName, service := range ErgoServices {
 		service.prefix = fmt.Sprintf("%s!%s@localhost", service.Name, service.Name)
 
 		// make `/MSG ServiceName HELP` work correctly
 		ircCmdDef.handler = serviceCmdHandler
 		for _, ircCmd := range service.CommandAliases {
 			Commands[ircCmd] = ircCmdDef
-			oragonoServicesByCommandAlias[ircCmd] = service
+			ergoServicesByCommandAlias[ircCmd] = service
 			Help[strings.ToLower(ircCmd)] = HelpEntry{
 				textGenerator: makeServiceHelpTextGenerator(ircCmd, service.HelpBanner),
 			}