matterbridge/bridge/xmpp/xmpp.go

337 lines
7.7 KiB
Go
Raw Normal View History

package bxmpp
import (
"crypto/tls"
"strings"
"time"
2018-02-27 00:33:21 +01:00
"github.com/42wim/matterbridge/bridge"
"github.com/42wim/matterbridge/bridge/config"
"github.com/42wim/matterbridge/bridge/helper"
"github.com/jpillora/backoff"
"github.com/matterbridge/go-xmpp"
"github.com/rs/xid"
)
type Bxmpp struct {
*bridge.Config
2019-05-30 12:31:54 +02:00
startTime time.Time
2019-05-30 12:31:54 +02:00
xc *xmpp.Client
xmppMap map[string]string
}
func New(cfg *bridge.Config) bridge.Bridger {
2019-05-30 12:31:54 +02:00
return &Bxmpp{
Config: cfg,
xmppMap: make(map[string]string),
}
2016-08-15 23:16:07 +02:00
}
func (b *Bxmpp) Connect() error {
b.Log.Infof("Connecting %s", b.GetString("Server"))
2019-05-30 12:31:54 +02:00
if err := b.createXMPP(); err != nil {
2018-02-27 00:33:21 +01:00
b.Log.Debugf("%#v", err)
2016-08-15 23:16:07 +02:00
return err
}
2019-05-30 12:31:54 +02:00
2018-02-27 00:33:21 +01:00
b.Log.Info("Connection succeeded")
2019-05-30 12:31:54 +02:00
go b.manageConnection()
2016-08-15 23:16:07 +02:00
return nil
}
func (b *Bxmpp) Disconnect() error {
return nil
}
func (b *Bxmpp) JoinChannel(channel config.ChannelInfo) error {
if channel.Options.Key != "" {
b.Log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
b.xc.JoinProtectedMUC(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"), channel.Options.Key, xmpp.NoHistory, 0, nil)
} else {
b.xc.JoinMUCNoHistory(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"))
}
return nil
}
func (b *Bxmpp) Send(msg config.Message) (string, error) {
// ignore delete messages
if msg.Event == config.EventMsgDelete {
return "", nil
}
2018-02-28 22:23:29 +01:00
b.Log.Debugf("=> Receiving %#v", msg)
2018-02-26 17:09:23 +01:00
2019-05-30 12:31:54 +02:00
// Upload a file (in XMPP case send the upload URL because XMPP has no native upload support).
if msg.Extra != nil {
for _, rmsg := range helper.HandleExtra(&msg, b.General) {
2019-05-30 12:31:54 +02:00
b.Log.Debugf("=> Sending attachement message %#v", rmsg)
if _, err := b.xc.Send(xmpp.Chat{
Type: "groupchat",
Remote: rmsg.Channel + "@" + b.GetString("Muc"),
Text: rmsg.Username + rmsg.Text,
}); err != nil {
b.Log.WithError(err).Error("Unable to send message with share URL.")
}
}
if len(msg.Extra["file"]) > 0 {
2019-05-30 12:31:54 +02:00
return "", b.handleUploadFile(&msg)
}
}
2019-05-30 12:31:54 +02:00
var msgReplaceID string
msgID := xid.New().String()
if msg.ID != "" {
2019-05-30 12:31:54 +02:00
msgID = msg.ID
msgReplaceID = msg.ID
}
2019-05-30 12:31:54 +02:00
// Post normal message.
b.Log.Debugf("=> Sending message %#v", msg)
if _, err := b.xc.Send(xmpp.Chat{
Type: "groupchat",
Remote: msg.Channel + "@" + b.GetString("Muc"),
Text: msg.Username + msg.Text,
ID: msgID,
ReplaceID: msgReplaceID,
}); err != nil {
2018-02-26 17:09:23 +01:00
return "", err
}
2019-05-30 12:31:54 +02:00
return msgID, nil
}
2019-05-30 12:31:54 +02:00
func (b *Bxmpp) createXMPP() error {
tc := &tls.Config{
ServerName: strings.Split(b.GetString("Jid"), "@")[1],
2019-05-30 12:31:54 +02:00
InsecureSkipVerify: b.GetBool("SkipTLSVerify"), // nolint: gosec
}
options := xmpp.Options{
Host: b.GetString("Server"),
User: b.GetString("Jid"),
Password: b.GetString("Password"),
NoTLS: true,
StartTLS: true,
TLSConfig: tc,
Debug: b.GetBool("debug"),
Logger: b.Log.Writer(),
Session: true,
Status: "",
StatusMessage: "",
Resource: "",
InsecureAllowUnencryptedAuth: false,
}
var err error
b.xc, err = options.NewClient()
2019-05-30 12:31:54 +02:00
return err
}
func (b *Bxmpp) manageConnection() {
initial := true
bf := &backoff.Backoff{
Min: time.Second,
Max: 5 * time.Minute,
Jitter: true,
}
// Main connection loop. Each iteration corresponds to a successful
// connection attempt and the subsequent handling of the connection.
for {
if initial {
initial = false
} else {
b.Remote <- config.Message{
Username: "system",
Text: "rejoin",
Channel: "",
Account: b.Account,
Event: config.EventRejoinChannels,
}
}
if err := b.handleXMPP(); err != nil {
b.Log.WithError(err).Error("Disconnected.")
}
// Reconnection loop using an exponential back-off strategy. We
// only break out of the loop if we have successfully reconnected.
for {
d := bf.Duration()
b.Log.Infof("Reconnecting in %s.", d)
time.Sleep(d)
b.Log.Infof("Reconnecting now.")
if err := b.createXMPP(); err == nil {
bf.Reset()
break
}
b.Log.Warn("Failed to reconnect.")
}
}
}
2016-11-26 15:02:39 +01:00
func (b *Bxmpp) xmppKeepAlive() chan bool {
done := make(chan bool)
go func() {
ticker := time.NewTicker(90 * time.Second)
2016-11-26 15:02:39 +01:00
defer ticker.Stop()
for {
select {
case <-ticker.C:
2018-02-27 00:33:21 +01:00
b.Log.Debugf("PING")
2019-05-30 12:31:54 +02:00
if err := b.xc.PingC2S("", ""); err != nil {
2018-02-27 00:33:21 +01:00
b.Log.Debugf("PING failed %#v", err)
}
2016-11-26 15:02:39 +01:00
case <-done:
return
}
}
}()
2016-11-26 15:02:39 +01:00
return done
}
2018-02-26 17:09:23 +01:00
func (b *Bxmpp) handleXMPP() error {
b.startTime = time.Now()
2019-05-30 12:31:54 +02:00
2016-11-26 15:02:39 +01:00
done := b.xmppKeepAlive()
defer close(done)
2019-05-30 12:31:54 +02:00
for {
m, err := b.xc.Recv()
if err != nil {
return err
}
2019-05-30 12:31:54 +02:00
switch v := m.(type) {
case xmpp.Chat:
if v.Type == "groupchat" {
b.Log.Debugf("== Receiving %#v", v)
2019-05-30 12:31:54 +02:00
// Skip invalid messages.
2018-02-26 17:09:23 +01:00
if b.skipMessage(v) {
continue
}
2019-05-30 12:31:54 +02:00
var event string
if strings.Contains(v.Text, "has set the subject to:") {
event = config.EventTopicChange
}
2019-05-30 12:31:54 +02:00
msgID := v.ID
if v.ReplaceID != "" {
2019-05-30 12:31:54 +02:00
msgID = v.ReplaceID
}
rmsg := config.Message{
Username: b.parseNick(v.Remote),
Text: v.Text,
Channel: b.parseChannel(v.Remote),
Account: b.Account,
UserID: v.Remote,
2019-05-30 12:31:54 +02:00
ID: msgID,
Event: event,
}
2018-02-26 17:09:23 +01:00
2019-05-30 12:31:54 +02:00
// Check if we have an action event.
var ok bool
2018-02-26 17:09:23 +01:00
rmsg.Text, ok = b.replaceAction(rmsg.Text)
if ok {
rmsg.Event = config.EventUserAction
}
2019-05-30 12:31:54 +02:00
2018-02-28 22:23:29 +01:00
b.Log.Debugf("<= Sending message from %s on %s to gateway", rmsg.Username, b.Account)
b.Log.Debugf("<= Message is %#v", rmsg)
2018-02-26 17:09:23 +01:00
b.Remote <- rmsg
}
case xmpp.Presence:
2019-05-30 12:31:54 +02:00
// Do nothing.
}
}
}
func (b *Bxmpp) replaceAction(text string) (string, bool) {
if strings.HasPrefix(text, "/me ") {
return strings.Replace(text, "/me ", "", -1), true
}
return text, false
}
2018-02-26 17:09:23 +01:00
// handleUploadFile handles native upload of files
2019-05-30 12:31:54 +02:00
func (b *Bxmpp) handleUploadFile(msg *config.Message) error {
var urlDesc string
2019-05-30 12:31:54 +02:00
for _, file := range msg.Extra["file"] {
fileInfo := file.(config.FileInfo)
if fileInfo.Comment != "" {
msg.Text += fileInfo.Comment + ": "
2018-02-26 17:09:23 +01:00
}
2019-05-30 12:31:54 +02:00
if fileInfo.URL != "" {
msg.Text = fileInfo.URL
if fileInfo.Comment != "" {
msg.Text = fileInfo.Comment + ": " + fileInfo.URL
urlDesc = fileInfo.Comment
2018-05-06 16:57:59 +02:00
}
2018-02-26 17:09:23 +01:00
}
2019-05-30 12:31:54 +02:00
if _, err := b.xc.Send(xmpp.Chat{
Type: "groupchat",
Remote: msg.Channel + "@" + b.GetString("Muc"),
Text: msg.Username + msg.Text,
}); err != nil {
return err
2018-02-26 17:09:23 +01:00
}
2019-05-30 12:31:54 +02:00
if fileInfo.URL != "" {
if _, err := b.xc.SendOOB(xmpp.Chat{
Type: "groupchat",
Remote: msg.Channel + "@" + b.GetString("Muc"),
Ooburl: fileInfo.URL,
Oobdesc: urlDesc,
}); err != nil {
b.Log.WithError(err).Warn("Failed to send share URL.")
}
}
2018-02-26 17:09:23 +01:00
}
2019-05-30 12:31:54 +02:00
return nil
2018-02-26 17:09:23 +01:00
}
func (b *Bxmpp) parseNick(remote string) string {
s := strings.Split(remote, "@")
if len(s) > 0 {
s = strings.Split(s[1], "/")
if len(s) == 2 {
return s[1] // nick
}
}
return ""
}
func (b *Bxmpp) parseChannel(remote string) string {
s := strings.Split(remote, "@")
if len(s) >= 2 {
return s[0] // channel
}
return ""
}
// skipMessage skips messages that need to be skipped
func (b *Bxmpp) skipMessage(message xmpp.Chat) bool {
// skip messages from ourselves
if b.parseNick(message.Remote) == b.GetString("Nick") {
2018-02-26 17:09:23 +01:00
return true
}
// skip empty messages
if message.Text == "" {
return true
}
// skip subject messages
if strings.Contains(message.Text, "</subject>") {
return true
}
// do not show subjects on connect #732
if strings.Contains(message.Text, "has set the subject to:") && time.Since(b.startTime) < time.Second*5 {
return true
}
2018-02-26 17:09:23 +01:00
// skip delayed messages
2019-06-14 00:44:31 +02:00
return !message.Stamp.IsZero() && time.Since(message.Stamp).Minutes() > 5
2018-02-26 17:09:23 +01:00
}