3
0
mirror of https://github.com/ergochat/ergo.git synced 2024-11-29 15:40:02 +01:00
ergo/irc/client.go

258 lines
4.6 KiB
Go
Raw Normal View History

2012-04-07 20:44:59 +02:00
package irc
import (
2012-04-18 07:11:35 +02:00
"fmt"
"log"
2012-04-07 20:44:59 +02:00
"net"
2012-12-12 08:12:35 +01:00
"time"
2012-04-07 20:44:59 +02:00
)
func IsNickname(nick string) bool {
return NicknameExpr.MatchString(nick)
}
2012-04-07 20:44:59 +02:00
type Client struct {
atime time.Time
2014-02-12 00:44:58 +01:00
awayMessage string
channels ChannelSet
2014-02-24 07:21:39 +01:00
commands chan editableCommand
2014-02-14 03:59:45 +01:00
ctime time.Time
2014-02-17 22:22:35 +01:00
flags map[UserMode]bool
2014-02-18 22:25:21 +01:00
hasQuit bool
2014-02-18 06:30:14 +01:00
hops uint
2014-02-12 00:44:58 +01:00
hostname string
idleTimer *time.Timer
loginTimer *time.Timer
2014-02-12 00:44:58 +01:00
nick string
2014-02-15 03:28:36 +01:00
phase Phase
2014-02-12 00:44:58 +01:00
quitTimer *time.Timer
realname string
server *Server
2014-02-14 04:37:16 +01:00
socket *Socket
2014-02-12 00:44:58 +01:00
username string
}
func NewClient(server *Server, conn net.Conn) *Client {
2014-02-14 03:59:45 +01:00
now := time.Now()
2012-12-09 21:51:50 +01:00
client := &Client{
atime: now,
channels: make(ChannelSet),
commands: make(chan editableCommand),
ctime: now,
flags: make(map[UserMode]bool),
phase: server.InitPhase(),
server: server,
2012-12-09 21:51:50 +01:00
}
2014-02-24 07:21:39 +01:00
client.socket = NewSocket(conn, client.commands)
2014-02-18 22:25:21 +01:00
client.loginTimer = time.AfterFunc(LOGIN_TIMEOUT, client.connectionTimeout)
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() {
for command := range client.commands {
command.SetClient(client)
checkPass, ok := command.(checkPasswordCommand)
if ok {
checkPass.LoadPassword(client.server)
checkPass.CheckPassword()
2014-02-24 07:21:39 +01:00
}
client.server.commands <- command
2014-02-24 07:21:39 +01:00
}
}
2014-02-18 22:25:21 +01:00
//
// idle timer goroutine
//
func (client *Client) connectionIdle() {
client.server.idle <- client
}
//
// quit timer goroutine
//
func (client *Client) connectionTimeout() {
client.server.timeout <- client
2014-02-18 22:25:21 +01:00
}
//
// server goroutine
//
func (client *Client) Active() {
client.atime = time.Now()
2014-02-18 22:25:21 +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-09 21:13:09 +01:00
if client.idleTimer == nil {
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() {
2014-02-22 20:40:32 +01:00
client.Reply(RplPing(client))
2014-02-09 21:13:09 +01:00
if client.quitTimer == nil {
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 22:25:21 +01:00
func (client *Client) Register() {
client.phase = Normal
client.loginTimer.Stop()
client.Touch()
2012-12-13 08:27:17 +01:00
}
func (client *Client) destroy() {
2014-02-18 08:58:02 +01:00
// clean up channels
for channel := range client.channels {
channel.Quit(client)
}
// clean up server
client.server.clients.Remove(client)
2014-02-14 08:16:07 +01:00
2014-02-23 20:08:01 +01:00
// clean up self
if client.loginTimer != nil {
client.loginTimer.Stop()
}
if client.idleTimer != nil {
client.idleTimer.Stop()
}
if client.quitTimer != nil {
client.quitTimer.Stop()
}
client.socket.Close()
if DEBUG_CLIENT {
2014-02-18 18:45:10 +01:00
log.Printf("%s: destroyed", client)
2014-02-14 05:42:06 +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())
}
func (client *Client) HasNick() bool {
return client.nick != ""
}
func (client *Client) HasUsername() bool {
return client.username != ""
}
2014-02-09 17:53:06 +01:00
// <mode>
func (c *Client) ModeString() (str string) {
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
if len(str) > 0 {
str = "+" + str
}
return
2012-04-18 05:24:26 +02:00
}
2012-04-18 06:13:12 +02:00
func (c *Client) UserHost() string {
username := "*"
if c.HasUsername() {
username = c.username
}
return fmt.Sprintf("%s!%s@%s", c.Nick(), username, c.hostname)
}
func (c *Client) Nick() string {
if c.HasNick() {
return c.nick
}
return "*"
2012-04-18 06:13:12 +02:00
}
2012-04-18 07:11:35 +02:00
func (c *Client) Id() string {
return c.UserHost()
2012-04-18 07:11:35 +02:00
}
func (c *Client) String() string {
2014-02-18 18:45:10 +01:00
return c.Id()
2013-05-11 22:55:01 +02:00
}
2014-02-19 00:28:20 +01:00
func (client *Client) Friends() ClientSet {
friends := make(ClientSet)
friends.Add(client)
for channel := range client.channels {
for member := range channel.members {
friends.Add(member)
}
}
2014-02-19 00:28:20 +01:00
return friends
}
2014-02-19 00:36:58 +01:00
func (client *Client) SetNickname(nickname string) {
client.nick = nickname
client.server.clients.Add(client)
}
func (client *Client) ChangeNickname(nickname string) {
2014-02-19 00:36:58 +01:00
// Make reply before changing nick to capture original source id.
reply := RplNick(client, nickname)
2014-02-19 00:36:58 +01:00
client.server.clients.Remove(client)
client.nick = nickname
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() {
2014-02-22 20:40:32 +01:00
friend.Reply(reply)
}
}
func (client *Client) Reply(reply string) {
client.socket.Write(reply)
}
func (client *Client) Quit(message string) {
2014-02-18 22:25:21 +01:00
if client.hasQuit {
return
}
2014-02-22 20:40:32 +01:00
client.Reply(RplError("connection closed"))
client.hasQuit = true
2014-02-19 00:28:20 +01:00
friends := client.Friends()
friends.Remove(client)
client.destroy()
2014-02-18 22:25:21 +01:00
2014-02-19 00:28:20 +01:00
if len(friends) > 0 {
reply := RplQuit(client, message)
2014-02-19 00:28:20 +01:00
for friend := range friends {
2014-02-22 20:40:32 +01:00
friend.Reply(reply)
}
}
}