mirror of
https://github.com/idanoo/autobrr
synced 2025-07-23 00:39:13 +00:00
442 lines
9.6 KiB
Go
442 lines
9.6 KiB
Go
package irc
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/autobrr/autobrr/internal/announce"
|
|
"github.com/autobrr/autobrr/internal/domain"
|
|
|
|
"github.com/rs/zerolog/log"
|
|
"gopkg.in/irc.v3"
|
|
)
|
|
|
|
var (
|
|
connectTimeout = 15 * time.Second
|
|
)
|
|
|
|
type Handler struct {
|
|
network *domain.IrcNetwork
|
|
announceService announce.Service
|
|
|
|
client *irc.Client
|
|
conn net.Conn
|
|
ctx context.Context
|
|
stopped chan struct{}
|
|
cancel context.CancelFunc
|
|
|
|
lastPing time.Time
|
|
lastAnnounce time.Time
|
|
}
|
|
|
|
func NewHandler(network domain.IrcNetwork, announceService announce.Service) *Handler {
|
|
return &Handler{
|
|
client: nil,
|
|
conn: nil,
|
|
ctx: nil,
|
|
stopped: make(chan struct{}),
|
|
network: &network,
|
|
announceService: announceService,
|
|
}
|
|
}
|
|
|
|
func (s *Handler) Run() error {
|
|
//log.Debug().Msgf("server %+v", s.network)
|
|
|
|
if s.network.Server == "" {
|
|
return errors.New("addr not set")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
s.ctx = ctx
|
|
s.cancel = cancel
|
|
|
|
dialer := net.Dialer{
|
|
Timeout: connectTimeout,
|
|
}
|
|
|
|
var netConn net.Conn
|
|
var err error
|
|
|
|
addr := fmt.Sprintf("%v:%v", s.network.Server, s.network.Port)
|
|
|
|
// decide to use SSL or not
|
|
if s.network.TLS {
|
|
tlsConf := &tls.Config{
|
|
InsecureSkipVerify: true,
|
|
}
|
|
|
|
netConn, err = dialer.DialContext(s.ctx, "tcp", addr)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("failed to dial %v", addr)
|
|
return fmt.Errorf("failed to dial %q: %v", addr, err)
|
|
}
|
|
|
|
netConn = tls.Client(netConn, tlsConf)
|
|
s.conn = netConn
|
|
} else {
|
|
netConn, err = dialer.DialContext(s.ctx, "tcp", addr)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("failed to dial %v", addr)
|
|
return fmt.Errorf("failed to dial %q: %v", addr, err)
|
|
}
|
|
|
|
s.conn = netConn
|
|
}
|
|
|
|
log.Info().Msgf("Connected to: %v", addr)
|
|
|
|
config := irc.ClientConfig{
|
|
Nick: s.network.NickServ.Account,
|
|
User: s.network.NickServ.Account,
|
|
Name: s.network.NickServ.Account,
|
|
Pass: s.network.Pass,
|
|
Handler: irc.HandlerFunc(func(c *irc.Client, m *irc.Message) {
|
|
switch m.Command {
|
|
case "001":
|
|
// 001 is a welcome event, so we join channels there
|
|
err := s.onConnect(c, s.network.Channels)
|
|
if err != nil {
|
|
log.Error().Msgf("error joining channels %v", err)
|
|
}
|
|
|
|
// 322 TOPIC
|
|
// 333 UP
|
|
// 353 @
|
|
// 396 Displayed host
|
|
case "366": // JOINED
|
|
s.handleJoined(m)
|
|
|
|
case "JOIN":
|
|
log.Debug().Msgf("%v: JOIN %v", s.network.Server, m)
|
|
|
|
case "433":
|
|
// TODO: handle nick in use
|
|
log.Debug().Msgf("%v: NICK IN USE: %v", s.network.Server, m)
|
|
|
|
case "448", "473", "475", "477":
|
|
// TODO: handle join failed
|
|
log.Debug().Msgf("%v: JOIN FAILED %v: %v", s.network.Server, m.Params[1], m.Trailing())
|
|
|
|
case "900": // Invite bot logged in
|
|
log.Debug().Msgf("%v: %v", s.network.Server, m.Trailing())
|
|
|
|
case "KICK":
|
|
log.Debug().Msgf("%v: KICK: %v", s.network.Server, m)
|
|
|
|
case "MODE":
|
|
err := s.handleMode(m)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error MODE change: %v", m)
|
|
}
|
|
|
|
case "INVITE":
|
|
// TODO: handle invite
|
|
log.Debug().Msgf("%v: INVITE: %v", s.network.Server, m)
|
|
|
|
case "PART":
|
|
// TODO: handle parted
|
|
log.Debug().Msgf("%v: PART: %v", s.network.Server, m)
|
|
|
|
case "PRIVMSG":
|
|
err := s.onMessage(m)
|
|
if err != nil {
|
|
log.Error().Msgf("error on message %v", err)
|
|
}
|
|
|
|
case "CAP":
|
|
log.Debug().Msgf("%v: CAP: %v", s.network.Server, m)
|
|
|
|
case "NOTICE":
|
|
log.Trace().Msgf("%v: %v", s.network.Server, m.Trailing())
|
|
|
|
case "PING":
|
|
err := s.handlePing(m)
|
|
if err != nil {
|
|
log.Error().Stack().Err(err)
|
|
}
|
|
|
|
//case "372":
|
|
// log.Debug().Msgf("372: %v", m)
|
|
default:
|
|
log.Trace().Msgf("%v: %v", s.network.Server, m.Trailing())
|
|
}
|
|
}),
|
|
}
|
|
|
|
// Create the client
|
|
client := irc.NewClient(s.conn, config)
|
|
|
|
s.client = client
|
|
|
|
// Connect
|
|
err = client.RunContext(ctx)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("could not connect to %v", addr)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) GetNetwork() *domain.IrcNetwork {
|
|
return s.network
|
|
}
|
|
|
|
func (s *Handler) Stop() {
|
|
s.cancel()
|
|
|
|
if !s.isStopped() {
|
|
close(s.stopped)
|
|
}
|
|
|
|
if s.conn != nil {
|
|
s.conn.Close()
|
|
}
|
|
}
|
|
|
|
func (s *Handler) isStopped() bool {
|
|
select {
|
|
case <-s.stopped:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (s *Handler) onConnect(client *irc.Client, channels []domain.IrcChannel) error {
|
|
identified := false
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
if s.network.NickServ.Password != "" {
|
|
err := s.handleNickServPRIVMSG(s.network.NickServ.Account, s.network.NickServ.Password)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error nickserv: %v", s.network.Name)
|
|
return err
|
|
}
|
|
identified = true
|
|
}
|
|
|
|
time.Sleep(3 * time.Second)
|
|
|
|
if s.network.InviteCommand != "" {
|
|
|
|
err := s.handleInvitePRIVMSG(s.network.InviteCommand)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error sending connect command %v to network: %v", s.network.InviteCommand, s.network.Name)
|
|
return err
|
|
}
|
|
|
|
time.Sleep(2 * time.Second)
|
|
}
|
|
|
|
if !identified {
|
|
for _, channel := range channels {
|
|
err := s.handleJoinChannel(channel.Name)
|
|
if err != nil {
|
|
log.Error().Err(err)
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) OnJoin(msg string) (interface{}, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *Handler) onMessage(msg *irc.Message) error {
|
|
//log.Debug().Msgf("raw msg: %v", msg)
|
|
|
|
// check if message is from announce bot and correct channel, if not return
|
|
//if msg.Name != s.network. {
|
|
//
|
|
//}
|
|
|
|
// parse announce
|
|
channel := &msg.Params[0]
|
|
announcer := &msg.Name
|
|
message := msg.Trailing()
|
|
// TODO add network
|
|
|
|
// add correlationID and tracing
|
|
|
|
announceID := fmt.Sprintf("%v:%v:%v", s.network.Server, *channel, *announcer)
|
|
announceID = strings.ToLower(announceID)
|
|
|
|
// clean message
|
|
cleanedMsg := cleanMessage(message)
|
|
log.Debug().Msgf("%v: %v %v: %v", s.network.Server, *channel, *announcer, cleanedMsg)
|
|
|
|
s.lastAnnounce = time.Now()
|
|
|
|
go func() {
|
|
err := s.announceService.Parse(announceID, cleanedMsg)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("could not parse line: %v", cleanedMsg)
|
|
}
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) sendPrivMessage(msg string) error {
|
|
msg = strings.TrimLeft(msg, "/")
|
|
privMsg := fmt.Sprintf("PRIVMSG %s", msg)
|
|
|
|
err := s.client.Write(privMsg)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("could not send priv msg: %v", msg)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) handleJoinChannel(channel string) error {
|
|
m := irc.Message{
|
|
Command: "JOIN",
|
|
Params: []string{channel},
|
|
}
|
|
|
|
log.Debug().Msgf("%v: %v", s.network.Server, m.String())
|
|
|
|
time.Sleep(1 * time.Second)
|
|
|
|
err := s.client.Write(m.String())
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error handling join: %v", m.String())
|
|
return err
|
|
}
|
|
|
|
//log.Info().Msgf("Monitoring channel %v %s", s.network.Name, channel)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) handleJoined(msg *irc.Message) {
|
|
log.Debug().Msgf("%v: JOINED: %v", s.network.Server, msg.Trailing())
|
|
|
|
log.Info().Msgf("%v: Monitoring channel %s", s.network.Server, msg.Params[1])
|
|
}
|
|
|
|
func (s *Handler) handleInvitePRIVMSG(msg string) error {
|
|
msg = strings.TrimPrefix(msg, "/msg")
|
|
split := strings.Split(msg, " ")
|
|
|
|
m := irc.Message{
|
|
Command: "PRIVMSG",
|
|
Params: split,
|
|
}
|
|
|
|
log.Info().Msgf("%v: Invite command: %v", s.network.Server, m.String())
|
|
|
|
err := s.client.Write(m.String())
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error handling invite: %v", m.String())
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) handlePRIVMSG(msg string) error {
|
|
msg = strings.TrimLeft(msg, "/")
|
|
|
|
m := irc.Message{
|
|
Command: "PRIVMSG",
|
|
Params: []string{msg},
|
|
}
|
|
log.Debug().Msgf("%v: Handle privmsg: %v", s.network.Server, m.String())
|
|
|
|
err := s.client.Write(m.String())
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error handling PRIVMSG: %v", m.String())
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) handleNickServPRIVMSG(nick, password string) error {
|
|
m := irc.Message{
|
|
Command: "PRIVMSG",
|
|
Params: []string{"NickServ", "IDENTIFY", nick, password},
|
|
}
|
|
|
|
log.Debug().Msgf("%v: NickServ: %v", s.network.Server, m.String())
|
|
|
|
err := s.client.Write(m.String())
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error identifying with nickserv: %v", m.String())
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) handleMode(msg *irc.Message) error {
|
|
log.Debug().Msgf("%v: MODE: %v %v", s.network.Server, msg.User, msg.Trailing())
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
if s.network.NickServ.Password != "" && !strings.Contains(msg.String(), s.client.CurrentNick()) || !strings.Contains(msg.String(), "+r") {
|
|
log.Trace().Msgf("%v: MODE: Not correct permission yet: %v", s.network.Server, msg.String())
|
|
return nil
|
|
}
|
|
|
|
for _, ch := range s.network.Channels {
|
|
err := s.handleJoinChannel(ch.Name)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error joining channel: %v", ch.Name)
|
|
continue
|
|
}
|
|
|
|
time.Sleep(1 * time.Second)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Handler) handlePing(msg *irc.Message) error {
|
|
//log.Trace().Msgf("%v: %v", s.network.Server, msg)
|
|
|
|
pong := irc.Message{
|
|
Command: "PONG",
|
|
Params: msg.Params,
|
|
}
|
|
|
|
log.Trace().Msgf("%v: %v", s.network.Server, pong.String())
|
|
|
|
err := s.client.Write(pong.String())
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error PING PONG response: %v", pong.String())
|
|
return err
|
|
}
|
|
|
|
s.lastPing = time.Now()
|
|
|
|
return nil
|
|
}
|
|
|
|
// irc line can contain lots of extra stuff like color so lets clean that
|
|
func cleanMessage(message string) string {
|
|
var regexMessageClean = `\x0f|\x1f|\x02|\x03(?:[\d]{1,2}(?:,[\d]{1,2})?)?`
|
|
|
|
rxp, err := regexp.Compile(regexMessageClean)
|
|
if err != nil {
|
|
log.Error().Err(err).Msgf("error compiling regex: %v", regexMessageClean)
|
|
return ""
|
|
}
|
|
|
|
return rxp.ReplaceAllString(message, "")
|
|
}
|