irc

package

Go to main page

Versions in this module

v1

v1.6.6

Dec 28, 2017

Changes in this version

+ var Commit = "HEAD"

type UserMode

+ const HostMask

v1.6.5

Dec 14, 2017

v1.6.4

Dec 3, 2017

Changes in this version

type Server

+ func (server *Server) Stop()

v1.6.3

Nov 28, 2017

Changes in this version

+ func CanSeeChannel(client *Client, channel *Channel) bool

type Metrics

+ func (m *Metrics) GaugeVec(subsystem, name string) *prometheus.GaugeVec

+ func (m *Metrics) NewGaugeVec(subsystem, name, help string, labels []string) *prometheus.GaugeVec

v1.6.2

Nov 26, 2017

Changes in this version

+ func SHA256(data string) string

type Config

+ Network struct{ ... }

type Server

+ func (s *Server) Network() Name

v1.6.1

Nov 25, 2017

Changes in this version

+ const AUTHENTICATE

+ const ERR_NICKLOCKED

+ const ERR_SASLABORTED

+ const ERR_SASLALREADY

+ const ERR_SASLFAIL

+ const ERR_SASLTOOLONG

+ const RPL_LOGGEDIN

+ const RPL_LOGGEDOUT

+ const RPL_SASLMECHS

+ const RPL_SASLSUCCESS

+ const RPL_WHOISLOGGEDIN

+ var DefaultPasswordHasher = &Base64BCryptPasswordHasher

+ var Package = "eris"

+ func RplAuthenticate(client *Client, arg string) string

+ type AuthenticateCommand struct

+ func (msg *AuthenticateCommand) HandleRegServer(server *Server)

+ type Base64BCryptPasswordHasher struct

+ func (hasher *Base64BCryptPasswordHasher) Compare(encoded, password []byte) error

+ func (hasher *Base64BCryptPasswordHasher) Decode(encoded []byte) (decoded []byte, err error)

+ func (hasher *Base64BCryptPasswordHasher) Encode(password []byte) (encoded []byte, err error)

type ChannelMode

+ const SecureChan

type Client

+ func (target *Client) ErrNickLocked()

+ func (target *Client) ErrSaslAborted()

+ func (target *Client) ErrSaslAlready()

+ func (target *Client) ErrSaslFail(message string)

+ func (target *Client) ErrSaslTooLong()

+ func (target *Client) RplLoggedIn(authcid string)

+ func (target *Client) RplLoggedOut()

+ func (target *Client) RplSaslMechs(mechs ...string)

+ func (target *Client) RplSaslSuccess()

+ func (target *Client) RplWhoisLoggedIn(client *Client)

type Command

+ func ParseAuthenticateCommand(args []string) (Command, error)

type Config

+ Account map[string]*PassConfig

+ func (conf *Config) Accounts() map[string][]byte

+ type MemoryPasswordStore struct

+ func NewMemoryPasswordStore(passwords map[string][]byte, opts PasswordStoreOpts) *MemoryPasswordStore

+ func (store *MemoryPasswordStore) Get(username string) ([]byte, bool)

+ func (store *MemoryPasswordStore) Set(username, password string) error

+ func (store *MemoryPasswordStore) Verify(username, password string) error

+ type PasswordHasher interface

+ Compare func(encoded []byte, password []byte) error

+ Decode func(encoded []byte) (decoded []byte, err error)

+ Encode func(password []byte) (encoded []byte, err error)

+ type PasswordStore interface

+ Get func(username string) ([]byte, bool)

+ Set func(username, password string) error

+ Verify func(username, password string) error

+ type PasswordStoreOpts struct

+ type SaslState struct

+ func NewSaslState() *SaslState

+ func (s *SaslState) Id() string

+ func (s *SaslState) Login(authcid string)

+ func (s *SaslState) Reset()

+ func (s *SaslState) Start()

+ func (s *SaslState) Started() bool

+ func (s *SaslState) String() string

+ func (s *SaslState) WriteString(data string)

+ func (s SaslState) Len() int

type UserMode

+ const Registered

v1.6.0

Nov 20, 2017

Changes in this version

+ const WALLOPS

+ var DefObjectives = map[float64]float64

type ChannelModeSet

+ func NewChannelModeSet() *ChannelModeSet

+ func (set *ChannelModeSet) Has(mode ChannelMode) bool

+ func (set *ChannelModeSet) Range(f func(mode ChannelMode) bool)

+ func (set *ChannelModeSet) Set(mode ChannelMode)

+ func (set *ChannelModeSet) Unset(mode ChannelMode)

type ChannelNameMap

+ func (c *ChannelNameMap) Count() int

type ChannelSet

+ func NewChannelSet() *ChannelSet

+ func (set *ChannelSet) Count() int

+ func (set *ChannelSet) Range(f func(channel *Channel) bool)

type ClientLookupSet

+ func (clients *ClientLookupSet) Range(f func(nick Name, client *Client) bool)

type ClientSet

+ func NewClientSet() *ClientSet

+ func (set *ClientSet) Count() int

+ func (set *ClientSet) Range(f func(client *Client) bool)

type Command

+ func ParseWallopsCommand(args []string) (Command, error)

+ type Counter struct

+ func (c *Counter) Dec()

+ func (c *Counter) Inc()

+ func (c *Counter) Value() int

+ type Identity struct

+ func NewIdentity(hostname string, args ...string) *Identity

+ func (id *Identity) Id() Name

+ func (id *Identity) Nick() Name

+ func (id *Identity) String() string

type MemberSet

+ func NewMemberSet() *MemberSet

+ func (set *MemberSet) Count() int

+ func (set *MemberSet) Get(member *Client) *ChannelModeSet

+ func (set *MemberSet) Range(f func(client *Client, modes *ChannelModeSet) bool)

+ type Metrics struct

+ func NewMetrics(namespace string) *Metrics

+ func (m *Metrics) Counter(subsystem, name string) prometheus.Counter

+ func (m *Metrics) Gauge(subsystem, name string) prometheus.Gauge

+ func (m *Metrics) Handler() http.Handler

+ func (m *Metrics) NewCounter(subsystem, name, help string) prometheus.Counter

+ func (m *Metrics) NewCounterFunc(subsystem, name, help string, f func() float64) prometheus.CounterFunc

+ func (m *Metrics) NewGauge(subsystem, name, help string) prometheus.Gauge

+ func (m *Metrics) NewGaugeFunc(subsystem, name, help string, f func() float64) prometheus.GaugeFunc

+ func (m *Metrics) NewSummary(subsystem, name, help string) prometheus.Summary

+ func (m *Metrics) NewSummaryVec(subsystem, name, help string, labels []string) *prometheus.SummaryVec

+ func (m *Metrics) Run(addr string)

+ func (m *Metrics) Summary(subsystem, name string) prometheus.Summary

+ func (m *Metrics) SummaryVec(subsystem, name string) *prometheus.SummaryVec

type Server

+ func (server *Server) Global(message string)

+ func (server *Server) Globalf(format string, args ...interface{})

+ type WallopsCommand struct

+ func (msg *WallopsCommand) HandleServer(server *Server)

v1.5.4

Nov 16, 2017

Changes in this version

type ChannelNameMap

+ func NewChannelNameMap() *ChannelNameMap

+ func (c *ChannelNameMap) Length() int

+ func (c *ChannelNameMap) Range(f func(kay Name, value *Channel) bool)

v1.5.3

Nov 6, 2017

Changes in this version

+ const LUSERS

+ const REHASH

+ var DefaultChannelModes = ChannelModes

+ func IsHostname(name string) bool

type Client

+ func (c *Client) Server() Name

+ func (c *Client) ServerInfo() string

+ func (target *Client) RplLUserChannels()

+ func (target *Client) RplLUserClient()

+ func (target *Client) RplLUserMe()

+ func (target *Client) RplLUserOp()

+ func (target *Client) RplLUserUnknown()

+ func (target *Client) RplRehashing()

+ func (target *Client) RplWhoisServer(client *Client)

type ClientLookupSet

+ func (clients *ClientLookupSet) Count() int

type Command

+ func ParseLUsersCommand(args []string) (Command, error)

+ func ParseRehashCommand(args []string) (Command, error)

type Config

+ func (conf *Config) Name() string

+ func (conf *Config) Reload() error

+ type LUsersCommand struct

+ func (msg *LUsersCommand) HandleServer(server *Server)

+ type RehashCommand struct

+ func (msg *RehashCommand) HandleServer(server *Server)

type Server

+ func (s *Server) Rehash() error

+ func (server *Server) Wallops(message string)

+ func (server *Server) Wallopsf(format string, args ...interface{})

v1.5.2

Nov 5, 2017

Changes in this version

+ const AWAY

+ const CAP

+ const CRLF

+ const DEBUG

+ const ERROR

+ const ERR_ALREADYREGISTRED

+ const ERR_BADCHANMASK

+ const ERR_BADCHANNELKEY

+ const ERR_BADMASK

+ const ERR_BANLISTFULL

+ const ERR_BANNEDFROMCHAN

+ const ERR_CANNOTSENDTOCHAN

+ const ERR_CANNOTSENDTOUSER

+ const ERR_CANTKILLSERVER

+ const ERR_CHANNELISFULL

+ const ERR_CHANOPRIVSNEEDED

+ const ERR_ERRONEUSNICKNAME

+ const ERR_FILEERROR

+ const ERR_INVALIDCAPCMD

+ const ERR_INVITEONLYCHAN

+ const ERR_KEYSET

+ const ERR_NEEDMOREPARAMS

+ const ERR_NICKCOLLISION

+ const ERR_NICKNAMEINUSE

+ const ERR_NOADMININFO

+ const ERR_NOCHANMODES

+ const ERR_NOLOGIN

+ const ERR_NOMOTD

+ const ERR_NONICKNAMEGIVEN

+ const ERR_NOOPERHOST

+ const ERR_NOORIGIN

+ const ERR_NOPERMFORHOST

+ const ERR_NOPRIVILEGES

+ const ERR_NORECIPIENT

+ const ERR_NOSUCHCHANNEL

+ const ERR_NOSUCHNICK

+ const ERR_NOSUCHSERVER

+ const ERR_NOSUCHSERVICE

+ const ERR_NOTEXTTOSEND

+ const ERR_NOTONCHANNEL

+ const ERR_NOTOPLEVEL

+ const ERR_NOTREGISTERED

+ const ERR_PASSWDMISMATCH

+ const ERR_RESTRICTED

+ const ERR_SUMMONDISABLED

+ const ERR_TOOMANYCHANNELS

+ const ERR_TOOMANYTARGETS

+ const ERR_UMODEUNKNOWNFLAG

+ const ERR_UNAVAILRESOURCE

+ const ERR_UNIQOPPRIVSNEEDED

+ const ERR_UNKNOWNCOMMAND

+ const ERR_UNKNOWNMODE

+ const ERR_USERNOTINCHANNEL

+ const ERR_USERONCHANNEL

+ const ERR_USERSDISABLED

+ const ERR_USERSDONTMATCH

+ const ERR_WASNOSUCHNICK

+ const ERR_WILDTOPLEVEL

+ const ERR_YOUREBANNEDCREEP

+ const ERR_YOUWILLBEBANNED

+ const IDLE_TIMEOUT

+ const INVITE

+ const ISON

+ const JOIN

+ const KICK

+ const KILL

+ const LIST

+ const MAX_REPLY_LEN

+ const MODE

+ const MOTD

+ const NAMES

+ const NICK

+ const NOTICE

+ const ONICK

+ const OPER

+ const PART

+ const PASS

+ const PING

+ const PONG

+ const PRIVMSG

+ const QUIT

+ const QUIT_TIMEOUT

+ const R

+ const RPL_ADMINEMAIL

+ const RPL_ADMINLOC1

+ const RPL_ADMINLOC2

+ const RPL_ADMINME

+ const RPL_AWAY

+ const RPL_BANLIST

+ const RPL_BOUNCE

+ const RPL_CHANNELMODEIS

+ const RPL_CREATED

+ const RPL_ENDOFBANLIST

+ const RPL_ENDOFEXCEPTLIST

+ const RPL_ENDOFINFO

+ const RPL_ENDOFINVITELIST

+ const RPL_ENDOFLINKS

+ const RPL_ENDOFMOTD

+ const RPL_ENDOFNAMES

+ const RPL_ENDOFSTATS

+ const RPL_ENDOFUSERS

+ const RPL_ENDOFWHO

+ const RPL_ENDOFWHOIS

+ const RPL_ENDOFWHOWAS

+ const RPL_EXCEPTLIST

+ const RPL_INFO

+ const RPL_INVITELIST

+ const RPL_INVITING

+ const RPL_ISON

+ const RPL_LINKS

+ const RPL_LIST

+ const RPL_LISTEND

+ const RPL_LUSERCHANNELS

+ const RPL_LUSERCLIENT

+ const RPL_LUSERME

+ const RPL_LUSEROP

+ const RPL_LUSERUNKNOWN

+ const RPL_MOTD

+ const RPL_MOTDSTART

+ const RPL_MYINFO

+ const RPL_NAMREPLY

+ const RPL_NOTOPIC

+ const RPL_NOUSERS

+ const RPL_NOWAWAY

+ const RPL_REHASHING

+ const RPL_SERVLIST

+ const RPL_SERVLISTEND

+ const RPL_STATSCOMMANDS

+ const RPL_STATSLINKINFO

+ const RPL_STATSOLINE

+ const RPL_STATSUPTIME

+ const RPL_SUMMONING

+ const RPL_TIME

+ const RPL_TOPIC

+ const RPL_TRACECLASS

+ const RPL_TRACECONNECTING

+ const RPL_TRACEEND

+ const RPL_TRACEHANDSHAKE

+ const RPL_TRACELINK

+ const RPL_TRACELOG

+ const RPL_TRACENEWTYPE

+ const RPL_TRACEOPERATOR

+ const RPL_TRACERECONNECT

+ const RPL_TRACESERVER

+ const RPL_TRACESERVICE

+ const RPL_TRACEUNKNOWN

+ const RPL_TRACEUSER

+ const RPL_TRYAGAIN

+ const RPL_UMODEIS

+ const RPL_UNAWAY

+ const RPL_UNIQOPIS

+ const RPL_USERHOST

+ const RPL_USERS

+ const RPL_USERSSTART

+ const RPL_VERSION

+ const RPL_WELCOME

+ const RPL_WHOISCHANNELS

+ const RPL_WHOISIDLE

+ const RPL_WHOISOPERATOR

+ const RPL_WHOISSECURE

+ const RPL_WHOISSERVER

+ const RPL_WHOISUSER

+ const RPL_WHOREPLY

+ const RPL_WHOWASUSER

+ const RPL_YOUREOPER

+ const RPL_YOURESERVICE

+ const RPL_YOURHOST

+ const TIME

+ const TOPIC

+ const USER

+ const VERSION

+ const W

+ const WHO

+ const WHOIS

+ const WHOWAS

+ var Build = "-dev"

+ var ChannelNameExpr = regexp.MustCompile(`^[&!#+][\pL\pN]{1,63}$`)

+ var EmptyPasswordError = errors.New("empty password")

+ var ErrNickMissing = errors.New("nick missing")

+ var ErrNicknameInUse = errors.New("nickname in use")

+ var ErrNicknameMismatch = errors.New("nickname mismatch")

+ var ErrParseCommand = errors.New("failed to parse message")

+ var GitCommit = "HEAD"

+ var Log = NewLogging("warn")

+ var NicknameExpr = regexp.MustCompile("^[\\pL\\pN\\pP\\pS]{1,32}$")

+ var NotEnoughArgsError = errors.New("not enough arguments")

+ var SERVER_SIGNALS = []os.Signal

+ var SupportedCapabilities = CapabilitySet

+ var SupportedChannelModes = ChannelModes

+ var SupportedUserModes = UserModes

+ var Version = "1.5.1"

+ func ComparePassword(hash, password []byte) error

+ func DecodePassword(encoded string) (decoded []byte, err error)

+ func FullVersion() string

+ func GenerateEncodedPassword(passwd string) (encoded string, err error)

+ func HasWildcards(mask string) bool

+ func NewLogger(on bool) *log.Logger

+ func NewNumericReply(target *Client, code NumericCode, format string, args ...interface{}) string

+ func NewStringReply(source Identifiable, code StringCode, format string, args ...interface{}) string

+ func OpenDB(path string) *sql.DB

+ func QuoteLike(userhost Name) string

+ func RplCTCPAction(source Identifiable, target Identifiable, action CTCPText) string

+ func RplCap(client *Client, subCommand CapSubCommand, arg interface{}) string

+ func RplChannelMode(client *Client, channel *Channel, changes ChannelModeChanges) string

+ func RplError(message string) string

+ func RplInviteMsg(inviter *Client, invitee *Client, channel Name) string

+ func RplJoin(client *Client, channel *Channel) string

+ func RplKick(channel *Channel, client *Client, target *Client, comment Text) string

+ func RplKill(client *Client, target *Client, comment Text) string

+ func RplModeChanges(client *Client, target *Client, changes ModeChanges) string

+ func RplNick(source Identifiable, newNick Name) string

+ func RplNotice(source Identifiable, target Identifiable, message Text) string

+ func RplPart(client *Client, channel *Channel, message Text) string

+ func RplPing(target Identifiable) string

+ func RplPong(client *Client, msg Text) string

+ func RplPrivMsg(source Identifiable, target Identifiable, message Text) string

+ func RplQuit(client *Client, message Text) string

+ func RplTopicMsg(source Identifiable, channel *Channel) string

+ type AwayCommand struct

+ func (msg *AwayCommand) HandleServer(server *Server)

+ type BaseCommand struct

+ func (command *BaseCommand) Client() *Client

+ func (command *BaseCommand) Code() StringCode

+ func (command *BaseCommand) SetClient(client *Client)

+ func (command *BaseCommand) SetCode(code StringCode)

+ type CTCPText string

+ func NewCTCPText(str string) CTCPText

+ type CapCommand struct

+ func (msg *CapCommand) HandleRegServer(server *Server)

+ type CapModifier rune

+ const Ack

+ const Disable

+ const Sticky

+ func (mod CapModifier) String() string

+ type CapState uint

+ const CapNegotiated

+ const CapNegotiating

+ const CapNone

+ type CapSubCommand string

+ const CAP_ACK

+ const CAP_CLEAR

+ const CAP_END

+ const CAP_LIST

+ const CAP_LS

+ const CAP_NAK

+ const CAP_REQ

+ type Capability string

+ const MultiPrefix

+ const SASL

+ func (capability Capability) String() string

+ type CapabilitySet map[Capability]bool

+ func (set CapabilitySet) DisableString() string

+ func (set CapabilitySet) String() string

+ type Channel struct

+ func NewChannel(s *Server, name Name) *Channel

+ func (channel *Channel) CanSpeak(client *Client) bool

+ func (channel *Channel) CheckKey(key Text) bool

+ func (channel *Channel) ClientIsOperator(client *Client) bool

+ func (channel *Channel) GetTopic(client *Client)

+ func (channel *Channel) Id() Name

+ func (channel *Channel) Invite(invitee *Client, inviter *Client)

+ func (channel *Channel) IsEmpty() bool

+ func (channel *Channel) IsFull() bool

+ func (channel *Channel) Join(client *Client, key Text)

+ func (channel *Channel) Kick(client *Client, target *Client, comment Text)

+ func (channel *Channel) Mode(client *Client, changes ChannelModeChanges)

+ func (channel *Channel) ModeString(client *Client) (str string)

+ func (channel *Channel) Names(client *Client)

+ func (channel *Channel) Nick() Name

+ func (channel *Channel) Nicks(target *Client) []string

+ func (channel *Channel) Notice(client *Client, message Text)

+ func (channel *Channel) Part(client *Client, message Text)

+ func (channel *Channel) PrivMsg(client *Client, message Text)

+ func (channel *Channel) Quit(client *Client)

+ func (channel *Channel) SetTopic(client *Client, topic Text)

+ func (channel *Channel) ShowMaskList(client *Client, mode ChannelMode)

+ func (channel *Channel) String() string

+ type ChannelMode rune

+ const Anonymous

+ const BanMask

+ const ChannelCreator

+ const ChannelOperator

+ const ExceptMask

+ const InviteMask

+ const InviteOnly

+ const Key

+ const Moderated

+ const NoOutside

+ const OpOnlyTopic

+ const Private

+ const Quiet

+ const ReOp

+ const Secret

+ const UserLimit

+ const Voice

+ func (mode ChannelMode) String() string

+ type ChannelModeChange struct

+ func (change *ChannelModeChange) String() (str string)

+ type ChannelModeChanges []*ChannelModeChange

+ func (changes ChannelModeChanges) String() (str string)

+ type ChannelModeCommand struct

+ func (msg *ChannelModeCommand) HandleServer(server *Server)

+ type ChannelModeSet map[ChannelMode]bool

+ func (set ChannelModeSet) String() string

+ type ChannelModes []ChannelMode

+ func (modes ChannelModes) String() string

+ type ChannelNameMap map[Name]*Channel

+ func (channels ChannelNameMap) Add(channel *Channel) error

+ func (channels ChannelNameMap) Get(name Name) *Channel

+ func (channels ChannelNameMap) Remove(channel *Channel) error

+ type ChannelSet map[*Channel]bool

+ func (channels ChannelSet) Add(channel *Channel)

+ func (channels ChannelSet) First() *Channel

+ func (channels ChannelSet) Remove(channel *Channel)

+ type Client struct

+ func NewClient(server *Server, conn net.Conn) *Client

+ func (c *Client) Id() Name

+ func (c *Client) ModeString() (str string)

+ func (c *Client) Nick() Name

+ func (c *Client) String() string

+ func (c *Client) UserHost() Name

+ func (client *Client) Active()

+ func (client *Client) CanSpeak(target *Client) bool

+ func (client *Client) ChangeNickname(nickname Name)

+ func (client *Client) Friends() ClientSet

+ func (client *Client) HasNick() bool

+ func (client *Client) HasUsername() bool

+ func (client *Client) Idle()

+ func (client *Client) IdleSeconds() uint64

+ func (client *Client) IdleTime() time.Duration

+ func (client *Client) Quit(message Text)

+ func (client *Client) Register()

+ func (client *Client) Reply(reply string) error

+ func (client *Client) SetNickname(nickname Name)

+ func (client *Client) SignonTime() int64

+ func (client *Client) Touch()

+ func (client *Client) WhoisChannelsNames() []string

+ func (target *Client) ErrAlreadyRegistered()

+ func (target *Client) ErrBadChannelKey(channel *Channel)

+ func (target *Client) ErrBannedFromChan(channel *Channel)

+ func (target *Client) ErrCannotSendToChan(channel *Channel)

+ func (target *Client) ErrCannotSendToUser(nick Name, reason string)

+ func (target *Client) ErrChanOPrivIsNeeded(channel *Channel)

+ func (target *Client) ErrChannelIsFull(channel *Channel)

+ func (target *Client) ErrConfiguredMode(mode ChannelMode)

+ func (target *Client) ErrErroneusNickname(nick Name)

+ func (target *Client) ErrInvalidCapCmd(subCommand CapSubCommand)

+ func (target *Client) ErrInviteOnlyChan(channel *Channel)

+ func (target *Client) ErrInviteOnlyChannel(channel *Channel)

+ func (target *Client) ErrNeedMoreParams(command StringCode)

+ func (target *Client) ErrNickNameInUse(nick Name)

+ func (target *Client) ErrNoChanModes(channel *Channel)

+ func (target *Client) ErrNoMOTD()

+ func (target *Client) ErrNoNicknameGiven()

+ func (target *Client) ErrNoPrivileges()

+ func (target *Client) ErrNoSuchChannel(channel Name)

+ func (target *Client) ErrNoSuchNick(nick Name)

+ func (target *Client) ErrNoSuchServer(server Name)

+ func (target *Client) ErrNotOnChannel(channel *Channel)

+ func (target *Client) ErrPasswdMismatch()

+ func (target *Client) ErrRestricted()

+ func (target *Client) ErrUnknownCommand(code StringCode)

+ func (target *Client) ErrUnknownMode(mode ChannelMode, channel *Channel)

+ func (target *Client) ErrUserNotInChannel(channel *Channel, client *Client)

+ func (target *Client) ErrUserOnChannel(channel *Channel, member *Client)

+ func (target *Client) ErrUsersDontMatch()

+ func (target *Client) ErrWasNoSuchNick(nickname Name)

+ func (target *Client) MultilineReply(names []string, code NumericCode, format string, args ...interface{})

+ func (target *Client) NumericReply(code NumericCode, format string, args ...interface{})

+ func (target *Client) RplAway(client *Client)

+ func (target *Client) RplBanList(channel *Channel, mask Name)

+ func (target *Client) RplChannelModeIs(channel *Channel)

+ func (target *Client) RplCreated()

+ func (target *Client) RplEndOfBanList(channel *Channel)

+ func (target *Client) RplEndOfExceptList(channel *Channel)

+ func (target *Client) RplEndOfInviteList(channel *Channel)

+ func (target *Client) RplEndOfMaskList(mode ChannelMode, channel *Channel)

+ func (target *Client) RplEndOfNames(channel *Channel)

+ func (target *Client) RplEndOfWho(name Name)

+ func (target *Client) RplEndOfWhoWas(nickname Name)

+ func (target *Client) RplEndOfWhois()

+ func (target *Client) RplExceptList(channel *Channel, mask Name)

+ func (target *Client) RplInviteList(channel *Channel, mask Name)

+ func (target *Client) RplInviting(invitee *Client, channel Name)

+ func (target *Client) RplInvitingMsg(invitee *Client, channel Name)

+ func (target *Client) RplIsOn(nicks []string)

+ func (target *Client) RplList(channel *Channel)

+ func (target *Client) RplListEnd(server *Server)

+ func (target *Client) RplMOTD(line string)

+ func (target *Client) RplMOTDEnd()

+ func (target *Client) RplMOTDStart()

+ func (target *Client) RplMaskList(mode ChannelMode, channel *Channel, mask Name)

+ func (target *Client) RplMyInfo()

+ func (target *Client) RplNamReply(channel *Channel)

+ func (target *Client) RplNoTopic(channel *Channel)

+ func (target *Client) RplNowAway()

+ func (target *Client) RplTime()

+ func (target *Client) RplTopic(channel *Channel)

+ func (target *Client) RplUModeIs(client *Client)

+ func (target *Client) RplUnAway()

+ func (target *Client) RplVersion()

+ func (target *Client) RplWelcome()

+ func (target *Client) RplWhoReply(channel *Channel, client *Client)

+ func (target *Client) RplWhoWasUser(whoWas *WhoWas)

+ func (target *Client) RplWhois(client *Client)

+ func (target *Client) RplWhoisChannels(client *Client)

+ func (target *Client) RplWhoisIdle(client *Client)

+ func (target *Client) RplWhoisOperator(client *Client)

+ func (target *Client) RplWhoisSecure(client *Client)

+ func (target *Client) RplWhoisUser(client *Client)

+ func (target *Client) RplYourHost()

+ func (target *Client) RplYoureOper()

+ type ClientDB struct

+ func NewClientDB() *ClientDB

+ func (db *ClientDB) Add(client *Client)

+ func (db *ClientDB) Remove(client *Client)

+ type ClientLookupSet struct

+ func NewClientLookupSet() *ClientLookupSet

+ func (clients *ClientLookupSet) Add(client *Client) error

+ func (clients *ClientLookupSet) Find(userhost Name) *Client

+ func (clients *ClientLookupSet) FindAll(userhost Name) (set ClientSet)

+ func (clients *ClientLookupSet) Get(nick Name) *Client

+ func (clients *ClientLookupSet) Remove(client *Client) error

+ type ClientSet map[*Client]bool

+ func (clients ClientSet) Add(client *Client)

+ func (clients ClientSet) Has(client *Client) bool

+ func (clients ClientSet) Remove(client *Client)

+ type Command interface

+ Client func() *Client

+ Code func() StringCode

+ SetClient func(*Client)

+ SetCode func(StringCode)

+ func ParseAwayCommand(args []string) (Command, error)

+ func ParseCapCommand(args []string) (Command, error)

+ func ParseChannelModeCommand(channel Name, args []string) (Command, error)

+ func ParseCommand(line string) (cmd Command, err error)

+ func ParseInviteCommand(args []string) (Command, error)

+ func ParseIsOnCommand(args []string) (Command, error)

+ func ParseJoinCommand(args []string) (Command, error)

+ func ParseKickCommand(args []string) (Command, error)

+ func ParseKillCommand(args []string) (Command, error)

+ func ParseListCommand(args []string) (Command, error)

+ func ParseMOTDCommand(args []string) (Command, error)

+ func ParseModeCommand(args []string) (Command, error)

+ func ParseNamesCommand(args []string) (Command, error)

+ func ParseNickCommand(args []string) (Command, error)

+ func ParseNoticeCommand(args []string) (Command, error)

+ func ParseOperCommand(args []string) (Command, error)

+ func ParseOperNickCommand(args []string) (Command, error)

+ func ParsePartCommand(args []string) (Command, error)

+ func ParsePassCommand(args []string) (Command, error)

+ func ParsePingCommand(args []string) (Command, error)

+ func ParsePongCommand(args []string) (Command, error)

+ func ParsePrivMsgCommand(args []string) (Command, error)

+ func ParseQuitCommand(args []string) (Command, error)

+ func ParseTimeCommand(args []string) (Command, error)

+ func ParseTopicCommand(args []string) (Command, error)

+ func ParseUserCommand(args []string) (Command, error)

+ func ParseUserModeCommand(nickname Name, args []string) (Command, error)

+ func ParseVersionCommand(args []string) (Command, error)

+ func ParseWhoCommand(args []string) (Command, error)

+ func ParseWhoWasCommand(args []string) (Command, error)

+ func ParseWhoisCommand(args []string) (Command, error)

+ type Config struct

+ Operator map[string]*PassConfig

+ Server struct{ ... }

+ func LoadConfig(filename string) (config *Config, err error)

+ func (conf *Config) Operators() map[Name][]byte

+ type Identifiable interface

+ Id func() Name

+ Nick func() Name

+ type InviteCommand struct

+ func (msg *InviteCommand) HandleServer(server *Server)

+ type IsOnCommand struct

+ func (msg *IsOnCommand) HandleServer(server *Server)

+ type JoinCommand struct

+ func (m *JoinCommand) HandleServer(s *Server)

+ type KickCommand struct

+ func (msg *KickCommand) Comment() Text

+ func (msg *KickCommand) HandleServer(server *Server)

+ type KillCommand struct

+ func (msg *KillCommand) HandleServer(server *Server)

+ type ListCommand struct

+ func (msg *ListCommand) HandleServer(server *Server)

+ type Logging struct

+ func NewLogging(level string) *Logging

+ func (logging *Logging) SetLevel(level string)

+ type MOTDCommand struct

+ func (msg *MOTDCommand) HandleServer(server *Server)

+ type MemberSet map[*Client]ChannelModeSet

+ func (members MemberSet) Add(member *Client)

+ func (members MemberSet) AnyHasMode(mode ChannelMode) bool

+ func (members MemberSet) Has(member *Client) bool

+ func (members MemberSet) HasMode(member *Client, mode ChannelMode) bool

+ func (members MemberSet) Remove(member *Client)

+ type ModeChange struct

+ func (change *ModeChange) String() string

+ type ModeChanges []*ModeChange

+ func (changes ModeChanges) String() string

+ type ModeCommand struct

+ func (m *ModeCommand) HandleServer(s *Server)

+ type ModeOp rune

+ const Add

+ const List

+ const Remove

+ func (op ModeOp) String() string

+ type Name string

+ func AddrLookupHostname(addr net.Addr) Name

+ func ExpandUserHost(userhost Name) (expanded Name)

+ func IPString(addr net.Addr) Name

+ func LookupHostname(addr Name) Name

+ func NewName(str string) Name

+ func NewNames(strs []string) []Name

+ func (name Name) IsChannel() bool

+ func (name Name) IsNickname() bool

+ func (name Name) String() string

+ func (name Name) Text() Text

+ func (name Name) ToLower() Name

+ type NamesCommand struct

+ func (msg *NamesCommand) HandleServer(server *Server)

+ type NickCommand struct

+ func (m *NickCommand) HandleRegServer(s *Server)

+ func (msg *NickCommand) HandleServer(server *Server)

+ type NoticeCommand struct

+ func (msg *NoticeCommand) HandleServer(server *Server)

+ type NumericCode uint

+ func (code NumericCode) String() string

+ type OperCommand struct

+ func (msg *OperCommand) HandleServer(server *Server)

+ func (msg *OperCommand) LoadPassword(server *Server)

+ type OperNickCommand struct

+ func (msg *OperNickCommand) HandleServer(server *Server)

+ type PartCommand struct

+ func (cmd *PartCommand) Message() Text

+ func (m *PartCommand) HandleServer(server *Server)

+ type PassCommand struct

+ func (cmd *PassCommand) CheckPassword()

+ func (cmd *PassCommand) LoadPassword(server *Server)

+ func (m *PassCommand) HandleServer(s *Server)

+ func (msg *PassCommand) HandleRegServer(server *Server)

+ type PassConfig struct

+ Password string

+ func (conf *PassConfig) PasswordBytes() []byte

+ type PingCommand struct

+ func (m *PingCommand) HandleServer(s *Server)

+ type PongCommand struct

+ func (m *PongCommand) HandleServer(s *Server)

+ type PrivMsgCommand struct

+ func (msg *PrivMsgCommand) HandleServer(server *Server)

+ type QuitCommand struct

+ func NewQuitCommand(message Text) *QuitCommand

+ func (msg *QuitCommand) HandleRegServer(server *Server)

+ func (msg *QuitCommand) HandleServer(server *Server)

+ type RFC1459UserCommand struct

+ func (msg *RFC1459UserCommand) HandleRegServer(server *Server)

+ type RFC2812UserCommand struct

+ func (cmd *RFC2812UserCommand) Flags() []UserMode

+ func (msg *RFC2812UserCommand) HandleRegServer(server *Server)

+ type RegServerCommand interface

+ HandleRegServer func(*Server)

+ type ReplyCode interface

+ String func() string

+ type Server struct

+ func NewServer(config *Config) *Server

+ func (s *Server) Id() Name

+ func (s *Server) Nick() Name

+ func (s *Server) String() string

+ func (server *Server) MOTD(client *Client)

+ func (server *Server) Reply(target *Client, message string)

+ func (server *Server) Replyf(target *Client, format string, args ...interface{})

+ func (server *Server) Run()

+ func (server *Server) Shutdown()

+ type ServerCommand interface

+ HandleServer func(*Server)

+ type Socket struct

+ func NewSocket(conn net.Conn) *Socket

+ func (socket *Socket) Close()

+ func (socket *Socket) Read() (line string, err error)

+ func (socket *Socket) String() string

+ func (socket *Socket) Write(line string) (err error)

+ type StringCode string

+ func ParseLine(line string) (command StringCode, args []string)

+ func (code StringCode) String() string

+ type TLSConfig struct

+ Cert string

+ Key string

+ type Text string

+ func NewText(str string) Text

+ func (text Text) String() string

+ type TimeCommand struct

+ func (msg *TimeCommand) HandleServer(server *Server)

+ type TopicCommand struct

+ func (msg *TopicCommand) HandleServer(server *Server)

+ type UnknownCommand struct

+ func ParseUnknownCommand(args []string) *UnknownCommand

+ type UserCommand struct

+ func (m *UserCommand) HandleServer(s *Server)

+ type UserMaskSet struct

+ func NewUserMaskSet() *UserMaskSet

+ func (set *UserMaskSet) Add(mask Name) bool

+ func (set *UserMaskSet) AddAll(masks []Name) (added bool)

+ func (set *UserMaskSet) Match(userhost Name) bool

+ func (set *UserMaskSet) Remove(mask Name) bool

+ func (set *UserMaskSet) String() string

+ type UserMode rune

+ const Away

+ const Invisible

+ const LocalOperator

+ const Operator

+ const Restricted

+ const SecureConn

+ const SecureOnly

+ const ServerNotice

+ const WallOps

+ func (mode UserMode) String() string

+ type UserModes []UserMode

+ func (modes UserModes) String() string

+ type VersionCommand struct

+ func (msg *VersionCommand) HandleServer(server *Server)

+ type WhoCommand struct

+ func (msg *WhoCommand) HandleServer(server *Server)

+ type WhoWas struct

+ type WhoWasCommand struct

+ func (msg *WhoWasCommand) HandleServer(server *Server)

+ type WhoWasList struct

+ func NewWhoWasList(size uint) *WhoWasList

+ func (list *WhoWasList) Append(client *Client)

+ func (list *WhoWasList) Each() <-chan *WhoWas

+ func (list *WhoWasList) Find(nickname Name, limit int64) []*WhoWas

+ type WhoisCommand struct

+ func (m *WhoisCommand) HandleServer(server *Server)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL