mirror of
https://github.com/tulir/mautrix-whatsapp
synced 2024-05-20 04:43:46 +02:00
263 lines
8.9 KiB
Go
263 lines
8.9 KiB
Go
// mautrix-whatsapp - A Matrix-WhatsApp puppeting bridge.
|
|
// Copyright (C) 2022 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 (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"go.mau.fi/whatsmeow"
|
|
log "maunium.net/go/maulogger/v2"
|
|
"maunium.net/go/mautrix"
|
|
"maunium.net/go/mautrix/bridge"
|
|
"maunium.net/go/mautrix/event"
|
|
"maunium.net/go/mautrix/id"
|
|
)
|
|
|
|
var (
|
|
errUserNotConnected = errors.New("you are not connected to WhatsApp")
|
|
errDifferentUser = errors.New("user is not the recipient of this private chat portal")
|
|
errUserNotLoggedIn = errors.New("user is not logged in and chat has no relay bot")
|
|
errMNoticeDisabled = errors.New("bridging m.notice messages is disabled")
|
|
errUnexpectedParsedContentType = errors.New("unexpected parsed content type")
|
|
errInvalidGeoURI = errors.New("invalid `geo:` URI in message")
|
|
errUnknownMsgType = errors.New("unknown msgtype")
|
|
errMediaDownloadFailed = errors.New("failed to download media")
|
|
errMediaDecryptFailed = errors.New("failed to decrypt media")
|
|
errMediaConvertFailed = errors.New("failed to convert media")
|
|
errMediaWhatsAppUploadFailed = errors.New("failed to upload media to WhatsApp")
|
|
errTargetNotFound = errors.New("target event not found")
|
|
errReactionDatabaseNotFound = errors.New("reaction database entry not found")
|
|
errReactionTargetNotFound = errors.New("reaction target message not found")
|
|
errTargetIsFake = errors.New("target is a fake event")
|
|
errTargetSentBySomeoneElse = errors.New("target is a fake event")
|
|
|
|
errBroadcastReactionNotSupported = errors.New("reacting to status messages is not currently supported")
|
|
errBroadcastSendDisabled = errors.New("sending status messages is disabled")
|
|
|
|
errMessageDisconnected = &whatsmeow.DisconnectedError{Action: "message send"}
|
|
errMessageRetryDisconnected = &whatsmeow.DisconnectedError{Action: "message send (retry)"}
|
|
|
|
errMessageTakingLong = errors.New("bridging the message is taking longer than usual")
|
|
errTimeoutBeforeHandling = errors.New("message timed out before handling was started")
|
|
)
|
|
|
|
func errorToStatusReason(err error) (reason event.MessageStatusReason, isCertain, canRetry, sendNotice bool) {
|
|
switch {
|
|
case errors.Is(err, whatsmeow.ErrBroadcastListUnsupported),
|
|
errors.Is(err, errUnexpectedParsedContentType),
|
|
errors.Is(err, errUnknownMsgType),
|
|
errors.Is(err, errInvalidGeoURI),
|
|
errors.Is(err, whatsmeow.ErrUnknownServer),
|
|
errors.Is(err, whatsmeow.ErrRecipientADJID),
|
|
errors.Is(err, errBroadcastReactionNotSupported),
|
|
errors.Is(err, errBroadcastSendDisabled):
|
|
return event.MessageStatusUnsupported, true, false, true
|
|
case errors.Is(err, errTimeoutBeforeHandling):
|
|
return event.MessageStatusTooOld, true, true, true
|
|
case errors.Is(err, context.DeadlineExceeded):
|
|
return event.MessageStatusTooOld, false, true, true
|
|
case errors.Is(err, errMessageTakingLong):
|
|
// Set can_retry=false here since we'll send another status event allowing the retry later
|
|
// Technically retrying when this happens is fine, but we'd just ignore it anyway.
|
|
return event.MessageStatusTooOld, false, false, true
|
|
case errors.Is(err, errTargetNotFound),
|
|
errors.Is(err, errTargetIsFake),
|
|
errors.Is(err, errReactionDatabaseNotFound),
|
|
errors.Is(err, errReactionTargetNotFound),
|
|
errors.Is(err, errTargetSentBySomeoneElse):
|
|
return event.MessageStatusGenericError, true, false, false
|
|
case errors.Is(err, whatsmeow.ErrNotConnected),
|
|
errors.Is(err, errUserNotConnected):
|
|
return event.MessageStatusGenericError, true, true, true
|
|
case errors.Is(err, errUserNotLoggedIn),
|
|
errors.Is(err, errDifferentUser):
|
|
return event.MessageStatusGenericError, true, true, false
|
|
case errors.Is(err, errMessageDisconnected),
|
|
errors.Is(err, errMessageRetryDisconnected):
|
|
return event.MessageStatusGenericError, false, true, true
|
|
default:
|
|
return event.MessageStatusGenericError, false, true, true
|
|
}
|
|
}
|
|
|
|
func (portal *Portal) sendErrorMessage(err error, confirmed bool, editID id.EventID) id.EventID {
|
|
if !portal.bridge.Config.Bridge.MessageErrorNotices {
|
|
return ""
|
|
}
|
|
certainty := "may not have been"
|
|
if confirmed {
|
|
certainty = "was not"
|
|
}
|
|
msg := fmt.Sprintf("\u26a0 Your message %s bridged: %v", certainty, err)
|
|
if errors.Is(err, errMessageTakingLong) {
|
|
msg = "\u26a0 Bridging your message is taking longer than usual"
|
|
}
|
|
content := &event.MessageEventContent{
|
|
MsgType: event.MsgNotice,
|
|
Body: msg,
|
|
}
|
|
if editID != "" {
|
|
content.SetEdit(editID)
|
|
}
|
|
resp, err := portal.sendMainIntentMessage(content)
|
|
if err != nil {
|
|
portal.log.Warnfln("Failed to send bridging error message:", err)
|
|
return ""
|
|
}
|
|
return resp.EventID
|
|
}
|
|
|
|
func (portal *Portal) sendStatusEvent(evtID, lastRetry id.EventID, err error) {
|
|
if !portal.bridge.Config.Bridge.MessageStatusEvents {
|
|
return
|
|
}
|
|
if lastRetry == evtID {
|
|
lastRetry = ""
|
|
}
|
|
intent := portal.bridge.Bot
|
|
if !portal.Encrypted {
|
|
// Bridge bot isn't present in unencrypted DMs
|
|
intent = portal.MainIntent()
|
|
}
|
|
content := event.BeeperMessageStatusEventContent{
|
|
Network: portal.getBridgeInfoStateKey(),
|
|
RelatesTo: event.RelatesTo{
|
|
Type: event.RelReference,
|
|
EventID: evtID,
|
|
},
|
|
Success: err == nil,
|
|
LastRetry: lastRetry,
|
|
}
|
|
if !content.Success {
|
|
reason, isCertain, canRetry, _ := errorToStatusReason(err)
|
|
content.Reason = reason
|
|
content.IsCertain = &isCertain
|
|
content.CanRetry = &canRetry
|
|
content.Error = err.Error()
|
|
}
|
|
_, err = intent.SendMessageEvent(portal.MXID, event.BeeperMessageStatus, &content)
|
|
if err != nil {
|
|
portal.log.Warnln("Failed to send message status event:", err)
|
|
}
|
|
}
|
|
|
|
func (portal *Portal) sendDeliveryReceipt(eventID id.EventID) {
|
|
if portal.bridge.Config.Bridge.DeliveryReceipts {
|
|
err := portal.bridge.Bot.MarkRead(portal.MXID, eventID)
|
|
if err != nil {
|
|
portal.log.Debugfln("Failed to send delivery receipt for %s: %v", eventID, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (portal *Portal) sendMessageMetrics(evt *event.Event, err error, part string, ms *metricSender) {
|
|
var msgType string
|
|
switch evt.Type {
|
|
case event.EventMessage:
|
|
msgType = "message"
|
|
case event.EventReaction:
|
|
msgType = "reaction"
|
|
case event.EventRedaction:
|
|
msgType = "redaction"
|
|
default:
|
|
msgType = "unknown event"
|
|
}
|
|
evtDescription := evt.ID.String()
|
|
if evt.Type == event.EventRedaction {
|
|
evtDescription += fmt.Sprintf(" of %s", evt.Redacts)
|
|
}
|
|
origEvtID := evt.ID
|
|
if retryMeta := evt.Content.AsMessage().MessageSendRetry; retryMeta != nil {
|
|
origEvtID = retryMeta.OriginalEventID
|
|
}
|
|
if err != nil {
|
|
level := log.LevelError
|
|
if part == "Ignoring" {
|
|
level = log.LevelDebug
|
|
}
|
|
portal.log.Logfln(level, "%s %s %s from %s: %v", part, msgType, evtDescription, evt.Sender, err)
|
|
reason, isCertain, _, sendNotice := errorToStatusReason(err)
|
|
status := bridge.ReasonToCheckpointStatus(reason)
|
|
portal.bridge.SendMessageCheckpoint(evt, bridge.MsgStepRemote, err, status, ms.getRetryNum())
|
|
if sendNotice {
|
|
ms.setNoticeID(portal.sendErrorMessage(err, isCertain, ms.getNoticeID()))
|
|
}
|
|
portal.sendStatusEvent(origEvtID, evt.ID, err)
|
|
} else {
|
|
portal.log.Debugfln("Handled Matrix %s %s", msgType, evtDescription)
|
|
portal.sendDeliveryReceipt(evt.ID)
|
|
portal.bridge.SendMessageSuccessCheckpoint(evt, bridge.MsgStepRemote, ms.getRetryNum())
|
|
portal.sendStatusEvent(origEvtID, evt.ID, nil)
|
|
if prevNotice := ms.popNoticeID(); prevNotice != "" {
|
|
_, _ = portal.MainIntent().RedactEvent(portal.MXID, prevNotice, mautrix.ReqRedact{
|
|
Reason: "error resolved",
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
type metricSender struct {
|
|
portal *Portal
|
|
previousNotice id.EventID
|
|
lock sync.Mutex
|
|
completed bool
|
|
retryNum int
|
|
}
|
|
|
|
func (ms *metricSender) getRetryNum() int {
|
|
if ms != nil {
|
|
return ms.retryNum
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ms *metricSender) getNoticeID() id.EventID {
|
|
if ms == nil {
|
|
return ""
|
|
}
|
|
return ms.previousNotice
|
|
}
|
|
|
|
func (ms *metricSender) popNoticeID() id.EventID {
|
|
if ms == nil {
|
|
return ""
|
|
}
|
|
evtID := ms.previousNotice
|
|
ms.previousNotice = ""
|
|
return evtID
|
|
}
|
|
|
|
func (ms *metricSender) setNoticeID(evtID id.EventID) {
|
|
if ms != nil && ms.previousNotice == "" {
|
|
ms.previousNotice = evtID
|
|
}
|
|
}
|
|
|
|
func (ms *metricSender) sendMessageMetrics(evt *event.Event, err error, part string, completed bool) {
|
|
ms.lock.Lock()
|
|
defer ms.lock.Unlock()
|
|
if !completed && ms.completed {
|
|
return
|
|
}
|
|
ms.portal.sendMessageMetrics(evt, err, part, ms)
|
|
ms.retryNum++
|
|
ms.completed = completed
|
|
}
|