matterbridge/vendor/github.com/lrstanley/girc/event.go

639 lines
17 KiB
Go

// Copyright (c) Liam Stanley <me@liamstanley.io>. All rights reserved. Use
// of this source code is governed by the MIT license that can be found in
// the LICENSE file.
package girc
import (
"bytes"
"fmt"
"strings"
"time"
)
const (
eventSpace byte = ' ' // Separator.
maxLength int = 510 // Maximum length is 510 (2 for line endings).
)
// cutCRFunc is used to trim CR characters from prefixes/messages.
func cutCRFunc(r rune) bool {
return r == '\r' || r == '\n'
}
// ParseEvent takes a string and attempts to create a Event struct. Returns
// nil if the Event is invalid.
func ParseEvent(raw string) (e *Event) {
// Ignore empty events.
if raw = strings.TrimFunc(raw, cutCRFunc); len(raw) < 2 {
return nil
}
var i, j int
e = &Event{Timestamp: time.Now()}
if raw[0] == prefixTag {
// Tags end with a space.
i = strings.IndexByte(raw, eventSpace)
if i < 2 {
return nil
}
e.Tags = ParseTags(raw[1:i])
if rawServerTime, ok := e.Tags.Get("time"); ok {
// Attempt to parse server-time. If we can't parse it, we just
// fall back to the time we received the message (locally.)
if stime, err := time.Parse(capServerTimeFormat, rawServerTime); err == nil {
e.Timestamp = stime.Local()
}
}
raw = raw[i+1:]
i = 0
}
if raw[0] == messagePrefix {
// Prefix ends with a space.
i = strings.IndexByte(raw, eventSpace)
// Prefix string must not be empty if the indicator is present.
if i < 2 {
return nil
}
e.Source = ParseSource(raw[1:i])
// Skip space at the end of the prefix.
i++
}
// Find end of command.
j = i + strings.IndexByte(raw[i:], eventSpace)
if j < i {
// If there are no proceeding spaces, it's the only thing specified.
e.Command = strings.ToUpper(raw[i:])
return e
}
e.Command = strings.ToUpper(raw[i:j])
// Skip the space after the command.
j++
// Check if and where the trailing text is within the incoming line.
var lastIndex, trailerIndex int
for {
// We must loop through, as it's possible that the first message
// prefix is not actually what we want. (e.g, colons are commonly
// used within ISUPPORT to delegate things like CHANLIMIT or TARGMAX.)
lastIndex = trailerIndex
trailerIndex = strings.IndexByte(raw[j+lastIndex:], messagePrefix)
if trailerIndex == -1 {
// No trailing argument found, assume the rest is just params.
e.Params = strings.Fields(raw[j:])
return e
}
// This means we found a prefix that was proceeded by a space, and
// it's good to assume this is the start of trailing text to the line.
if raw[j+lastIndex+trailerIndex-1] == eventSpace {
i = lastIndex + trailerIndex
break
}
// Keep looping through until we either can't find any more prefixes,
// or we find the one we want.
trailerIndex += lastIndex + 1
}
// Set i to that of the substring we were using before, and where the
// trailing prefix is.
i = j + i
// Check if we need to parse arguments. If so, take everything after the
// command, and right before the trailing prefix, and cut it up.
if i > j {
e.Params = strings.Fields(raw[j : i-1])
}
e.Params = append(e.Params, raw[i+1:])
return e
}
// Event represents an IRC protocol message, see RFC1459 section 2.3.1
//
// <message> :: [':' <prefix> <SPACE>] <command> <params> <crlf>
// <prefix> :: <servername> | <nick> ['!' <user>] ['@' <host>]
// <command> :: <letter>{<letter>} | <number> <number> <number>
// <SPACE> :: ' '{' '}
// <params> :: <SPACE> [':' <trailing> | <middle> <params>]
// <middle> :: <Any *non-empty* sequence of octets not including SPACE or NUL
// or CR or LF, the first of which may not be ':'>
// <trailing> :: <Any, possibly empty, sequence of octets not including NUL or
// CR or LF>
// <crlf> :: CR LF
type Event struct {
// Source is the origin of the event.
Source *Source `json:"source"`
// Tags are the IRCv3 style message tags for the given event. Only use
// if network supported.
Tags Tags `json:"tags"`
// Timestamp is the time the event was received. This could optionally be
// used for client-stored sent messages too. If the server supports the
// "server-time" capability, this is synced to the UTC time that the server
// specifies.
Timestamp time.Time `json:"timestamp"`
// Command that represents the event, e.g. JOIN, PRIVMSG, KILL.
Command string `json:"command"`
// Params (parameters/args) to the command. Commonly nickname, channel, etc.
// The last item in the slice could potentially contain spaces (commonly
// referred to as the "trailing" parameter).
Params []string `json:"params"`
// Sensitive should be true if the message is sensitive (e.g. and should
// not be logged/shown in debugging output).
Sensitive bool `json:"sensitive"`
// If the event is an echo-message response.
Echo bool `json:"echo"`
}
// Last returns the last parameter in Event.Params if it exists.
func (e *Event) Last() string {
if len(e.Params) >= 1 {
return e.Params[len(e.Params)-1]
}
return ""
}
// Copy makes a deep copy of a given event, for use with allowing untrusted
// functions/handlers edit the event without causing potential issues with
// other handlers.
func (e *Event) Copy() *Event {
if e == nil {
return nil
}
newEvent := &Event{
Timestamp: e.Timestamp,
Command: e.Command,
Sensitive: e.Sensitive,
Echo: e.Echo,
}
// Copy Source field, as it's a pointer and needs to be dereferenced.
if e.Source != nil {
newEvent.Source = e.Source.Copy()
}
// Copy Params in order to dereference as well.
if e.Params != nil {
newEvent.Params = make([]string, len(e.Params))
copy(newEvent.Params, e.Params)
}
// Copy tags as necessary.
if e.Tags != nil {
newEvent.Tags = Tags{}
for k, v := range e.Tags {
newEvent.Tags[k] = v
}
}
return newEvent
}
// Equals compares two Events for equality.
func (e *Event) Equals(ev *Event) bool {
if e.Command != ev.Command || len(e.Params) != len(ev.Params) {
return false
}
for i := 0; i < len(e.Params); i++ {
if e.Params[i] != ev.Params[i] {
return false
}
}
if !e.Source.Equals(ev.Source) || !e.Tags.Equals(ev.Tags) {
return false
}
return true
}
// Len calculates the length of the string representation of event. Note that
// this will return the true length (even if longer than what IRC supports),
// which may be useful if you are trying to check and see if a message is
// too long, to trim it down yourself.
func (e *Event) Len() (length int) {
if e.Tags != nil {
// Include tags and trailing space.
length = e.Tags.Len() + 1
}
if e.Source != nil {
// Include prefix and trailing space.
length += e.Source.Len() + 2
}
length += len(e.Command)
if len(e.Params) > 0 {
// Spaces before each param.
length += len(e.Params)
for i := 0; i < len(e.Params); i++ {
length += len(e.Params[i])
// If param contains a space or it's empty, it's trailing, so it should be
// prefixed with a colon (:).
if i == len(e.Params)-1 && (strings.Contains(e.Params[i], " ") || strings.HasPrefix(e.Params[i], ":") || e.Params[i] == "") {
length++
}
}
}
return
}
// Bytes returns a []byte representation of event. Strips all newlines and
// carriage returns.
//
// Per RFC2812 section 2.3, messages should not exceed 512 characters in
// length. This method forces that limit by discarding any characters
// exceeding the length limit.
func (e *Event) Bytes() []byte {
buffer := new(bytes.Buffer)
// Tags.
if e.Tags != nil {
e.Tags.writeTo(buffer)
}
// Event prefix.
if e.Source != nil {
buffer.WriteByte(messagePrefix)
e.Source.writeTo(buffer)
buffer.WriteByte(eventSpace)
}
// Command is required.
buffer.WriteString(e.Command)
// Space separated list of arguments.
if len(e.Params) > 0 {
for i := 0; i < len(e.Params); i++ {
if i == len(e.Params)-1 && (strings.Contains(e.Params[i], " ") || strings.HasPrefix(e.Params[i], ":") || e.Params[i] == "") {
buffer.WriteString(string(eventSpace) + string(messagePrefix) + e.Params[i])
continue
}
buffer.WriteString(string(eventSpace) + e.Params[i])
}
}
// We need the limit the buffer length.
if buffer.Len() > (maxLength) {
buffer.Truncate(maxLength)
}
out := buffer.Bytes()
// Strip newlines and carriage returns.
for i := 0; i < len(out); i++ {
if out[i] == '\n' || out[i] == '\r' {
out = append(out[:i], out[i+1:]...)
i-- // Decrease the index so we can pick up where we left off.
}
}
return out
}
// String returns a string representation of this event. Strips all newlines
// and carriage returns.
func (e *Event) String() string {
return string(e.Bytes())
}
// Pretty returns a prettified string of the event. If the event doesn't
// support prettification, ok is false. Pretty is not just useful to make
// an event prettier, but also to filter out events that most don't visually
// see in normal IRC clients. e.g. most clients don't show WHO queries.
func (e *Event) Pretty() (out string, ok bool) {
if e.Sensitive || e.Echo {
return "", false
}
if e.Command == ERROR {
return fmt.Sprintf("[*] an error occurred: %s", e.Last()), true
}
if e.Source == nil {
if e.Command != PRIVMSG && e.Command != NOTICE {
return "", false
}
if len(e.Params) > 0 {
return fmt.Sprintf("[>] writing %s", e.String()), true
}
return "", false
}
if e.Command == INITIALIZED {
return fmt.Sprintf("[*] connection to %s initialized", e.Last()), true
}
if e.Command == CONNECTED {
return fmt.Sprintf("[*] successfully connected to %s", e.Last()), true
}
if (e.Command == PRIVMSG || e.Command == NOTICE) && len(e.Params) > 0 {
if ctcp := DecodeCTCP(e); ctcp != nil {
if ctcp.Reply {
return
}
if ctcp.Command == CTCP_ACTION {
return fmt.Sprintf("[%s] **%s** %s", strings.Join(e.Params[0:len(e.Params)-1], ","), ctcp.Source.Name, ctcp.Text), true
}
return fmt.Sprintf("[*] CTCP query from %s: %s%s", ctcp.Source.Name, ctcp.Command, " "+ctcp.Text), true
}
var source string
if e.Command == PRIVMSG {
source = fmt.Sprintf("(%s)", e.Source.Name)
} else { // NOTICE
source = fmt.Sprintf("--%s--", e.Source.Name)
}
return fmt.Sprintf("[%s] %s %s", strings.Join(e.Params[0:len(e.Params)-1], ","), source, e.Last()), true
}
if e.Command == RPL_MOTD || e.Command == RPL_MOTDSTART ||
e.Command == RPL_WELCOME || e.Command == RPL_YOURHOST ||
e.Command == RPL_CREATED || e.Command == RPL_LUSERCLIENT {
return "[*] " + e.Last(), true
}
if e.Command == JOIN && len(e.Params) > 0 {
return fmt.Sprintf("[*] %s (%s) has joined %s", e.Source.Name, e.Source.Host, e.Params[0]), true
}
if e.Command == PART && len(e.Params) > 0 {
return fmt.Sprintf("[*] %s (%s) has left %s (%s)", e.Source.Name, e.Source.Host, e.Params[0], e.Last()), true
}
if e.Command == QUIT {
return fmt.Sprintf("[*] %s has quit (%s)", e.Source.Name, e.Last()), true
}
if e.Command == INVITE && len(e.Params) == 1 {
return fmt.Sprintf("[*] %s invited to %s by %s", e.Params[0], e.Last(), e.Source.Name), true
}
if e.Command == KICK && len(e.Params) >= 2 {
return fmt.Sprintf("[%s] *** %s has kicked %s: %s", e.Params[0], e.Source.Name, e.Params[1], e.Last()), true
}
if e.Command == NICK {
return fmt.Sprintf("[*] %s is now known as %s", e.Source.Name, e.Last()), true
}
if e.Command == TOPIC && len(e.Params) >= 2 {
return fmt.Sprintf("[%s] *** %s has set the topic to: %s", e.Params[0], e.Source.Name, e.Last()), true
}
if e.Command == RPL_TOPIC && len(e.Params) > 0 {
if len(e.Params) >= 2 {
return fmt.Sprintf("[*] topic for %s is: %s", e.Params[1], e.Last()), true
}
return fmt.Sprintf("[*] topic for %s is: %s", e.Params[0], e.Last()), true
}
if e.Command == MODE && len(e.Params) > 2 {
return fmt.Sprintf("[%s] *** %s set modes: %s", e.Params[0], e.Source.Name, strings.Join(e.Params[1:], " ")), true
}
if e.Command == CAP_AWAY {
if len(e.Params) > 0 {
return fmt.Sprintf("[*] %s is now away: %s", e.Source.Name, e.Last()), true
}
return fmt.Sprintf("[*] %s is no longer away", e.Source.Name), true
}
if e.Command == CAP_CHGHOST && len(e.Params) == 2 {
return fmt.Sprintf("[*] %s has changed their host to %s (was %s)", e.Source.Name, e.Params[1], e.Source.Host), true
}
if e.Command == CAP_ACCOUNT && len(e.Params) == 1 {
if e.Params[0] == "*" {
return fmt.Sprintf("[*] %s has become un-authenticated", e.Source.Name), true
}
return fmt.Sprintf("[*] %s has authenticated for account: %s", e.Source.Name, e.Params[0]), true
}
if e.Command == CAP && len(e.Params) >= 2 && e.Params[1] == CAP_ACK {
return "[*] enabling capabilities: " + e.Last(), true
}
return "", false
}
// IsAction checks to see if the event is an ACTION (/me).
func (e *Event) IsAction() bool {
if e.Command != PRIVMSG {
return false
}
ok, ctcp := e.IsCTCP()
return ok && ctcp.Command == CTCP_ACTION
}
// IsCTCP checks to see if the event is a CTCP event, and if so, returns the
// converted CTCP event.
func (e *Event) IsCTCP() (ok bool, ctcp *CTCPEvent) {
ctcp = DecodeCTCP(e)
return ctcp != nil, ctcp
}
// IsFromChannel checks to see if a message was from a channel (rather than
// a private message).
func (e *Event) IsFromChannel() bool {
if e.Source == nil || (e.Command != PRIVMSG && e.Command != NOTICE) || len(e.Params) < 1 {
return false
}
if !IsValidChannel(e.Params[0]) {
return false
}
return true
}
// IsFromUser checks to see if a message was from a user (rather than a
// channel).
func (e *Event) IsFromUser() bool {
if e.Source == nil || (e.Command != PRIVMSG && e.Command != NOTICE) || len(e.Params) < 1 {
return false
}
if !IsValidNick(e.Params[0]) {
return false
}
return true
}
// StripAction returns the stripped version of the action encoding from a
// PRIVMSG ACTION (/me).
func (e *Event) StripAction() string {
if !e.IsAction() {
return e.Last()
}
msg := e.Last()
return msg[8 : len(msg)-1]
}
const (
messagePrefix byte = ':' // Prefix or last argument.
prefixIdent byte = '!' // Username.
prefixHost byte = '@' // Hostname.
)
// Source represents the sender of an IRC event, see RFC1459 section 2.3.1.
// <servername> | <nick> [ '!' <user> ] [ '@' <host> ]
type Source struct {
// Name is the nickname, server name, or service name, in its original
// non-rfc1459 form.
Name string `json:"name"`
// Ident is commonly known as the "user".
Ident string `json:"ident"`
// Host is the hostname or IP address of the user/service. Is not accurate
// due to how IRC servers can spoof hostnames.
Host string `json:"host"`
}
// ID is the nickname, server name, or service name, in it's converted
// and comparable) form.
func (s *Source) ID() string {
return ToRFC1459(s.Name)
}
// Equals compares two Sources for equality.
func (s *Source) Equals(ss *Source) bool {
if s == nil && ss == nil {
return true
}
if s != nil && ss == nil || s == nil && ss != nil {
return false
}
if s.ID() != ss.ID() || s.Ident != ss.Ident || s.Host != ss.Host {
return false
}
return true
}
// Copy returns a deep copy of Source.
func (s *Source) Copy() *Source {
if s == nil {
return nil
}
newSource := &Source{
Name: s.Name,
Ident: s.Ident,
Host: s.Host,
}
return newSource
}
// ParseSource takes a string and attempts to create a Source struct.
func ParseSource(raw string) (src *Source) {
src = new(Source)
user := strings.IndexByte(raw, prefixIdent)
host := strings.IndexByte(raw, prefixHost)
switch {
case user > 0 && host > user:
src.Name = raw[:user]
src.Ident = raw[user+1 : host]
src.Host = raw[host+1:]
case user > 0:
src.Name = raw[:user]
src.Ident = raw[user+1:]
case host > 0:
src.Name = raw[:host]
src.Host = raw[host+1:]
default:
src.Name = raw
}
return src
}
// Len calculates the length of the string representation of prefix
func (s *Source) Len() (length int) {
length = len(s.Name)
if len(s.Ident) > 0 {
length = 1 + length + len(s.Ident)
}
if len(s.Host) > 0 {
length = 1 + length + len(s.Host)
}
return
}
// Bytes returns a []byte representation of source.
func (s *Source) Bytes() []byte {
buffer := new(bytes.Buffer)
s.writeTo(buffer)
return buffer.Bytes()
}
// String returns a string representation of source.
func (s *Source) String() (out string) {
out = s.Name
if len(s.Ident) > 0 {
out = out + string(prefixIdent) + s.Ident
}
if len(s.Host) > 0 {
out = out + string(prefixHost) + s.Host
}
return
}
// IsHostmask returns true if source looks like a user hostmask.
func (s *Source) IsHostmask() bool {
return len(s.Ident) > 0 && len(s.Host) > 0
}
// IsServer returns true if this source looks like a server name.
func (s *Source) IsServer() bool {
return s.Ident == "" && s.Host == ""
}
// writeTo is an utility function to write the source to the bytes.Buffer
// in Event.String().
func (s *Source) writeTo(buffer *bytes.Buffer) {
buffer.WriteString(s.Name)
if len(s.Ident) > 0 {
buffer.WriteByte(prefixIdent)
buffer.WriteString(s.Ident)
}
if len(s.Host) > 0 {
buffer.WriteByte(prefixHost)
buffer.WriteString(s.Host)
}
}