summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/42wim
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/42wim')
-rw-r--r--vendor/github.com/42wim/go-gitter/.gitignore3
-rw-r--r--vendor/github.com/42wim/go-gitter/README.md154
-rw-r--r--vendor/github.com/42wim/go-ircevent/LICENSE27
-rw-r--r--vendor/github.com/42wim/go-ircevent/irc.go578
-rw-r--r--vendor/github.com/42wim/go-ircevent/irc_callback.go222
-rw-r--r--vendor/github.com/42wim/go-ircevent/irc_sasl.go53
-rw-r--r--vendor/github.com/42wim/go-ircevent/irc_struct.go76
-rw-r--r--vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go14
8 files changed, 157 insertions, 970 deletions
diff --git a/vendor/github.com/42wim/go-gitter/.gitignore b/vendor/github.com/42wim/go-gitter/.gitignore
new file mode 100644
index 00000000..f8601221
--- /dev/null
+++ b/vendor/github.com/42wim/go-gitter/.gitignore
@@ -0,0 +1,3 @@
+.idea
+/test
+app.yaml \ No newline at end of file
diff --git a/vendor/github.com/42wim/go-gitter/README.md b/vendor/github.com/42wim/go-gitter/README.md
new file mode 100644
index 00000000..5d58526d
--- /dev/null
+++ b/vendor/github.com/42wim/go-gitter/README.md
@@ -0,0 +1,154 @@
+# gitter
+Gitter API in Go
+https://developer.gitter.im
+
+#### Install
+
+`go get github.com/sromku/go-gitter`
+
+- [Initialize](#initialize)
+- [Users](#users)
+- [Rooms](#rooms)
+- [Messages](#messages)
+- [Stream](#stream)
+- [Faye (Experimental)](#faye-experimental)
+- [Debug](#debug)
+- [App Engine](#app-engine)
+
+##### Initialize
+``` Go
+api := gitter.New("YOUR_ACCESS_TOKEN")
+```
+
+##### Users
+
+- Get current user
+
+ ``` Go
+ user, err := api.GetUser()
+ ```
+
+##### Rooms
+
+- Get all rooms
+ ``` Go
+ rooms, err := api.GetRooms()
+ ```
+
+- Get room by id
+ ``` Go
+ room, err := api.GetRoom("roomID")
+ ```
+
+- Get rooms of some user
+ ``` Go
+ rooms, err := api.GetRooms("userID")
+ ```
+
+- Join room
+ ``` Go
+ room, err := api.JoinRoom("roomID", "userID")
+ ```
+
+- Leave room
+ ``` Go
+ room, err := api.LeaveRoom("roomID", "userID")
+ ```
+
+- Get room id
+ ``` Go
+ id, err := api.GetRoomId("room/uri")
+ ```
+
+- Search gitter rooms
+ ``` Go
+ rooms, err := api.SearchRooms("search/string")
+ ```
+##### Messages
+
+- Get messages of room
+ ``` Go
+ messages, err := api.GetMessages("roomID", nil)
+ ```
+
+- Get one message
+ ``` Go
+ message, err := api.GetMessage("roomID", "messageID")
+ ```
+
+- Send message
+ ``` Go
+ err := api.SendMessage("roomID", "free chat text")
+ ```
+
+##### Stream
+
+Create stream to the room and start listening to incoming messages
+
+``` Go
+stream := api.Stream(room.Id)
+go api.Listen(stream)
+
+for {
+ event := <-stream.Event
+ switch ev := event.Data.(type) {
+ case *gitter.MessageReceived:
+ fmt.Println(ev.Message.From.Username + ": " + ev.Message.Text)
+ case *gitter.GitterConnectionClosed:
+ // connection was closed
+ }
+}
+```
+
+Close stream connection
+
+``` Go
+stream.Close()
+```
+
+##### Faye (Experimental)
+
+``` Go
+faye := api.Faye(room.ID)
+go faye.Listen()
+
+for {
+ event := <-faye.Event
+ switch ev := event.Data.(type) {
+ case *gitter.MessageReceived:
+ fmt.Println(ev.Message.From.Username + ": " + ev.Message.Text)
+ case *gitter.GitterConnectionClosed: //this one is never called in Faye
+ // connection was closed
+ }
+}
+```
+
+##### Debug
+
+You can print the internal errors by enabling debug to true
+
+``` Go
+api.SetDebug(true, nil)
+```
+
+You can also define your own `io.Writer` in case you want to persist the logs somewhere.
+For example keeping the errors on file
+
+``` Go
+logFile, err := os.Create("gitter.log")
+api.SetDebug(true, logFile)
+```
+
+##### App Engine
+
+Initialize app engine client and continue as usual
+
+``` Go
+c := appengine.NewContext(r)
+client := urlfetch.Client(c)
+
+api := gitter.New("YOUR_ACCESS_TOKEN")
+api.SetClient(client)
+```
+
+[Documentation](https://godoc.org/github.com/sromku/go-gitter)
diff --git a/vendor/github.com/42wim/go-ircevent/LICENSE b/vendor/github.com/42wim/go-ircevent/LICENSE
deleted file mode 100644
index d6bf3577..00000000
--- a/vendor/github.com/42wim/go-ircevent/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2009 Thomas Jager. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/42wim/go-ircevent/irc.go b/vendor/github.com/42wim/go-ircevent/irc.go
deleted file mode 100644
index ea9c1f05..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc.go
+++ /dev/null
@@ -1,578 +0,0 @@
-// Copyright 2009 Thomas Jager <mail@jager.no> All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-This package provides an event based IRC client library. It allows to
-register callbacks for the events you need to handle. Its features
-include handling standard CTCP, reconnecting on errors and detecting
-stones servers.
-Details of the IRC protocol can be found in the following RFCs:
-https://tools.ietf.org/html/rfc1459
-https://tools.ietf.org/html/rfc2810
-https://tools.ietf.org/html/rfc2811
-https://tools.ietf.org/html/rfc2812
-https://tools.ietf.org/html/rfc2813
-The details of the client-to-client protocol (CTCP) can be found here: http://www.irchelp.org/irchelp/rfc/ctcpspec.html
-*/
-
-package irc
-
-import (
- "bufio"
- "bytes"
- "crypto/tls"
- "errors"
- "fmt"
- "log"
- "net"
- "os"
- "strconv"
- "strings"
- "time"
-)
-
-const (
- VERSION = "go-ircevent v2.1"
-)
-
-var ErrDisconnected = errors.New("Disconnect Called")
-
-// Read data from a connection. To be used as a goroutine.
-func (irc *Connection) readLoop() {
- defer irc.Done()
- br := bufio.NewReaderSize(irc.socket, 512)
-
- errChan := irc.ErrorChan()
-
- for {
- select {
- case <-irc.end:
- return
- default:
- // Set a read deadline based on the combined timeout and ping frequency
- // We should ALWAYS have received a response from the server within the timeout
- // after our own pings
- if irc.socket != nil {
- irc.socket.SetReadDeadline(time.Now().Add(irc.Timeout + irc.PingFreq))
- }
-
- msg, err := br.ReadString('\n')
-
- // We got past our blocking read, so bin timeout
- if irc.socket != nil {
- var zero time.Time
- irc.socket.SetReadDeadline(zero)
- }
-
- if err != nil {
- errChan <- err
- return
- }
-
- if irc.Debug {
- irc.Log.Printf("<-- %s\n", strings.TrimSpace(msg))
- }
-
- irc.Lock()
- irc.lastMessage = time.Now()
- irc.Unlock()
- event, err := parseToEvent(msg)
- event.Connection = irc
- if err == nil {
- /* XXX: len(args) == 0: args should be empty */
- irc.RunCallbacks(event)
- }
- }
- }
-}
-
-// Unescape tag values as defined in the IRCv3.2 message tags spec
-// http://ircv3.net/specs/core/message-tags-3.2.html
-func unescapeTagValue(value string) string {
- value = strings.Replace(value, "\\:", ";", -1)
- value = strings.Replace(value, "\\s", " ", -1)
- value = strings.Replace(value, "\\\\", "\\", -1)
- value = strings.Replace(value, "\\r", "\r", -1)
- value = strings.Replace(value, "\\n", "\n", -1)
- return value
-}
-
-//Parse raw irc messages
-func parseToEvent(msg string) (*Event, error) {
- msg = strings.TrimSuffix(msg, "\n") //Remove \r\n
- msg = strings.TrimSuffix(msg, "\r")
- event := &Event{Raw: msg}
- if len(msg) < 5 {
- return nil, errors.New("Malformed msg from server")
- }
-
- if msg[0] == '@' {
- // IRCv3 Message Tags
- if i := strings.Index(msg, " "); i > -1 {
- event.Tags = make(map[string]string)
- tags := strings.Split(msg[1:i], ";")
- for _, data := range tags {
- parts := strings.SplitN(data, "=", 2)
- if len(parts) == 1 {
- event.Tags[parts[0]] = ""
- } else {
- event.Tags[parts[0]] = unescapeTagValue(parts[1])
- }
- }
- msg = msg[i+1 : len(msg)]
- } else {
- return nil, errors.New("Malformed msg from server")
- }
- }
-
- if msg[0] == ':' {
- if i := strings.Index(msg, " "); i > -1 {
- event.Source = msg[1:i]
- msg = msg[i+1 : len(msg)]
-
- } else {
- return nil, errors.New("Malformed msg from server")
- }
-
- if i, j := strings.Index(event.Source, "!"), strings.Index(event.Source, "@"); i > -1 && j > -1 && i < j {
- event.Nick = event.Source[0:i]
- event.User = event.Source[i+1 : j]
- event.Host = event.Source[j+1 : len(event.Source)]
- }
- }
-
- split := strings.SplitN(msg, " :", 2)
- args := strings.Split(split[0], " ")
- event.Code = strings.ToUpper(args[0])
- event.Arguments = args[1:]
- if len(split) > 1 {
- event.Arguments = append(event.Arguments, split[1])
- }
- return event, nil
-
-}
-
-// Loop to write to a connection. To be used as a goroutine.
-func (irc *Connection) writeLoop() {
- defer irc.Done()
- errChan := irc.ErrorChan()
- for {
- select {
- case <-irc.end:
- return
- case b, ok := <-irc.pwrite:
- if !ok || b == "" || irc.socket == nil {
- return
- }
-
- if irc.Debug {
- irc.Log.Printf("--> %s\n", strings.TrimSpace(b))
- }
-
- // Set a write deadline based on the time out
- irc.socket.SetWriteDeadline(time.Now().Add(irc.Timeout))
-
- _, err := irc.socket.Write([]byte(b))
-
- // Past blocking write, bin timeout
- var zero time.Time
- irc.socket.SetWriteDeadline(zero)
-
- if err != nil {
- errChan <- err
- return
- }
- }
- }
-}
-
-// Pings the server if we have not received any messages for 5 minutes
-// to keep the connection alive. To be used as a goroutine.
-func (irc *Connection) pingLoop() {
- defer irc.Done()
- ticker := time.NewTicker(1 * time.Minute) // Tick every minute for monitoring
- ticker2 := time.NewTicker(irc.PingFreq) // Tick at the ping frequency.
- for {
- select {
- case <-ticker.C:
- //Ping if we haven't received anything from the server within the keep alive period
- if time.Since(irc.lastMessage) >= irc.KeepAlive {
- irc.SendRawf("PING %d", time.Now().UnixNano())
- }
- case <-ticker2.C:
- //Ping at the ping frequency
- irc.SendRawf("PING %d", time.Now().UnixNano())
- //Try to recapture nickname if it's not as configured.
- irc.Lock()
- if irc.nick != irc.nickcurrent {
- irc.nickcurrent = irc.nick
- irc.SendRawf("NICK %s", irc.nick)
- }
- irc.Unlock()
- case <-irc.end:
- ticker.Stop()
- ticker2.Stop()
- return
- }
- }
-}
-
-func (irc *Connection) isQuitting() bool {
- irc.Lock()
- defer irc.Unlock()
- return irc.quit
-}
-
-// Main loop to control the connection.
-func (irc *Connection) Loop() {
- errChan := irc.ErrorChan()
- connTime := time.Now()
- for !irc.isQuitting() {
- err := <-errChan
- close(irc.end)
- irc.Wait()
- for !irc.isQuitting() {
- irc.Log.Printf("Error, disconnected: %s\n", err)
- if time.Now().Sub(connTime) < time.Second*5 {
- irc.Log.Println("Rreconnecting too fast, sleeping 60 seconds")
- time.Sleep(60 * time.Second)
- }
- if err = irc.Reconnect(); err != nil {
- irc.Log.Printf("Error while reconnecting: %s\n", err)
- time.Sleep(60 * time.Second)
- } else {
- errChan = irc.ErrorChan()
- break
- }
- }
- connTime = time.Now()
- }
-}
-
-// Quit the current connection and disconnect from the server
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.1.6
-func (irc *Connection) Quit() {
- quit := "QUIT"
-
- if irc.QuitMessage != "" {
- quit = fmt.Sprintf("QUIT :%s", irc.QuitMessage)
- }
-
- irc.SendRaw(quit)
- irc.Lock()
- irc.stopped = true
- irc.quit = true
- irc.Unlock()
-}
-
-// Use the connection to join a given channel.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.2.1
-func (irc *Connection) Join(channel string) {
- irc.pwrite <- fmt.Sprintf("JOIN %s\r\n", channel)
-}
-
-// Leave a given channel.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.2.2
-func (irc *Connection) Part(channel string) {
- irc.pwrite <- fmt.Sprintf("PART %s\r\n", channel)
-}
-
-// Send a notification to a nickname. This is similar to Privmsg but must not receive replies.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.4.2
-func (irc *Connection) Notice(target, message string) {
- irc.pwrite <- fmt.Sprintf("NOTICE %s :%s\r\n", target, message)
-}
-
-// Send a formated notification to a nickname.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.4.2
-func (irc *Connection) Noticef(target, format string, a ...interface{}) {
- irc.Notice(target, fmt.Sprintf(format, a...))
-}
-
-// Send (action) message to a target (channel or nickname).
-// No clear RFC on this one...
-func (irc *Connection) Action(target, message string) {
- irc.pwrite <- fmt.Sprintf("PRIVMSG %s :\001ACTION %s\001\r\n", target, message)
-}
-
-// Send formatted (action) message to a target (channel or nickname).
-func (irc *Connection) Actionf(target, format string, a ...interface{}) {
- irc.Action(target, fmt.Sprintf(format, a...))
-}
-
-// Send (private) message to a target (channel or nickname).
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.4.1
-func (irc *Connection) Privmsg(target, message string) {
- irc.pwrite <- fmt.Sprintf("PRIVMSG %s :%s\r\n", target, message)
-}
-
-// Send formated string to specified target (channel or nickname).
-func (irc *Connection) Privmsgf(target, format string, a ...interface{}) {
- irc.Privmsg(target, fmt.Sprintf(format, a...))
-}
-
-// Kick <user> from <channel> with <msg>. For no message, pass empty string ("")
-func (irc *Connection) Kick(user, channel, msg string) {
- var cmd bytes.Buffer
- cmd.WriteString(fmt.Sprintf("KICK %s %s", channel, user))
- if msg != "" {
- cmd.WriteString(fmt.Sprintf(" :%s", msg))
- }
- cmd.WriteString("\r\n")
- irc.pwrite <- cmd.String()
-}
-
-// Kick all <users> from <channel> with <msg>. For no message, pass
-// empty string ("")
-func (irc *Connection) MultiKick(users []string, channel string, msg string) {
- var cmd bytes.Buffer
- cmd.WriteString(fmt.Sprintf("KICK %s %s", channel, strings.Join(users, ",")))
- if msg != "" {
- cmd.WriteString(fmt.Sprintf(" :%s", msg))
- }
- cmd.WriteString("\r\n")
- irc.pwrite <- cmd.String()
-}
-
-// Send raw string.
-func (irc *Connection) SendRaw(message string) {
- irc.pwrite <- message + "\r\n"
-}
-
-// Send raw formated string.
-func (irc *Connection) SendRawf(format string, a ...interface{}) {
- irc.SendRaw(fmt.Sprintf(format, a...))
-}
-
-// Set (new) nickname.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.1.2
-func (irc *Connection) Nick(n string) {
- irc.nick = n
- irc.SendRawf("NICK %s", n)
-}
-
-// Determine nick currently used with the connection.
-func (irc *Connection) GetNick() string {
- return irc.nickcurrent
-}
-
-// Query information about a particular nickname.
-// RFC 1459: https://tools.ietf.org/html/rfc1459#section-4.5.2
-func (irc *Connection) Whois(nick string) {
- irc.SendRawf("WHOIS %s", nick)
-}
-
-// Query information about a given nickname in the server.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.5.1
-func (irc *Connection) Who(nick string) {
- irc.SendRawf("WHO %s", nick)
-}
-
-// Set different modes for a target (channel or nickname).
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.2.3
-func (irc *Connection) Mode(target string, modestring ...string) {
- if len(modestring) > 0 {
- mode := strings.Join(modestring, " ")
- irc.SendRawf("MODE %s %s", target, mode)
- return
- }
- irc.SendRawf("MODE %s", target)
-}
-
-func (irc *Connection) ErrorChan() chan error {
- return irc.Error
-}
-
-// Returns true if the connection is connected to an IRC server.
-func (irc *Connection) Connected() bool {
- return !irc.stopped
-}
-
-// A disconnect sends all buffered messages (if possible),
-// stops all goroutines and then closes the socket.
-func (irc *Connection) Disconnect() {
- if irc.socket != nil {
- irc.socket.Close()
- }
- irc.ErrorChan() <- ErrDisconnected
-}
-
-// Reconnect to a server using the current connection.
-func (irc *Connection) Reconnect() error {
- irc.end = make(chan struct{})
- return irc.Connect(irc.Server)
-}
-
-// Connect to a given server using the current connection configuration.
-// This function also takes care of identification if a password is provided.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.1
-func (irc *Connection) Connect(server string) error {
- irc.Server = server
- // mark Server as stopped since there can be an error during connect
- irc.stopped = true
-
- // make sure everything is ready for connection
- if len(irc.Server) == 0 {
- return errors.New("empty 'server'")
- }
- if strings.Count(irc.Server, ":") != 1 {
- return errors.New("wrong number of ':' in address")
- }
- if strings.Index(irc.Server, ":") == 0 {
- return errors.New("hostname is missing")
- }
- if strings.Index(irc.Server, ":") == len(irc.Server)-1 {
- return errors.New("port missing")
- }
- // check for valid range
- ports := strings.Split(irc.Server, ":")[1]
- port, err := strconv.Atoi(ports)
- if err != nil {
- return errors.New("extracting port failed")
- }
- if !((port >= 0) && (port <= 65535)) {
- return errors.New("port number outside valid range")
- }
- if irc.Log == nil {
- return errors.New("'Log' points to nil")
- }
- if len(irc.nick) == 0 {
- return errors.New("empty 'nick'")
- }
- if len(irc.user) == 0 {
- return errors.New("empty 'user'")
- }
-
- if irc.UseTLS {
- dialer := &net.Dialer{Timeout: irc.Timeout}
- irc.socket, err = tls.DialWithDialer(dialer, "tcp", irc.Server, irc.TLSConfig)
- } else {
- irc.socket, err = net.DialTimeout("tcp", irc.Server, irc.Timeout)
- }
- if err != nil {
- return err
- }
-
- irc.stopped = false
- irc.Log.Printf("Connected to %s (%s)\n", irc.Server, irc.socket.RemoteAddr())
-
- irc.pwrite = make(chan string, 10)
- irc.Error = make(chan error, 2)
- irc.Add(3)
- go irc.readLoop()
- go irc.writeLoop()
- go irc.pingLoop()
- if len(irc.Password) > 0 {
- irc.pwrite <- fmt.Sprintf("PASS %s\r\n", irc.Password)
- }
-
- err = irc.negotiateCaps()
- if err != nil {
- return err
- }
-
- irc.pwrite <- fmt.Sprintf("NICK %s\r\n", irc.nick)
- irc.pwrite <- fmt.Sprintf("USER %s 0.0.0.0 0.0.0.0 :%s\r\n", irc.user, irc.user)
- return nil
-}
-
-// Negotiate IRCv3 capabilities
-func (irc *Connection) negotiateCaps() error {
- saslResChan := make(chan *SASLResult)
- if irc.UseSASL {
- irc.RequestCaps = append(irc.RequestCaps, "sasl")
- irc.setupSASLCallbacks(saslResChan)
- }
-
- if len(irc.RequestCaps) == 0 {
- return nil
- }
-
- cap_chan := make(chan bool, len(irc.RequestCaps))
- irc.AddCallback("CAP", func(e *Event) {
- if len(e.Arguments) != 3 {
- return
- }
- command := e.Arguments[1]
-
- if command == "LS" {
- missing_caps := len(irc.RequestCaps)
- for _, cap_name := range strings.Split(e.Arguments[2], " ") {
- for _, req_cap := range irc.RequestCaps {
- if cap_name == req_cap {
- irc.pwrite <- fmt.Sprintf("CAP REQ :%s\r\n", cap_name)
- missing_caps--
- }
- }
- }
-
- for i := 0; i < missing_caps; i++ {
- cap_chan <- true
- }
- } else if command == "ACK" || command == "NAK" {
- for _, cap_name := range strings.Split(strings.TrimSpace(e.Arguments[2]), " ") {
- if cap_name == "" {
- continue
- }
-
- if command == "ACK" {
- irc.AcknowledgedCaps = append(irc.AcknowledgedCaps, cap_name)
- }
- cap_chan <- true
- }
- }
- })
-
- irc.pwrite <- "CAP LS\r\n"
-
- if irc.UseSASL {
- select {
- case res := <-saslResChan:
- if res.Failed {
- close(saslResChan)
- return res.Err
- }
- case <-time.After(time.Second * 15):
- close(saslResChan)
- return errors.New("SASL setup timed out. This shouldn't happen.")
- }
- }
-
- // Wait for all capabilities to be ACKed or NAKed before ending negotiation
- for i := 0; i < len(irc.RequestCaps); i++ {
- <-cap_chan
- }
- irc.pwrite <- fmt.Sprintf("CAP END\r\n")
-
- return nil
-}
-
-// Create a connection with the (publicly visible) nickname and username.
-// The nickname is later used to address the user. Returns nil if nick
-// or user are empty.
-func IRC(nick, user string) *Connection {
- // catch invalid values
- if len(nick) == 0 {
- return nil
- }
- if len(user) == 0 {
- return nil
- }
-
- irc := &Connection{
- nick: nick,
- nickcurrent: nick,
- user: user,
- Log: log.New(os.Stdout, "", log.LstdFlags),
- end: make(chan struct{}),
- Version: VERSION,
- KeepAlive: 4 * time.Minute,
- Timeout: 1 * time.Minute,
- PingFreq: 15 * time.Minute,
- SASLMech: "PLAIN",
- QuitMessage: "",
- }
- irc.setupCallbacks()
- return irc
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_callback.go b/vendor/github.com/42wim/go-ircevent/irc_callback.go
deleted file mode 100644
index d389f731..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_callback.go
+++ /dev/null
@@ -1,222 +0,0 @@
-package irc
-
-import (
- "strconv"
- "strings"
- "time"
-)
-
-// Register a callback to a connection and event code. A callback is a function
-// which takes only an Event pointer as parameter. Valid event codes are all
-// IRC/CTCP commands and error/response codes. This function returns the ID of
-// the registered callback for later management.
-func (irc *Connection) AddCallback(eventcode string, callback func(*Event)) int {
- eventcode = strings.ToUpper(eventcode)
- id := 0
- if _, ok := irc.events[eventcode]; !ok {
- irc.events[eventcode] = make(map[int]func(*Event))
- id = 0
- } else {
- id = len(irc.events[eventcode])
- }
- irc.events[eventcode][id] = callback
- return id
-}
-
-// Remove callback i (ID) from the given event code. This functions returns
-// true upon success, false if any error occurs.
-func (irc *Connection) RemoveCallback(eventcode string, i int) bool {
- eventcode = strings.ToUpper(eventcode)
-
- if event, ok := irc.events[eventcode]; ok {
- if _, ok := event[i]; ok {
- delete(irc.events[eventcode], i)
- return true
- }
- irc.Log.Printf("Event found, but no callback found at id %d\n", i)
- return false
- }
-
- irc.Log.Println("Event not found")
- return false
-}
-
-// Remove all callbacks from a given event code. It returns true
-// if given event code is found and cleared.
-func (irc *Connection) ClearCallback(eventcode string) bool {
- eventcode = strings.ToUpper(eventcode)
-
- if _, ok := irc.events[eventcode]; ok {
- irc.events[eventcode] = make(map[int]func(*Event))
- return true
- }
-
- irc.Log.Println("Event not found")
- return false
-}
-
-// Replace callback i (ID) associated with a given event code with a new callback function.
-func (irc *Connection) ReplaceCallback(eventcode string, i int, callback func(*Event)) {
- eventcode = strings.ToUpper(eventcode)
-
- if event, ok := irc.events[eventcode]; ok {
- if _, ok := event[i]; ok {
- event[i] = callback
- return
- }
- irc.Log.Printf("Event found, but no callback found at id %d\n", i)
- }
- irc.Log.Printf("Event not found. Use AddCallBack\n")
-}
-
-// Execute all callbacks associated with a given event.
-func (irc *Connection) RunCallbacks(event *Event) {
- msg := event.Message()
- if event.Code == "PRIVMSG" && len(msg) > 2 && msg[0] == '\x01' {
- event.Code = "CTCP" //Unknown CTCP
-
- if i := strings.LastIndex(msg, "\x01"); i > 0 {
- msg = msg[1:i]
- } else {
- irc.Log.Printf("Invalid CTCP Message: %s\n", strconv.Quote(msg))
- return
- }
-
- if msg == "VERSION" {
- event.Code = "CTCP_VERSION"
-
- } else if msg == "TIME" {
- event.Code = "CTCP_TIME"
-
- } else if strings.HasPrefix(msg, "PING") {
- event.Code = "CTCP_PING"
-
- } else if msg == "USERINFO" {
- event.Code = "CTCP_USERINFO"
-
- } else if msg == "CLIENTINFO" {
- event.Code = "CTCP_CLIENTINFO"
-
- } else if strings.HasPrefix(msg, "ACTION") {
- event.Code = "CTCP_ACTION"
- if len(msg) > 6 {
- msg = msg[7:]
- } else {
- msg = ""
- }
- }
-
- event.Arguments[len(event.Arguments)-1] = msg
- }
-
- 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 {
- callback(event)
- }
- } else if irc.VerboseCallbackHandler {
- irc.Log.Printf("%v (0) >> %#v\n", event.Code, event)
- }
-
- if callbacks, ok := irc.events["*"]; ok {
- if irc.VerboseCallbackHandler {
- irc.Log.Printf("%v (0) >> %#v\n", event.Code, event)
- }
-
- for _, callback := range callbacks {
- callback(event)
- }
- }
-}
-
-// Set up some initial callbacks to handle the IRC/CTCP protocol.
-func (irc *Connection) setupCallbacks() {
- irc.events = make(map[string]map[int]func(*Event))
-
- //Handle error events.
- irc.AddCallback("ERROR", func(e *Event) { irc.Disconnect() })
-
- //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, irc.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()) })
-
- // 437: ERR_UNAVAILRESOURCE "<nick/channel> :Nick/channel is temporarily unavailable"
- // Add a _ to current nick. If irc.nickcurrent is empty this cannot
- // work. It has to be set somewhere first in case the nick is already
- // taken or unavailable from the beginning.
- irc.AddCallback("437", func(e *Event) {
- // If irc.nickcurrent hasn't been set yet, set to irc.nick
- if irc.nickcurrent == "" {
- irc.nickcurrent = irc.nick
- }
-
- if len(irc.nickcurrent) > 8 {
- irc.nickcurrent = "_" + irc.nickcurrent
- } else {
- irc.nickcurrent = irc.nickcurrent + "_"
- }
- irc.SendRawf("NICK %s", irc.nickcurrent)
- })
-
- // 433: ERR_NICKNAMEINUSE "<nick> :Nickname is already in use"
- // Add a _ to current nick.
- irc.AddCallback("433", func(e *Event) {
- // If irc.nickcurrent hasn't been set yet, set to irc.nick
- if irc.nickcurrent == "" {
- irc.nickcurrent = irc.nick
- }
-
- 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)
- if irc.Debug {
- irc.Log.Printf("Lag: %.3f s\n", delta.Seconds())
- }
- })
-
- // NICK Define a nickname.
- // Set irc.nickcurrent to the new nick actually used in this connection.
- irc.AddCallback("NICK", func(e *Event) {
- if e.Nick == irc.nick {
- irc.nickcurrent = e.Message()
- }
- })
-
- // 1: RPL_WELCOME "Welcome to the Internet Relay Network <nick>!<user>@<host>"
- // Set irc.nickcurrent to the actually used nick in this connection.
- irc.AddCallback("001", func(e *Event) {
- irc.Lock()
- irc.nickcurrent = e.Arguments[0]
- irc.Unlock()
- })
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_sasl.go b/vendor/github.com/42wim/go-ircevent/irc_sasl.go
deleted file mode 100644
index fd9df7ba..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_sasl.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package irc
-
-import (
- "encoding/base64"
- "errors"
- "fmt"
- "strings"
-)
-
-type SASLResult struct {
- Failed bool
- Err error
-}
-
-func (irc *Connection) setupSASLCallbacks(result chan<- *SASLResult) {
- irc.AddCallback("CAP", func(e *Event) {
- if len(e.Arguments) == 3 {
- if e.Arguments[1] == "LS" {
- if !strings.Contains(e.Arguments[2], "sasl") {
- result <- &SASLResult{true, errors.New("no SASL capability " + e.Arguments[2])}
- }
- }
- if e.Arguments[1] == "ACK" {
- if irc.SASLMech != "PLAIN" {
- result <- &SASLResult{true, errors.New("only PLAIN is supported")}
- }
- irc.SendRaw("AUTHENTICATE " + irc.SASLMech)
- }
- }
- })
- irc.AddCallback("AUTHENTICATE", func(e *Event) {
- str := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s\x00%s\x00%s", irc.SASLLogin, irc.SASLLogin, irc.SASLPassword)))
- irc.SendRaw("AUTHENTICATE " + str)
- })
- irc.AddCallback("901", func(e *Event) {
- irc.SendRaw("CAP END")
- irc.SendRaw("QUIT")
- result <- &SASLResult{true, errors.New(e.Arguments[1])}
- })
- irc.AddCallback("902", func(e *Event) {
- irc.SendRaw("CAP END")
- irc.SendRaw("QUIT")
- result <- &SASLResult{true, errors.New(e.Arguments[1])}
- })
- irc.AddCallback("903", func(e *Event) {
- result <- &SASLResult{false, nil}
- })
- irc.AddCallback("904", func(e *Event) {
- irc.SendRaw("CAP END")
- irc.SendRaw("QUIT")
- result <- &SASLResult{true, errors.New(e.Arguments[1])}
- })
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_struct.go b/vendor/github.com/42wim/go-ircevent/irc_struct.go
deleted file mode 100644
index c064cb80..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_struct.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2009 Thomas Jager <mail@jager.no> 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 (
- "crypto/tls"
- "log"
- "net"
- "sync"
- "time"
-)
-
-type Connection struct {
- sync.Mutex
- sync.WaitGroup
- Debug bool
- Error chan error
- Password string
- UseTLS bool
- UseSASL bool
- RequestCaps []string
- AcknowledgedCaps []string
- SASLLogin string
- SASLPassword string
- SASLMech string
- TLSConfig *tls.Config
- Version string
- Timeout time.Duration
- PingFreq time.Duration
- KeepAlive time.Duration
- Server string
-
- socket net.Conn
- pwrite chan string
- end chan struct{}
-
- nick string //The nickname we want.
- nickcurrent string //The nickname we currently have.
- user string
- registered bool
- events map[string]map[int]func(*Event)
-
- QuitMessage string
- lastMessage time.Time
-
- VerboseCallbackHandler bool
- Log *log.Logger
-
- stopped bool
- quit bool //User called Quit, do not reconnect.
-}
-
-// A struct to represent an event.
-type Event struct {
- Code string
- Raw string
- Nick string //<nick>
- Host string //<nick>!<usr>@<host>
- Source string //<host>
- User string //<usr>
- Arguments []string
- Tags map[string]string
- Connection *Connection
-}
-
-// Retrieve the last message from Event arguments.
-// This function leaves the arguments untouched and
-// returns an empty string if there are none.
-func (e *Event) Message() string {
- if len(e.Arguments) == 0 {
- return ""
- }
- return e.Arguments[len(e.Arguments)-1]
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go b/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go
deleted file mode 100644
index 82202e1c..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// +build gofuzz
-
-package irc
-
-func Fuzz(data []byte) int {
- b := bytes.NewBuffer(data)
- event, err := parseToEvent(b.String())
- if err == nil {
- irc := IRC("go-eventirc", "go-eventirc")
- irc.RunCallbacks(event)
- return 1
- }
- return 0
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 21:26:16 +0000