2020-02-06 15:18:19 +00:00
|
|
|
package jounce
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"net"
|
2020-02-07 10:46:44 +00:00
|
|
|
"strings"
|
2020-02-06 15:18:19 +00:00
|
|
|
|
2020-03-11 18:09:32 +00:00
|
|
|
"golang.org/x/crypto/bcrypt"
|
2020-02-06 15:18:19 +00:00
|
|
|
"gopkg.in/irc.v3"
|
|
|
|
)
|
|
|
|
|
|
|
|
type ircError struct {
|
|
|
|
Message *irc.Message
|
|
|
|
}
|
|
|
|
|
2020-03-11 18:09:32 +00:00
|
|
|
func (err ircError) Error() string {
|
|
|
|
return err.Message.String()
|
|
|
|
}
|
|
|
|
|
2020-02-06 15:18:19 +00:00
|
|
|
func newUnknownCommandError(cmd string) ircError {
|
|
|
|
return ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_UNKNOWNCOMMAND,
|
|
|
|
Params: []string{
|
|
|
|
"*",
|
|
|
|
cmd,
|
|
|
|
"Unknown command",
|
|
|
|
},
|
|
|
|
}}
|
|
|
|
}
|
|
|
|
|
|
|
|
func newNeedMoreParamsError(cmd string) ircError {
|
|
|
|
return ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_NEEDMOREPARAMS,
|
|
|
|
Params: []string{
|
|
|
|
"*",
|
|
|
|
cmd,
|
|
|
|
"Not enough parameters",
|
|
|
|
},
|
|
|
|
}}
|
|
|
|
}
|
|
|
|
|
2020-03-11 18:09:32 +00:00
|
|
|
var errAuthFailed = ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_PASSWDMISMATCH,
|
|
|
|
Params: []string{"*", "Invalid username or password"},
|
|
|
|
}}
|
2020-02-06 15:18:19 +00:00
|
|
|
|
2020-02-19 17:25:19 +00:00
|
|
|
type consumption struct {
|
|
|
|
consumer *RingConsumer
|
|
|
|
upstreamConn *upstreamConn
|
|
|
|
}
|
|
|
|
|
2020-02-06 15:18:19 +00:00
|
|
|
type downstreamConn struct {
|
2020-02-19 17:25:19 +00:00
|
|
|
net net.Conn
|
|
|
|
irc *irc.Conn
|
|
|
|
srv *Server
|
|
|
|
logger Logger
|
|
|
|
messages chan *irc.Message
|
|
|
|
consumptions chan consumption
|
|
|
|
closed chan struct{}
|
2020-02-06 20:11:35 +00:00
|
|
|
|
2020-02-06 15:18:19 +00:00
|
|
|
registered bool
|
2020-02-07 10:36:42 +00:00
|
|
|
user *user
|
2020-02-06 15:18:19 +00:00
|
|
|
nick string
|
|
|
|
username string
|
|
|
|
realname string
|
2020-03-11 18:09:32 +00:00
|
|
|
password string // empty after authentication
|
2020-03-04 17:22:58 +00:00
|
|
|
network *network // can be nil
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
|
|
|
|
2020-02-06 20:11:35 +00:00
|
|
|
func newDownstreamConn(srv *Server, netConn net.Conn) *downstreamConn {
|
2020-02-17 11:36:42 +00:00
|
|
|
dc := &downstreamConn{
|
2020-02-19 17:25:19 +00:00
|
|
|
net: netConn,
|
|
|
|
irc: irc.NewConn(netConn),
|
|
|
|
srv: srv,
|
|
|
|
logger: &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())},
|
|
|
|
messages: make(chan *irc.Message, 64),
|
|
|
|
consumptions: make(chan consumption),
|
|
|
|
closed: make(chan struct{}),
|
2020-02-06 20:11:35 +00:00
|
|
|
}
|
2020-02-06 20:52:04 +00:00
|
|
|
|
|
|
|
go func() {
|
2020-02-17 11:41:27 +00:00
|
|
|
if err := dc.writeMessages(); err != nil {
|
|
|
|
dc.logger.Printf("failed to write message: %v", err)
|
2020-02-06 20:52:04 +00:00
|
|
|
}
|
2020-02-17 11:36:42 +00:00
|
|
|
if err := dc.net.Close(); err != nil {
|
|
|
|
dc.logger.Printf("failed to close connection: %v", err)
|
2020-02-07 11:42:24 +00:00
|
|
|
} else {
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.logger.Printf("connection closed")
|
2020-02-07 11:42:24 +00:00
|
|
|
}
|
2020-02-06 20:52:04 +00:00
|
|
|
}()
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
return dc
|
2020-02-06 20:11:35 +00:00
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) prefix() *irc.Prefix {
|
2020-02-06 21:19:31 +00:00
|
|
|
return &irc.Prefix{
|
2020-02-17 11:36:42 +00:00
|
|
|
Name: dc.nick,
|
|
|
|
User: dc.username,
|
2020-02-06 21:19:31 +00:00
|
|
|
// TODO: fill the host?
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-19 17:25:19 +00:00
|
|
|
func (dc *downstreamConn) marshalChannel(uc *upstreamConn, name string) string {
|
|
|
|
return name
|
|
|
|
}
|
|
|
|
|
2020-03-04 14:44:13 +00:00
|
|
|
func (dc *downstreamConn) forEachUpstream(f func(*upstreamConn)) {
|
|
|
|
dc.user.forEachUpstream(func(uc *upstreamConn) {
|
2020-03-04 17:22:58 +00:00
|
|
|
if dc.network != nil && uc.network != dc.network {
|
2020-03-04 14:44:13 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
f(uc)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-03-12 17:33:03 +00:00
|
|
|
// upstream returns the upstream connection, if any. If there are zero or if
|
|
|
|
// there are multiple upstream connections, it returns nil.
|
|
|
|
func (dc *downstreamConn) upstream() *upstreamConn {
|
|
|
|
if dc.network == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var upstream *upstreamConn
|
|
|
|
dc.forEachUpstream(func(uc *upstreamConn) {
|
|
|
|
upstream = uc
|
|
|
|
})
|
|
|
|
return upstream
|
|
|
|
}
|
|
|
|
|
2020-02-19 17:25:19 +00:00
|
|
|
func (dc *downstreamConn) unmarshalChannel(name string) (*upstreamConn, string, error) {
|
2020-03-12 17:33:03 +00:00
|
|
|
if uc := dc.upstream(); uc != nil {
|
|
|
|
return uc, name, nil
|
|
|
|
}
|
|
|
|
|
2020-03-04 14:44:13 +00:00
|
|
|
// TODO: extract network name from channel name if dc.upstream == nil
|
|
|
|
var channel *upstreamChannel
|
|
|
|
var err error
|
|
|
|
dc.forEachUpstream(func(uc *upstreamConn) {
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if ch, ok := uc.channels[name]; ok {
|
|
|
|
if channel != nil {
|
|
|
|
err = fmt.Errorf("ambiguous channel name %q", name)
|
|
|
|
} else {
|
|
|
|
channel = ch
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
if channel == nil {
|
|
|
|
return nil, "", ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_NOSUCHCHANNEL,
|
|
|
|
Params: []string{name, "No such channel"},
|
|
|
|
}}
|
2020-02-19 17:25:19 +00:00
|
|
|
}
|
2020-03-04 14:44:13 +00:00
|
|
|
return channel.conn, channel.Name, nil
|
2020-02-19 17:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (dc *downstreamConn) marshalNick(uc *upstreamConn, nick string) string {
|
|
|
|
if nick == uc.nick {
|
|
|
|
return dc.nick
|
|
|
|
}
|
|
|
|
return nick
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dc *downstreamConn) marshalUserPrefix(uc *upstreamConn, prefix *irc.Prefix) *irc.Prefix {
|
|
|
|
if prefix.Name == uc.nick {
|
|
|
|
return dc.prefix()
|
|
|
|
}
|
|
|
|
return prefix
|
|
|
|
}
|
|
|
|
|
2020-02-17 14:46:29 +00:00
|
|
|
func (dc *downstreamConn) isClosed() bool {
|
|
|
|
select {
|
|
|
|
case <-dc.closed:
|
|
|
|
return true
|
|
|
|
default:
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) readMessages() error {
|
|
|
|
dc.logger.Printf("new connection")
|
2020-02-06 20:11:35 +00:00
|
|
|
|
|
|
|
for {
|
2020-02-17 11:36:42 +00:00
|
|
|
msg, err := dc.irc.ReadMessage()
|
2020-02-06 20:11:35 +00:00
|
|
|
if err == io.EOF {
|
|
|
|
break
|
|
|
|
} else if err != nil {
|
|
|
|
return fmt.Errorf("failed to read IRC command: %v", err)
|
|
|
|
}
|
|
|
|
|
2020-02-18 15:31:18 +00:00
|
|
|
if dc.srv.Debug {
|
|
|
|
dc.logger.Printf("received: %v", msg)
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
err = dc.handleMessage(msg)
|
2020-02-06 20:11:35 +00:00
|
|
|
if ircErr, ok := err.(ircError); ok {
|
2020-02-17 11:36:42 +00:00
|
|
|
ircErr.Message.Prefix = dc.srv.prefix()
|
|
|
|
dc.SendMessage(ircErr.Message)
|
2020-02-06 20:11:35 +00:00
|
|
|
} else if err != nil {
|
|
|
|
return fmt.Errorf("failed to handle IRC command %q: %v", msg.Command, err)
|
|
|
|
}
|
|
|
|
|
2020-02-17 14:46:29 +00:00
|
|
|
if dc.isClosed() {
|
2020-02-06 20:11:35 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-07 11:42:24 +00:00
|
|
|
return nil
|
2020-02-06 20:11:35 +00:00
|
|
|
}
|
|
|
|
|
2020-02-17 11:41:27 +00:00
|
|
|
func (dc *downstreamConn) writeMessages() error {
|
2020-02-17 14:46:29 +00:00
|
|
|
for {
|
|
|
|
var err error
|
|
|
|
var closed bool
|
|
|
|
select {
|
|
|
|
case msg := <-dc.messages:
|
2020-02-18 15:31:18 +00:00
|
|
|
if dc.srv.Debug {
|
|
|
|
dc.logger.Printf("sent: %v", msg)
|
|
|
|
}
|
2020-02-17 14:46:29 +00:00
|
|
|
err = dc.irc.WriteMessage(msg)
|
2020-02-19 17:25:19 +00:00
|
|
|
case consumption := <-dc.consumptions:
|
|
|
|
consumer, uc := consumption.consumer, consumption.upstreamConn
|
2020-02-17 14:46:29 +00:00
|
|
|
for {
|
|
|
|
msg := consumer.Peek()
|
|
|
|
if msg == nil {
|
|
|
|
break
|
|
|
|
}
|
2020-02-19 17:25:19 +00:00
|
|
|
msg = msg.Copy()
|
|
|
|
switch msg.Command {
|
|
|
|
case "PRIVMSG":
|
|
|
|
// TODO: detect whether it's a user or a channel
|
|
|
|
msg.Params[0] = dc.marshalChannel(uc, msg.Params[0])
|
|
|
|
default:
|
|
|
|
panic("expected to consume a PRIVMSG message")
|
|
|
|
}
|
2020-02-18 15:31:18 +00:00
|
|
|
if dc.srv.Debug {
|
|
|
|
dc.logger.Printf("sent: %v", msg)
|
|
|
|
}
|
2020-02-17 14:46:29 +00:00
|
|
|
err = dc.irc.WriteMessage(msg)
|
|
|
|
if err != nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
consumer.Consume()
|
|
|
|
}
|
|
|
|
case <-dc.closed:
|
|
|
|
closed = true
|
|
|
|
}
|
|
|
|
if err != nil {
|
2020-02-17 11:41:27 +00:00
|
|
|
return err
|
|
|
|
}
|
2020-02-17 14:46:29 +00:00
|
|
|
if closed {
|
|
|
|
break
|
|
|
|
}
|
2020-02-17 11:41:27 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) Close() error {
|
2020-02-17 14:46:29 +00:00
|
|
|
if dc.isClosed() {
|
2020-02-06 20:52:04 +00:00
|
|
|
return fmt.Errorf("downstream connection already closed")
|
|
|
|
}
|
2020-02-07 10:56:36 +00:00
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
if u := dc.user; u != nil {
|
2020-02-07 10:56:36 +00:00
|
|
|
u.lock.Lock()
|
|
|
|
for i := range u.downstreamConns {
|
2020-02-17 11:36:42 +00:00
|
|
|
if u.downstreamConns[i] == dc {
|
2020-02-07 10:56:36 +00:00
|
|
|
u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
|
2020-02-18 14:08:06 +00:00
|
|
|
break
|
2020-02-07 10:56:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
u.lock.Unlock()
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
2020-02-07 10:56:36 +00:00
|
|
|
|
2020-02-17 14:46:29 +00:00
|
|
|
close(dc.closed)
|
2020-02-07 11:42:24 +00:00
|
|
|
return nil
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) SendMessage(msg *irc.Message) {
|
|
|
|
dc.messages <- msg
|
2020-02-17 11:27:48 +00:00
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
|
2020-02-06 15:18:19 +00:00
|
|
|
switch msg.Command {
|
2020-02-06 21:22:14 +00:00
|
|
|
case "QUIT":
|
2020-02-17 11:36:42 +00:00
|
|
|
return dc.Close()
|
2020-02-06 15:18:19 +00:00
|
|
|
case "PING":
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-06 15:18:19 +00:00
|
|
|
Command: "PONG",
|
2020-02-18 19:40:32 +00:00
|
|
|
Params: msg.Params,
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-06 20:52:04 +00:00
|
|
|
return nil
|
2020-02-06 15:18:19 +00:00
|
|
|
default:
|
2020-02-17 11:36:42 +00:00
|
|
|
if dc.registered {
|
|
|
|
return dc.handleMessageRegistered(msg)
|
2020-02-06 15:18:19 +00:00
|
|
|
} else {
|
2020-02-17 11:36:42 +00:00
|
|
|
return dc.handleMessageUnregistered(msg)
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
|
2020-02-06 15:18:19 +00:00
|
|
|
switch msg.Command {
|
|
|
|
case "NICK":
|
2020-02-17 11:36:42 +00:00
|
|
|
if err := parseMessageParams(msg, &dc.nick); err != nil {
|
2020-02-07 11:36:02 +00:00
|
|
|
return err
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
|
|
|
case "USER":
|
2020-02-07 11:36:02 +00:00
|
|
|
var username string
|
2020-02-17 11:36:42 +00:00
|
|
|
if err := parseMessageParams(msg, &username, nil, nil, &dc.realname); err != nil {
|
2020-02-07 11:36:02 +00:00
|
|
|
return err
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.username = "~" + username
|
2020-03-11 18:09:32 +00:00
|
|
|
case "PASS":
|
|
|
|
if err := parseMessageParams(msg, &dc.password); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-02-06 15:18:19 +00:00
|
|
|
default:
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.logger.Printf("unhandled message: %v", msg)
|
2020-02-06 15:18:19 +00:00
|
|
|
return newUnknownCommandError(msg.Command)
|
|
|
|
}
|
2020-02-17 11:36:42 +00:00
|
|
|
if dc.username != "" && dc.nick != "" {
|
|
|
|
return dc.register()
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) register() error {
|
2020-03-04 14:44:13 +00:00
|
|
|
username := strings.TrimPrefix(dc.username, "~")
|
2020-03-04 17:22:58 +00:00
|
|
|
var networkName string
|
2020-03-04 14:44:13 +00:00
|
|
|
if i := strings.LastIndexAny(username, "/@"); i >= 0 {
|
2020-03-04 17:22:58 +00:00
|
|
|
networkName = username[i+1:]
|
2020-03-04 14:44:13 +00:00
|
|
|
}
|
|
|
|
if i := strings.IndexAny(username, "/@"); i >= 0 {
|
|
|
|
username = username[:i]
|
|
|
|
}
|
|
|
|
|
2020-03-11 18:09:32 +00:00
|
|
|
password := dc.password
|
|
|
|
dc.password = ""
|
|
|
|
|
2020-03-04 14:44:13 +00:00
|
|
|
u := dc.srv.getUser(username)
|
2020-02-07 10:39:56 +00:00
|
|
|
if u == nil {
|
2020-03-11 18:09:32 +00:00
|
|
|
dc.logger.Printf("failed authentication for %q: unknown username", username)
|
|
|
|
return errAuthFailed
|
|
|
|
}
|
|
|
|
|
|
|
|
err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
|
|
|
|
if err != nil {
|
|
|
|
dc.logger.Printf("failed authentication for %q: %v", username, err)
|
|
|
|
return errAuthFailed
|
2020-02-07 10:36:42 +00:00
|
|
|
}
|
|
|
|
|
2020-03-12 17:21:41 +00:00
|
|
|
var network *network
|
2020-03-04 17:22:58 +00:00
|
|
|
if networkName != "" {
|
2020-03-12 17:21:41 +00:00
|
|
|
network = u.getNetwork(networkName)
|
|
|
|
if network == nil {
|
2020-03-04 17:22:58 +00:00
|
|
|
dc.logger.Printf("failed registration: unknown network %q", networkName)
|
2020-03-04 14:44:13 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
|
|
|
Command: irc.ERR_PASSWDMISMATCH,
|
2020-03-04 17:22:58 +00:00
|
|
|
Params: []string{"*", fmt.Sprintf("Unknown network %q", networkName)},
|
2020-03-04 14:44:13 +00:00
|
|
|
})
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.registered = true
|
|
|
|
dc.user = u
|
2020-03-12 17:21:41 +00:00
|
|
|
dc.network = network
|
2020-02-06 15:18:19 +00:00
|
|
|
|
2020-02-07 10:56:36 +00:00
|
|
|
u.lock.Lock()
|
2020-02-17 14:46:29 +00:00
|
|
|
firstDownstream := len(u.downstreamConns) == 0
|
2020-02-17 11:36:42 +00:00
|
|
|
u.downstreamConns = append(u.downstreamConns, dc)
|
2020-02-07 10:56:36 +00:00
|
|
|
u.lock.Unlock()
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-06 15:18:19 +00:00
|
|
|
Command: irc.RPL_WELCOME,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, "Welcome to jounce, " + dc.nick},
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-06 15:18:19 +00:00
|
|
|
Command: irc.RPL_YOURHOST,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-06 15:18:19 +00:00
|
|
|
Command: irc.RPL_CREATED,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, "Who cares when the server was created?"},
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-06 15:18:19 +00:00
|
|
|
Command: irc.RPL_MYINFO,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, dc.srv.Hostname, "jounce", "aiwroO", "OovaimnqpsrtklbeI"},
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-06 15:18:19 +00:00
|
|
|
Command: irc.ERR_NOMOTD,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, "No MOTD"},
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-06 15:18:19 +00:00
|
|
|
|
2020-03-04 14:44:13 +00:00
|
|
|
dc.forEachUpstream(func(uc *upstreamConn) {
|
2020-02-06 21:29:24 +00:00
|
|
|
// TODO: fix races accessing upstream connection data
|
|
|
|
for _, ch := range uc.channels {
|
|
|
|
if ch.complete {
|
2020-02-17 11:36:42 +00:00
|
|
|
forwardChannel(dc, ch)
|
2020-02-06 21:29:24 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-07 15:43:14 +00:00
|
|
|
|
2020-03-04 14:44:13 +00:00
|
|
|
historyName := dc.username
|
2020-02-17 14:46:29 +00:00
|
|
|
|
|
|
|
var seqPtr *uint64
|
|
|
|
if firstDownstream {
|
|
|
|
seq, ok := uc.history[historyName]
|
|
|
|
if ok {
|
|
|
|
seqPtr = &seq
|
2020-02-07 15:43:14 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-17 14:46:29 +00:00
|
|
|
|
2020-02-17 15:09:35 +00:00
|
|
|
consumer, ch := uc.ring.NewConsumer(seqPtr)
|
2020-02-17 14:46:29 +00:00
|
|
|
go func() {
|
|
|
|
for {
|
|
|
|
var closed bool
|
|
|
|
select {
|
|
|
|
case <-ch:
|
2020-02-19 17:25:19 +00:00
|
|
|
dc.consumptions <- consumption{consumer, uc}
|
2020-02-17 14:46:29 +00:00
|
|
|
case <-dc.closed:
|
|
|
|
closed = true
|
|
|
|
}
|
|
|
|
if closed {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
seq := consumer.Close()
|
|
|
|
|
|
|
|
dc.user.lock.Lock()
|
|
|
|
lastDownstream := len(dc.user.downstreamConns) == 0
|
|
|
|
dc.user.lock.Unlock()
|
|
|
|
|
|
|
|
if lastDownstream {
|
|
|
|
uc.history[historyName] = seq
|
|
|
|
}
|
|
|
|
}()
|
2020-02-07 10:46:44 +00:00
|
|
|
})
|
2020-02-07 15:43:14 +00:00
|
|
|
|
2020-02-06 15:18:19 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
|
2020-02-06 15:18:19 +00:00
|
|
|
switch msg.Command {
|
2020-02-07 11:19:42 +00:00
|
|
|
case "USER":
|
2020-02-06 15:18:19 +00:00
|
|
|
return ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_ALREADYREGISTERED,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, "You may not reregister"},
|
2020-02-06 15:18:19 +00:00
|
|
|
}}
|
2020-02-07 11:19:42 +00:00
|
|
|
case "NICK":
|
2020-03-04 14:44:13 +00:00
|
|
|
dc.forEachUpstream(func(uc *upstreamConn) {
|
2020-02-17 15:17:31 +00:00
|
|
|
uc.SendMessage(msg)
|
2020-02-07 11:19:42 +00:00
|
|
|
})
|
2020-02-19 17:25:19 +00:00
|
|
|
case "JOIN", "PART":
|
2020-02-07 12:36:32 +00:00
|
|
|
var name string
|
|
|
|
if err := parseMessageParams(msg, &name); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-02-19 17:25:19 +00:00
|
|
|
uc, upstreamName, err := dc.unmarshalChannel(name)
|
2020-02-07 12:36:32 +00:00
|
|
|
if err != nil {
|
2020-02-19 17:25:19 +00:00
|
|
|
return ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_NOSUCHCHANNEL,
|
|
|
|
Params: []string{name, err.Error()},
|
|
|
|
}}
|
2020-02-07 12:36:32 +00:00
|
|
|
}
|
|
|
|
|
2020-02-19 17:25:19 +00:00
|
|
|
uc.SendMessage(&irc.Message{
|
|
|
|
Command: msg.Command,
|
|
|
|
Params: []string{upstreamName},
|
|
|
|
})
|
2020-03-12 17:33:03 +00:00
|
|
|
|
|
|
|
switch msg.Command {
|
|
|
|
case "JOIN":
|
|
|
|
err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
|
|
|
|
Name: upstreamName,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
|
|
|
|
}
|
|
|
|
case "PART":
|
|
|
|
if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
|
|
|
|
dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
|
|
|
|
}
|
|
|
|
}
|
2020-02-07 12:08:27 +00:00
|
|
|
case "MODE":
|
2020-02-19 17:25:19 +00:00
|
|
|
if msg.Prefix == nil {
|
|
|
|
return fmt.Errorf("missing prefix")
|
|
|
|
}
|
|
|
|
|
2020-02-07 12:08:27 +00:00
|
|
|
var name string
|
|
|
|
if err := parseMessageParams(msg, &name); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var modeStr string
|
|
|
|
if len(msg.Params) > 1 {
|
|
|
|
modeStr = msg.Params[1]
|
|
|
|
}
|
|
|
|
|
|
|
|
if msg.Prefix.Name != name {
|
2020-02-19 17:25:19 +00:00
|
|
|
uc, upstreamName, err := dc.unmarshalChannel(name)
|
2020-02-07 12:08:27 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if modeStr != "" {
|
2020-02-19 17:25:19 +00:00
|
|
|
uc.SendMessage(&irc.Message{
|
|
|
|
Command: "MODE",
|
|
|
|
Params: []string{upstreamName, modeStr},
|
|
|
|
})
|
2020-02-07 12:08:27 +00:00
|
|
|
} else {
|
2020-02-19 17:25:19 +00:00
|
|
|
ch, ok := uc.channels[upstreamName]
|
|
|
|
if !ok {
|
|
|
|
return ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_NOSUCHCHANNEL,
|
|
|
|
Params: []string{name, "No such channel"},
|
|
|
|
}}
|
|
|
|
}
|
|
|
|
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-07 12:08:27 +00:00
|
|
|
Command: irc.RPL_CHANNELMODEIS,
|
2020-02-19 17:25:19 +00:00
|
|
|
Params: []string{name, string(ch.modes)},
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-07 12:08:27 +00:00
|
|
|
}
|
|
|
|
} else {
|
2020-02-17 11:36:42 +00:00
|
|
|
if name != dc.nick {
|
2020-02-07 12:08:27 +00:00
|
|
|
return ircError{&irc.Message{
|
|
|
|
Command: irc.ERR_USERSDONTMATCH,
|
2020-02-17 11:36:42 +00:00
|
|
|
Params: []string{dc.nick, "Cannot change mode for other users"},
|
2020-02-07 12:08:27 +00:00
|
|
|
}}
|
|
|
|
}
|
|
|
|
|
|
|
|
if modeStr != "" {
|
2020-03-04 14:44:13 +00:00
|
|
|
dc.forEachUpstream(func(uc *upstreamConn) {
|
2020-02-19 17:25:19 +00:00
|
|
|
uc.SendMessage(&irc.Message{
|
|
|
|
Command: "MODE",
|
|
|
|
Params: []string{uc.nick, modeStr},
|
|
|
|
})
|
2020-02-07 12:08:27 +00:00
|
|
|
})
|
|
|
|
} else {
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Prefix: dc.srv.prefix(),
|
2020-02-07 12:08:27 +00:00
|
|
|
Command: irc.RPL_UMODEIS,
|
|
|
|
Params: []string{""}, // TODO
|
2020-02-17 11:27:48 +00:00
|
|
|
})
|
2020-02-07 12:08:27 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-17 14:56:18 +00:00
|
|
|
case "PRIVMSG":
|
|
|
|
var targetsStr, text string
|
|
|
|
if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, name := range strings.Split(targetsStr, ",") {
|
2020-02-19 17:25:19 +00:00
|
|
|
uc, upstreamName, err := dc.unmarshalChannel(name)
|
2020-02-17 14:56:18 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-02-19 17:25:19 +00:00
|
|
|
uc.SendMessage(&irc.Message{
|
2020-02-17 14:56:18 +00:00
|
|
|
Command: "PRIVMSG",
|
2020-02-19 17:25:19 +00:00
|
|
|
Params: []string{upstreamName, text},
|
2020-02-17 15:17:31 +00:00
|
|
|
})
|
2020-02-17 14:56:18 +00:00
|
|
|
}
|
2020-02-06 15:18:19 +00:00
|
|
|
default:
|
2020-02-17 11:36:42 +00:00
|
|
|
dc.logger.Printf("unhandled message: %v", msg)
|
2020-02-06 15:18:19 +00:00
|
|
|
return newUnknownCommandError(msg.Command)
|
|
|
|
}
|
2020-02-07 11:19:42 +00:00
|
|
|
return nil
|
2020-02-06 15:18:19 +00:00
|
|
|
}
|