mirror of
https://github.com/tulir/mautrix-whatsapp
synced 2024-11-18 07:53:14 +01:00
286 lines
8.7 KiB
Go
286 lines
8.7 KiB
Go
// mautrix-whatsapp - A Matrix-WhatsApp puppeting bridge.
|
|
// Copyright (C) 2020 Tulir Asokan
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"maunium.net/go/maulogger/v2"
|
|
|
|
"maunium.net/go/mautrix/appservice"
|
|
"maunium.net/go/mautrix/event"
|
|
"maunium.net/go/mautrix/format"
|
|
"maunium.net/go/mautrix/id"
|
|
)
|
|
|
|
type MatrixHandler struct {
|
|
bridge *Bridge
|
|
as *appservice.AppService
|
|
log maulogger.Logger
|
|
cmd *CommandHandler
|
|
}
|
|
|
|
func NewMatrixHandler(bridge *Bridge) *MatrixHandler {
|
|
handler := &MatrixHandler{
|
|
bridge: bridge,
|
|
as: bridge.AS,
|
|
log: bridge.Log.Sub("Matrix"),
|
|
cmd: NewCommandHandler(bridge),
|
|
}
|
|
bridge.EventProcessor.On(event.EventMessage, handler.HandleMessage)
|
|
bridge.EventProcessor.On(event.EventEncrypted, handler.HandleEncrypted)
|
|
bridge.EventProcessor.On(event.EventSticker, handler.HandleMessage)
|
|
bridge.EventProcessor.On(event.EventRedaction, handler.HandleRedaction)
|
|
bridge.EventProcessor.On(event.StateMember, handler.HandleMembership)
|
|
bridge.EventProcessor.On(event.StateRoomName, handler.HandleRoomMetadata)
|
|
bridge.EventProcessor.On(event.StateRoomAvatar, handler.HandleRoomMetadata)
|
|
bridge.EventProcessor.On(event.StateTopic, handler.HandleRoomMetadata)
|
|
bridge.EventProcessor.On(event.StateEncryption, handler.HandleEncryption)
|
|
return handler
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleEncryption(evt *event.Event) {
|
|
defer mx.bridge.Metrics.TrackEvent(evt.Type)()
|
|
if evt.Content.AsEncryption().Algorithm != id.AlgorithmMegolmV1 {
|
|
return
|
|
}
|
|
portal := mx.bridge.GetPortalByMXID(evt.RoomID)
|
|
if portal != nil && !portal.Encrypted {
|
|
mx.log.Debugfln("%s enabled encryption in %s", evt.Sender, evt.RoomID)
|
|
portal.Encrypted = true
|
|
portal.Update()
|
|
}
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleBotInvite(evt *event.Event) {
|
|
intent := mx.as.BotIntent()
|
|
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
if user == nil {
|
|
return
|
|
}
|
|
|
|
resp, err := intent.JoinRoomByID(evt.RoomID)
|
|
if err != nil {
|
|
mx.log.Debugln("Failed to join room", evt.RoomID, "with invite from", evt.Sender)
|
|
return
|
|
}
|
|
|
|
members, err := intent.JoinedMembers(resp.RoomID)
|
|
if err != nil {
|
|
mx.log.Debugln("Failed to get members in room", resp.RoomID, "after accepting invite from", evt.Sender)
|
|
intent.LeaveRoom(resp.RoomID)
|
|
return
|
|
}
|
|
|
|
if len(members.Joined) < 2 {
|
|
mx.log.Debugln("Leaving empty room", resp.RoomID, "after accepting invite from", evt.Sender)
|
|
intent.LeaveRoom(resp.RoomID)
|
|
return
|
|
}
|
|
|
|
if !user.Whitelisted {
|
|
intent.SendNotice(resp.RoomID, "You are not whitelisted to use this bridge.\n"+
|
|
"If you're the owner of this bridge, see the bridge.permissions section in your config file.")
|
|
intent.LeaveRoom(resp.RoomID)
|
|
return
|
|
}
|
|
|
|
if evt.RoomID == mx.bridge.Config.Bridge.Relaybot.ManagementRoom {
|
|
intent.SendNotice(evt.RoomID, "This is the relaybot management room. Send `!wa help` to get a list of commands.")
|
|
mx.log.Debugln("Joined relaybot management room", evt.RoomID, "after invite from", evt.Sender)
|
|
return
|
|
}
|
|
|
|
hasPuppets := false
|
|
for mxid, _ := range members.Joined {
|
|
if mxid == intent.UserID || mxid == evt.Sender {
|
|
continue
|
|
} else if _, ok := mx.bridge.ParsePuppetMXID(mxid); ok {
|
|
hasPuppets = true
|
|
continue
|
|
}
|
|
mx.log.Debugln("Leaving multi-user room", resp.RoomID, "after accepting invite from", evt.Sender)
|
|
intent.SendNotice(resp.RoomID, "This bridge is user-specific, please don't invite me into rooms with other users.")
|
|
intent.LeaveRoom(resp.RoomID)
|
|
return
|
|
}
|
|
|
|
if !hasPuppets {
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
user.SetManagementRoom(resp.RoomID)
|
|
intent.SendNotice(user.ManagementRoom, "This room has been registered as your bridge management/status room. Send `help` to get a list of commands.")
|
|
mx.log.Debugln(resp.RoomID, "registered as a management room with", evt.Sender)
|
|
}
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleMembership(evt *event.Event) {
|
|
if _, isPuppet := mx.bridge.ParsePuppetMXID(evt.Sender); evt.Sender == mx.bridge.Bot.UserID || isPuppet {
|
|
return
|
|
}
|
|
defer mx.bridge.Metrics.TrackEvent(evt.Type)()
|
|
|
|
if mx.bridge.Crypto != nil {
|
|
mx.bridge.Crypto.HandleMemberEvent(evt)
|
|
}
|
|
|
|
content := evt.Content.AsMember()
|
|
if content.Membership == event.MembershipInvite && id.UserID(evt.GetStateKey()) == mx.as.BotMXID() {
|
|
mx.HandleBotInvite(evt)
|
|
}
|
|
|
|
portal := mx.bridge.GetPortalByMXID(evt.RoomID)
|
|
if portal == nil {
|
|
return
|
|
}
|
|
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
if user == nil || !user.Whitelisted || !user.IsConnected() {
|
|
return
|
|
}
|
|
|
|
if content.Membership == event.MembershipLeave {
|
|
if id.UserID(evt.GetStateKey()) == evt.Sender {
|
|
if evt.Unsigned.PrevContent != nil {
|
|
_ = evt.Unsigned.PrevContent.ParseRaw(evt.Type)
|
|
prevContent, ok := evt.Unsigned.PrevContent.Parsed.(*event.MemberEventContent)
|
|
if ok {
|
|
if portal.IsPrivateChat() || prevContent.Membership == "join" {
|
|
portal.HandleMatrixLeave(user)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
portal.HandleMatrixKick(user, evt)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleRoomMetadata(evt *event.Event) {
|
|
defer mx.bridge.Metrics.TrackEvent(evt.Type)()
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
if user == nil || !user.Whitelisted || !user.IsConnected() {
|
|
return
|
|
}
|
|
|
|
portal := mx.bridge.GetPortalByMXID(evt.RoomID)
|
|
if portal == nil || portal.IsPrivateChat() {
|
|
return
|
|
}
|
|
|
|
var resp <-chan string
|
|
var err error
|
|
switch content := evt.Content.Parsed.(type) {
|
|
case *event.RoomNameEventContent:
|
|
resp, err = user.Conn.UpdateGroupSubject(content.Name, portal.Key.JID)
|
|
case *event.TopicEventContent:
|
|
resp, err = user.Conn.UpdateGroupDescription(portal.Key.JID, content.Topic)
|
|
case *event.RoomAvatarEventContent:
|
|
return
|
|
}
|
|
if err != nil {
|
|
mx.log.Errorln(err)
|
|
} else {
|
|
out := <-resp
|
|
mx.log.Infoln(out)
|
|
}
|
|
}
|
|
|
|
func (mx *MatrixHandler) shouldIgnoreEvent(evt *event.Event) bool {
|
|
if _, isPuppet := mx.bridge.ParsePuppetMXID(evt.Sender); evt.Sender == mx.bridge.Bot.UserID || isPuppet {
|
|
return true
|
|
}
|
|
isCustomPuppet, ok := evt.Content.Raw["net.maunium.whatsapp.puppet"].(bool)
|
|
if ok && isCustomPuppet && mx.bridge.GetPuppetByCustomMXID(evt.Sender) != nil {
|
|
return true
|
|
}
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
if !user.RelaybotWhitelisted {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleEncrypted(evt *event.Event) {
|
|
defer mx.bridge.Metrics.TrackEvent(evt.Type)()
|
|
if mx.shouldIgnoreEvent(evt) || mx.bridge.Crypto == nil {
|
|
return
|
|
}
|
|
|
|
decrypted, err := mx.bridge.Crypto.Decrypt(evt)
|
|
if err != nil {
|
|
mx.log.Warnfln("Failed to decrypt %s: %v", evt.ID, err)
|
|
return
|
|
}
|
|
mx.bridge.EventProcessor.Dispatch(decrypted)
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleMessage(evt *event.Event) {
|
|
defer mx.bridge.Metrics.TrackEvent(evt.Type)()
|
|
if mx.shouldIgnoreEvent(evt) {
|
|
return
|
|
}
|
|
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
content := evt.Content.AsMessage()
|
|
if user.Whitelisted && content.MsgType == event.MsgText {
|
|
commandPrefix := mx.bridge.Config.Bridge.CommandPrefix
|
|
hasCommandPrefix := strings.HasPrefix(content.Body, commandPrefix)
|
|
if hasCommandPrefix {
|
|
content.Body = strings.TrimLeft(content.Body[len(commandPrefix):], " ")
|
|
}
|
|
if hasCommandPrefix || evt.RoomID == user.ManagementRoom {
|
|
mx.cmd.Handle(evt.RoomID, user, content.Body)
|
|
return
|
|
}
|
|
}
|
|
|
|
portal := mx.bridge.GetPortalByMXID(evt.RoomID)
|
|
if portal != nil && (user.Whitelisted || portal.HasRelaybot()) {
|
|
portal.HandleMatrixMessage(user, evt)
|
|
}
|
|
}
|
|
|
|
func (mx *MatrixHandler) HandleRedaction(evt *event.Event) {
|
|
defer mx.bridge.Metrics.TrackEvent(evt.Type)()
|
|
if _, isPuppet := mx.bridge.ParsePuppetMXID(evt.Sender); evt.Sender == mx.bridge.Bot.UserID || isPuppet {
|
|
return
|
|
}
|
|
|
|
user := mx.bridge.GetUserByMXID(evt.Sender)
|
|
|
|
if !user.Whitelisted {
|
|
return
|
|
}
|
|
|
|
if !user.HasSession() {
|
|
return
|
|
} else if !user.IsConnected() {
|
|
msg := format.RenderMarkdown(fmt.Sprintf("[%[1]s](https://matrix.to/#/%[1]s): \u26a0 "+
|
|
"You are not connected to WhatsApp, so your redaction was not bridged. "+
|
|
"Use `%[2]s reconnect` to reconnect.", user.MXID, mx.bridge.Config.Bridge.CommandPrefix), true, false)
|
|
msg.MsgType = event.MsgNotice
|
|
_, _ = mx.bridge.Bot.SendMessageEvent(evt.RoomID, event.EventMessage, msg)
|
|
return
|
|
}
|
|
|
|
portal := mx.bridge.GetPortalByMXID(evt.RoomID)
|
|
if portal != nil {
|
|
portal.HandleMatrixRedaction(user, evt)
|
|
}
|
|
}
|