From a5f3a91fd10f090f8c54d7d3568b88b92ff39e29 Mon Sep 17 00:00:00 2001 From: Thomas Jager Date: Mon, 5 Nov 2012 23:46:47 +0100 Subject: [PATCH] go get not working quite as i thought --- irc.go | 216 ++++++++++++++++++++++++++++++++++++++++++++++++ irc_callback.go | 117 ++++++++++++++++++++++++++ irc_struct.go | 46 +++++++++++ irc_test.go | 35 ++++++++ 4 files changed, 414 insertions(+) create mode 100644 irc.go create mode 100644 irc_callback.go create mode 100644 irc_struct.go create mode 100644 irc_test.go diff --git a/irc.go b/irc.go new file mode 100644 index 0000000..1910704 --- /dev/null +++ b/irc.go @@ -0,0 +1,216 @@ +// Copyright 2009 Thomas Jager All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package irc + +import ( + "bufio" + "fmt" + "log" + "net" + "os" + "strings" + "time" +) + +const ( + VERSION = "GolangBOT v1.0" +) + +var error_ bool + +func reader(irc *Connection) { + br := bufio.NewReader(irc.socket) + for !error_ { + msg, err := br.ReadString('\n') + if err != nil { + irc.Error <- err + break + } + irc.lastMessage = time.Now() + msg = msg[0 : len(msg)-2] //Remove \r\n + event := &Event{Raw: msg} + if msg[0] == ':' { + if i := strings.Index(msg, " "); i > -1 { + event.Source = msg[1:i] + msg = msg[i+1 : len(msg)] + } else { + irc.log.Printf("Misformed msg from server: %#s\n", msg) + } + if i, j := strings.Index(event.Source, "!"), strings.Index(event.Source, "@"); i > -1 && j > -1 { + event.Nick = event.Source[0:i] + event.User = event.Source[i+1 : j] + event.Host = event.Source[j+1 : len(event.Source)] + } + } + args := strings.SplitN(msg, " :", 2) + if len(args) > 1 { + event.Message = args[1] + } + args = strings.Split(args[0], " ") + event.Code = strings.ToUpper(args[0]) + if len(args) > 1 { + event.Arguments = args[1:len(args)] + } + irc.RunCallbacks(event) + } + irc.syncreader <- true +} + +func writer(irc *Connection) { + b, ok := <-irc.pwrite + for !error_ && ok { + if b == "" || irc.socket == nil { + break + } + _, err := irc.socket.Write([]byte(b)) + if err != nil { + irc.log.Printf("%s\n", err) + irc.Error <- err + break + } + b, ok = <-irc.pwrite + } + irc.syncwriter <- true +} + +//Pings the server if we have not recived any messages for 5 minutes +func pinger(i *Connection) { + i.ticker = time.Tick(1 * time.Minute) //Tick every minute. + i.ticker2 = time.Tick(15 * time.Minute) //Tick every 15 minutes. + for { + select { + case <-i.ticker: + //Ping if we haven't recived anything from the server within 4 minutes + if time.Since(i.lastMessage) >= (4 * time.Minute) { + i.SendRawf("PING %d", time.Now().UnixNano()) + } + case <-i.ticker2: + //Ping every 15 minutes. + i.SendRawf("PING %d", time.Now().UnixNano()) + //Try to recapture nickname if it's not as configured. + if i.nick != i.nickcurrent { + i.nickcurrent = i.nick + i.SendRawf("NICK %s", i.nick) + } + } + } +} + +func (irc *Connection) Cycle() { + irc.SendRaw("QUIT") + irc.Reconnect() +} + +func (irc *Connection) Quit() { + irc.quitting = true + irc.SendRaw("QUIT") +} + +func (irc *Connection) Join(channel string) { + irc.pwrite <- fmt.Sprintf("JOIN %s\r\n", channel) +} + +func (irc *Connection) Part(channel string) { + irc.pwrite <- fmt.Sprintf("PART %s\r\n", channel) +} + +func (irc *Connection) Notice(target, message string) { + irc.pwrite <- fmt.Sprintf("NOTICE %s :%s\r\n", target, message) +} + +func (irc *Connection) Privmsg(target, message string) { + irc.pwrite <- fmt.Sprintf("PRIVMSG %s :%s\r\n", target, message) +} + +func (irc *Connection) SendRaw(message string) { + irc.log.Printf("--> %s\n", message) + irc.pwrite <- fmt.Sprintf("%s\r\n", message) +} + +func (irc *Connection) SendRawf(format string, a ...interface{}) { + irc.SendRaw(fmt.Sprintf(format, a...)) +} + +func (irc *Connection) GetNick() string { + return irc.nickcurrent +} + +func (i *Connection) Reconnect() error { + close(i.pwrite) + close(i.pread) + <-i.syncreader + <-i.syncwriter + for { + i.log.Printf("Reconnecting to %s\n", i.server) + var err error + i.socket, err = net.Dial("tcp", i.server) + if err == nil { + break + } + i.log.Printf("Error: %s\n", err) + } + error_ = false + i.log.Printf("Connected to %s (%s)\n", i.server, i.socket.RemoteAddr()) + go reader(i) + go writer(i) + i.pwrite <- fmt.Sprintf("NICK %s\r\n", i.nick) + i.pwrite <- fmt.Sprintf("USER %s 0.0.0.0 0.0.0.0 :%s\r\n", i.user, i.user) + return nil +} + +func (i *Connection) Loop() { + for !i.quitting { + e := <-i.Error + if i.quitting { + break + } + i.log.Printf("Error: %s\n", e) + error_ = true + i.Reconnect() + } + close(i.pwrite) + close(i.pread) + <-i.syncreader + <-i.syncwriter +} + +func (i *Connection) Connect(server string) error { + i.server = server + i.log.Printf("Connecting to %s\n", i.server) + var err error + i.socket, err = net.Dial("tcp", i.server) + if err != nil { + return err + } + i.log.Printf("Connected to %s (%s)\n", i.server, i.socket.RemoteAddr()) + i.pread = make(chan string, 100) + i.pwrite = make(chan string, 100) + i.Error = make(chan error, 10) + i.syncreader = make(chan bool) + i.syncwriter = make(chan bool) + go reader(i) + go writer(i) + go pinger(i) + i.pwrite <- fmt.Sprintf("NICK %s\r\n", i.nick) + i.pwrite <- fmt.Sprintf("USER %s 0.0.0.0 0.0.0.0 :%s\r\n", i.user, i.user) + if len(i.Password) > 0 { + i.pwrite <- fmt.Sprintf("PASS %s\r\n", i.Password) + } + return nil +} + +func IRC(nick, user string) *Connection { + irc := new(Connection) + irc.registered = false + irc.pread = make(chan string, 100) + irc.pwrite = make(chan string, 100) + irc.Error = make(chan error) + irc.nick = nick + irc.user = user + irc.VerboseCallbackHandler = false + irc.log = log.New(os.Stdout, "", log.LstdFlags) + irc.setupCallbacks() + return irc +} diff --git a/irc_callback.go b/irc_callback.go new file mode 100644 index 0000000..b8f4d69 --- /dev/null +++ b/irc_callback.go @@ -0,0 +1,117 @@ +package irc + +import ( + "strconv" + "strings" + "time" +) + +func (irc *Connection) AddCallback(eventcode string, callback func(*Event)) { + eventcode = strings.ToUpper(eventcode) + if _, ok := irc.events[eventcode]; ok { + irc.events[eventcode] = append(irc.events[eventcode], callback) + } else { + irc.events[eventcode] = make([]func(*Event), 1) + irc.events[eventcode][0] = callback + } +} + +func (irc *Connection) ReplaceCallback(eventcode string, i int, callback func(*Event)) { + eventcode = strings.ToUpper(eventcode) + if event, ok := irc.events[eventcode]; ok { + if i < len(event) { + event[i] = callback + return + } + irc.log.Printf("Event found, but no callback found at index %d. Use AddCallback\n", i) + return + } + irc.log.Printf("Event not found. Use AddCallBack\n") +} + +func (irc *Connection) RunCallbacks(event *Event) { + if event.Code == "PRIVMSG" && len(event.Message) > 0 && event.Message[0] == '\x01' { + event.Code = "CTCP" //Unknown CTCP + if i := strings.LastIndex(event.Message, "\x01"); i > -1 { + event.Message = event.Message[1:i] + } + if event.Message == "VERSION" { + event.Code = "CTCP_VERSION" + } else if event.Message == "TIME" { + event.Code = "CTCP_TIME" + } else if event.Message[0:4] == "PING" { + event.Code = "CTCP_PING" + } else if event.Message == "USERINFO" { + event.Code = "CTCP_USERINFO" + } else if event.Message == "CLIENTINFO" { + event.Code = "CTCP_CLIENTINFO" + } + } + if callbacks, ok := irc.events[event.Code]; ok { + if irc.VerboseCallbackHandler { + irc.log.Printf("%v (%v) >> %#v\n", event.Code, len(callbacks), event) + } + for _, callback := range callbacks { + go callback(event) + } + } else if irc.VerboseCallbackHandler { + irc.log.Printf("%v (0) >> %#v\n", event.Code, event) + } +} + +func (irc *Connection) setupCallbacks() { + irc.events = make(map[string][]func(*Event)) + + //Handle ping events + irc.AddCallback("PING", func(e *Event) { irc.SendRaw("PONG :" + e.Message) }) + + //Version handler + irc.AddCallback("CTCP_VERSION", func(e *Event) { + irc.SendRawf("NOTICE %s :\x01VERSION %s\x01", e.Nick, VERSION) + }) + + irc.AddCallback("CTCP_USERINFO", func(e *Event) { + irc.SendRawf("NOTICE %s :\x01USERINFO %s\x01", e.Nick, irc.user) + }) + + irc.AddCallback("CTCP_CLIENTINFO", func(e *Event) { + irc.SendRawf("NOTICE %s :\x01CLIENTINFO PING VERSION TIME USERINFO CLIENTINFO\x01", e.Nick) + }) + + irc.AddCallback("CTCP_TIME", func(e *Event) { + ltime := time.Now() + irc.SendRawf("NOTICE %s :\x01TIME %s\x01", e.Nick, ltime.String()) + }) + + irc.AddCallback("CTCP_PING", func(e *Event) { irc.SendRawf("NOTICE %s :\x01%s\x01", e.Nick, e.Message) }) + + irc.AddCallback("437", func(e *Event) { + irc.nickcurrent = irc.nickcurrent + "_" + irc.SendRawf("NICK %s", irc.nickcurrent) + }) + + irc.AddCallback("433", func(e *Event) { + if len(irc.nickcurrent) > 8 { + irc.nickcurrent = "_" + irc.nickcurrent + } else { + irc.nickcurrent = irc.nickcurrent + "_" + } + irc.SendRawf("NICK %s", irc.nickcurrent) + }) + + irc.AddCallback("PONG", func(e *Event) { + ns, _ := strconv.ParseInt(e.Message, 10, 64) + delta := time.Duration(time.Now().UnixNano() - ns) + irc.log.Printf("Lag: %vs\n", delta) + }) + + irc.AddCallback("NICK", func(e *Event) { + if e.Nick == irc.nick { + irc.nickcurrent = e.Arguments[0] + } + }) + + irc.AddCallback("001", func(e *Event) { + irc.nickcurrent = e.Arguments[0] + }) +} diff --git a/irc_struct.go b/irc_struct.go new file mode 100644 index 0000000..70c7176 --- /dev/null +++ b/irc_struct.go @@ -0,0 +1,46 @@ +// Copyright 2009 Thomas Jager All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package irc + +import ( + "log" + "net" + "time" +) + +type Connection struct { + socket net.Conn + pread, pwrite chan string + Error chan error + syncreader, syncwriter chan bool + nick string //The nickname we want. + nickcurrent string //The nickname we currently have. + user string + registered bool + server string + Password string + events map[string][]func(*Event) + + lastMessage time.Time + ticker <-chan time.Time + ticker2 <-chan time.Time + + VerboseCallbackHandler bool + log *log.Logger + + quitting bool +} + +type Event struct { + Code string + Message string + Raw string + Nick string // + Host string //!@ + Source string // + User string // + + Arguments []string +} diff --git a/irc_test.go b/irc_test.go new file mode 100644 index 0000000..b11a348 --- /dev/null +++ b/irc_test.go @@ -0,0 +1,35 @@ +package irc + +import ( + // irc "github.com/thoj/Go-IRC-Client-Library" + "fmt" + "testing" +) + + +func TestConnection(t *testing.T) { + irccon := IRC("invisible", "invisible") + + fmt.Printf("Testing connection\n") + + err := irccon.Connect("irc.freenode.net:6667") + + fmt.Printf("Connecting...") + + if err != nil { + t.Fatal("Can't connect to freenode.") + } + irccon.AddCallback("001", func(e *Event) { irccon.Join("#invisible") }) + + irccon.AddCallback("PRIVMSG" , func(e *Event) { + irccon.Privmsg("#invisible", "WHAT IS THIS\n") + fmt.Printf("Got private message, likely should respond!\n") + irccon.Privmsg(e.Nick , "WHAT") + + + }) + + irccon.Loop() + + +}