2016-06-15 13:50:56 +02:00
|
|
|
// Copyright (c) 2012-2014 Jeremy Latt
|
|
|
|
// Copyright (c) 2014-2015 Edmund Huber
|
|
|
|
// Copyright (c) 2016- Daniel Oaks <daniel@danieloaks.net>
|
|
|
|
// released under the MIT license
|
|
|
|
|
2012-04-07 20:44:59 +02:00
|
|
|
package irc
|
|
|
|
|
|
|
|
import (
|
2012-04-18 07:11:35 +02:00
|
|
|
"fmt"
|
2016-06-30 11:28:34 +02:00
|
|
|
"log"
|
2012-04-07 20:44:59 +02:00
|
|
|
"net"
|
2016-06-30 07:35:34 +02:00
|
|
|
"strconv"
|
2012-12-12 08:12:35 +01:00
|
|
|
"time"
|
2016-06-17 14:17:42 +02:00
|
|
|
|
|
|
|
"github.com/DanielOaks/girc-go/ircmsg"
|
2016-06-30 11:28:34 +02:00
|
|
|
"github.com/DanielOaks/go-ident"
|
2012-04-07 20:44:59 +02:00
|
|
|
)
|
|
|
|
|
2014-03-13 01:52:25 +01:00
|
|
|
const (
|
2016-07-02 11:12:00 +02:00
|
|
|
IDLE_TIMEOUT = time.Minute + time.Second*30 // how long before a client is considered idle
|
|
|
|
QUIT_TIMEOUT = time.Minute // how long after idle before a client is kicked
|
|
|
|
IdentTimeoutSeconds = 8
|
2016-06-30 07:35:34 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
TIMEOUT_STATED_SECONDS = strconv.Itoa(int((IDLE_TIMEOUT + QUIT_TIMEOUT).Seconds()))
|
2014-03-13 01:52:25 +01:00
|
|
|
)
|
|
|
|
|
2012-04-07 20:44:59 +02:00
|
|
|
type Client struct {
|
2016-10-11 15:51:46 +02:00
|
|
|
account *ClientAccount
|
|
|
|
atime time.Time
|
|
|
|
authorized bool
|
|
|
|
awayMessage string
|
|
|
|
capabilities CapabilitySet
|
|
|
|
capState CapState
|
2016-10-16 05:54:09 +02:00
|
|
|
capVersion CapVersion
|
2016-10-11 15:51:46 +02:00
|
|
|
certfp string
|
|
|
|
channels ChannelSet
|
|
|
|
ctime time.Time
|
|
|
|
flags map[UserMode]bool
|
|
|
|
isDestroyed bool
|
|
|
|
isQuitting bool
|
|
|
|
hasQuit bool
|
|
|
|
hops uint
|
|
|
|
hostname string
|
|
|
|
idleTimer *time.Timer
|
2016-10-16 12:14:56 +02:00
|
|
|
monitoring map[string]bool
|
2016-10-11 15:51:46 +02:00
|
|
|
nick string
|
|
|
|
nickCasefolded string
|
|
|
|
nickMaskString string // cache for nickmask string since it's used with lots of replies
|
|
|
|
nickMaskCasefolded string
|
|
|
|
quitTimer *time.Timer
|
|
|
|
realname string
|
|
|
|
registered bool
|
|
|
|
saslInProgress bool
|
|
|
|
saslMechanism string
|
|
|
|
saslValue string
|
|
|
|
server *Server
|
|
|
|
socket *Socket
|
|
|
|
username string
|
2012-12-17 04:13:53 +01:00
|
|
|
}
|
|
|
|
|
2016-10-16 12:14:56 +02:00
|
|
|
// NewClient returns a client with all the appropriate info setup.
|
2016-06-28 17:09:07 +02:00
|
|
|
func NewClient(server *Server, conn net.Conn, isTLS bool) *Client {
|
2014-02-14 03:59:45 +01:00
|
|
|
now := time.Now()
|
2016-06-15 13:21:45 +02:00
|
|
|
socket := NewSocket(conn)
|
2012-12-09 21:51:50 +01:00
|
|
|
client := &Client{
|
2016-09-19 14:30:29 +02:00
|
|
|
atime: now,
|
|
|
|
authorized: server.password == nil,
|
|
|
|
capabilities: make(CapabilitySet),
|
2016-10-16 05:54:09 +02:00
|
|
|
capState: CapNone,
|
|
|
|
capVersion: Cap301,
|
2016-09-19 14:30:29 +02:00
|
|
|
channels: make(ChannelSet),
|
|
|
|
ctime: now,
|
|
|
|
flags: make(map[UserMode]bool),
|
2016-10-16 12:14:56 +02:00
|
|
|
monitoring: make(map[string]bool),
|
2016-09-19 14:30:29 +02:00
|
|
|
server: server,
|
|
|
|
socket: &socket,
|
|
|
|
account: &NoAccount,
|
2016-10-11 15:51:46 +02:00
|
|
|
nick: "*", // * is used until actual nick is given
|
|
|
|
nickCasefolded: "*",
|
2016-09-19 14:30:29 +02:00
|
|
|
nickMaskString: "*", // * is used until actual nick is given
|
2012-12-09 21:51:50 +01:00
|
|
|
}
|
2016-06-28 17:09:07 +02:00
|
|
|
if isTLS {
|
|
|
|
client.flags[TLS] = true
|
2016-09-07 13:32:58 +02:00
|
|
|
|
|
|
|
// error is not useful to us here anyways so we can ignore it
|
|
|
|
client.certfp, _ = client.socket.CertFP()
|
2016-06-28 17:09:07 +02:00
|
|
|
}
|
2016-06-30 11:28:34 +02:00
|
|
|
if server.checkIdent {
|
|
|
|
_, serverPortString, err := net.SplitHostPort(conn.LocalAddr().String())
|
|
|
|
serverPort, _ := strconv.Atoi(serverPortString)
|
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
clientHost, clientPortString, err := net.SplitHostPort(conn.RemoteAddr().String())
|
|
|
|
clientPort, _ := strconv.Atoi(clientPortString)
|
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
client.Notice("*** Looking up your username")
|
2016-07-02 11:12:00 +02:00
|
|
|
resp, err := ident.Query(clientHost, serverPort, clientPort, IdentTimeoutSeconds)
|
2016-06-30 11:28:34 +02:00
|
|
|
if err == nil {
|
|
|
|
username := resp.Identifier
|
2016-10-11 15:51:46 +02:00
|
|
|
_, err := CasefoldName(username) // ensure it's a valid username
|
|
|
|
if err == nil {
|
2016-06-30 11:28:34 +02:00
|
|
|
client.Notice("*** Found your username")
|
2016-10-11 15:51:46 +02:00
|
|
|
client.username = username
|
2016-06-30 11:28:34 +02:00
|
|
|
// we don't need to updateNickMask here since nickMask is not used for anything yet
|
|
|
|
} else {
|
|
|
|
client.Notice("*** Got a malformed username, ignoring")
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
client.Notice("*** Could not find your username")
|
|
|
|
}
|
|
|
|
}
|
2014-04-15 17:49:52 +02:00
|
|
|
client.Touch()
|
2014-02-24 07:21:39 +01:00
|
|
|
go client.run()
|
2012-12-13 08:27:17 +01:00
|
|
|
|
2012-04-08 08:32:08 +02:00
|
|
|
return client
|
2012-04-07 20:44:59 +02:00
|
|
|
}
|
|
|
|
|
2014-02-24 07:21:39 +01:00
|
|
|
//
|
|
|
|
// command goroutine
|
|
|
|
//
|
|
|
|
|
|
|
|
func (client *Client) run() {
|
2014-04-15 17:49:52 +02:00
|
|
|
var err error
|
2016-06-17 14:17:42 +02:00
|
|
|
var isExiting bool
|
2014-04-15 17:49:52 +02:00
|
|
|
var line string
|
2016-06-17 14:17:42 +02:00
|
|
|
var msg ircmsg.IrcMessage
|
2014-04-15 17:49:52 +02:00
|
|
|
|
2016-10-15 08:29:34 +02:00
|
|
|
// Set the hostname for this client
|
2016-04-21 08:39:31 +02:00
|
|
|
client.hostname = AddrLookupHostname(client.socket.conn.RemoteAddr())
|
2014-04-15 17:49:52 +02:00
|
|
|
|
2016-06-17 14:17:42 +02:00
|
|
|
//TODO(dan): Make this a socketreactor from ircbnc
|
|
|
|
for {
|
|
|
|
line, err = client.socket.Read()
|
|
|
|
if err != nil {
|
|
|
|
client.Quit("connection closed")
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
2016-06-19 02:01:30 +02:00
|
|
|
msg, err = ircmsg.ParseLine(line)
|
2016-06-17 14:17:42 +02:00
|
|
|
if err != nil {
|
2016-06-20 14:53:45 +02:00
|
|
|
client.Quit("received malformed line")
|
2016-06-17 14:17:42 +02:00
|
|
|
break
|
2014-02-24 07:21:39 +01:00
|
|
|
}
|
2014-04-15 17:49:52 +02:00
|
|
|
|
2016-06-19 02:01:30 +02:00
|
|
|
cmd, exists := Commands[msg.Command]
|
|
|
|
if !exists {
|
2016-10-11 15:51:46 +02:00
|
|
|
client.Send(nil, client.server.name, ERR_UNKNOWNCOMMAND, client.nick, msg.Command, "Unknown command")
|
2016-06-20 14:53:45 +02:00
|
|
|
continue
|
2016-06-19 02:01:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
isExiting = cmd.Run(client.server, client, msg)
|
2016-06-22 14:04:13 +02:00
|
|
|
if isExiting || client.isQuitting {
|
2016-06-17 14:17:42 +02:00
|
|
|
break
|
|
|
|
}
|
2014-02-24 07:21:39 +01:00
|
|
|
}
|
|
|
|
|
2016-06-17 14:17:42 +02:00
|
|
|
// ensure client connection gets closed
|
2016-06-19 02:01:30 +02:00
|
|
|
client.destroy()
|
2014-04-15 17:49:52 +02:00
|
|
|
}
|
|
|
|
|
2016-06-17 14:17:42 +02:00
|
|
|
//
|
2014-04-15 17:49:52 +02:00
|
|
|
// quit timer goroutine
|
2016-06-17 14:17:42 +02:00
|
|
|
//
|
2014-04-15 17:49:52 +02:00
|
|
|
|
2014-03-01 04:21:33 +01:00
|
|
|
func (client *Client) connectionTimeout() {
|
2016-06-30 07:35:34 +02:00
|
|
|
client.Quit(fmt.Sprintf("Ping timeout: %s seconds", TIMEOUT_STATED_SECONDS))
|
2016-06-22 14:04:13 +02:00
|
|
|
client.isQuitting = true
|
2014-03-01 04:21:33 +01:00
|
|
|
}
|
|
|
|
|
2014-02-18 22:25:21 +01:00
|
|
|
//
|
|
|
|
// idle timer goroutine
|
|
|
|
//
|
|
|
|
|
|
|
|
func (client *Client) connectionIdle() {
|
|
|
|
client.server.idle <- client
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// server goroutine
|
|
|
|
//
|
|
|
|
|
|
|
|
func (client *Client) Active() {
|
2014-02-14 03:39:33 +01:00
|
|
|
client.atime = time.Now()
|
2014-02-18 22:25:21 +01:00
|
|
|
}
|
2014-02-14 03:39:33 +01:00
|
|
|
|
2014-02-18 22:25:21 +01:00
|
|
|
func (client *Client) Touch() {
|
2014-02-09 21:13:09 +01:00
|
|
|
if client.quitTimer != nil {
|
|
|
|
client.quitTimer.Stop()
|
|
|
|
}
|
2014-02-14 03:39:33 +01:00
|
|
|
|
2014-02-09 21:13:09 +01:00
|
|
|
if client.idleTimer == nil {
|
2014-02-18 20:22:56 +01:00
|
|
|
client.idleTimer = time.AfterFunc(IDLE_TIMEOUT, client.connectionIdle)
|
2014-02-09 21:13:09 +01:00
|
|
|
} else {
|
|
|
|
client.idleTimer.Reset(IDLE_TIMEOUT)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (client *Client) Idle() {
|
2016-10-11 15:51:46 +02:00
|
|
|
client.Send(nil, "", "PING", client.nick)
|
2014-02-18 20:22:56 +01:00
|
|
|
|
2014-02-09 21:13:09 +01:00
|
|
|
if client.quitTimer == nil {
|
2014-02-18 02:58:22 +01:00
|
|
|
client.quitTimer = time.AfterFunc(QUIT_TIMEOUT, client.connectionTimeout)
|
2014-02-09 21:13:09 +01:00
|
|
|
} else {
|
|
|
|
client.quitTimer.Reset(QUIT_TIMEOUT)
|
|
|
|
}
|
2014-02-18 20:22:56 +01:00
|
|
|
}
|
2014-02-14 03:39:33 +01:00
|
|
|
|
2014-02-18 22:25:21 +01:00
|
|
|
func (client *Client) Register() {
|
2014-03-13 01:52:25 +01:00
|
|
|
if client.registered {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
client.registered = true
|
2014-02-18 22:25:21 +01:00
|
|
|
client.Touch()
|
2016-10-16 12:14:56 +02:00
|
|
|
|
|
|
|
client.alertMonitors()
|
2012-12-13 08:27:17 +01:00
|
|
|
}
|
|
|
|
|
2014-02-18 00:25:32 +01:00
|
|
|
func (client *Client) IdleTime() time.Duration {
|
|
|
|
return time.Since(client.atime)
|
|
|
|
}
|
|
|
|
|
2014-02-18 04:56:06 +01:00
|
|
|
func (client *Client) SignonTime() int64 {
|
|
|
|
return client.ctime.Unix()
|
|
|
|
}
|
|
|
|
|
2014-02-18 04:08:57 +01:00
|
|
|
func (client *Client) IdleSeconds() uint64 {
|
|
|
|
return uint64(client.IdleTime().Seconds())
|
|
|
|
}
|
|
|
|
|
2014-02-09 02:10:04 +01:00
|
|
|
func (client *Client) HasNick() bool {
|
2016-10-11 15:51:46 +02:00
|
|
|
return client.nick != "" && client.nick != "*"
|
2012-12-17 04:13:53 +01:00
|
|
|
}
|
|
|
|
|
2014-02-09 02:10:04 +01:00
|
|
|
func (client *Client) HasUsername() bool {
|
2016-10-11 15:51:46 +02:00
|
|
|
return client.username != "" && client.username != "*"
|
2014-02-09 02:10:04 +01:00
|
|
|
}
|
|
|
|
|
2014-02-09 17:53:06 +01:00
|
|
|
// <mode>
|
|
|
|
func (c *Client) ModeString() (str string) {
|
2016-09-07 13:50:42 +02:00
|
|
|
str = "+"
|
|
|
|
|
2014-02-17 22:22:35 +01:00
|
|
|
for flag := range c.flags {
|
|
|
|
str += flag.String()
|
2014-02-09 19:07:40 +01:00
|
|
|
}
|
|
|
|
|
2014-02-09 17:53:06 +01:00
|
|
|
return
|
2012-04-18 05:24:26 +02:00
|
|
|
}
|
2012-04-18 06:13:12 +02:00
|
|
|
|
2016-10-11 15:51:46 +02:00
|
|
|
func (c *Client) UserHost() string {
|
|
|
|
return fmt.Sprintf("%s!%s@%s", c.nick, c.username, c.hostname)
|
2012-04-18 06:13:12 +02:00
|
|
|
}
|
2012-04-18 07:11:35 +02:00
|
|
|
|
2016-10-11 15:51:46 +02:00
|
|
|
func (c *Client) Id() string {
|
2012-12-09 07:54:58 +01:00
|
|
|
return c.UserHost()
|
2012-04-18 07:11:35 +02:00
|
|
|
}
|
2012-12-15 23:34:20 +01:00
|
|
|
|
2016-06-17 14:17:42 +02:00
|
|
|
// Friends refers to clients that share a channel with this client.
|
2016-10-13 10:08:08 +02:00
|
|
|
func (client *Client) Friends(Capabilities ...Capability) ClientSet {
|
2014-02-19 00:28:20 +01:00
|
|
|
friends := make(ClientSet)
|
|
|
|
friends.Add(client)
|
|
|
|
for channel := range client.channels {
|
|
|
|
for member := range channel.members {
|
2016-10-13 10:08:08 +02:00
|
|
|
// make sure they have all the required caps
|
|
|
|
for _, Cap := range Capabilities {
|
|
|
|
if !member.capabilities[Cap] {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2014-02-19 00:28:20 +01:00
|
|
|
friends.Add(member)
|
|
|
|
}
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
2014-02-19 00:28:20 +01:00
|
|
|
return friends
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
|
|
|
|
2016-06-19 07:37:29 +02:00
|
|
|
func (client *Client) updateNickMask() {
|
2016-10-11 15:51:46 +02:00
|
|
|
casefoldedName, err := CasefoldName(client.nick)
|
|
|
|
if err != nil {
|
|
|
|
log.Println(fmt.Sprintf("ERROR: Nick [%s] couldn't be casefolded... this should never happen.", client.nick))
|
|
|
|
}
|
|
|
|
client.nickCasefolded = casefoldedName
|
|
|
|
|
|
|
|
client.nickMaskString = fmt.Sprintf("%s!%s@%s", client.nick, client.username, client.hostname)
|
|
|
|
|
|
|
|
nickMaskCasefolded, err := Casefold(client.nickMaskString)
|
|
|
|
if err != nil {
|
|
|
|
log.Println(fmt.Sprintf("ERROR: Nickmask [%s] couldn't be casefolded... this should never happen.", client.nickMaskString))
|
|
|
|
}
|
|
|
|
client.nickMaskCasefolded = nickMaskCasefolded
|
2016-06-19 07:37:29 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 15:51:46 +02:00
|
|
|
func (client *Client) SetNickname(nickname string) {
|
2014-03-17 20:11:35 +01:00
|
|
|
if client.HasNick() {
|
2016-10-11 15:51:46 +02:00
|
|
|
Log.error.Printf("%s nickname already set!", client.nickMaskString)
|
2014-03-17 20:11:35 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-19 00:36:58 +01:00
|
|
|
client.nick = nickname
|
2016-06-19 07:37:29 +02:00
|
|
|
client.updateNickMask()
|
2014-02-19 00:36:58 +01:00
|
|
|
client.server.clients.Add(client)
|
|
|
|
}
|
|
|
|
|
2016-10-11 15:51:46 +02:00
|
|
|
func (client *Client) ChangeNickname(nickname string) {
|
2016-06-19 07:37:29 +02:00
|
|
|
origNickMask := client.nickMaskString
|
2014-02-19 00:36:58 +01:00
|
|
|
client.server.clients.Remove(client)
|
2014-03-06 22:55:25 +01:00
|
|
|
client.server.whoWas.Append(client)
|
2014-02-17 07:20:42 +01:00
|
|
|
client.nick = nickname
|
2016-06-19 07:37:29 +02:00
|
|
|
client.updateNickMask()
|
2014-02-19 00:36:58 +01:00
|
|
|
client.server.clients.Add(client)
|
2014-02-19 00:28:20 +01:00
|
|
|
for friend := range client.Friends() {
|
2016-10-11 15:51:46 +02:00
|
|
|
friend.Send(nil, origNickMask, "NICK", nickname)
|
2014-02-22 20:40:32 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-15 18:07:25 +02:00
|
|
|
func (client *Client) Reply(reply string) error {
|
2016-06-15 13:21:45 +02:00
|
|
|
//TODO(dan): We'll be passing around real message objects instead of raw strings
|
|
|
|
return client.socket.WriteLine(reply)
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
|
|
|
|
2016-06-19 02:01:30 +02:00
|
|
|
func (client *Client) Quit(message string) {
|
2016-06-19 06:55:24 +02:00
|
|
|
client.Send(nil, client.nickMaskString, "QUIT", message)
|
|
|
|
client.Send(nil, client.nickMaskString, "ERROR", message)
|
2016-06-17 14:17:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (client *Client) destroy() {
|
|
|
|
if client.isDestroyed {
|
2014-02-18 22:25:21 +01:00
|
|
|
return
|
|
|
|
}
|
2014-02-20 03:46:46 +01:00
|
|
|
|
2016-06-17 14:17:42 +02:00
|
|
|
client.isDestroyed = true
|
2014-03-06 22:55:25 +01:00
|
|
|
client.server.whoWas.Append(client)
|
2014-02-19 00:28:20 +01:00
|
|
|
friends := client.Friends()
|
|
|
|
friends.Remove(client)
|
2016-06-17 14:17:42 +02:00
|
|
|
|
2016-10-16 12:14:56 +02:00
|
|
|
// alert monitors
|
|
|
|
for _, mClient := range client.server.monitoring[client.nickCasefolded] {
|
|
|
|
mClient.Send(nil, client.server.name, RPL_MONOFFLINE, mClient.nick, client.nick)
|
|
|
|
}
|
|
|
|
|
|
|
|
// remove my monitors
|
|
|
|
client.clearMonitorList()
|
|
|
|
|
2016-06-17 14:17:42 +02:00
|
|
|
// clean up channels
|
|
|
|
for channel := range client.channels {
|
|
|
|
channel.Quit(client)
|
|
|
|
}
|
|
|
|
|
|
|
|
// clean up server
|
|
|
|
client.server.clients.Remove(client)
|
|
|
|
|
|
|
|
// clean up self
|
|
|
|
if client.idleTimer != nil {
|
|
|
|
client.idleTimer.Stop()
|
|
|
|
}
|
|
|
|
if client.quitTimer != nil {
|
|
|
|
client.quitTimer.Stop()
|
|
|
|
}
|
|
|
|
|
|
|
|
client.socket.Close()
|
2016-06-19 02:01:30 +02:00
|
|
|
for friend := range client.Friends() {
|
|
|
|
//TODO(dan): store quit message in user, if exists use that instead here
|
2016-06-19 06:55:24 +02:00
|
|
|
friend.Send(nil, client.nickMaskString, "QUIT", "Exited")
|
2016-06-19 02:01:30 +02:00
|
|
|
}
|
|
|
|
}
|
2014-02-18 22:25:21 +01:00
|
|
|
|
2016-09-12 03:25:31 +02:00
|
|
|
// SendFromClient sends an IRC line coming from a specific client.
|
|
|
|
// Adds account-tag to the line as well.
|
|
|
|
func (client *Client) SendFromClient(from *Client, tags *map[string]ircmsg.TagValue, prefix string, command string, params ...string) error {
|
|
|
|
// attach account-tag
|
|
|
|
if client.capabilities[AccountTag] && from.account != &NoAccount {
|
|
|
|
if tags == nil {
|
|
|
|
tags = ircmsg.MakeTags("account", from.account.Name)
|
|
|
|
} else {
|
|
|
|
(*tags)["account"] = ircmsg.MakeTagValue(from.account.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return client.Send(tags, prefix, command, params...)
|
|
|
|
}
|
|
|
|
|
2016-06-19 02:01:30 +02:00
|
|
|
// Send sends an IRC line to the client.
|
|
|
|
func (client *Client) Send(tags *map[string]ircmsg.TagValue, prefix string, command string, params ...string) error {
|
2016-08-13 14:04:21 +02:00
|
|
|
// attach server-time
|
|
|
|
if client.capabilities[ServerTime] {
|
|
|
|
if tags == nil {
|
2016-09-07 13:48:03 +02:00
|
|
|
tags = ircmsg.MakeTags("time", time.Now().Format("2006-01-02T15:04:05.999Z"))
|
2016-08-13 14:04:21 +02:00
|
|
|
} else {
|
2016-09-07 13:48:03 +02:00
|
|
|
(*tags)["time"] = ircmsg.MakeTagValue(time.Now().Format("2006-01-02T15:04:05.999Z"))
|
2016-08-13 14:04:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// send out the message
|
2016-09-19 15:00:19 +02:00
|
|
|
message := ircmsg.MakeMessage(tags, prefix, command, params...)
|
|
|
|
line, err := message.Line()
|
2016-06-19 02:01:30 +02:00
|
|
|
if err != nil {
|
2016-09-19 15:00:19 +02:00
|
|
|
// try not to fail quietly - especially useful when running tests, as a note to dig deeper
|
2016-10-11 15:51:46 +02:00
|
|
|
message = ircmsg.MakeMessage(nil, client.server.name, ERR_UNKNOWNERROR, "*", "Error assembling message for sending")
|
2016-09-19 15:00:19 +02:00
|
|
|
line, _ := message.Line()
|
|
|
|
client.socket.Write(line)
|
2016-06-19 02:01:30 +02:00
|
|
|
return err
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|
2016-06-19 02:01:30 +02:00
|
|
|
client.socket.Write(line)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Notice sends the client a notice from the server.
|
|
|
|
func (client *Client) Notice(text string) {
|
2016-10-11 15:51:46 +02:00
|
|
|
client.Send(nil, client.server.name, "NOTICE", client.nick, text)
|
2014-02-17 02:23:47 +01:00
|
|
|
}
|