girc

func (*CMode) Short ¶

func (c *CMode) Short() string

Short returns a short representation of a mode without arguments. E.g. "+a", or "-b".

func (*CMode) String ¶

func (c *CMode) String() string

String returns a string representation of a mode, including optional arguments. E.g. "+b user*!ident@host.*.com"

func (*CModes) Apply ¶

func (c *CModes) Apply(modes []CMode)

Apply merges two state changes, or one state change into a state of modes. For example, the latter would mean applying an incoming MODE with the modes stored for a channel.

func (*CModes) Copy ¶

func (c *CModes) Copy() (nc CModes)

Copy returns a deep copy of CModes.

func (*CModes) Get ¶

func (c *CModes) Get(mode string) (args string, ok bool)

Get returns the arguments for a given mode within this session, if it supports args.

func (*CModes) HasMode ¶

func (c *CModes) HasMode(mode string) bool

HasMode checks if the CModes state has a given mode. E.g. "m", or "I".

func (*CModes) Parse ¶

func (c *CModes) Parse(flags string, args []string) (out []CMode)

Parse parses a set of flags and args, returning the necessary list of mappings for the mode flags.

func (*CModes) String ¶

func (c *CModes) String() string

String returns a complete set of modes for this given state (change?). For example, "+a-b+cde some-arg".

func (*CTCP) Clear ¶

func (c *CTCP) Clear(cmd string)

Clear removes currently setup handler for cmd, if one is set.

func (*CTCP) ClearAll ¶

func (c *CTCP) ClearAll()

ClearAll removes all currently setup and re-sets the default handlers.

func (*CTCP) Set ¶

func (c *CTCP) Set(cmd string, handler func(client *Client, ctcp CTCPEvent))

Set saves handler for execution upon a matching incoming CTCP event. Use SetBg if the handler may take an extended period of time to execute. If you would like to have a handler which will catch ALL CTCP requests, simply use "*" in place of the command.

func (*CTCP) SetBg ¶

func (c *CTCP) SetBg(cmd string, handler func(client *Client, ctcp CTCPEvent))

SetBg is much like Set, however the handler is executed in the background, ensuring that event handling isn't hung during long running tasks. See Set for more information.

func (*Caller) Add ¶

func (c *Caller) Add(cmd string, handler func(client *Client, event Event)) (cuid string)

Add registers the handler function for the given event. cuid is the handler uid which can be used to remove the handler with Caller.Remove().

func (*Caller) AddBg ¶

func (c *Caller) AddBg(cmd string, handler func(client *Client, event Event)) (cuid string)

AddBg registers the handler function for the given event and executes it in a go-routine. cuid is the handler uid which can be used to remove the handler with Caller.Remove().

func (*Caller) AddHandler ¶

func (c *Caller) AddHandler(cmd string, handler Handler) (cuid string)

AddHandler registers a handler (matching the handler interface) for the given event. cuid is the handler uid which can be used to remove the handler with Caller.Remove().

func (*Caller) AddTmp ¶

func (c *Caller) AddTmp(cmd string, deadline time.Duration, handler func(client *Client, event Event) bool) (cuid string, done chan struct{})

AddTmp adds a "temporary" handler, which is good for one-time or few-time uses. This supports a deadline and/or manual removal, as this differs much from how normal handlers work. An example of a good use for this would be to capture the entire output of a multi-response query to the server. (e.g. LIST, WHOIS, etc)

The supplied handler is able to return a boolean, which if true, will remove the handler from the handler stack.

Additionally, AddTmp has a useful option, deadline. When set to greater than 0, deadline will be the amount of time that passes before the handler is removed from the stack, regardless of if the handler returns true or not. This is useful in that it ensures that the handler is cleaned up if the server does not respond appropriately, or takes too long to respond.

Note that handlers supplied with AddTmp are executed in a goroutine to ensure that they are not blocking other handlers. However, if you are creating a temporary handler from another handler, it should be a background handler.

Use cuid with Caller.Remove() to prematurely remove the handler from the stack, bypassing the timeout or waiting for the handler to return that it wants to be removed from the stack.

func (*Caller) Clear ¶

func (c *Caller) Clear(cmd string)

Clear clears all of the handlers for the given event. This ignores internal handlers.

func (*Caller) ClearAll ¶

func (c *Caller) ClearAll()

ClearAll clears all external handlers currently setup within the client. This ignores internal handlers.

func (*Caller) Count ¶

func (c *Caller) Count(cmd string) int

Count is much like Caller.Len(), however it counts the number of registered handlers for a given command.

func (*Caller) Len ¶

func (c *Caller) Len() int

Len returns the total amount of user-entered registered handlers.

func (*Caller) Remove ¶

func (c *Caller) Remove(cuid string) (success bool)

Remove removes the handler with cuid from the handler stack. success indicates that it existed, and has been removed. If not success, it wasn't a registered handler.

func (*Caller) String ¶

func (c *Caller) String() string

func (Channel) Admins ¶

func (ch Channel) Admins(c *Client) []*User

Admins returns a list of users which have half-op (if supported), or greater permissions (op, admin, owner, etc) in the given channel. See Perms.IsAdmin() for more information.

func (*Channel) Copy ¶

func (ch *Channel) Copy() *Channel

Copy returns a deep copy of a given channel.

func (*Channel) Len ¶

func (ch *Channel) Len() int

Len returns the count of users in a given channel.

func (*Channel) Lifetime ¶

func (ch *Channel) Lifetime() time.Duration

Lifetime represents the amount of time that has passed since we have first joined the channel.

func (Channel) Trusted ¶

func (ch Channel) Trusted(c *Client) []*User

Trusted returns a list of users which have voice or greater in the given channel. See Perms.IsTrusted() for more information.

func (*Channel) UserIn ¶

func (ch *Channel) UserIn(name string) bool

UserIn checks to see if a given user is in a channel.

func (Channel) Users ¶

func (ch Channel) Users(c *Client) []*User

Users returns a reference of *Users that the client knows the channel has If you're just looking for just the name of the users, use Channnel.UserList.

func (*Client) ChannelList ¶

func (c *Client) ChannelList() []string

ChannelList returns the (sorted) active list of channel names that the client is in. Panics if tracking is disabled.

func (*Client) Channels ¶

func (c *Client) Channels() []*Channel

Channels returns the (sorted) active channels that the client is in. Panics if tracking is disabled.

func (*Client) Close ¶

func (c *Client) Close()

Close closes the network connection to the server, and sends a CLOSED event. This should cause Connect() to return with nil. This should be safe to call multiple times. See Connect()'s documentation on how handlers and goroutines are handled when disconnected from the server.

func (*Client) ConnSince ¶

func (c *Client) ConnSince() (since *time.Duration, err error)

ConnSince is the duration that has past since the client successfully connected to the server.

func (*Client) Connect ¶

func (c *Client) Connect() error

Connect attempts to connect to the given IRC server. Returns only when an error has occurred, or a disconnect was requested with Close(). Connect will only return once all client-based goroutines have been closed to ensure there are no long-running routines becoming backed up.

Connect will wait for all non-goroutine handlers to complete on error/quit, however it will not wait for goroutine-based handlers.

If this returns nil, this means that the client requested to be closed (e.g. Client.Close()). Connect will panic if called when the last call has not completed.

func (*Client) DialerConnect ¶

func (c *Client) DialerConnect(dialer Dialer) error

DialerConnect allows you to specify your own custom dialer which implements the Dialer interface.

An example of using this library would be to take advantage of the golang.org/x/net/proxy library:

proxyUrl, _ := proxyURI, err = url.Parse("socks5://1.2.3.4:8888")
dialer, _ := proxy.FromURL(proxyURI, &net.Dialer{Timeout: 5 * time.Second})
_ := girc.DialerConnect(dialer)

func (*Client) DisableTracking ¶

func (c *Client) DisableTracking()

DisableTracking disables all channel/user-level/CAP tracking, and clears all internal handlers. Useful for highly embedded scripts with single purposes. This cannot be un-done on a client.

func (*Client) GetHost ¶

func (c *Client) GetHost() (host string)

GetHost returns the current host of the active connection. Panics if tracking is disabled. May be empty, as this is obtained from when we join a channel, as there is no other more efficient method to return this info.

func (*Client) GetID ¶

func (c *Client) GetID() string

GetID returns an RFC1459 compliant version of the current nickname. Panics if tracking is disabled.

func (*Client) GetIdent ¶

func (c *Client) GetIdent() string

GetIdent returns the current ident of the active connection. Panics if tracking is disabled. May be empty, as this is obtained from when we join a channel, as there is no other more efficient method to return this info.

func (*Client) GetNick ¶

func (c *Client) GetNick() string

GetNick returns the current nickname of the active connection. Panics if tracking is disabled.

func (*Client) GetServerOption ¶

func (c *Client) GetServerOption(key string) (result string, ok bool)

GetServerOption retrieves a server capability setting that was retrieved during client connection. This is also known as ISUPPORT (or RPL_PROTOCTL). Will panic if used when tracking has been disabled. Examples of usage:

nickLen, success := GetServerOption("MAXNICKLEN")

func (*Client) HasCapability ¶

func (c *Client) HasCapability(name string) (has bool)

HasCapability checks if the client connection has the given capability. If you want the full list of capabilities, listen for the girc.CAP_ACK event. Will panic if used when tracking has been disabled.

func (*Client) IsConnected ¶

func (c *Client) IsConnected() bool

IsConnected returns true if the client is connected to the server.

func (*Client) IsInChannel ¶

func (c *Client) IsInChannel(channel string) (in bool)

IsInChannel returns true if the client is in channel. Panics if tracking is disabled.

func (*Client) Latency ¶

func (c *Client) Latency() (delta time.Duration)

Latency is the latency between the server and the client. This is measured by determining the difference in time between when we ping the server, and when we receive a pong.

func (*Client) Lifetime ¶

func (c *Client) Lifetime() time.Duration

Lifetime returns the amount of time that has passed since the client was created.

func (*Client) LookupChannel ¶

func (c *Client) LookupChannel(name string) (channel *Channel)

LookupChannel looks up a given channel in state. If the channel doesn't exist, nil is returned. Panics if tracking is disabled.

func (*Client) LookupUser ¶

func (c *Client) LookupUser(nick string) (user *User)

LookupUser looks up a given user in state. If the user doesn't exist, nil is returned. Panics if tracking is disabled.

func (*Client) MockConnect ¶

func (c *Client) MockConnect(conn net.Conn) error

MockConnect is used to implement mocking with an IRC server. Supply a net.Conn that will be used to spoof the server. A useful way to do this is to so net.Pipe(), pass one end into MockConnect(), and the other end into bufio.NewReader().

For example:

client := girc.New(girc.Config{
	Server: "dummy.int",
	Port:   6667,
	Nick:   "test",
	User:   "test",
	Name:   "Testing123",
})

in, out := net.Pipe()
defer in.Close()
defer out.Close()
b := bufio.NewReader(in)

go func() {
	if err := client.MockConnect(out); err != nil {
		panic(err)
	}
}()

defer client.Close(false)

for {
	in.SetReadDeadline(time.Now().Add(300 * time.Second))
	line, err := b.ReadString(byte('\n'))
	if err != nil {
		panic(err)
	}

	event := girc.ParseEvent(line)

	if event == nil {
 		continue
 	}

 	// Do stuff with event here.
 }

func (*Client) NetworkName ¶

func (c *Client) NetworkName() (name string)

NetworkName returns the network identifier. E.g. "EsperNet", "ByteIRC". May be empty if the server does not support RPL_ISUPPORT (or RPL_PROTOCTL). Will panic if used when tracking has been disabled.

func (*Client) Quit ¶

func (c *Client) Quit(reason string)

Quit sends a QUIT message to the server with a given reason to close the connection. Underlying this event being sent, Client.Close() is called as well. This is different than just calling Client.Close() in that it provides a reason as to why the connection was closed (for bots to tell users the bot is restarting, or shutting down, etc).

NOTE: servers may delay showing of QUIT reasons, until you've been connected to the server for a certain period of time (e.g. 5 minutes). Keep this in mind.

func (*Client) RunHandlers ¶

func (c *Client) RunHandlers(event *Event)

RunHandlers manually runs handlers for a given event.

func (*Client) Send ¶

func (c *Client) Send(event *Event)

Send sends an event to the server. Use Client.RunHandlers() if you are simply looking to trigger handlers with an event.

func (*Client) Server ¶

func (c *Client) Server() string

Server returns the string representation of host+port pair for the connection.

func (*Client) ServerMOTD ¶

func (c *Client) ServerMOTD() (motd string)

ServerMOTD returns the servers message of the day, if the server has sent it upon connect. Will panic if used when tracking has been disabled.

func (*Client) ServerVersion ¶

func (c *Client) ServerVersion() (version string)

ServerVersion returns the server software version, if the server has supplied this information during connection. May be empty if the server does not support RPL_MYINFO. Will panic if used when tracking has been disabled.

func (*Client) String ¶

func (c *Client) String() string

String returns a brief description of the current client state.

func (*Client) TLSConnectionState ¶

func (c *Client) TLSConnectionState() (*tls.ConnectionState, error)

TLSConnectionState returns the TLS connection state from tls.Conn{}, which is useful to return needed TLS fingerprint info, certificates, verify cert expiration dates, etc. Will only return an error if the underlying connection wasn't established using TLS (see ErrConnNotTLS), or if the client isn't connected.

func (*Client) Uptime ¶

func (c *Client) Uptime() (up time.Time, err error)

Uptime is the time at which the client successfully connected to the server.

func (*Client) UserList ¶

func (c *Client) UserList() []string

UserList returns the (sorted) active list of nicknames that the client is tracking across all channels. Panics if tracking is disabled.

func (*Client) Users ¶

func (c *Client) Users() []*User

Users returns the (sorted) active users that the client is tracking across all channels. Panics if tracking is disabled.

func (*Commands) Action ¶

func (cmd *Commands) Action(target, message string)

Action sends a PRIVMSG ACTION (/me) to target (either channel, service, or user).

func (*Commands) Actionf ¶

func (cmd *Commands) Actionf(target, format string, a ...interface{})

Actionf sends a formated PRIVMSG ACTION (/me) to target (either channel, service, or user).

func (*Commands) Away ¶

func (cmd *Commands) Away(reason string)

Away sends a AWAY query to the server, suggesting that the client is no longer active. If reason is blank, Client.Back() is called. Also see Client.Back().

func (*Commands) Back ¶

func (cmd *Commands) Back()

Back sends a AWAY query to the server, however the query is blank, suggesting that the client is active once again. Also see Client.Away().

func (*Commands) Ban ¶

func (cmd *Commands) Ban(channel, mask string)

Ban adds the +b mode on the given mask on a channel.

func (*Commands) Invite ¶

func (cmd *Commands) Invite(channel string, users ...string)

Invite sends a INVITE query to the server, to invite nick to channel.

func (*Commands) Join ¶

func (cmd *Commands) Join(channels ...string)

Join attempts to enter a list of IRC channels, at bulk if possible to prevent sending extensive JOIN commands.

func (*Commands) JoinKey ¶

func (cmd *Commands) JoinKey(channel, password string)

JoinKey attempts to enter an IRC channel with a password.

func (*Commands) Kick ¶

func (cmd *Commands) Kick(channel, user, reason string)

Kick sends a KICK query to the server, attempting to kick nick from channel, with reason. If reason is blank, one will not be sent to the server.

func (*Commands) List ¶

func (cmd *Commands) List(channels ...string)

List sends a LIST query to the server, which will list channels and topics. Supports multiple channels at once, in hopes it will reduce extensive LIST queries to the server. Supply no channels to run a list against the entire server (warning, that may mean LOTS of channels!)

func (*Commands) Message ¶

func (cmd *Commands) Message(target, message string)

Message sends a PRIVMSG to target (either channel, service, or user).

func (*Commands) Messagef ¶

func (cmd *Commands) Messagef(target, format string, a ...interface{})

Messagef sends a formated PRIVMSG to target (either channel, service, or user).

func (*Commands) Mode ¶

func (cmd *Commands) Mode(target, modes string, params ...string)

Mode sends a mode change to the server which should be applied to target (usually a channel or user), along with a set of modes (generally "+m", "+mmmm", or "-m", where "m" is the mode you want to change). Params is only needed if the mode change requires a parameter (ban or invite-only exclude.)

func (*Commands) Monitor ¶

func (cmd *Commands) Monitor(modifier rune, args ...string)

Monitor sends a MONITOR query to the server. The results of the query depends on the given modifier, see https://ircv3.net/specs/core/monitor-3.2.html

func (*Commands) Nick ¶

func (cmd *Commands) Nick(name string)

Nick changes the client nickname.

func (*Commands) Notice ¶

func (cmd *Commands) Notice(target, message string)

Notice sends a NOTICE to target (either channel, service, or user).

func (*Commands) Noticef ¶

func (cmd *Commands) Noticef(target, format string, a ...interface{})

Noticef sends a formated NOTICE to target (either channel, service, or user).

func (*Commands) Oper ¶

func (cmd *Commands) Oper(user, pass string)

Oper sends a OPER authentication query to the server, with a username and password.

func (*Commands) Part ¶

func (cmd *Commands) Part(channels ...string)

Part leaves an IRC channel.

func (*Commands) PartMessage ¶

func (cmd *Commands) PartMessage(channel, message string)

PartMessage leaves an IRC channel with a specified leave message.

func (*Commands) Ping ¶

func (cmd *Commands) Ping(id string)

Ping sends a PING query to the server, with a specific identifier that the server should respond with.

func (*Commands) Pong ¶

func (cmd *Commands) Pong(id string)

Pong sends a PONG query to the server, with an identifier which was received from a previous PING query received by the client.

func (*Commands) Reply ¶

func (cmd *Commands) Reply(event Event, message string)

Reply sends a reply to channel or user, based on where the supplied event originated from. See also ReplyTo(). Panics if the incoming event has no source.

func (*Commands) ReplyBan ¶

func (cmd *Commands) ReplyBan(event Event, reason string)

ReplyBan kicks the source of the event from the channel where the event originated

func (*Commands) ReplyKick ¶

func (cmd *Commands) ReplyKick(event Event, reason string)

ReplyKick kicks the source of the event from the channel where the event originated

func (*Commands) ReplyTo ¶

func (cmd *Commands) ReplyTo(event Event, message string)

ReplyTo sends a reply to a channel or user, based on where the supplied event originated from. ReplyTo(), when originating from a channel will default to replying with "<user>, <message>". See also Reply(). Panics if the incoming event has no source.

func (*Commands) ReplyTof ¶

func (cmd *Commands) ReplyTof(event Event, format string, a ...interface{})

ReplyTof sends a reply to a channel or user with a format string, based on where the supplied event originated from. ReplyTo(), when originating from a channel will default to replying with "<user>, <message>". See also Replyf(). Panics if the incoming event has no source.

func (*Commands) Replyf ¶

func (cmd *Commands) Replyf(event Event, format string, a ...interface{})

Replyf sends a reply to channel or user with a format string, based on where the supplied event originated from. See also ReplyTof(). Panics if the incoming event has no source.

func (*Commands) SendCTCP ¶

func (cmd *Commands) SendCTCP(target, ctcpType, message string)

SendCTCP sends a CTCP request to target. Note that this method uses PRIVMSG specifically. ctcpType is the CTCP command, e.g. "FINGER", "TIME", "VERSION", etc.

func (*Commands) SendCTCPReply ¶

func (cmd *Commands) SendCTCPReply(target, ctcpType, message string)

SendCTCPReply sends a CTCP response to target. Note that this method uses NOTICE specifically.

func (*Commands) SendCTCPReplyf ¶

func (cmd *Commands) SendCTCPReplyf(target, ctcpType, format string, a ...interface{})

SendCTCPReplyf sends a CTCP response to target using a specific format. Note that this method uses NOTICE specifically. ctcpType is the CTCP command, e.g. "FINGER", "TIME", "VERSION", etc.

func (*Commands) SendCTCPf ¶

func (cmd *Commands) SendCTCPf(target, ctcpType, format string, a ...interface{})

SendCTCPf sends a CTCP request to target using a specific format. Note that this method uses PRIVMSG specifically. ctcpType is the CTCP command, e.g. "FINGER", "TIME", "VERSION", etc.

func (*Commands) SendRaw ¶

func (cmd *Commands) SendRaw(raw ...string) error

SendRaw sends a raw string (or multiple) to the server, without carriage returns or newlines. Returns an error if one of the raw strings cannot be properly parsed.

func (*Commands) SendRawf ¶

func (cmd *Commands) SendRawf(format string, a ...interface{}) error

SendRawf sends a formated string back to the server, without carriage returns or newlines.

func (*Commands) Topic ¶

func (cmd *Commands) Topic(channel, message string)

Topic sets the topic of channel to message. Does not verify the length of the topic.

func (*Commands) Unban ¶

func (cmd *Commands) Unban(channel, mask string)

Unban removes the +b mode on the given mask on a channel.

func (*Commands) Who ¶

func (cmd *Commands) Who(users ...string)

Who sends a WHO query to the server, which will attempt WHOX by default. See http://faerion.sourceforge.net/doc/irc/whox.var for more details. This sends "%tcuhnr,2" per default. Do not use "1" as this will conflict with girc's builtin tracking functionality.

func (*Commands) Whois ¶

func (cmd *Commands) Whois(users ...string)

Whois sends a WHOIS query to the server, targeted at a specific user (or set of users). As WHOIS is a bit slower, you may want to use WHO for brief user info.

func (*Commands) Whowas ¶

func (cmd *Commands) Whowas(user string, amount int)

Whowas sends a WHOWAS query to the server. amount is the amount of results you want back.

func (*ErrEvent) Error ¶

func (e *ErrEvent) Error() string

func (ErrInvalidConfig) Error ¶

func (e ErrInvalidConfig) Error() string

func (ErrParseEvent) Error ¶

func (e ErrParseEvent) Error() string

func (ErrSTSUpgradeFailed) Error ¶

func (e ErrSTSUpgradeFailed) Error() string

func (ErrTimedOut) Error ¶

func (ErrTimedOut) Error() string

func (*Event) Bytes ¶

func (e *Event) Bytes() []byte

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 (*Event) Copy ¶

func (e *Event) Copy() *Event

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 (*Event) Equals ¶

func (e *Event) Equals(ev *Event) bool

Equals compares two Events for equality.

func (*Event) IsAction ¶

func (e *Event) IsAction() bool

IsAction checks to see if the event is an ACTION (/me).

func (*Event) IsCTCP ¶

func (e *Event) IsCTCP() (ok bool, ctcp *CTCPEvent)

IsCTCP checks to see if the event is a CTCP event, and if so, returns the converted CTCP event.

func (*Event) IsFromChannel ¶

func (e *Event) IsFromChannel() bool

IsFromChannel checks to see if a message was from a channel (rather than a private message).

func (*Event) IsFromUser ¶

func (e *Event) IsFromUser() bool

IsFromUser checks to see if a message was from a user (rather than a channel).

func (*Event) Last ¶

func (e *Event) Last() string

Last returns the last parameter in Event.Params if it exists.

func (*Event) Len ¶

func (e *Event) Len() (length int)

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 (*Event) Pretty ¶

func (e *Event) Pretty() (out string, ok bool)

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 (*Event) String ¶

func (e *Event) String() string

String returns a string representation of this event. Strips all newlines and carriage returns.

func (*Event) StripAction ¶

func (e *Event) StripAction() string

StripAction returns the stripped version of the action encoding from a PRIVMSG ACTION (/me).

func (*HandlerError) Error ¶

func (e *HandlerError) Error() string

Error returns a prettified version of HandlerError, containing ID, file, line, and basic error string.

func (*HandlerError) String ¶

func (e *HandlerError) String() string

String returns the error that panic returned, as well as the entire call trace of where it originated.

func (HandlerFunc) Execute ¶

func (f HandlerFunc) Execute(client *Client, event Event)

Execute calls the HandlerFunc with the sender and irc message.

func (Perms) IsAdmin ¶

func (m Perms) IsAdmin() bool

IsAdmin indicates that the user has banning abilities, and are likely a very trustable user (e.g. op+).

func (Perms) IsTrusted ¶

func (m Perms) IsTrusted() bool

IsTrusted indicates that the user at least has modes set upon them, higher than a regular joining user.

func (*SASLExternal) Encode ¶

func (sasl *SASLExternal) Encode(params []string) string

Encode for external SALS authentication should really only return a "+", unless the user has specified pre-authentication or identification data. See https://tools.ietf.org/html/rfc4422#appendix-A for more info.

func (*SASLExternal) Method ¶

func (sasl *SASLExternal) Method() string

Method identifies what type of SASL this implements.

func (*SASLPlain) Encode ¶

func (sasl *SASLPlain) Encode(params []string) string

Encode encodes the plain user+password into a SASL PLAIN implementation. See https://tools.ietf.org/rfc/rfc4422.txt for more info.

func (*SASLPlain) Method ¶

func (sasl *SASLPlain) Method() string

Method identifies what type of SASL this implements.

func (*Source) Bytes ¶

func (s *Source) Bytes() []byte

Bytes returns a []byte representation of source.

func (*Source) Copy ¶

func (s *Source) Copy() *Source

Copy returns a deep copy of Source.

func (*Source) Equals ¶

func (s *Source) Equals(ss *Source) bool

Equals compares two Sources for equality.

func (*Source) ID ¶

func (s *Source) ID() string

ID is the nickname, server name, or service name, in it's converted and comparable) form.

func (*Source) IsHostmask ¶

func (s *Source) IsHostmask() bool

IsHostmask returns true if source looks like a user hostmask.

func (*Source) IsServer ¶

func (s *Source) IsServer() bool

IsServer returns true if this source looks like a server name.

func (*Source) Len ¶

func (s *Source) Len() (length int)

Len calculates the length of the string representation of prefix

func (*Source) String ¶

func (s *Source) String() (out string)

String returns a string representation of source.

func (Tags) Bytes ¶

func (t Tags) Bytes() []byte

Bytes returns a []byte representation of this tag map, including the tag prefix ("@"). Note that this will return the tags sorted, regardless of the order of how they were originally parsed.

func (Tags) Count ¶

func (t Tags) Count() int

Count finds how many total tags that there are.

func (Tags) Equals ¶

func (t Tags) Equals(tt Tags) bool

Equals compares two Tags for equality. With the msgid IRCv3 spec +\ echo-message (amongst others), we may receive events that have msgid's, whereas our local events will not have the msgid. As such, don't compare all tags, only the necessary/important tags.

func (Tags) Get ¶

func (t Tags) Get(key string) (tag string, success bool)

Get returns the unescaped value of given tag key. Note that this is not concurrent safe.

func (Tags) Keys ¶

func (t Tags) Keys() (keys []string)

Keys returns a slice of (unsorted) tag keys.

func (Tags) Len ¶

func (t Tags) Len() (length int)

Len determines the length of the bytes representation of this tag map. This does not include the trailing space required when creating an event, but does include the tag prefix ("@").

func (Tags) Remove ¶

func (t Tags) Remove(key string) (success bool)

Remove deletes the tag frwom the tag map.

func (Tags) Set ¶

func (t Tags) Set(key, value string) error

Set escapes given value and saves it as the value for given key. Note that this is not concurrent safe.

func (Tags) String ¶

func (t Tags) String() string

String returns a string representation of this tag map.

func (*User) Active ¶

func (u *User) Active() time.Duration

Active represents the the amount of time that has passed since we have last seen the user.

func (User) Channels ¶

func (u User) Channels(c *Client) []*Channel

Channels returns a reference of *Channels that the client knows the user is in. If you're just looking for the namme of the channels, use User.ChannelList.

func (*User) Copy ¶

func (u *User) Copy() *User

Copy returns a deep copy of the user which can be modified without making changes to the actual state.

func (*User) InChannel ¶

func (u *User) InChannel(name string) bool

InChannel checks to see if a user is in the given channel.

func (*User) IsActive ¶

func (u *User) IsActive() bool

IsActive returns true if they were active within the last 30 minutes.

func (*User) Lifetime ¶

func (u *User) Lifetime() time.Duration

Lifetime represents the amount of time that has passed since we have first seen the user.

func (*UserPerms) Copy ¶

func (p *UserPerms) Copy() (perms *UserPerms)

Copy returns a deep copy of the channel permissions.

func (*UserPerms) Lookup ¶

func (p *UserPerms) Lookup(channel string) (perms Perms, ok bool)

Lookup looks up the users permissions for a given channel. ok is false if the user is not in the given channel.

func (*UserPerms) MarshalJSON ¶

func (p *UserPerms) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler.

func (WebIRC) Params ¶

func (w WebIRC) Params() []string

Params returns the arguments for the WEBIRC command that can be passed to the server.