mirror/goirc
1
0
Fork 0
mirror of https://github.com/fluffle/goirc synced 2025-11-04 03:58:03 +00:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'fluffle/master' into commandmerge

Browse source 
Conflicts:
	README.md
	client.go
	client/connection.go
	client/connection_test.go
	client/dispatch.go
	client/dispatch_test.go
	client/handlers.go
	client/handlers_test.go
This commit is contained in:
Chris Rhodes 2013-02-17 19:03:23 -08:00
commit 930f29959b
10 changed files with 219 additions and 186 deletions
Download patch file Download diff file Expand all files Collapse all files

6
client/commands.go
View file

@ -3,9 +3,9 @@ package client
import "strings"
const (
INIT = "init"
CONNECTED = "connected"
DISCONNECTED = "disconnected"
REGISTER = "REGISTER"
CONNECTED = "CONNECTED"
DISCONNECTED = "DISCONNECTED"
ACTION = "ACTION"
AWAY = "AWAY"
CTCP = "CTCP"

144
client/connection.go
View file

@ -14,36 +14,46 @@ import (
// An IRC connection is represented by this struct.
type Conn struct {
// Connection Hostname and Nickname
Host string
Me *state.Nick
Network string
password string
// Connection related vars people will care about
Me *state.Nick
Host string
Network string
Connected bool
// Deprecated: future work to turn Conn into an interface will break this.
// Use the State field to store external state that handlers might need.
State interface{}
// Contains parameters that people can tweak to change client behaviour.
cfg *Config
// Handlers and Commands
handlers *handlerSet
commands *commandList
// State tracker for nicks and channels
ST state.StateTracker
st bool
st state.Tracker
stRemovers []Remover
// Use the State field to store external state that handlers might need.
// Remember ... you might need locking for this ;-)
State interface{}
// I/O stuff to server
sock net.Conn
io *bufio.ReadWriter
in chan *Line
out chan string
Connected bool
sock net.Conn
io *bufio.ReadWriter
in chan *Line
out chan string
// Control channels to goroutines
cSend, cLoop, cPing chan bool
// Misc knobs to tweak client behaviour:
// Internal counters for flood protection
badness time.Duration
lastsent time.Time
}
// Misc knobs to tweak client behaviour go in here
type Config struct {
// Set this to provide the Nick, Ident and Name for the client to use.
Me *state.Nick
// Are we connecting via SSL? Do we care about certificate validity?
SSL bool
SSLConfig *tls.Config
@ -59,16 +69,9 @@ type Conn struct {
// Set this to true to disable flood protection and false to re-enable
Flood bool
// Internal counters for flood protection
badness time.Duration
lastsent time.Time
}
// Creates a new IRC connection object, but doesn't connect to anything so
// that you can add event handlers to it. See AddHandler() for details
func Client(nick string, args ...string) *Conn {
logging.InitFromFlags()
func NewConfig(nick string, args ...string) *Config {
ident := "goirc"
name := "Powered by GoIRC"
@ -78,7 +81,30 @@ func Client(nick string, args ...string) *Conn {
if len(args) > 1 && args[1] != "" {
name = args[1]
}
cfg := &Config{
PingFreq: 3 * time.Minute,
NewNick: func(s string) string { return s + "_" },
}
cfg.Me = state.NewNick(nick)
cfg.Me.Ident = ident
cfg.Me.Name = name
return cfg
}
// Creates a new IRC connection object, but doesn't connect to anything so
// that you can add event handlers to it. See AddHandler() for details
func SimpleClient(nick string, args ...string) (*Conn, error) {
return Client(NewConfig(nick, args...))
}
func Client(cfg *Config) (*Conn, error) {
logging.InitFromFlags()
if cfg.Me == nil || cfg.Me.Nick == "" || cfg.Me.Ident == "" {
return nil, fmt.Errorf("Must provide a valid state.Nick in cfg.Me.")
}
conn := &Conn{
Me: cfg.Me,
cfg: cfg,
in: make(chan *Line, 32),
out: make(chan string, 32),
cSend: make(chan bool),
@ -87,46 +113,46 @@ func Client(nick string, args ...string) *Conn {
handlers: newHandlerSet(),
commands: newCommandList(),
stRemovers: make([]Remover, 0, len(stHandlers)),
PingFreq: 3 * time.Minute,
NewNick: func(s string) string { return s + "_" },
lastsent: time.Now(),
}
conn.addIntHandlers()
conn.Me = state.NewNick(nick)
conn.Me.Ident = ident
conn.Me.Name = name
conn.initialise()
return conn
return conn, nil
}
func (conn *Conn) Config() *Config {
return conn.cfg
}
func (conn *Conn) EnableStateTracking() {
if !conn.st {
if conn.st == nil {
n := conn.Me
conn.ST = state.NewTracker(n.Nick)
conn.Me = conn.ST.Me()
conn.st = state.NewTracker(n.Nick)
conn.Me = conn.st.Me()
conn.Me.Ident = n.Ident
conn.Me.Name = n.Name
conn.addSTHandlers()
conn.st = true
}
}
func (conn *Conn) DisableStateTracking() {
if conn.st {
conn.st = false
if conn.st != nil {
conn.delSTHandlers()
conn.ST.Wipe()
conn.ST = nil
conn.st.Wipe()
conn.st = nil
}
}
func (conn *Conn) StateTracker() state.Tracker {
return conn.st
}
// Per-connection state initialisation.
func (conn *Conn) initialise() {
conn.io = nil
conn.sock = nil
if conn.st {
conn.ST.Wipe()
if conn.st != nil {
conn.st.Wipe()
}
}
@ -142,12 +168,12 @@ func (conn *Conn) Connect(host string, pass ...string) error {
conn.Host, host))
}
if conn.SSL {
if conn.cfg.SSL {
if !hasPort(host) {
host += ":6697"
}
logging.Info("irc.Connect(): Connecting to %s with SSL.", host)
if s, err := tls.Dial("tcp", host, conn.SSLConfig); err == nil {
if s, err := tls.Dial("tcp", host, conn.cfg.SSLConfig); err == nil {
conn.sock = s
} else {
return err
@ -165,13 +191,13 @@ func (conn *Conn) Connect(host string, pass ...string) error {
}
conn.Host = host
conn.Connected = true
if len(pass) > 0 {
conn.password = pass[0]
} else {
conn.password = ""
}
conn.postConnect()
conn.dispatch(&Line{Cmd: INIT})
if len(pass) > 0 {
conn.Pass(pass[0])
}
conn.Nick(conn.Me.Nick)
conn.User(conn.Me.Ident, conn.Me.Name)
return nil
}
@ -182,7 +208,7 @@ func (conn *Conn) postConnect() {
bufio.NewWriter(conn.sock))
go conn.send()
go conn.recv()
if conn.PingFreq > 0 {
if conn.cfg.PingFreq > 0 {
go conn.ping()
} else {
// Otherwise the send in shutdown will hang :-/
@ -232,11 +258,11 @@ func (conn *Conn) recv() {
// Repeatedly pings the server every PingFreq seconds (no matter what)
func (conn *Conn) ping() {
tick := time.NewTicker(conn.PingFreq)
tick := time.NewTicker(conn.cfg.PingFreq)
for {
select {
case <-tick.C:
conn.Ping(fmt.Sprintf("%d", time.Now().UnixNano()))
conn.Raw(fmt.Sprintf("PING :%d", time.Now().UnixNano()))
case <-conn.cPing:
tick.Stop()
return
@ -258,9 +284,9 @@ func (conn *Conn) runLoop() {
}
// Write a \r\n terminated line of output to the connected server,
// using Hybrid's algorithm to rate limit if conn.Flood is false.
// using Hybrid's algorithm to rate limit if conn.cfg.Flood is false.
func (conn *Conn) write(line string) {
if !conn.Flood {
if !conn.cfg.Flood {
if t := conn.rateLimit(len(line)); t != 0 {
// sleep for the current line's time value before sending it
logging.Debug("irc.rateLimit(): Flood! Sleeping for %.2f secs.",
@ -303,10 +329,10 @@ func (conn *Conn) rateLimit(chars int) time.Duration {
func (conn *Conn) shutdown() {
// Guard against double-call of shutdown() if we get an error in send()
// as calling sock.Close() will cause recv() to recieve EOF in readstring()
// as calling sock.Close() will cause recv() to receive EOF in readstring()
if conn.Connected {
logging.Info("irc.shutdown(): Disconnected from server.")
conn.dispatch(&Line{Cmd: DISCONNECTED})
conn.dispatch(&Line{Cmd: "disconnected"})
conn.Connected = false
conn.sock.Close()
conn.cSend <- true
@ -329,8 +355,8 @@ func (conn *Conn) String() string {
str += "Not currently connected!\n\n"
}
str += conn.Me.String() + "\n"
if conn.st {
str += conn.ST.String() + "\n"
if conn.st != nil {
str += conn.st.String() + "\n"
}
return str
}

27
client/connection_test.go
View file

@ -12,22 +12,21 @@ import (
type testState struct {
ctrl *gomock.Controller
st *state.MockStateTracker
st *state.MockTracker
nc *mockNetConn
c *Conn
}
func setUp(t *testing.T, start ...bool) (*Conn, *testState) {
ctrl := gomock.NewController(t)
st := state.NewMockStateTracker(ctrl)
st := state.NewMockTracker(ctrl)
nc := MockNetConn(t)
c := Client("test", "test", "Testing IRC")
c, _ := SimpleClient("test", "test", "Testing IRC")
logging.SetLogLevel(logging.LogFatal)
c.ST = st
c.st = true
c.st = st
c.sock = nc
c.Flood = true // Tests can take a while otherwise
c.cfg.Flood = true // Tests can take a while otherwise
c.Connected = true
if len(start) == 0 {
// Hack to allow tests of send, recv, write etc.
@ -83,8 +82,8 @@ func TestEOF(t *testing.T) {
func TestClientAndStateTracking(t *testing.T) {
ctrl := gomock.NewController(t)
st := state.NewMockStateTracker(ctrl)
c := Client("test", "test", "Testing IRC")
st := state.NewMockTracker(ctrl)
c, _ := SimpleClient("test", "test", "Testing IRC")
// Assert some basic things about the initial state of the Conn struct
if c.Me.Nick != "test" || c.Me.Ident != "test" ||
@ -115,16 +114,16 @@ func TestClientAndStateTracking(t *testing.T) {
c.Me.Name != "Testing IRC" || c.Me.Host != "" {
t.Errorf("Enabling state tracking did not replace Me correctly.")
}
if !c.st || c.ST == nil || c.Me != c.ST.Me() {
if c.st == nil || c.Me != c.st.Me() {
t.Errorf("State tracker not enabled correctly.")
}
// Now, shim in the mock state tracker and test disabling state tracking
me := c.Me
c.ST = st
c.st = st
st.EXPECT().Wipe()
c.DisableStateTracking()
if c.st || c.ST != nil || c.Me != me {
if c.st != nil || c.Me != me {
t.Errorf("State tracker not disabled correctly.")
}
@ -280,7 +279,7 @@ func TestPing(t *testing.T) {
defer s.ctrl.Finish()
// Set a low ping frequency for testing.
c.PingFreq = 50 * time.Millisecond
c.cfg.PingFreq = 50 * time.Millisecond
// reader is a helper to do a "non-blocking" read of c.out
reader := func() string {
@ -431,13 +430,13 @@ func TestWrite(t *testing.T) {
c.write("yo momma")
s.nc.Expect("yo momma")
// Flood control is disabled -- setUp sets c.Flood = true -- so we should
// Flood control is disabled -- setUp sets c.cfg.Flood = true -- so we should
// not have set c.badness at this point.
if c.badness != 0 {
t.Errorf("Flood control used when Flood = true.")
}
c.Flood = false
c.cfg.Flood = false
c.write("she so useless")
s.nc.Expect("she so useless")

2
client/dispatch.go
View file

@ -185,7 +185,7 @@ var SimpleCommandRegex string = `^!%v(\s|$)`
func (conn *Conn) SimpleCommand(prefix string, handler Handler) Remover {
stripHandler := func(conn *Conn, line *Line) {
text := line.Message()
if conn.SimpleCommandStripPrefix {
if conn.cfg.SimpleCommandStripPrefix {
text = strings.TrimSpace(text[len(prefix):])
}
if text != line.Message() {

44
client/handlers.go
View file

@ -9,13 +9,13 @@ import (
// sets up the internal event handlers to do essential IRC protocol things
var intHandlers = map[string]HandlerFunc{
INIT: (*Conn).h_init,
"001": (*Conn).h_001,
"433": (*Conn).h_433,
CTCP: (*Conn).h_CTCP,
NICK: (*Conn).h_NICK,
PING: (*Conn).h_PING,
PRIVMSG: (*Conn).h_PRIVMSG,
REGISTER: (*Conn).h_REGISTER,
"001": (*Conn).h_001,
"433": (*Conn).h_433,
CTCP: (*Conn).h_CTCP,
NICK: (*Conn).h_NICK,
PING: (*Conn).h_PING,
PRIVMSG: (*Conn).h_PRIVMSG,
}
func (conn *Conn) addIntHandlers() {
@ -26,20 +26,20 @@ func (conn *Conn) addIntHandlers() {
}
}
// Password/User/Nick broadcast on connection.
func (conn *Conn) h_init(line *Line) {
if conn.password != "" {
conn.Pass(conn.password)
}
conn.Nick(conn.Me.Nick)
conn.User(conn.Me.Ident, conn.Me.Name)
}
// Basic ping/pong handler
func (conn *Conn) h_PING(line *Line) {
conn.Pong(line.Args[0])
}
// Handler for initial registration with server once tcp connection is made.
func (conn *Conn) h_REGISTER(line *Line) {
if conn.cfg.Pass != "" {
conn.Pass(conn.cfg.Pass)
}
conn.Nick(conn.cfg.Me.Nick)
conn.User(conn.cfg.Me.Ident, conn.cfg.Me.Name)
}
// Handler to trigger a "CONNECTED" event on receipt of numeric 001
func (conn *Conn) h_001(line *Line) {
// we're connected!
@ -65,14 +65,14 @@ func (conn *Conn) h_001(line *Line) {
// Handler to deal with "433 :Nickname already in use"
func (conn *Conn) h_433(line *Line) {
// Args[1] is the new nick we were attempting to acquire
neu := conn.NewNick(line.Args[1])
neu := conn.cfg.NewNick(line.Args[1])
conn.Nick(neu)
// if this is happening before we're properly connected (i.e. the nick
// we sent in the initial NICK command is in use) we will not receive
// a NICK message to confirm our change of nick, so ReNick here...
if line.Args[1] == conn.Me.Nick {
if conn.st {
conn.ST.ReNick(conn.Me.Nick, neu)
if conn.st != nil {
conn.st.ReNick(conn.Me.Nick, neu)
} else {
conn.Me.Nick = neu
}
@ -90,15 +90,15 @@ func (conn *Conn) h_CTCP(line *Line) {
// Handle updating our own NICK if we're not using the state tracker
func (conn *Conn) h_NICK(line *Line) {
if !conn.st && line.Nick == conn.Me.Nick {
conn.Me.Nick = line.Args[0]
if conn.st == nil && line.Nick == conn.cfg.Me.Nick {
conn.cfg.Me.Nick = line.Args[0]
}
}
// Handle PRIVMSGs that trigger Commands
func (conn *Conn) h_PRIVMSG(line *Line) {
text := line.Message()
if conn.CommandStripNick && strings.HasPrefix(text, conn.Me.Nick) {
if conn.cfg.CommandStripNick && strings.HasPrefix(text, conn.Me.Nick) {
// Look for '^${nick}[:;>,-]? '
l := len(conn.Me.Nick)
switch text[l] {

16
client/handlers_test.go
View file

@ -74,14 +74,14 @@ func Test433(t *testing.T) {
}
// Test the code path that *doesn't* involve state tracking.
c.st = false
c.st = nil
c.h_433(parseLine(":irc.server.org 433 test test :Nickname is already in use."))
s.nc.Expect("NICK test_")
if c.Me.Nick != "test_" {
t.Errorf("My nick not updated from '%s'.", c.Me.Nick)
}
c.st = true
c.st = s.st
}
// Test the handler for NICK messages when state tracking is disabled
@ -90,7 +90,7 @@ func TestNICK(t *testing.T) {
defer s.tearDown()
// State tracking is enabled by default in setUp
c.st = false
c.st = nil
// Call handler with a NICK line changing "our" nick to test1.
c.h_NICK(parseLine(":test!test@somehost.com NICK :test1"))
@ -109,7 +109,7 @@ func TestNICK(t *testing.T) {
}
// Re-enable state tracking and send a line that *should* change nick.
c.st = true
c.st = s.st
c.h_NICK(parseLine(":test1!test@somehost.com NICK :test2"))
// Verify that our Nick hasn't changed (should be handled by h_STNICK).
@ -159,26 +159,26 @@ func TestPRIVMSG(t *testing.T) {
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar"))
s.nc.ExpectNothing()
c.CommandStripNick = true
c.cfg.CommandStripNick = true
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :prefix bar"))
s.nc.Expect("PRIVMSG #foo :prefix bar")
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar"))
s.nc.Expect("PRIVMSG #foo :prefix bar")
c.SimpleCommandStripPrefix = true
c.cfg.SimpleCommandStripPrefix = true
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :prefix bar"))
s.nc.Expect("PRIVMSG #foo :bar")
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar"))
s.nc.Expect("PRIVMSG #foo :bar")
c.CommandStripNick = false
c.cfg.CommandStripNick = false
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :prefix bar"))
s.nc.Expect("PRIVMSG #foo :bar")
c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar"))
s.nc.ExpectNothing()
// Check the various nick addressing notations that are supported.
c.CommandStripNick = true
c.cfg.CommandStripNick = true
for _, addr := range []string{":", ";", ",", ">", "-", ""} {
c.h_PRIVMSG(parseLine(fmt.Sprintf(
":blah!moo@cows.com PRIVMSG #foo :test%s prefix bar", addr)))

48
client/state_handlers.go
View file

@ -40,13 +40,13 @@ func (conn *Conn) delSTHandlers() {
// Handle NICK messages that need to update the state tracker
func (conn *Conn) h_STNICK(line *Line) {
// all nicks should be handled the same way, our own included
conn.ST.ReNick(line.Nick, line.Args[0])
conn.st.ReNick(line.Nick, line.Args[0])
}
// Handle JOINs to channels to maintain state
func (conn *Conn) h_JOIN(line *Line) {
ch := conn.ST.GetChannel(line.Args[0])
nk := conn.ST.GetNick(line.Nick)
ch := conn.st.GetChannel(line.Args[0])
nk := conn.st.GetNick(line.Nick)
if ch == nil {
// first we've seen of this channel, so should be us joining it
// NOTE this will also take care of nk == nil && ch == nil
@ -55,7 +55,7 @@ func (conn *Conn) h_JOIN(line *Line) {
"from (non-me) nick %s", line.Args[0], line.Nick)
return
}
ch = conn.ST.NewChannel(line.Args[0])
ch = conn.st.NewChannel(line.Args[0])
// since we don't know much about this channel, ask server for info
// we get the channel users automatically in 353 and the channel
// topic in 332 on join, so we just need to get the modes
@ -66,41 +66,41 @@ func (conn *Conn) h_JOIN(line *Line) {
}
if nk == nil {
// this is the first we've seen of this nick
nk = conn.ST.NewNick(line.Nick)
nk = conn.st.NewNick(line.Nick)
nk.Ident = line.Ident
nk.Host = line.Host
// since we don't know much about this nick, ask server for info
conn.Who(nk.Nick)
}
// this takes care of both nick and channel linking \o/
conn.ST.Associate(ch, nk)
conn.st.Associate(ch, nk)
}
// Handle PARTs from channels to maintain state
func (conn *Conn) h_PART(line *Line) {
conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]),
conn.ST.GetNick(line.Nick))
conn.st.Dissociate(conn.st.GetChannel(line.Args[0]),
conn.st.GetNick(line.Nick))
}
// Handle KICKs from channels to maintain state
func (conn *Conn) h_KICK(line *Line) {
// XXX: this won't handle autorejoining channels on KICK
// it's trivial to do this in a seperate handler...
conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]),
conn.ST.GetNick(line.Args[1]))
conn.st.Dissociate(conn.st.GetChannel(line.Args[0]),
conn.st.GetNick(line.Args[1]))
}
// Handle other people's QUITs
func (conn *Conn) h_QUIT(line *Line) {
conn.ST.DelNick(line.Nick)
conn.st.DelNick(line.Nick)
}
// Handle MODE changes for channels we know about (and our nick personally)
func (conn *Conn) h_MODE(line *Line) {
if ch := conn.ST.GetChannel(line.Args[0]); ch != nil {
if ch := conn.st.GetChannel(line.Args[0]); ch != nil {
// channel modes first
ch.ParseModes(line.Args[1], line.Args[2:]...)
} else if nk := conn.ST.GetNick(line.Args[0]); nk != nil {
} else if nk := conn.st.GetNick(line.Args[0]); nk != nil {
// nick mode change, should be us
if nk != conn.Me {
logging.Warn("irc.MODE(): recieved MODE %s for (non-me) nick %s",
@ -116,7 +116,7 @@ func (conn *Conn) h_MODE(line *Line) {
// Handle TOPIC changes for channels
func (conn *Conn) h_TOPIC(line *Line) {
if ch := conn.ST.GetChannel(line.Args[0]); ch != nil {
if ch := conn.st.GetChannel(line.Args[0]); ch != nil {
ch.Topic = line.Args[1]
} else {
logging.Warn("irc.TOPIC(): topic change on unknown channel %s",
@ -126,7 +126,7 @@ func (conn *Conn) h_TOPIC(line *Line) {
// Handle 311 whois reply
func (conn *Conn) h_311(line *Line) {
if nk := conn.ST.GetNick(line.Args[1]); nk != nil {
if nk := conn.st.GetNick(line.Args[1]); nk != nil {
nk.Ident = line.Args[2]
nk.Host = line.Args[3]
nk.Name = line.Args[5]
@ -138,7 +138,7 @@ func (conn *Conn) h_311(line *Line) {
// Handle 324 mode reply
func (conn *Conn) h_324(line *Line) {
if ch := conn.ST.GetChannel(line.Args[1]); ch != nil {
if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
ch.ParseModes(line.Args[2], line.Args[3:]...)
} else {
logging.Warn("irc.324(): received MODE settings for unknown channel %s",
@ -148,7 +148,7 @@ func (conn *Conn) h_324(line *Line) {
// Handle 332 topic reply on join to channel
func (conn *Conn) h_332(line *Line) {
if ch := conn.ST.GetChannel(line.Args[1]); ch != nil {
if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
ch.Topic = line.Args[2]
} else {
logging.Warn("irc.332(): received TOPIC value for unknown channel %s",
@ -158,7 +158,7 @@ func (conn *Conn) h_332(line *Line) {
// Handle 352 who reply
func (conn *Conn) h_352(line *Line) {
if nk := conn.ST.GetNick(line.Args[5]); nk != nil {
if nk := conn.st.GetNick(line.Args[5]); nk != nil {
nk.Ident = line.Args[2]
nk.Host = line.Args[3]
// XXX: do we care about the actual server the nick is on?
@ -180,7 +180,7 @@ func (conn *Conn) h_352(line *Line) {
// Handle 353 names reply
func (conn *Conn) h_353(line *Line) {
if ch := conn.ST.GetChannel(line.Args[2]); ch != nil {
if ch := conn.st.GetChannel(line.Args[2]); ch != nil {
nicks := strings.Split(line.Args[len(line.Args)-1], " ")
for _, nick := range nicks {
// UnrealIRCd's coders are lazy and leave a trailing space
@ -192,15 +192,15 @@ func (conn *Conn) h_353(line *Line) {
nick = nick[1:]
fallthrough
default:
nk := conn.ST.GetNick(nick)
nk := conn.st.GetNick(nick)
if nk == nil {
// we don't know this nick yet!
nk = conn.ST.NewNick(nick)
nk = conn.st.NewNick(nick)
}
cp, ok := conn.ST.IsOn(ch.Name, nick)
cp, ok := conn.st.IsOn(ch.Name, nick)
if !ok {
// This nick isn't associated with this channel yet!
cp = conn.ST.Associate(ch, nk)
cp = conn.st.Associate(ch, nk)
}
switch c {
case '~':
@ -224,7 +224,7 @@ func (conn *Conn) h_353(line *Line) {
// Handle 671 whois reply (nick connected via SSL)
func (conn *Conn) h_671(line *Line) {
if nk := conn.ST.GetNick(line.Args[1]); nk != nil {
if nk := conn.st.GetNick(line.Args[1]); nk != nil {
nk.Modes.SSL = true
} else {
logging.Warn("irc.671(): received WHOIS SSL info for unknown nick %s",