message signalmeow.IncomingSignalMessage

user *User

sender *Puppet

sync bool

*database.Portal

bridge *SignalBridge

log zerolog.Logger

roomCreateLock sync.Mutex

encryptLock sync.Mutex

signalMessages chan portalSignalMessage

matrixMessages chan portalMatrixMessage

currentlyTyping []id.UserID

currentlyTypingLock sync.Mutex

latestReadTimestamp uint64 // Cache the latest read timestamp to avoid unnecessary read receipts

relayUser *User

portal.Encrypted = true

err := portal.Update(context.TODO())

if err != nil {

portal.log.Err(err).Msg("Failed to update portal in database after marking as encrypted")

}

if user.GetPermissionLevel() >= bridgeconfig.PermissionLevelUser || portal.HasRelaybot() {

portal.matrixMessages <- portalMatrixMessage{user: user.(*User), evt: evt}

}

if !portal.HasRelaybot() {

return nil

} else if portal.relayUser == nil {

portal.relayUser = portal.bridge.GetUserByMXID(portal.RelayUserID)

}

return portal.relayUser

if _, uuidErr := uuid.Parse(s); uuidErr == nil {

return true

}

return false

if portal.IsPrivateChat() {

return portal.bridge.GetPuppetBySignalID(portal.UserID()).DefaultIntent()

}

return portal.bridge.Bot

bridgeInfo := event.BridgeEventContent{

BridgeBot: portal.bridge.Bot.UserID,

Creator: portal.MainIntent().UserID,

Protocol: event.BridgeInfoSection{

ID: "signal",

DisplayName: "Signal",

AvatarURL: portal.bridge.Config.AppService.Bot.ParsedAvatar.CUString(),

ExternalURL: "https://signal.org/",

},

Channel: event.BridgeInfoSection{

ID: portal.ChatID,

DisplayName: portal.Name,

AvatarURL: portal.AvatarURL.CUString(),

},

}

var bridgeInfoStateKey string

bridgeInfoStateKey = fmt.Sprintf("fi.mau.signal://signal/%s", portal.ChatID)

bridgeInfo.Channel.ExternalURL = fmt.Sprintf("https://signal.me/#p/%s", portal.ChatID)

var roomType string

if portal.IsPrivateChat() {

roomType = "dm"

}

return bridgeInfoStateKey, CustomBridgeInfoContent{bridgeInfo, roomType}

if len(portal.MXID) == 0 {

portal.log.Debug().Msg("Not updating bridge info: no Matrix room created")

return

}

portal.log.Debug().Msg("Updating bridge info...")

stateKey, content := portal.getBridgeInfo()

_, err := portal.MainIntent().SendStateEvent(portal.MXID, event.StateBridge, stateKey, content)

if err != nil {

portal.log.Warn().Msgf("Failed to update m.bridge: %v", err)

}

// TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec

_, err = portal.MainIntent().SendStateEvent(portal.MXID, event.StateHalfShotBridge, stateKey, content)

if err != nil {

portal.log.Warn().Msgf("Failed to update uk.half-shot.bridge: %v", err)

}

portals, err := br.dbPortalsToPortals(br.DB.Portal.GetAllWithMXID(context.TODO()))

if err != nil {

br.ZLog.Err(err).Msg("Failed to get all portals with mxid")

return nil

}

return portals

portals, err := br.dbPortalsToPortals(br.DB.Portal.GetAllWithMXID(context.TODO()))

if err != nil {

br.ZLog.Err(err).Msg("Failed to get all portals with mxid")

return nil

}

iportals = make([]bridge.Portal, len(portals))

for i, portal := range portals {

iportals[i] = portal

}

return iportals

if err != nil {

return nil, err

}

br.portalsLock.Lock()

defer br.portalsLock.Unlock()

output := make([]*Portal, len(dbPortals))

for index, dbPortal := range dbPortals {

if dbPortal == nil {

continue

}

portal, ok := br.portalsByID[dbPortal.PortalKey]

if !ok {

portal = br.loadPortal(context.TODO(), dbPortal, nil)

}

output[index] = portal

}

return output, nil

portal := &Portal{

Portal: dbPortal,

bridge: br,

log: br.ZLog.With().Str("chat_id", dbPortal.ChatID).Logger(),

signalMessages: make(chan portalSignalMessage, br.Config.Bridge.PortalMessageBuffer),

matrixMessages: make(chan portalMatrixMessage, br.Config.Bridge.PortalMessageBuffer),

}

go portal.messageLoop()

return portal

for {

select {

case msg := <-portal.matrixMessages:

portal.handleMatrixMessages(msg)

case msg := <-portal.signalMessages:

portal.handleSignalMessages(msg)

}

}

// If we have no SignalDevice, the bridge isn't logged in properly,

// so send BAD_CREDENTIALS so the user knows

if !msg.user.SignalDevice.IsDeviceLoggedIn() && !portal.HasRelaybot() {

go portal.sendMessageMetrics(msg.evt, errUserNotLoggedIn, "Ignoring", nil)

msg.user.BridgeState.Send(status.BridgeState{StateEvent: status.StateBadCredentials, Message: "You have been logged out of Signal, please reconnect"})

return

}

log := portal.log.With().Str("event_id", msg.evt.ID.String()).Logger()

ctx := log.WithContext(context.TODO())

switch msg.evt.Type {

case event.EventMessage, event.EventSticker:

portal.handleMatrixMessage(ctx, msg.user, msg.evt)

case event.EventRedaction:

portal.handleMatrixRedaction(ctx, msg.user, msg.evt)

case event.EventReaction:

portal.handleMatrixReaction(ctx, msg.user, msg.evt)

default:

log.Warn().Str("type", msg.evt.Type.String()).Msg("Unhandled matrix message type")

}

evtTS := time.UnixMilli(evt.Timestamp)

timings := messageTimings{

initReceive: evt.Mautrix.ReceivedAt.Sub(evtTS),

decrypt: evt.Mautrix.DecryptionDuration,

totalReceive: time.Since(evtTS),

}

implicitRRStart := time.Now()

timings.implicitRR = time.Since(implicitRRStart)

start := time.Now()

messageAge := timings.totalReceive

ms := metricSender{portal: portal, timings: &timings}

portal.log.Debug().Msgf("Received message %s from %s (age: %s)", evt.ID, evt.Sender, messageAge)

errorAfter := portal.bridge.Config.Bridge.MessageHandlingTimeout.ErrorAfter

deadline := portal.bridge.Config.Bridge.MessageHandlingTimeout.Deadline

isScheduled, _ := evt.Content.Raw["com.beeper.scheduled"].(bool)

if isScheduled {

portal.log.Debug().Msgf("%s is a scheduled message, extending handling timeouts", evt.ID)

errorAfter *= 10

deadline *= 10

}

if errorAfter > 0 {

remainingTime := errorAfter - messageAge

if remainingTime < 0 {

go ms.sendMessageMetrics(evt, errTimeoutBeforeHandling, "Timeout handling", true)

return

} else if remainingTime < 1*time.Second {

portal.log.Warn().Msgf("Message %s was delayed before reaching the bridge, only have %s (of %s timeout) until delay warning", evt.ID, remainingTime, errorAfter)

}

go func() {

time.Sleep(remainingTime)

ms.sendMessageMetrics(evt, errMessageTakingLong, "Timeout handling", false)

}()

}

if deadline > 0 {

var cancel context.CancelFunc

ctx, cancel = context.WithTimeout(ctx, deadline)

defer cancel()

}

timings.preproc = time.Since(start)

start = time.Now()

msg, err := portal.convertMatrixMessage(ctx, sender, evt)

if err != nil || msg == nil {

if err == nil {

err = fmt.Errorf("msg is nil")

}

portal.log.Error().Msgf("Error converting message %s: %v", evt.ID, err)

go ms.sendMessageMetrics(evt, err, "Error converting", true)

return

}

timestamp := *msg.DataMessage.Timestamp

if timestamp == 0 {

timestamp = uint64(start.UnixMilli())

}

timings.convert = time.Since(start)

start = time.Now()

// If the portal has disappearing messages enabled, set the expiration time

if portal.ExpirationTime > 0 {

signalmeow.AddExpiryToDataMessage(msg, uint32(portal.ExpirationTime))

}

if !sender.IsLoggedIn() {

sender = portal.GetRelayUser()

}

err = portal.sendSignalMessage(ctx, msg, sender, evt.ID)

timings.totalSend = time.Since(start)

go ms.sendMessageMetrics(evt, err, "Error sending", true)

if err == nil {

portal.storeMessageInDB(ctx, evt.ID, sender.SignalID, timestamp, 0)

if portal.ExpirationTime > 0 {

portal.addDisappearingMessage(ctx, evt.ID, int64(portal.ExpirationTime), true)

}

}

log := zerolog.Ctx(ctx)

// Find the original signal message based on eventID

dbMessage, err := portal.bridge.DB.Message.GetByMXID(ctx, evt.Redacts)

if err != nil {

log.Err(err).Msg("Failed to get redaction target message")

}

// Might be a reaction redaction, find the original message for the reaction

dbReaction, err := portal.bridge.DB.Reaction.GetByMXID(ctx, evt.Redacts)

if err != nil {

log.Err(err).Msg("Failed to get redaction target reaction")

}

if dbMessage == nil && dbReaction == nil {

portal.sendMessageStatusCheckpointFailed(evt, errors.New("could not find original message or reaction"))

log.Warn().Msg("No target message or reaction found for redaction")

return

}

if !sender.IsLoggedIn() {

sender = portal.GetRelayUser()

}

// If this is a message redaction, send a redaction to Signal

if dbMessage != nil {

msg := signalmeow.DataMessageForDelete(dbMessage.Timestamp)

err = portal.sendSignalMessage(ctx, msg, sender, evt.ID)

if err != nil {

portal.sendMessageStatusCheckpointFailed(evt, err)

log.Err(err).Msg("Failed to send message redaction to Signal")

return

}

err = dbMessage.Delete(ctx)

if err != nil {

log.Err(err).Msg("Failed to delete redacted message from database")

} else if otherParts, err := portal.bridge.DB.Message.GetAllPartsBySignalID(ctx, dbMessage.Sender, dbMessage.Timestamp, portal.Receiver); err != nil {

log.Err(err).Msg("Failed to get other parts of redacted message from database")

} else if len(otherParts) > 0 {

// If there are other parts of the message, send a redaction for each of them

for _, otherPart := range otherParts {

_, err = portal.MainIntent().RedactEvent(portal.MXID, otherPart.MXID, mautrix.ReqRedact{

Reason: "Other part of Signal message redacted",

TxnID: "mxsg_partredact_" + otherPart.MXID.String(),

})

if err != nil {

log.Err(err).

Str("part_event_id", otherPart.MXID.String()).

Int("part_index", otherPart.PartIndex).

Msg("Failed to redact other part of redacted message")

}

err = otherPart.Delete(ctx)

if err != nil {

log.Err(err).

Str("part_event_id", otherPart.MXID.String()).

Int("part_index", otherPart.PartIndex).

Msg("Failed to delete other part of redacted message from database")

}

}

}

}

if dbReaction != nil {

msg := signalmeow.DataMessageForReaction(dbReaction.Emoji, dbReaction.MsgAuthor, dbReaction.MsgTimestamp, true)

err = portal.sendSignalMessage(ctx, msg, sender, evt.ID)

if err != nil {

portal.sendMessageStatusCheckpointFailed(evt, err)

log.Err(err).Msg("Failed to send reaction redaction to Signal")

return

}

err = dbReaction.Delete(ctx)

if err != nil {

log.Err(err).Msg("Failed to delete redacted reaction from database")

}

}

portal.sendMessageStatusCheckpointSuccess(evt)

log := zerolog.Ctx(ctx)

if !sender.IsLoggedIn() {

log.Error().Msg("Cannot relay reaction from non-logged-in user. Ignoring")

return

}

// Find the original signal message based on eventID

relatedEventID := evt.Content.AsReaction().RelatesTo.EventID

dbMessage, err := portal.bridge.DB.Message.GetByMXID(ctx, relatedEventID)

if err != nil {

portal.sendMessageStatusCheckpointFailed(evt, err)

log.Err(err).Msg("Failed to get reaction target message")

return

} else if dbMessage == nil {

portal.sendMessageStatusCheckpointFailed(evt, errors.New("could not find original message for reaction"))

log.Warn().Msg("No target message found for reaction")

return

}

emoji := evt.Content.AsReaction().RelatesTo.Key

signalEmoji := variationselector.FullyQualify(emoji) // Signal seems to require fully qualified emojis

targetAuthorUUID := dbMessage.Sender

targetTimestamp := dbMessage.Timestamp

msg := signalmeow.DataMessageForReaction(signalEmoji, targetAuthorUUID, targetTimestamp, false)

err = portal.sendSignalMessage(context.Background(), msg, sender, evt.ID)

if err != nil {

portal.sendMessageStatusCheckpointFailed(evt, err)

portal.log.Error().Msgf("Failed to send reaction %s", evt.ID)

return

}

// Signal only allows one reaction from each user

// Check if there's an existing reaction in the database for this sender and redact/delete it

dbReaction, err := portal.bridge.DB.Reaction.GetBySignalID(

ctx,

targetAuthorUUID,

targetTimestamp,

sender.SignalID,

portal.Receiver,

)

if err != nil {

log.Err(err).Msg("Failed to get existing reaction from database")

} else if dbReaction != nil {

log.Debug().Str("existing_event_id", dbReaction.MXID.String()).Msg("Redacting existing reaction after sending new one")

_, err = portal.MainIntent().RedactEvent(portal.MXID, dbReaction.MXID)

if err != nil {

log.Err(err).Msg("Failed to redact existing reaction")

}

// TODO update instead of deleting

err = dbReaction.Delete(ctx)

if err != nil {

log.Err(err).Msg("Failed to delete reaction from database")

}

}

// Store our new reaction in the database

portal.storeReactionInDB(ctx, evt.ID, sender.SignalID, targetAuthorUUID, targetTimestamp, signalEmoji)

portal.sendMessageStatusCheckpointSuccess(evt)

var file *event.EncryptedFileInfo

rawMXC := content.URL

if content.File != nil {

file = content.File

rawMXC = file.URL

}

mxc, err := rawMXC.Parse()

if err != nil {

return nil, err

}

data, err := portal.MainIntent().DownloadBytesContext(ctx, mxc)

if err != nil {

return nil, exerrors.NewDualError(errMediaDownloadFailed, err)

}

if file != nil {

err = file.DecryptInPlace(data)

if err != nil {

return nil, exerrors.NewDualError(errMediaDecryptFailed, err)

}

}

return data, nil

webpDecoded, err := webp.Decode(bytes.NewReader(webpImage))

if err != nil {

return nil, fmt.Errorf("failed to decode webp image: %w", err)

}

var pngBuffer bytes.Buffer

if err = png.Encode(&pngBuffer, webpDecoded); err != nil {

return nil, fmt.Errorf("failed to encode png image: %w", err)

}

return pngBuffer.Bytes(), nil

image.Image

Size int

OffsetX int

OffsetY int

decodedImg, _, err := image.Decode(bytes.NewReader(img))

if err != nil {

return img, fmt.Errorf("failed to decode image: %w", err)

}

bounds := decodedImg.Bounds()

width, height := bounds.Dx(), bounds.Dy()

if width != height {

paddedImg := &PaddedImage{

Image: decodedImg,

OffsetX: bounds.Min.Y,

OffsetY: bounds.Min.X,

}

if width > height {

paddedImg.Size = width

paddedImg.OffsetY -= (paddedImg.Size - height) / 2

} else {

paddedImg.Size = height

paddedImg.OffsetX -= (paddedImg.Size - width) / 2

}

decodedImg = paddedImg

}

var webpBuffer bytes.Buffer

if err = cwebp.Encode(&webpBuffer, decodedImg, nil); err != nil {

return img, fmt.Errorf("failed to encode webp image: %w", err)

}

return webpBuffer.Bytes(), nil

var outMimeType string

var outImage []byte

var err error

switch mimeType {

case "image/jpeg", "image/png", "image/gif":

// Allowed

outMimeType = mimeType

outImage = image

case "image/webp":

outMimeType = "image/png"

outImage, err = convertWebPtoPNG(image)

default:

return "", nil, fmt.Errorf("%w %q", errMediaUnsupportedType, mimeType)

}

if err != nil {

return "", nil, fmt.Errorf("%w (%s to %s)", errMediaConvertFailed, mimeType, outMimeType)

}

return outMimeType, outImage, nil

var outMimeType string = mimeType

var outSticker []byte = sticker

var err error

if mimeType != "image/webp" || width != height {

outSticker, err = convertToWebPSticker(sticker)

outMimeType = "image/webp"

}

if err != nil {

return "", nil, fmt.Errorf("%w (%s to %s)", errMediaConvertFailed, mimeType, outMimeType)

}

return outMimeType, outSticker, nil

var outMimeType string

var outVideo []byte

var err error

switch mimeType {

case "video/mp4", "video/3gpp":

// Allowed

outMimeType = mimeType

outVideo = video

case "video/webm":

outMimeType = "video/mp4"

outVideo, err = ffmpeg.ConvertBytes(ctx, video, ".mp4", []string{"-f", "webm"}, []string{

"-pix_fmt", "yuv420p", "-c:v", "libx264",

}, mimeType)

default:

return "", nil, fmt.Errorf("%w %q in video message", errMediaUnsupportedType, mimeType)

}

if err != nil {

return "", nil, fmt.Errorf("%w (%s to %s)", errMediaConvertFailed, mimeType, outMimeType)

}

return outMimeType, outVideo, nil

content, ok := evt.Content.Parsed.(*event.MessageEventContent)

if !ok {

return nil, fmt.Errorf("%w %T", errUnexpectedParsedContentType, evt.Content.Parsed)

}

if evt.Type == event.EventSticker {

content.MsgType = event.MessageType(event.EventSticker.Type)

}

realSenderMXID := sender.MXID

isRelay := false

if !sender.IsLoggedIn() {

if !portal.HasRelaybot() {

return nil, errUserNotLoggedIn

}

sender = portal.GetRelayUser()

if !sender.IsLoggedIn() {

return nil, errRelaybotNotLoggedIn

}

isRelay = true

}

var outgoingMessage *signalmeow.SignalContent

relaybotFormatted := isRelay && portal.addRelaybotFormat(realSenderMXID, content)

if relaybotFormatted && content.FileName == "" {

content.FileName = content.Body

}

if evt.Type == event.EventSticker {

if relaybotFormatted {

// Stickers can't have captions, so force relaybot stickers to be images

content.MsgType = event.MsgImage

} else {

content.MsgType = event.MessageType(event.EventSticker.Type)

}

}

switch content.MsgType {

case event.MsgText, event.MsgEmote, event.MsgNotice:

if content.MsgType == event.MsgNotice && !portal.bridge.Config.Bridge.BridgeNotices {

return nil, errMNoticeDisabled

}

if content.MsgType == event.MsgEmote && !relaybotFormatted {

content.Body = "/me " + content.Body

if content.FormattedBody != "" {

content.FormattedBody = "/me " + content.FormattedBody

}

}

outgoingMessage = signalmeow.DataMessageForText(matrixfmt.Parse(matrixFormatParams, content))

if ctx.Err() != nil {

return nil, ctx.Err()

}

case event.MsgImage:

fileName := content.Body

var caption string

var ranges []*signalpb.BodyRange

if content.FileName != "" && (content.Body != content.FileName || content.Format == event.FormatHTML) {

fileName = content.FileName

caption, ranges = matrixfmt.Parse(matrixFormatParams, content)

}

image, err := portal.downloadAndDecryptMatrixMedia(ctx, content)

if err != nil {

return nil, err

}

newMimeType, convertedImage, err := convertImage(ctx, content.GetInfo().MimeType, image)

if err != nil {

return nil, err

}

attachmentPointer, err := signalmeow.UploadAttachment(sender.SignalDevice, convertedImage, newMimeType, fileName)

if err != nil {

return nil, err

}

attachmentPointer.Height = proto.Uint32(uint32(content.GetInfo().Height))

attachmentPointer.Width = proto.Uint32(uint32(content.GetInfo().Width))

outgoingMessage = signalmeow.DataMessageForAttachment(attachmentPointer, caption, ranges)

case event.MessageType(event.EventSticker.Type):

var emoji *string

// TODO check for single grapheme cluster?

if len([]rune(content.Body)) == 1 {

emoji = proto.String(variationselector.Remove(content.Body))

}

image, err := portal.downloadAndDecryptMatrixMedia(ctx, content)

if err != nil {

return nil, err

}

newMimeType, convertedSticker, err := convertSticker(ctx, content.GetInfo().MimeType, image, content.GetInfo().Width, content.GetInfo().Height)

if err != nil {

return nil, err

}

attachmentPointer, err := signalmeow.UploadAttachment(sender.SignalDevice, convertedSticker, newMimeType, content.FileName)

if err != nil {

return nil, err

}

attachmentPointer.Height = proto.Uint32(uint32(content.GetInfo().Height))

attachmentPointer.Width = proto.Uint32(uint32(content.GetInfo().Width))

attachmentPointer.Flags = proto.Uint32(uint32(signalpb.AttachmentPointer_BORDERLESS))

outgoingMessage = &signalmeow.SignalContent{

DataMessage: &signalpb.DataMessage{

Timestamp: proto.Uint64(uint64(time.Now().UnixMilli())),

Sticker: &signalpb.DataMessage_Sticker{

// Signal iOS validates that pack id/key are of the correct length.

// Android is fine with any non-nil values (like a zero-length byte string).

PackId: make([]byte, 16),

PackKey: make([]byte, 32),

StickerId: proto.Uint32(0),

Data: (*signalpb.AttachmentPointer)(attachmentPointer),

Emoji: emoji,

},

},

}

case event.MsgVideo:

fileName := content.Body

var caption string

var ranges []*signalpb.BodyRange

if content.FileName != "" && (content.Body != content.FileName || content.Format == event.FormatHTML) {

fileName = content.FileName

caption, ranges = matrixfmt.Parse(matrixFormatParams, content)

}

image, err := portal.downloadAndDecryptMatrixMedia(ctx, content)

if err != nil {

return nil, err

}

newMimeType, convertedVideo, err := convertVideo(ctx, content.GetInfo().MimeType, image)

if err != nil {

return nil, err

}

attachmentPointer, err := signalmeow.UploadAttachment(sender.SignalDevice, convertedVideo, newMimeType, fileName)

if err != nil {

return nil, err

}

outgoingMessage = signalmeow.DataMessageForAttachment(attachmentPointer, caption, ranges)

case event.MsgAudio:

fileName := content.Body

var caption string

var ranges []*signalpb.BodyRange

if content.FileName != "" && (content.Body != content.FileName || content.Format == event.FormatHTML) {

fileName = content.FileName

caption, ranges = matrixfmt.Parse(matrixFormatParams, content)

}

data, err := portal.downloadAndDecryptMatrixMedia(ctx, content)

if err != nil {

return nil, err

}

_, isVoice := evt.Content.Raw["org.matrix.msc3245.voice"]

mime := content.GetInfo().MimeType

if isVoice {

data, err = ffmpeg.ConvertBytes(ctx, data, ".m4a", []string{}, []string{"-c:a", "aac"}, mime)

if err != nil {

return nil, err

}

mime = "audio/aac"

fileName += ".m4a"

}

attachmentPointer, err := signalmeow.UploadAttachment(sender.SignalDevice, data, mime, fileName)

if err != nil {

return nil, err

}

if isVoice {

attachmentPointer.Flags = proto.Uint32(uint32(signalpb.AttachmentPointer_VOICE_MESSAGE))

}

outgoingMessage = signalmeow.DataMessageForAttachment(attachmentPointer, caption, ranges)

case event.MsgFile:

fileName := content.Body

var caption string

var ranges []*signalpb.BodyRange

if content.FileName != "" && (content.Body != content.FileName || content.Format == event.FormatHTML) {

fileName = content.FileName

caption, ranges = matrixfmt.Parse(matrixFormatParams, content)

}

file, err := portal.downloadAndDecryptMatrixMedia(ctx, content)

if err != nil {

return nil, err

}

attachmentPointer, err := signalmeow.UploadAttachment(sender.SignalDevice, file, content.GetInfo().MimeType, fileName)

if err != nil {

return nil, err

}

outgoingMessage = signalmeow.DataMessageForAttachment(attachmentPointer, caption, ranges)

case event.MsgLocation:

fallthrough

default:

return nil, fmt.Errorf("%w %q", errUnknownMsgType, content.MsgType)

}

// Include a quote if this is a reply

replyID := content.RelatesTo.GetReplyTo()

if replyID != "" {

originalMessage, err := portal.bridge.DB.Message.GetByMXID(ctx, replyID)

if err != nil {

return nil, fmt.Errorf("failed to get reply target: %w", err)

} else if originalMessage != nil {

signalmeow.AddQuoteToDataMessage(

outgoingMessage,

originalMessage.Sender,

originalMessage.Timestamp,

)

} else {

zerolog.Ctx(ctx).Warn().Str("reply_event_id", replyID.String()).Msg("Reply target not found")

}

}

return outgoingMessage, nil

recipientSignalID := portal.ChatID

portal.log.Debug().Msgf("Sending event %s to Signal %s", evtID, recipientSignalID)

// Check to see if recipientSignalID is a standard UUID (with dashes)

var err error

if _, uuidErr := uuid.Parse(recipientSignalID); uuidErr == nil {

// this is a 1:1 chat

result := signalmeow.SendMessage(ctx, sender.SignalDevice, recipientSignalID, msg)

if !result.WasSuccessful {

err = result.FailedSendResult.Error

portal.log.Error().Msgf("Error sending event %s to Signal %s: %s", evtID, recipientSignalID, err)

}

} else {

// this is a group chat

groupID := signalmeow.GroupIdentifier(recipientSignalID)

result, err := signalmeow.SendGroupMessage(ctx, sender.SignalDevice, groupID, msg)

if err != nil {

// check the start of the error string, see if it starts with "No group master key found for group identifier"

if strings.HasPrefix(err.Error(), "No group master key found for group identifier") {

portal.MainIntent().SendNotice(portal.MXID, "Missing group encryption key. Please ask a group member to send a message in this chat, then retry sending.")

}

portal.log.Error().Msgf("Error sending event %s to Signal group %s: %s", evtID, recipientSignalID, err)

return err

}

totalRecipients := len(result.FailedToSendTo) + len(result.SuccessfullySentTo)

if len(result.FailedToSendTo) > 0 {

portal.log.Error().Msgf("Failed to send event %s to %d of %d members of Signal group %s", evtID, len(result.FailedToSendTo), totalRecipients, recipientSignalID)

}

if len(result.SuccessfullySentTo) == 0 && len(result.FailedToSendTo) == 0 {

portal.log.Debug().Msgf("No successes or failures - Probably sent to myself")

} else if len(result.SuccessfullySentTo) == 0 {

portal.log.Error().Msgf("Failed to send event %s to all %d members of Signal group %s", evtID, totalRecipients, recipientSignalID)

err = errors.New("failed to send to any members of Signal group")

} else if len(result.SuccessfullySentTo) < totalRecipients {

portal.log.Warn().Msgf("Only sent event %s to %d of %d members of Signal group %s", evtID, len(result.SuccessfullySentTo), totalRecipients, recipientSignalID)

} else {

portal.log.Debug().Msgf("Sent event %s to all %d members of Signal group %s", evtID, totalRecipients, recipientSignalID)

}

}

return err

portal.sendDeliveryReceipt(evt.ID)

portal.bridge.SendMessageSuccessCheckpoint(evt, status.MsgStepRemote, 0)

var deliveredTo *[]id.UserID

if portal.IsPrivateChat() {

deliveredTo = &[]id.UserID{}

}

portal.sendStatusEvent(evt.ID, "", nil, deliveredTo)

portal.sendDeliveryReceipt(evt.ID)

portal.bridge.SendMessageErrorCheckpoint(evt, status.MsgStepRemote, err, true, 0)

portal.sendStatusEvent(evt.ID, "", err, nil)

log := portal.log.With().

Str("action", "handle signal message").

Str("sender", portalMessage.sender.SignalID.String()).

Uint64("timestamp", portalMessage.message.Base().Timestamp).

Int("part_index", portalMessage.message.Base().PartIndex).

Logger()

ctx := log.WithContext(context.TODO())

if existingMessage, err := portal.bridge.DB.Message.GetBySignalID(

ctx,

portalMessage.sender.SignalID,

portalMessage.message.Base().Timestamp,

portalMessage.message.Base().PartIndex,

portal.Receiver,

); err != nil {

log.Err(err).Msg("Failed to check if message was already handled")

return

} else if existingMessage != nil {

log.Debug().Msg("Ignoring duplicate message")

return

}

if portal.MXID == "" {

log.Debug().Msg("Creating Matrix room from incoming message")

if err := portal.CreateMatrixRoom(portalMessage.user, nil); err != nil {

log.Error().Err(err).Msg("Failed to create portal room")

return

}

ensureGroupPuppetsAreJoinedToPortal(context.Background(), portalMessage.user, portal)

signalmeow.SendContactSyncRequest(context.TODO(), portalMessage.user.SignalDevice)

}

intent := portalMessage.sender.IntentFor(portal)

if intent == nil {

portal.log.Error().Msg("Failed to get message intent")

return

}

var err error

if portalMessage.message.MessageType() == signalmeow.IncomingSignalMessageTypeText {

err = portal.handleSignalTextMessage(ctx, portalMessage, intent)

if err != nil {

portal.log.Error().Err(err).Msg("Failed to handle text message")

return

}

} else if portalMessage.message.MessageType() == signalmeow.IncomingSignalMessageTypeAttachment {

err = portal.handleSignalAttachmentMessage(ctx, portalMessage, intent)

if err != nil {

portal.log.Error().Err(err).Msg("Failed to handle attachment message")

return

}

} else if portalMessage.message.MessageType() == signalmeow.IncomingSignalMessageTypeReaction {

portal.handleSignalReactionMessage(ctx, portalMessage, intent)

} else if portalMessage.message.MessageType() == signalmeow.IncomingSignalMessageTypeDelete {

portal.handleSignalDeleteMessage(ctx, portalMessage, intent)

} else if portalMessage.message.MessageType() == signalmeow.IncomingSignalMessageTypeSticker {

err := portal.handleSignalStickerMessage(ctx, portalMessage, intent)

if err != nil {

portal.log.Error().Err(err).Msg("Failed to handle sticker message")

return

}

} else if portalMessage.message.MessageType() == signalmeow.IncomingSignalMessageTypeTyping {

err := portal.handleSignalTypingMessage(portalMessage, intent)

if err != nil {