Merge pull request #35 from jlatt/fix-goroutine-leak

fix two bugs

irc/channel.go

 		client.ErrCannotSendToChan(channel)
 		return
 	}
+	reply := RplPrivMsg(client, channel, message)
 	for member := range channel.members {
 		if member == client {
 			continue
 		}
-		member.Reply(RplPrivMsg(client, channel, message))
+		member.Reply(reply)
 	}
 }
 
 		client.ErrCannotSendToChan(channel)
 		return
 	}
+	reply := RplNotice(client, channel, message)
 	for member := range channel.members {
 		if member == client {
 			continue
 		}
-		member.Reply(RplNotice(client, channel, message))
+		member.Reply(reply)
 	}
 }
 

irc/client.go

 
 func (client *Client) run() {
 	for command := range client.commands {
-		command.SetClient(client)
-
-		checkPass, ok := command.(checkPasswordCommand)
-		if ok {
+		if checkPass, ok := command.(checkPasswordCommand); ok {
 			checkPass.LoadPassword(client.server)
 			// Block the client thread while handling a potentially expensive
 			// password bcrypt operation. Since the server is single-threaded
 			// completes. This could be a form of DoS if handled naively.
 			checkPass.CheckPassword()
 		}
-
+		command.SetClient(client)
 		client.server.commands <- command
 	}
 }
 
 func (client *Client) connectionTimeout() {
-	client.commands <- &QuitCommand{
-		message: "connection timeout",
-	}
+	client.commands <- NewQuitCommand("connection timeout")
 }
 
 //
 		return
 	}
 
-	client.Reply(RplError("connection closed"))
 	client.hasQuit = true
+	client.Reply(RplError("quit"))
 	client.server.whoWas.Append(client)
 	friends := client.Friends()
 	friends.Remove(client)

irc/client_lookup_set.go

 		return
 	}
 	for rows.Next() {
-		var nickname Name
-		err := rows.Scan(&nickname)
+		var sqlNickname string
+		err := rows.Scan(&sqlNickname)
 		if err != nil {
 			Log.error.Println("ClientLookupSet.FindAll.Scan:", err)
 			return
 		}
+		nickname := Name(sqlNickname)
 		client := clients.Get(nickname)
 		if client == nil {
 			Log.error.Println("ClientLookupSet.FindAll: missing client:", nickname)

irc/commands.go

 	NotEnoughArgsError = errors.New("not enough arguments")
 	ErrParseCommand    = errors.New("failed to parse message")
 	parseCommandFuncs  = map[StringCode]parseCommandFunc{
-		AWAY:    NewAwayCommand,
-		CAP:     NewCapCommand,
-		DEBUG:   NewDebugCommand,
-		INVITE:  NewInviteCommand,
-		ISON:    NewIsOnCommand,
-		JOIN:    NewJoinCommand,
-		KICK:    NewKickCommand,
-		KILL:    NewKillCommand,
-		LIST:    NewListCommand,
-		MODE:    NewModeCommand,
-		MOTD:    NewMOTDCommand,
-		NAMES:   NewNamesCommand,
-		NICK:    NewNickCommand,
-		NOTICE:  NewNoticeCommand,
-		ONICK:   NewOperNickCommand,
-		OPER:    NewOperCommand,
-		PART:    NewPartCommand,
-		PASS:    NewPassCommand,
-		PING:    NewPingCommand,
-		PONG:    NewPongCommand,
-		PRIVMSG: NewPrivMsgCommand,
-		PROXY:   NewProxyCommand,
-		QUIT:    NewQuitCommand,
-		THEATER: NewTheaterCommand, // nonstandard
-		TIME:    NewTimeCommand,
-		TOPIC:   NewTopicCommand,
-		USER:    NewUserCommand,
-		VERSION: NewVersionCommand,
-		WHO:     NewWhoCommand,
-		WHOIS:   NewWhoisCommand,
-		WHOWAS:  NewWhoWasCommand,
+		AWAY:    ParseAwayCommand,
+		CAP:     ParseCapCommand,
+		DEBUG:   ParseDebugCommand,
+		INVITE:  ParseInviteCommand,
+		ISON:    ParseIsOnCommand,
+		JOIN:    ParseJoinCommand,
+		KICK:    ParseKickCommand,
+		KILL:    ParseKillCommand,
+		LIST:    ParseListCommand,
+		MODE:    ParseModeCommand,
+		MOTD:    ParseMOTDCommand,
+		NAMES:   ParseNamesCommand,
+		NICK:    ParseNickCommand,
+		NOTICE:  ParseNoticeCommand,
+		ONICK:   ParseOperNickCommand,
+		OPER:    ParseOperCommand,
+		PART:    ParsePartCommand,
+		PASS:    ParsePassCommand,
+		PING:    ParsePingCommand,
+		PONG:    ParsePongCommand,
+		PRIVMSG: ParsePrivMsgCommand,
+		PROXY:   ParseProxyCommand,
+		QUIT:    ParseQuitCommand,
+		THEATER: ParseTheaterCommand, // nonstandard
+		TIME:    ParseTimeCommand,
+		TOPIC:   ParseTopicCommand,
+		USER:    ParseUserCommand,
+		VERSION: ParseVersionCommand,
+		WHO:     ParseWhoCommand,
+		WHOIS:   ParseWhoisCommand,
+		WHOWAS:  ParseWhoWasCommand,
 	}
 )
 
 	code, args := ParseLine(line)
 	constructor := parseCommandFuncs[code]
 	if constructor == nil {
-		cmd = NewUnknownCommand(args)
+		cmd = ParseUnknownCommand(args)
 	} else {
 		cmd, err = constructor(args)
 	}
 	args []string
 }
 
-func (cmd *UnknownCommand) String() string {
-	return fmt.Sprintf("UNKNOWN(command=%s, args=%s)", cmd.Code(), cmd.args)
-}
-
-func NewUnknownCommand(args []string) *UnknownCommand {
+func ParseUnknownCommand(args []string) *UnknownCommand {
 	return &UnknownCommand{
 		args: args,
 	}
 	server2 Name
 }
 
-func (cmd *PingCommand) String() string {
-	return fmt.Sprintf("PING(server=%s, server2=%s)", cmd.server, cmd.server2)
-}
-
-func NewPingCommand(args []string) (Command, error) {
+func ParsePingCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 	server2 Name
 }
 
-func (cmd *PongCommand) String() string {
-	return fmt.Sprintf("PONG(server1=%s, server2=%s)", cmd.server1, cmd.server2)
-}
-
-func NewPongCommand(args []string) (Command, error) {
+func ParsePongCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 	err      error
 }
 
-func (cmd *PassCommand) String() string {
-	return fmt.Sprintf("PASS(password=%s)", cmd.password)
-}
-
 func (cmd *PassCommand) LoadPassword(server *Server) {
 	cmd.hash = server.password
 }
 	cmd.err = ComparePassword(cmd.hash, cmd.password)
 }
 
-func NewPassCommand(args []string) (Command, error) {
+func ParsePassCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 
 // NICK <nickname>
 
-func NewNickCommand(args []string) (Command, error) {
+func ParseNickCommand(args []string) (Command, error) {
 	if len(args) != 1 {
 		return nil, NotEnoughArgsError
 	}
 	servername Name
 }
 
-func (cmd *RFC1459UserCommand) String() string {
-	return fmt.Sprintf("USER(username=%s, hostname=%s, servername=%s, realname=%s)",
-		cmd.username, cmd.hostname, cmd.servername, cmd.realname)
-}
-
 // USER <user> <mode> <unused> <realname>
 type RFC2812UserCommand struct {
 	UserCommand
 	unused string
 }
 
-func (cmd *RFC2812UserCommand) String() string {
-	return fmt.Sprintf("USER(username=%s, mode=%d, unused=%s, realname=%s)",
-		cmd.username, cmd.mode, cmd.unused, cmd.realname)
-}
-
 func (cmd *RFC2812UserCommand) Flags() []UserMode {
 	flags := make([]UserMode, 0)
 	if (cmd.mode & 4) == 4 {
 	return flags
 }
 
-func NewUserCommand(args []string) (Command, error) {
+func ParseUserCommand(args []string) (Command, error) {
 	if len(args) != 4 {
 		return nil, NotEnoughArgsError
 	}
 	message Text
 }
 
-func (cmd *QuitCommand) String() string {
-	return fmt.Sprintf("QUIT(message=%s)", cmd.message)
+func NewQuitCommand(message Text) *QuitCommand {
+	cmd := &QuitCommand{
+		message: message,
+	}
+	cmd.code = QUIT
+	return cmd
 }
 
-func NewQuitCommand(args []string) (Command, error) {
+func ParseQuitCommand(args []string) (Command, error) {
 	msg := &QuitCommand{}
 	if len(args) > 0 {
 		msg.message = NewText(args[0])
 	zero     bool
 }
 
-func (cmd *JoinCommand) String() string {
-	return fmt.Sprintf("JOIN(channels=%s, zero=%t)", cmd.channels, cmd.zero)
-}
-
-func NewJoinCommand(args []string) (Command, error) {
+func ParseJoinCommand(args []string) (Command, error) {
 	msg := &JoinCommand{
 		channels: make(map[Name]Text),
 	}
 	return cmd.message
 }
 
-func (cmd *PartCommand) String() string {
-	return fmt.Sprintf("PART(channels=%s, message=%s)", cmd.channels, cmd.message)
-}
-
-func NewPartCommand(args []string) (Command, error) {
+func ParsePartCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 	message Text
 }
 
-func (cmd *PrivMsgCommand) String() string {
-	return fmt.Sprintf("PRIVMSG(target=%s, message=%s)", cmd.target, cmd.message)
-}
-
-func NewPrivMsgCommand(args []string) (Command, error) {
+func ParsePrivMsgCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}
 	topic    Text
 }
 
-func (cmd *TopicCommand) String() string {
-	return fmt.Sprintf("TOPIC(channel=%s, topic=%s)", cmd.channel, cmd.topic)
-}
-
-func NewTopicCommand(args []string) (Command, error) {
+func ParseTopicCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 }
 
 // MODE <nickname> *( ( "+" / "-" ) *( "i" / "w" / "o" / "O" / "r" ) )
-func NewUserModeCommand(nickname Name, args []string) (Command, error) {
+func ParseUserModeCommand(nickname Name, args []string) (Command, error) {
 	cmd := &ModeCommand{
 		nickname: nickname,
 		changes:  make(ModeChanges, 0),
 	return cmd, nil
 }
 
-func (cmd *ModeCommand) String() string {
-	return fmt.Sprintf("MODE(nickname=%s, changes=%s)", cmd.nickname, cmd.changes)
-}
-
 type ChannelModeChange struct {
 	mode ChannelMode
 	op   ModeOp
 }
 
 // MODE <channel> *( ( "-" / "+" ) *<modes> *<modeparams> )
-func NewChannelModeCommand(channel Name, args []string) (Command, error) {
+func ParseChannelModeCommand(channel Name, args []string) (Command, error) {
 	cmd := &ChannelModeCommand{
 		channel: channel,
 		changes: make(ChannelModeChanges, 0),
 	return cmd, nil
 }
 
-func (msg *ChannelModeCommand) String() string {
-	return fmt.Sprintf("MODE(channel=%s, changes=%s)", msg.channel, msg.changes)
-}
-
-func NewModeCommand(args []string) (Command, error) {
+func ParseModeCommand(args []string) (Command, error) {
 	if len(args) == 0 {
 		return nil, NotEnoughArgsError
 	}
 
 	name := NewName(args[0])
 	if name.IsChannel() {
-		return NewChannelModeCommand(name, args[1:])
+		return ParseChannelModeCommand(name, args[1:])
 	} else {
-		return NewUserModeCommand(name, args[1:])
+		return ParseUserModeCommand(name, args[1:])
 	}
 }
 
 }
 
 // WHOIS [ <target> ] <mask> *( "," <mask> )
-func NewWhoisCommand(args []string) (Command, error) {
+func ParseWhoisCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 	}, nil
 }
 
-func (msg *WhoisCommand) String() string {
-	return fmt.Sprintf("WHOIS(target=%s, masks=%s)", msg.target, msg.masks)
-}
-
 type WhoCommand struct {
 	BaseCommand
 	mask         Name
 }
 
 // WHO [ <mask> [ "o" ] ]
-func NewWhoCommand(args []string) (Command, error) {
+func ParseWhoCommand(args []string) (Command, error) {
 	cmd := &WhoCommand{}
 
 	if len(args) > 0 {
 	return cmd, nil
 }
 
-func (msg *WhoCommand) String() string {
-	return fmt.Sprintf("WHO(mask=%s, operatorOnly=%t)", msg.mask, msg.operatorOnly)
-}
-
 type OperCommand struct {
 	PassCommand
 	name Name
 }
 
-func (msg *OperCommand) String() string {
-	return fmt.Sprintf("OPER(name=%s, password=%s)", msg.name, msg.password)
-}
-
 func (msg *OperCommand) LoadPassword(server *Server) {
 	msg.hash = server.operators[msg.name]
 }
 
 // OPER <name> <password>
-func NewOperCommand(args []string) (Command, error) {
+func ParseOperCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}
 	capabilities CapabilitySet
 }
 
-func (msg *CapCommand) String() string {
-	return fmt.Sprintf("CAP(subCommand=%s, capabilities=%s)",
-		msg.subCommand, msg.capabilities)
-}
-
-func NewCapCommand(args []string) (Command, error) {
+func ParseCapCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 	hostname   Name // looked up in socket thread
 }
 
-func (msg *ProxyCommand) String() string {
-	return fmt.Sprintf("PROXY(sourceIP=%s, sourcePort=%s)", msg.sourceIP, msg.sourcePort)
+func NewProxyCommand(hostname Name) *ProxyCommand {
+	cmd := &ProxyCommand{
+		hostname: hostname,
+	}
+	cmd.code = PROXY
+	return cmd
 }
 
-func NewProxyCommand(args []string) (Command, error) {
+func ParseProxyCommand(args []string) (Command, error) {
 	if len(args) < 5 {
 		return nil, NotEnoughArgsError
 	}
 	away bool
 }
 
-func (msg *AwayCommand) String() string {
-	return fmt.Sprintf("AWAY(%s)", msg.text)
-}
-
-func NewAwayCommand(args []string) (Command, error) {
+func ParseAwayCommand(args []string) (Command, error) {
 	cmd := &AwayCommand{}
 
 	if len(args) > 0 {
 	nicks []Name
 }
 
-func (msg *IsOnCommand) String() string {
-	return fmt.Sprintf("ISON(nicks=%s)", msg.nicks)
-}
-
-func NewIsOnCommand(args []string) (Command, error) {
+func ParseIsOnCommand(args []string) (Command, error) {
 	if len(args) == 0 {
 		return nil, NotEnoughArgsError
 	}
 	target Name
 }
 
-func NewMOTDCommand(args []string) (Command, error) {
+func ParseMOTDCommand(args []string) (Command, error) {
 	cmd := &MOTDCommand{}
 	if len(args) > 0 {
 		cmd.target = NewName(args[0])
 	message Text
 }
 
-func (cmd *NoticeCommand) String() string {
-	return fmt.Sprintf("NOTICE(target=%s, message=%s)", cmd.target, cmd.message)
-}
-
-func NewNoticeCommand(args []string) (Command, error) {
+func ParseNoticeCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}
 	return msg.comment
 }
 
-func NewKickCommand(args []string) (Command, error) {
+func ParseKickCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}
 	target   Name
 }
 
-func NewListCommand(args []string) (Command, error) {
+func ParseListCommand(args []string) (Command, error) {
 	cmd := &ListCommand{}
 	if len(args) > 0 {
 		cmd.channels = NewNames(strings.Split(args[0], ","))
 	target   Name
 }
 
-func NewNamesCommand(args []string) (Command, error) {
+func ParseNamesCommand(args []string) (Command, error) {
 	cmd := &NamesCommand{}
 	if len(args) > 0 {
 		cmd.channels = NewNames(strings.Split(args[0], ","))
 	subCommand Name
 }
 
-func NewDebugCommand(args []string) (Command, error) {
+func ParseDebugCommand(args []string) (Command, error) {
 	if len(args) == 0 {
 		return nil, NotEnoughArgsError
 	}
 	target Name
 }
 
-func NewVersionCommand(args []string) (Command, error) {
+func ParseVersionCommand(args []string) (Command, error) {
 	cmd := &VersionCommand{}
 	if len(args) > 0 {
 		cmd.target = NewName(args[0])
 	channel  Name
 }
 
-func NewInviteCommand(args []string) (Command, error) {
+func ParseInviteCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}
 	}, nil
 }
 
-func NewTheaterCommand(args []string) (Command, error) {
+func ParseTheaterCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	} else if upperSubCmd := strings.ToUpper(args[0]); upperSubCmd == "IDENTIFY" && len(args) == 3 {
 	target Name
 }
 
-func NewTimeCommand(args []string) (Command, error) {
+func ParseTimeCommand(args []string) (Command, error) {
 	cmd := &TimeCommand{}
 	if len(args) > 0 {
 		cmd.target = NewName(args[0])
 	comment  Text
 }
 
-func NewKillCommand(args []string) (Command, error) {
+func ParseKillCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}
 	target    Name
 }
 
-func NewWhoWasCommand(args []string) (Command, error) {
+func ParseWhoWasCommand(args []string) (Command, error) {
 	if len(args) < 1 {
 		return nil, NotEnoughArgsError
 	}
 	return cmd, nil
 }
 
-func NewOperNickCommand(args []string) (Command, error) {
+func ParseOperNickCommand(args []string) (Command, error) {
 	if len(args) < 2 {
 		return nil, NotEnoughArgsError
 	}

irc/nickname.go

 package irc
 
-import (
-	"fmt"
-)
-
 type NickCommand struct {
 	BaseCommand
 	nickname Name
 }
 
-func (m *NickCommand) String() string {
-	return fmt.Sprintf("NICK(nickname=%s)", m.nickname)
-}
-
 func (m *NickCommand) HandleRegServer(s *Server) {
 	client := m.Client()
 	if !client.authorized {
 		return
 	}
 
+	if msg.nick == client.nick {
+		return
+	}
+
 	target := server.clients.Get(msg.target)
 	if target == nil {
 		client.ErrNoSuchNick(msg.target)
 		return
 	}
 
+	if server.clients.Get(msg.nick) != nil {
+		client.ErrNickNameInUse(msg.nick)
+		return
+	}
+
 	target.ChangeNickname(msg.nick)
 }

irc/reply.go

 	for to < len(names) {
 		if (from < (to - 1)) && tooLong(names[from:to]) {
 			target.NumericReply(code, format, argsAndNames(names[from:to-1])...)
-			from, to = to-1, to
+			from = to - 1
 		} else {
 			to += 1
 		}

irc/server.go

 
 func (server *Server) processCommand(cmd Command) {
 	client := cmd.Client()
-	Log.debug.Printf("%s → %s %s", client, server, cmd)
+	Log.debug.Printf("%s → %+v", client, cmd)
 
 	if !client.registered {
 		regCmd, ok := cmd.(RegServerCommand)
 		server.Reply(client, "OK")
 
 	case "GCSTATS":
-		stats := &debug.GCStats{
+		stats := debug.GCStats{
+			Pause:          make([]time.Duration, 10),
 			PauseQuantiles: make([]time.Duration, 5),
 		}
+		debug.ReadGCStats(&stats)
 		server.Reply(client, "last GC:     %s", stats.LastGC.Format(time.RFC1123))
 		server.Reply(client, "num GC:      %d", stats.NumGC)
 		server.Reply(client, "pause total: %s", stats.PauseTotal)
 		server.Reply(client, "num goroutines: %d", count)
 
 	case "PROFILEHEAP":
-		file, err := os.Create("ergonomadic.heap.prof")
+		profFile := "ergonomadic-heap.prof"
+		file, err := os.Create(profFile)
 		if err != nil {
 			log.Printf("error: %s", err)
 			break
 		}
 		defer file.Close()
 		pprof.Lookup("heap").WriteTo(file, 0)
-		server.Reply(client, "written to ergonomadic-heap.prof")
+		server.Reply(client, "written to %s", profFile)
 	}
 }
 

irc/socket.go

 	"bufio"
 	"io"
 	"net"
-	"strings"
 )
 
 const (
 
 type Socket struct {
 	conn   net.Conn
-	reader *bufio.Reader
 	writer *bufio.Writer
 }
 
 func NewSocket(conn net.Conn, commands chan<- Command) *Socket {
 	socket := &Socket{
 		conn:   conn,
-		reader: bufio.NewReader(conn),
 		writer: bufio.NewWriter(conn),
 	}
 
 }
 
 func (socket *Socket) readLines(commands chan<- Command) {
-	commands <- &ProxyCommand{
-		hostname: AddrLookupHostname(socket.conn.RemoteAddr()),
-	}
+	commands <- NewProxyCommand(AddrLookupHostname(socket.conn.RemoteAddr()))
 
-	for {
-		line, err := socket.reader.ReadString('\n')
-		if socket.isError(err, R) {
-			break
-		}
-		line = strings.TrimRight(line, CRLF)
+	scanner := bufio.NewScanner(socket.conn)
+	for scanner.Scan() {
+		line := scanner.Text()
 		if len(line) == 0 {
 			continue
 		}
 		commands <- msg
 	}
 
-	commands <- &QuitCommand{
-		message: "connection closed",
+	if err := scanner.Err(); err != nil {
+		Log.debug.Printf("%s error: %s", socket, err)
 	}
+
+	commands <- NewQuitCommand("connection closed")
+
+	close(commands)
 }
 
 func (socket *Socket) Write(line string) (err error) {

irc/theater.go

 package irc
 
-import (
-	"fmt"
-)
-
 type TheaterClient Name
 
 func (c TheaterClient) Id() Name {
 	m.hash = s.theaters[m.channel]
 }
 
-func (cmd *TheaterIdentifyCommand) String() string {
-	return fmt.Sprintf("THEATER_IDENTIFY(channel=%s)", cmd.channel)
-}
-
 func (m *TheaterIdentifyCommand) HandleServer(s *Server) {
 	client := m.Client()
 	if !m.channel.IsChannel() {
 	message Text
 }
 
-func (cmd *TheaterPrivMsgCommand) String() string {
-	return fmt.Sprintf("THEATER_PRIVMSG(channel=%s, asNick=%s, message=%s)", cmd.channel, cmd.asNick, cmd.message)
-
-}
 func (m *TheaterPrivMsgCommand) HandleServer(s *Server) {
 	client := m.Client()
 
 		return
 	}
 
+	reply := RplPrivMsg(TheaterClient(m.asNick), channel, m.message)
 	for member := range channel.members {
-		member.Reply(RplPrivMsg(TheaterClient(m.asNick), channel, m.message))
+		member.Reply(reply)
 	}
 }
 
 	action  CTCPText
 }
 
-func (cmd *TheaterActionCommand) String() string {
-	return fmt.Sprintf("THEATER_ACTION(channel=%s, asNick=%s, action=%s)", cmd.channel, cmd.asNick, cmd.action)
-}
-
 func (m *TheaterActionCommand) HandleServer(s *Server) {
 	client := m.Client()
 
 		return
 	}
 
+	reply := RplCTCPAction(TheaterClient(m.asNick), channel, m.action)
 	for member := range channel.members {
-		member.Reply(RplCTCPAction(TheaterClient(m.asNick), channel, m.action))
+		member.Reply(reply)
 	}
 }